diff --git a/web_widget_mermaid/static/src/js/mermaid.js b/web_widget_mermaid/static/src/js/mermaid.js new file mode 100644 index 000000000..8befbc3d3 --- /dev/null +++ b/web_widget_mermaid/static/src/js/mermaid.js @@ -0,0 +1,137378 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if (typeof exports === "object" && typeof module === "object") + module.exports = factory(); + else if (typeof define === "function" && define.amd) define([], factory); + else if (typeof exports === "object") exports.mermaid = factory(); + else root.mermaid = factory(); +})(window, function () { + 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; // Define getter function for harmony exports + /** ****/ + /** ****/ /** ****/ __webpack_require__.d = function (exports, name, getter) { + /** ****/ if (!__webpack_require__.o(exports, name)) { + /** ****/ Object.defineProperty(exports, name, { + enumerable: true, + get: getter, + }); + /** ****/ + } + /** ****/ + }; // Define __esModule on exports + /** ****/ + /** ****/ /** ****/ __webpack_require__.r = function (exports) { + /** ****/ if (typeof Symbol !== "undefined" && Symbol.toStringTag) { + /** ****/ Object.defineProperty(exports, Symbol.toStringTag, { + value: "Module", + }); + /** ****/ + } + /** ****/ Object.defineProperty(exports, "__esModule", {value: true}); + /** ****/ + }; // Create a fake namespace object // mode & 1: value is a module id, require it // mode & 2: merge all properties of value into the ns // mode & 4: return value when already ns object // mode & 8|1: behave like require + /** ****/ + /** ****/ /** ****/ /** ****/ /** ****/ /** ****/ /** ****/ __webpack_require__.t = function ( + value, + mode + ) { + /** ****/ if (mode & 1) value = __webpack_require__(value); + /** ****/ if (mode & 8) return value; + /** ****/ if ( + mode & 4 && + typeof value === "object" && + value && + value.__esModule + ) + return value; + /** ****/ var ns = Object.create(null); + /** ****/ __webpack_require__.r(ns); + /** ****/ Object.defineProperty(ns, "default", { + enumerable: true, + value: value, + }); + /** ****/ if (mode & 2 && typeof value !== "string") + for (var key in value) + __webpack_require__.d( + ns, + key, + function (key) { + return value[key]; + }.bind(null, key) + ); + /** ****/ return ns; + /** ****/ + }; // 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 = "./src/mermaid.js") + ); + /** ****/ + })( + /** **********************************************************************/ + /** ****/ { + /***/ "./node_modules/@braintree/sanitize-url/index.js": + /* !*******************************************************!*\ + !*** ./node_modules/@braintree/sanitize-url/index.js ***! + \*******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var invalidPrototcolRegex = /^(%20|\s)*(javascript|data)/im; + var ctrlCharactersRegex = /[^\x20-\x7E]/gim; + var urlSchemeRegex = /^([^:]+):/gm; + var relativeFirstCharacters = [".", "/"]; + + function isRelativeUrl(url) { + return relativeFirstCharacters.indexOf(url[0]) > -1; + } + + function sanitizeUrl(url) { + if (!url) { + return "about:blank"; + } + + var urlScheme, urlSchemeParseResults; + var sanitizedUrl = url.replace(ctrlCharactersRegex, "").trim(); + + if (isRelativeUrl(sanitizedUrl)) { + return sanitizedUrl; + } + + urlSchemeParseResults = sanitizedUrl.match(urlSchemeRegex); + + if (!urlSchemeParseResults) { + return "about:blank"; + } + + urlScheme = urlSchemeParseResults[0]; + + if (invalidPrototcolRegex.test(urlScheme)) { + return "about:blank"; + } + + return sanitizedUrl; + } + + module.exports = { + sanitizeUrl: sanitizeUrl, + }; + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1.js": + /* !******************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1.js ***! + \******************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var asn1 = exports; + asn1.bignum = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + asn1.define = __webpack_require__( + /* ! ./asn1/api */ "./node_modules/asn1.js/lib/asn1/api.js" + ).define; + asn1.base = __webpack_require__( + /* ! ./asn1/base */ "./node_modules/asn1.js/lib/asn1/base/index.js" + ); + asn1.constants = __webpack_require__( + /* ! ./asn1/constants */ "./node_modules/asn1.js/lib/asn1/constants/index.js" + ); + asn1.decoders = __webpack_require__( + /* ! ./asn1/decoders */ "./node_modules/asn1.js/lib/asn1/decoders/index.js" + ); + asn1.encoders = __webpack_require__( + /* ! ./asn1/encoders */ "./node_modules/asn1.js/lib/asn1/encoders/index.js" + ); + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/api.js": + /* !**********************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/api.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var asn1 = __webpack_require__( + /* ! ../asn1 */ "./node_modules/asn1.js/lib/asn1.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var api = exports; + + api.define = function define(name, body) { + return new Entity(name, body); + }; + + function Entity(name, body) { + this.name = name; + this.body = body; + this.decoders = {}; + this.encoders = {}; + } + + Entity.prototype._createNamed = function createNamed(base) { + var named; + + try { + named = __webpack_require__( + /* ! vm */ "./node_modules/vm-browserify/index.js" + ).runInThisContext( + "(function " + + this.name + + "(entity) {\n" + + " this._initNamed(entity);\n" + + "})" + ); + } catch (e) { + named = function named(entity) { + this._initNamed(entity); + }; + } + + inherits(named, base); + + named.prototype._initNamed = function initnamed(entity) { + base.call(this, entity); + }; + + return new named(this); + }; + + Entity.prototype._getDecoder = function _getDecoder(enc) { + enc = enc || "der"; // Lazily create decoder + + if (!this.decoders.hasOwnProperty(enc)) + this.decoders[enc] = this._createNamed(asn1.decoders[enc]); + return this.decoders[enc]; + }; + + Entity.prototype.decode = function decode(data, enc, options) { + return this._getDecoder(enc).decode(data, options); + }; + + Entity.prototype._getEncoder = function _getEncoder(enc) { + enc = enc || "der"; // Lazily create encoder + + if (!this.encoders.hasOwnProperty(enc)) + this.encoders[enc] = this._createNamed(asn1.encoders[enc]); + return this.encoders[enc]; + }; + + Entity.prototype.encode = function encode( + data, + enc, + /* Internal */ + reporter + ) { + return this._getEncoder(enc).encode(data, reporter); + }; + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/base/buffer.js": + /* !******************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/base/buffer.js ***! + \******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Reporter = __webpack_require__( + /* ! ../base */ "./node_modules/asn1.js/lib/asn1/base/index.js" + ).Reporter; + + var Buffer = __webpack_require__( + /* ! buffer */ "./node_modules/buffer/index.js" + ).Buffer; + + function DecoderBuffer(base, options) { + Reporter.call(this, options); + + if (!Buffer.isBuffer(base)) { + this.error("Input not Buffer"); + return; + } + + this.base = base; + this.offset = 0; + this.length = base.length; + } + + inherits(DecoderBuffer, Reporter); + exports.DecoderBuffer = DecoderBuffer; + + DecoderBuffer.prototype.save = function save() { + return { + offset: this.offset, + reporter: Reporter.prototype.save.call(this), + }; + }; + + DecoderBuffer.prototype.restore = function restore(save) { + // Return skipped data + var res = new DecoderBuffer(this.base); + res.offset = save.offset; + res.length = this.offset; + this.offset = save.offset; + Reporter.prototype.restore.call(this, save.reporter); + return res; + }; + + DecoderBuffer.prototype.isEmpty = function isEmpty() { + return this.offset === this.length; + }; + + DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) { + if (this.offset + 1 <= this.length) + return this.base.readUInt8(this.offset++, true); + return this.error(fail || "DecoderBuffer overrun"); + }; + + DecoderBuffer.prototype.skip = function skip(bytes, fail) { + if (!(this.offset + bytes <= this.length)) + return this.error(fail || "DecoderBuffer overrun"); + var res = new DecoderBuffer(this.base); // Share reporter state + + res._reporterState = this._reporterState; + res.offset = this.offset; + res.length = this.offset + bytes; + this.offset += bytes; + return res; + }; + + DecoderBuffer.prototype.raw = function raw(save) { + return this.base.slice( + save ? save.offset : this.offset, + this.length + ); + }; + + function EncoderBuffer(value, reporter) { + if (Array.isArray(value)) { + this.length = 0; + this.value = value.map(function (item) { + if (!(item instanceof EncoderBuffer)) + item = new EncoderBuffer(item, reporter); + this.length += item.length; + return item; + }, this); + } else if (typeof value === "number") { + if (!(value >= 0 && value <= 0xff)) + return reporter.error("non-byte EncoderBuffer value"); + this.value = value; + this.length = 1; + } else if (typeof value === "string") { + this.value = value; + this.length = Buffer.byteLength(value); + } else if (Buffer.isBuffer(value)) { + this.value = value; + this.length = value.length; + } else { + return reporter.error( + "Unsupported type: " + _typeof(value) + ); + } + } + + exports.EncoderBuffer = EncoderBuffer; + + EncoderBuffer.prototype.join = function join(out, offset) { + if (!out) out = new Buffer(this.length); + if (!offset) offset = 0; + if (this.length === 0) return out; + + if (Array.isArray(this.value)) { + this.value.forEach(function (item) { + item.join(out, offset); + offset += item.length; + }); + } else { + if (typeof this.value === "number") + out[offset] = this.value; + else if (typeof this.value === "string") + out.write(this.value, offset); + else if (Buffer.isBuffer(this.value)) + this.value.copy(out, offset); + offset += this.length; + } + + return out; + }; + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/base/index.js": + /* !*****************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/base/index.js ***! + \*****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var base = exports; + base.Reporter = __webpack_require__( + /* ! ./reporter */ "./node_modules/asn1.js/lib/asn1/base/reporter.js" + ).Reporter; + base.DecoderBuffer = __webpack_require__( + /* ! ./buffer */ "./node_modules/asn1.js/lib/asn1/base/buffer.js" + ).DecoderBuffer; + base.EncoderBuffer = __webpack_require__( + /* ! ./buffer */ "./node_modules/asn1.js/lib/asn1/base/buffer.js" + ).EncoderBuffer; + base.Node = __webpack_require__( + /* ! ./node */ "./node_modules/asn1.js/lib/asn1/base/node.js" + ); + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/base/node.js": + /* !****************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/base/node.js ***! + \****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + var Reporter = __webpack_require__( + /* ! ../base */ "./node_modules/asn1.js/lib/asn1/base/index.js" + ).Reporter; + + var EncoderBuffer = __webpack_require__( + /* ! ../base */ "./node_modules/asn1.js/lib/asn1/base/index.js" + ).EncoderBuffer; + + var DecoderBuffer = __webpack_require__( + /* ! ../base */ "./node_modules/asn1.js/lib/asn1/base/index.js" + ).DecoderBuffer; + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); // Supported tags + + var tags = [ + "seq", + "seqof", + "set", + "setof", + "objid", + "bool", + "gentime", + "utctime", + "null_", + "enum", + "int", + "objDesc", + "bitstr", + "bmpstr", + "charstr", + "genstr", + "graphstr", + "ia5str", + "iso646str", + "numstr", + "octstr", + "printstr", + "t61str", + "unistr", + "utf8str", + "videostr", + ]; // Public methods list + + var methods = [ + "key", + "obj", + "use", + "optional", + "explicit", + "implicit", + "def", + "choice", + "any", + "contains", + ].concat(tags); // Overrided methods list + + var overrided = [ + "_peekTag", + "_decodeTag", + "_use", + "_decodeStr", + "_decodeObjid", + "_decodeTime", + "_decodeNull", + "_decodeInt", + "_decodeBool", + "_decodeList", + "_encodeComposite", + "_encodeStr", + "_encodeObjid", + "_encodeTime", + "_encodeNull", + "_encodeInt", + "_encodeBool", + ]; + + function Node(enc, parent) { + var state = {}; + this._baseState = state; + state.enc = enc; + state.parent = parent || null; + state.children = null; // State + + state.tag = null; + state.args = null; + state.reverseArgs = null; + state.choice = null; + state.optional = false; + state.any = false; + state.obj = false; + state.use = null; + state.useDecoder = null; + state.key = null; + state.default = null; + state.explicit = null; + state.implicit = null; + state.contains = null; // Should create new instance on each method + + if (!state.parent) { + state.children = []; + + this._wrap(); + } + } + + module.exports = Node; + var stateProps = [ + "enc", + "parent", + "children", + "tag", + "args", + "reverseArgs", + "choice", + "optional", + "any", + "obj", + "use", + "alteredUse", + "key", + "default", + "explicit", + "implicit", + "contains", + ]; + + Node.prototype.clone = function clone() { + var state = this._baseState; + var cstate = {}; + stateProps.forEach(function (prop) { + cstate[prop] = state[prop]; + }); + var res = new this.constructor(cstate.parent); + res._baseState = cstate; + return res; + }; + + Node.prototype._wrap = function wrap() { + var state = this._baseState; + methods.forEach(function (method) { + this[method] = function _wrappedMethod() { + var clone = new this.constructor(this); + state.children.push(clone); + return clone[method].apply(clone, arguments); + }; + }, this); + }; + + Node.prototype._init = function init(body) { + var state = this._baseState; + assert(state.parent === null); + body.call(this); // Filter children + + state.children = state.children.filter(function (child) { + return child._baseState.parent === this; + }, this); + assert.equal( + state.children.length, + 1, + "Root node can have only one child" + ); + }; + + Node.prototype._useArgs = function useArgs(args) { + var state = this._baseState; // Filter children and args + + var children = args.filter(function (arg) { + return arg instanceof this.constructor; + }, this); + args = args.filter(function (arg) { + return !(arg instanceof this.constructor); + }, this); + + if (children.length !== 0) { + assert(state.children === null); + state.children = children; // Replace parent to maintain backward link + + children.forEach(function (child) { + child._baseState.parent = this; + }, this); + } + + if (args.length !== 0) { + assert(state.args === null); + state.args = args; + state.reverseArgs = args.map(function (arg) { + if ( + _typeof(arg) !== "object" || + arg.constructor !== Object + ) + return arg; + var res = {}; + Object.keys(arg).forEach(function (key) { + if (key == (key | 0)) key |= 0; + var value = arg[key]; + res[value] = key; + }); + return res; + }); + } + }; // + // Overrided methods + // + + overrided.forEach(function (method) { + Node.prototype[method] = function _overrided() { + var state = this._baseState; + throw new Error( + method + " not implemented for encoding: " + state.enc + ); + }; + }); // + // Public methods + // + + tags.forEach(function (tag) { + Node.prototype[tag] = function _tagMethod() { + var state = this._baseState; + var args = Array.prototype.slice.call(arguments); + assert(state.tag === null); + state.tag = tag; + + this._useArgs(args); + + return this; + }; + }); + + Node.prototype.use = function use(item) { + assert(item); + var state = this._baseState; + assert(state.use === null); + state.use = item; + return this; + }; + + Node.prototype.optional = function optional() { + var state = this._baseState; + state.optional = true; + return this; + }; + + Node.prototype.def = function def(val) { + var state = this._baseState; + assert(state.default === null); + state.default = val; + state.optional = true; + return this; + }; + + Node.prototype.explicit = function explicit(num) { + var state = this._baseState; + assert(state.explicit === null && state.implicit === null); + state.explicit = num; + return this; + }; + + Node.prototype.implicit = function implicit(num) { + var state = this._baseState; + assert(state.explicit === null && state.implicit === null); + state.implicit = num; + return this; + }; + + Node.prototype.obj = function obj() { + var state = this._baseState; + var args = Array.prototype.slice.call(arguments); + state.obj = true; + if (args.length !== 0) this._useArgs(args); + return this; + }; + + Node.prototype.key = function key(newKey) { + var state = this._baseState; + assert(state.key === null); + state.key = newKey; + return this; + }; + + Node.prototype.any = function any() { + var state = this._baseState; + state.any = true; + return this; + }; + + Node.prototype.choice = function choice(obj) { + var state = this._baseState; + assert(state.choice === null); + state.choice = obj; + + this._useArgs( + Object.keys(obj).map(function (key) { + return obj[key]; + }) + ); + + return this; + }; + + Node.prototype.contains = function contains(item) { + var state = this._baseState; + assert(state.use === null); + state.contains = item; + return this; + }; // + // Decoding + // + + Node.prototype._decode = function decode(input, options) { + var state = this._baseState; // Decode root node + + if (state.parent === null) + return input.wrapResult( + state.children[0]._decode(input, options) + ); + var result = state.default; + var present = true; + var prevKey = null; + if (state.key !== null) prevKey = input.enterKey(state.key); // Check if tag is there + + if (state.optional) { + var tag = null; + if (state.explicit !== null) tag = state.explicit; + else if (state.implicit !== null) tag = state.implicit; + else if (state.tag !== null) tag = state.tag; + + if (tag === null && !state.any) { + // Trial and Error + var save = input.save(); + + try { + if (state.choice === null) + this._decodeGeneric(state.tag, input, options); + else this._decodeChoice(input, options); + present = true; + } catch (e) { + present = false; + } + + input.restore(save); + } else { + present = this._peekTag(input, tag, state.any); + if (input.isError(present)) return present; + } + } // Push object on stack + + var prevObj; + if (state.obj && present) prevObj = input.enterObject(); + + if (present) { + // Unwrap explicit values + if (state.explicit !== null) { + var explicit = this._decodeTag(input, state.explicit); + + if (input.isError(explicit)) return explicit; + input = explicit; + } + + var start = input.offset; // Unwrap implicit and normal values + + if (state.use === null && state.choice === null) { + if (state.any) var save = input.save(); + + var body = this._decodeTag( + input, + state.implicit !== null + ? state.implicit + : state.tag, + state.any + ); + + if (input.isError(body)) return body; + if (state.any) result = input.raw(save); + else input = body; + } + + if (options && options.track && state.tag !== null) + options.track( + input.path(), + start, + input.length, + "tagged" + ); + if (options && options.track && state.tag !== null) + options.track( + input.path(), + input.offset, + input.length, + "content" + ); // Select proper method for tag + + if (state.any) result = result; + else if (state.choice === null) + result = this._decodeGeneric(state.tag, input, options); + else result = this._decodeChoice(input, options); + if (input.isError(result)) return result; // Decode children + + if ( + !state.any && + state.choice === null && + state.children !== null + ) { + state.children.forEach(function decodeChildren(child) { + // NOTE: We are ignoring errors here, to let parser continue with other + // parts of encoded data + child._decode(input, options); + }); + } // Decode contained/encoded by schema, only in bit or octet strings + + if ( + state.contains && + (state.tag === "octstr" || state.tag === "bitstr") + ) { + var data = new DecoderBuffer(result); + result = this._getUse( + state.contains, + input._reporterState.obj + )._decode(data, options); + } + } // Pop object + + if (state.obj && present) result = input.leaveObject(prevObj); // Set key + + if (state.key !== null && (result !== null || present === true)) + input.leaveKey(prevKey, state.key, result); + else if (prevKey !== null) input.exitKey(prevKey); + return result; + }; + + Node.prototype._decodeGeneric = function decodeGeneric( + tag, + input, + options + ) { + var state = this._baseState; + if (tag === "seq" || tag === "set") return null; + if (tag === "seqof" || tag === "setof") + return this._decodeList(input, tag, state.args[0], options); + else if (/str$/.test(tag)) + return this._decodeStr(input, tag, options); + else if (tag === "objid" && state.args) + return this._decodeObjid( + input, + state.args[0], + state.args[1], + options + ); + else if (tag === "objid") + return this._decodeObjid(input, null, null, options); + else if (tag === "gentime" || tag === "utctime") + return this._decodeTime(input, tag, options); + else if (tag === "null_") + return this._decodeNull(input, options); + else if (tag === "bool") + return this._decodeBool(input, options); + else if (tag === "objDesc") + return this._decodeStr(input, tag, options); + else if (tag === "int" || tag === "enum") + return this._decodeInt( + input, + state.args && state.args[0], + options + ); + + if (state.use !== null) { + return this._getUse( + state.use, + input._reporterState.obj + )._decode(input, options); + } + return input.error("unknown tag: " + tag); + + }; + + Node.prototype._getUse = function _getUse(entity, obj) { + var state = this._baseState; // Create altered use decoder if implicit is set + + state.useDecoder = this._use(entity, obj); + assert(state.useDecoder._baseState.parent === null); + state.useDecoder = state.useDecoder._baseState.children[0]; + + if (state.implicit !== state.useDecoder._baseState.implicit) { + state.useDecoder = state.useDecoder.clone(); + state.useDecoder._baseState.implicit = state.implicit; + } + + return state.useDecoder; + }; + + Node.prototype._decodeChoice = function decodeChoice( + input, + options + ) { + var state = this._baseState; + var result = null; + var match = false; + Object.keys(state.choice).some(function (key) { + var save = input.save(); + var node = state.choice[key]; + + try { + var value = node._decode(input, options); + + if (input.isError(value)) return false; + result = { + type: key, + value: value, + }; + match = true; + } catch (e) { + input.restore(save); + return false; + } + + return true; + }, this); + if (!match) return input.error("Choice not matched"); + return result; + }; // + // Encoding + // + + Node.prototype._createEncoderBuffer = function createEncoderBuffer( + data + ) { + return new EncoderBuffer(data, this.reporter); + }; + + Node.prototype._encode = function encode(data, reporter, parent) { + var state = this._baseState; + if (state.default !== null && state.default === data) + return; + + var result = this._encodeValue(data, reporter, parent); + + if (result === undefined) return; + if (this._skipDefault(result, reporter, parent)) return; + return result; + }; + + Node.prototype._encodeValue = function encode( + data, + reporter, + parent + ) { + var state = this._baseState; // Decode root node + + if (state.parent === null) + return state.children[0]._encode( + data, + reporter || new Reporter() + ); + var result = null; // Set reporter to share it with a child class + + this.reporter = reporter; // Check if data is there + + if (state.optional && data === undefined) { + if (state.default !== null) data = state.default; + else return; + } // Encode children first + + var content = null; + var primitive = false; + + if (state.any) { + // Anything that was given is translated to buffer + result = this._createEncoderBuffer(data); + } else if (state.choice) { + result = this._encodeChoice(data, reporter); + } else if (state.contains) { + content = this._getUse(state.contains, parent)._encode( + data, + reporter + ); + primitive = true; + } else if (state.children) { + content = state.children + .map(function (child) { + if (child._baseState.tag === "null_") + return child._encode(null, reporter, data); + if (child._baseState.key === null) + return reporter.error( + "Child should have a key" + ); + var prevKey = reporter.enterKey( + child._baseState.key + ); + if (_typeof(data) !== "object") + return reporter.error( + "Child expected, but input is not object" + ); + + var res = child._encode( + data[child._baseState.key], + reporter, + data + ); + + reporter.leaveKey(prevKey); + return res; + }, this) + .filter(function (child) { + return child; + }); + content = this._createEncoderBuffer(content); + } else if (state.tag === "seqof" || state.tag === "setof") { + // TODO(indutny): this should be thrown on DSL level + if (!(state.args && state.args.length === 1)) + return reporter.error( + "Too many args for : " + state.tag + ); + if (!Array.isArray(data)) + return reporter.error( + "seqof/setof, but data is not Array" + ); + var child = this.clone(); + child._baseState.implicit = null; + content = this._createEncoderBuffer( + data.map(function (item) { + var state = this._baseState; + return this._getUse( + state.args[0], + data + )._encode(item, reporter); + }, child) + ); + } else if (state.use !== null) { + result = this._getUse(state.use, parent)._encode( + data, + reporter + ); + } else { + content = this._encodePrimitive(state.tag, data); + primitive = true; + } // Encode data itself + + var result; + + if (!state.any && state.choice === null) { + var tag = + state.implicit !== null ? state.implicit : state.tag; + var cls = state.implicit === null ? "universal" : "context"; + + if (tag === null) { + if (state.use === null) + reporter.error( + "Tag could be omitted only for .use()" + ); + } else if (state.use === null) + result = this._encodeComposite( + tag, + primitive, + cls, + content + ); + } // Wrap in explicit + + if (state.explicit !== null) + result = this._encodeComposite( + state.explicit, + false, + "context", + result + ); + return result; + }; + + Node.prototype._encodeChoice = function encodeChoice( + data, + reporter + ) { + var state = this._baseState; + var node = state.choice[data.type]; + + if (!node) { + assert( + false, + data.type + + " not found in " + + JSON.stringify(Object.keys(state.choice)) + ); + } + + return node._encode(data.value, reporter); + }; + + Node.prototype._encodePrimitive = function encodePrimitive( + tag, + data + ) { + var state = this._baseState; + if (/str$/.test(tag)) return this._encodeStr(data, tag); + else if (tag === "objid" && state.args) + return this._encodeObjid( + data, + state.reverseArgs[0], + state.args[1] + ); + else if (tag === "objid") + return this._encodeObjid(data, null, null); + else if (tag === "gentime" || tag === "utctime") + return this._encodeTime(data, tag); + else if (tag === "null_") return this._encodeNull(); + else if (tag === "int" || tag === "enum") + return this._encodeInt( + data, + state.args && state.reverseArgs[0] + ); + else if (tag === "bool") return this._encodeBool(data); + else if (tag === "objDesc") return this._encodeStr(data, tag); + throw new Error("Unsupported tag: " + tag); + }; + + Node.prototype._isNumstr = function isNumstr(str) { + return /^[0-9 ]*$/.test(str); + }; + + Node.prototype._isPrintstr = function isPrintstr(str) { + return /^[A-Za-z0-9 '\(\)\+,\-\.\/:=\?]*$/.test(str); + }; + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/base/reporter.js": + /* !********************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/base/reporter.js ***! + \********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + function Reporter(options) { + this._reporterState = { + obj: null, + path: [], + options: options || {}, + errors: [], + }; + } + + exports.Reporter = Reporter; + + Reporter.prototype.isError = function isError(obj) { + return obj instanceof ReporterError; + }; + + Reporter.prototype.save = function save() { + var state = this._reporterState; + return { + obj: state.obj, + pathLen: state.path.length, + }; + }; + + Reporter.prototype.restore = function restore(data) { + var state = this._reporterState; + state.obj = data.obj; + state.path = state.path.slice(0, data.pathLen); + }; + + Reporter.prototype.enterKey = function enterKey(key) { + return this._reporterState.path.push(key); + }; + + Reporter.prototype.exitKey = function exitKey(index) { + var state = this._reporterState; + state.path = state.path.slice(0, index - 1); + }; + + Reporter.prototype.leaveKey = function leaveKey(index, key, value) { + var state = this._reporterState; + this.exitKey(index); + if (state.obj !== null) state.obj[key] = value; + }; + + Reporter.prototype.path = function path() { + return this._reporterState.path.join("/"); + }; + + Reporter.prototype.enterObject = function enterObject() { + var state = this._reporterState; + var prev = state.obj; + state.obj = {}; + return prev; + }; + + Reporter.prototype.leaveObject = function leaveObject(prev) { + var state = this._reporterState; + var now = state.obj; + state.obj = prev; + return now; + }; + + Reporter.prototype.error = function error(msg) { + var err; + var state = this._reporterState; + var inherited = msg instanceof ReporterError; + + if (inherited) { + err = msg; + } else { + err = new ReporterError( + state.path + .map(function (elem) { + return "[" + JSON.stringify(elem) + "]"; + }) + .join(""), + msg.message || msg, + msg.stack + ); + } + + if (!state.options.partial) throw err; + if (!inherited) state.errors.push(err); + return err; + }; + + Reporter.prototype.wrapResult = function wrapResult(result) { + var state = this._reporterState; + if (!state.options.partial) return result; + return { + result: this.isError(result) ? null : result, + errors: state.errors, + }; + }; + + function ReporterError(path, msg) { + this.path = path; + this.rethrow(msg); + } + + inherits(ReporterError, Error); + + ReporterError.prototype.rethrow = function rethrow(msg) { + this.message = msg + " at: " + (this.path || "(shallow)"); + if (Error.captureStackTrace) + Error.captureStackTrace(this, ReporterError); + + if (!this.stack) { + try { + // IE only adds stack when thrown + throw new Error(this.message); + } catch (e) { + this.stack = e.stack; + } + } + + return this; + }; + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/constants/der.js": + /* !********************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/constants/der.js ***! + \********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var constants = __webpack_require__( + /* ! ../constants */ "./node_modules/asn1.js/lib/asn1/constants/index.js" + ); + + exports.tagClass = { + 0: "universal", + 1: "application", + 2: "context", + 3: "private", + }; + exports.tagClassByName = constants._reverse(exports.tagClass); + exports.tag = { + 0x00: "end", + 0x01: "bool", + 0x02: "int", + 0x03: "bitstr", + 0x04: "octstr", + 0x05: "null_", + 0x06: "objid", + 0x07: "objDesc", + 0x08: "external", + 0x09: "real", + 0x0a: "enum", + 0x0b: "embed", + 0x0c: "utf8str", + 0x0d: "relativeOid", + 0x10: "seq", + 0x11: "set", + 0x12: "numstr", + 0x13: "printstr", + 0x14: "t61str", + 0x15: "videostr", + 0x16: "ia5str", + 0x17: "utctime", + 0x18: "gentime", + 0x19: "graphstr", + 0x1a: "iso646str", + 0x1b: "genstr", + 0x1c: "unistr", + 0x1d: "charstr", + 0x1e: "bmpstr", + }; + exports.tagByName = constants._reverse(exports.tag); + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/constants/index.js": + /* !**********************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/constants/index.js ***! + \**********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var constants = exports; // Helper + + constants._reverse = function reverse(map) { + var res = {}; + Object.keys(map).forEach(function (key) { + // Convert key to integer if it is stringified + if ((key | 0) == key) key |= 0; + var value = map[key]; + res[value] = key; + }); + return res; + }; + + constants.der = __webpack_require__( + /* ! ./der */ "./node_modules/asn1.js/lib/asn1/constants/der.js" + ); + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/decoders/der.js": + /* !*******************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/decoders/der.js ***! + \*******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var asn1 = __webpack_require__( + /* ! ../../asn1 */ "./node_modules/asn1.js/lib/asn1.js" + ); + + var base = asn1.base; + var bignum = asn1.bignum; // Import DER constants + + var der = asn1.constants.der; + + function DERDecoder(entity) { + this.enc = "der"; + this.name = entity.name; + this.entity = entity; // Construct base tree + + this.tree = new DERNode(); + + this.tree._init(entity.body); + } + + module.exports = DERDecoder; + + DERDecoder.prototype.decode = function decode(data, options) { + if (!(data instanceof base.DecoderBuffer)) + data = new base.DecoderBuffer(data, options); + return this.tree._decode(data, options); + }; // Tree methods + + function DERNode(parent) { + base.Node.call(this, "der", parent); + } + + inherits(DERNode, base.Node); + + DERNode.prototype._peekTag = function peekTag(buffer, tag, any) { + if (buffer.isEmpty()) return false; + var state = buffer.save(); + var decodedTag = derDecodeTag( + buffer, + 'Failed to peek tag: "' + tag + '"' + ); + if (buffer.isError(decodedTag)) return decodedTag; + buffer.restore(state); + return ( + decodedTag.tag === tag || + decodedTag.tagStr === tag || + decodedTag.tagStr + "of" === tag || + any + ); + }; + + DERNode.prototype._decodeTag = function decodeTag( + buffer, + tag, + any + ) { + var decodedTag = derDecodeTag( + buffer, + 'Failed to decode tag of "' + tag + '"' + ); + if (buffer.isError(decodedTag)) return decodedTag; + var len = derDecodeLen( + buffer, + decodedTag.primitive, + 'Failed to get length of "' + tag + '"' + ); // Failure + + if (buffer.isError(len)) return len; + + if ( + !any && + decodedTag.tag !== tag && + decodedTag.tagStr !== tag && + decodedTag.tagStr + "of" !== tag + ) { + return buffer.error('Failed to match tag: "' + tag + '"'); + } + + if (decodedTag.primitive || len !== null) + return buffer.skip( + len, + 'Failed to match body of: "' + tag + '"' + ); // Indefinite length... find END tag + + var state = buffer.save(); + + var res = this._skipUntilEnd( + buffer, + 'Failed to skip indefinite length body: "' + this.tag + '"' + ); + + if (buffer.isError(res)) return res; + len = buffer.offset - state.offset; + buffer.restore(state); + return buffer.skip( + len, + 'Failed to match body of: "' + tag + '"' + ); + }; + + DERNode.prototype._skipUntilEnd = function skipUntilEnd( + buffer, + fail + ) { + while (true) { + var tag = derDecodeTag(buffer, fail); + if (buffer.isError(tag)) return tag; + var len = derDecodeLen(buffer, tag.primitive, fail); + if (buffer.isError(len)) return len; + var res; + if (tag.primitive || len !== null) res = buffer.skip(len); + else res = this._skipUntilEnd(buffer, fail); // Failure + + if (buffer.isError(res)) return res; + if (tag.tagStr === "end") break; + } + }; + + DERNode.prototype._decodeList = function decodeList( + buffer, + tag, + decoder, + options + ) { + var result = []; + + while (!buffer.isEmpty()) { + var possibleEnd = this._peekTag(buffer, "end"); + + if (buffer.isError(possibleEnd)) return possibleEnd; + var res = decoder.decode(buffer, "der", options); + if (buffer.isError(res) && possibleEnd) break; + result.push(res); + } + + return result; + }; + + DERNode.prototype._decodeStr = function decodeStr(buffer, tag) { + if (tag === "bitstr") { + var unused = buffer.readUInt8(); + if (buffer.isError(unused)) return unused; + return { + unused: unused, + data: buffer.raw(), + }; + } else if (tag === "bmpstr") { + var raw = buffer.raw(); + if (raw.length % 2 === 1) + return buffer.error( + "Decoding of string type: bmpstr length mismatch" + ); + var str = ""; + + for (var i = 0; i < raw.length / 2; i++) { + str += String.fromCharCode(raw.readUInt16BE(i * 2)); + } + + return str; + } else if (tag === "numstr") { + var numstr = buffer.raw().toString("ascii"); + + if (!this._isNumstr(numstr)) { + return buffer.error( + "Decoding of string type: " + + "numstr unsupported characters" + ); + } + + return numstr; + } else if (tag === "octstr") { + return buffer.raw(); + } else if (tag === "objDesc") { + return buffer.raw(); + } else if (tag === "printstr") { + var printstr = buffer.raw().toString("ascii"); + + if (!this._isPrintstr(printstr)) { + return buffer.error( + "Decoding of string type: " + + "printstr unsupported characters" + ); + } + + return printstr; + } else if (/str$/.test(tag)) { + return buffer.raw().toString(); + } + return buffer.error( + "Decoding of string type: " + tag + " unsupported" + ); + + }; + + DERNode.prototype._decodeObjid = function decodeObjid( + buffer, + values, + relative + ) { + var result; + var identifiers = []; + var ident = 0; + + while (!buffer.isEmpty()) { + var subident = buffer.readUInt8(); + ident <<= 7; + ident |= subident & 0x7f; + + if ((subident & 0x80) === 0) { + identifiers.push(ident); + ident = 0; + } + } + + if (subident & 0x80) identifiers.push(ident); + var first = (identifiers[0] / 40) | 0; + var second = identifiers[0] % 40; + if (relative) result = identifiers; + else result = [first, second].concat(identifiers.slice(1)); + + if (values) { + var tmp = values[result.join(" ")]; + if (tmp === undefined) tmp = values[result.join(".")]; + if (tmp !== undefined) result = tmp; + } + + return result; + }; + + DERNode.prototype._decodeTime = function decodeTime(buffer, tag) { + var str = buffer.raw().toString(); + + if (tag === "gentime") { + var year = str.slice(0, 4) | 0; + var mon = str.slice(4, 6) | 0; + var day = str.slice(6, 8) | 0; + var hour = str.slice(8, 10) | 0; + var min = str.slice(10, 12) | 0; + var sec = str.slice(12, 14) | 0; + } else if (tag === "utctime") { + var year = str.slice(0, 2) | 0; + var mon = str.slice(2, 4) | 0; + var day = str.slice(4, 6) | 0; + var hour = str.slice(6, 8) | 0; + var min = str.slice(8, 10) | 0; + var sec = str.slice(10, 12) | 0; + if (year < 70) year = 2000 + year; + else year = 1900 + year; + } else { + return buffer.error( + "Decoding " + tag + " time is not supported yet" + ); + } + + return Date.UTC(year, mon - 1, day, hour, min, sec, 0); + }; + + DERNode.prototype._decodeNull = function decodeNull(buffer) { + return null; + }; + + DERNode.prototype._decodeBool = function decodeBool(buffer) { + var res = buffer.readUInt8(); + if (buffer.isError(res)) return res; + return res !== 0; + }; + + DERNode.prototype._decodeInt = function decodeInt(buffer, values) { + // Bigint, return as it is (assume big endian) + var raw = buffer.raw(); + var res = new bignum(raw); + if (values) res = values[res.toString(10)] || res; + return res; + }; + + DERNode.prototype._use = function use(entity, obj) { + if (typeof entity === "function") entity = entity(obj); + return entity._getDecoder("der").tree; + }; // Utility methods + + function derDecodeTag(buf, fail) { + var tag = buf.readUInt8(fail); + if (buf.isError(tag)) return tag; + var cls = der.tagClass[tag >> 6]; + var primitive = (tag & 0x20) === 0; // Multi-octet tag - load + + if ((tag & 0x1f) === 0x1f) { + var oct = tag; + tag = 0; + + while ((oct & 0x80) === 0x80) { + oct = buf.readUInt8(fail); + if (buf.isError(oct)) return oct; + tag <<= 7; + tag |= oct & 0x7f; + } + } else { + tag &= 0x1f; + } + + var tagStr = der.tag[tag]; + return { + cls: cls, + primitive: primitive, + tag: tag, + tagStr: tagStr, + }; + } + + function derDecodeLen(buf, primitive, fail) { + var len = buf.readUInt8(fail); + if (buf.isError(len)) return len; // Indefinite form + + if (!primitive && len === 0x80) return null; // Definite form + + if ((len & 0x80) === 0) { + // Short form + return len; + } // Long form + + var num = len & 0x7f; + if (num > 4) return buf.error("length octect is too long"); + len = 0; + + for (var i = 0; i < num; i++) { + len <<= 8; + var j = buf.readUInt8(fail); + if (buf.isError(j)) return j; + len |= j; + } + + return len; + } + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/decoders/index.js": + /* !*********************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/decoders/index.js ***! + \*********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var decoders = exports; + decoders.der = __webpack_require__( + /* ! ./der */ "./node_modules/asn1.js/lib/asn1/decoders/der.js" + ); + decoders.pem = __webpack_require__( + /* ! ./pem */ "./node_modules/asn1.js/lib/asn1/decoders/pem.js" + ); + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/decoders/pem.js": + /* !*******************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/decoders/pem.js ***! + \*******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Buffer = __webpack_require__( + /* ! buffer */ "./node_modules/buffer/index.js" + ).Buffer; + + var DERDecoder = __webpack_require__( + /* ! ./der */ "./node_modules/asn1.js/lib/asn1/decoders/der.js" + ); + + function PEMDecoder(entity) { + DERDecoder.call(this, entity); + this.enc = "pem"; + } + + inherits(PEMDecoder, DERDecoder); + module.exports = PEMDecoder; + + PEMDecoder.prototype.decode = function decode(data, options) { + var lines = data.toString().split(/[\r\n]+/g); + var label = options.label.toUpperCase(); + var re = /^-----(BEGIN|END) ([^-]+)-----$/; + var start = -1; + var end = -1; + + for (var i = 0; i < lines.length; i++) { + var match = lines[i].match(re); + if (match === null) continue; + if (match[2] !== label) continue; + + if (start === -1) { + if (match[1] !== "BEGIN") break; + start = i; + } else { + if (match[1] !== "END") break; + end = i; + break; + } + } + + if (start === -1 || end === -1) + throw new Error("PEM section not found for: " + label); + var base64 = lines.slice(start + 1, end).join(""); // Remove excessive symbols + + base64.replace(/[^a-z0-9\+\/=]+/gi, ""); + var input = new Buffer(base64, "base64"); + return DERDecoder.prototype.decode.call(this, input, options); + }; + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/encoders/der.js": + /* !*******************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/encoders/der.js ***! + \*******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Buffer = __webpack_require__( + /* ! buffer */ "./node_modules/buffer/index.js" + ).Buffer; + + var asn1 = __webpack_require__( + /* ! ../../asn1 */ "./node_modules/asn1.js/lib/asn1.js" + ); + + var base = asn1.base; // Import DER constants + + var der = asn1.constants.der; + + function DEREncoder(entity) { + this.enc = "der"; + this.name = entity.name; + this.entity = entity; // Construct base tree + + this.tree = new DERNode(); + + this.tree._init(entity.body); + } + + module.exports = DEREncoder; + + DEREncoder.prototype.encode = function encode(data, reporter) { + return this.tree._encode(data, reporter).join(); + }; // Tree methods + + function DERNode(parent) { + base.Node.call(this, "der", parent); + } + + inherits(DERNode, base.Node); + + DERNode.prototype._encodeComposite = function encodeComposite( + tag, + primitive, + cls, + content + ) { + var encodedTag = encodeTag(tag, primitive, cls, this.reporter); // Short form + + if (content.length < 0x80) { + var header = new Buffer(2); + header[0] = encodedTag; + header[1] = content.length; + return this._createEncoderBuffer([header, content]); + } // Long form + // Count octets required to store length + + var lenOctets = 1; + + for (var i = content.length; i >= 0x100; i >>= 8) { + lenOctets++; + } + + var header = new Buffer(1 + 1 + lenOctets); + header[0] = encodedTag; + header[1] = 0x80 | lenOctets; + + for ( + var i = 1 + lenOctets, j = content.length; + j > 0; + i--, j >>= 8 + ) { + header[i] = j & 0xff; + } + + return this._createEncoderBuffer([header, content]); + }; + + DERNode.prototype._encodeStr = function encodeStr(str, tag) { + if (tag === "bitstr") { + return this._createEncoderBuffer([ + str.unused | 0, + str.data, + ]); + } else if (tag === "bmpstr") { + var buf = new Buffer(str.length * 2); + + for (var i = 0; i < str.length; i++) { + buf.writeUInt16BE(str.charCodeAt(i), i * 2); + } + + return this._createEncoderBuffer(buf); + } else if (tag === "numstr") { + if (!this._isNumstr(str)) { + return this.reporter.error( + "Encoding of string type: numstr supports " + + "only digits and space" + ); + } + + return this._createEncoderBuffer(str); + } else if (tag === "printstr") { + if (!this._isPrintstr(str)) { + return this.reporter.error( + "Encoding of string type: printstr supports " + + "only latin upper and lower case letters, " + + "digits, space, apostrophe, left and rigth " + + "parenthesis, plus sign, comma, hyphen, " + + "dot, slash, colon, equal sign, " + + "question mark" + ); + } + + return this._createEncoderBuffer(str); + } else if (/str$/.test(tag)) { + return this._createEncoderBuffer(str); + } else if (tag === "objDesc") { + return this._createEncoderBuffer(str); + } + return this.reporter.error( + "Encoding of string type: " + tag + " unsupported" + ); + + }; + + DERNode.prototype._encodeObjid = function encodeObjid( + id, + values, + relative + ) { + if (typeof id === "string") { + if (!values) + return this.reporter.error( + "string objid given, but no values map found" + ); + if (!values.hasOwnProperty(id)) + return this.reporter.error( + "objid not found in values map" + ); + id = values[id].split(/[\s\.]+/g); + + for (var i = 0; i < id.length; i++) { + id[i] |= 0; + } + } else if (Array.isArray(id)) { + id = id.slice(); + + for (var i = 0; i < id.length; i++) { + id[i] |= 0; + } + } + + if (!Array.isArray(id)) { + return this.reporter.error( + "objid() should be either array or string, " + + "got: " + + JSON.stringify(id) + ); + } + + if (!relative) { + if (id[1] >= 40) + return this.reporter.error( + "Second objid identifier OOB" + ); + id.splice(0, 2, id[0] * 40 + id[1]); + } // Count number of octets + + var size = 0; + + for (var i = 0; i < id.length; i++) { + var ident = id[i]; + + for (size++; ident >= 0x80; ident >>= 7) { + size++; + } + } + + var objid = new Buffer(size); + var offset = objid.length - 1; + + for (var i = id.length - 1; i >= 0; i--) { + var ident = id[i]; + objid[offset--] = ident & 0x7f; + + while ((ident >>= 7) > 0) { + objid[offset--] = 0x80 | (ident & 0x7f); + } + } + + return this._createEncoderBuffer(objid); + }; + + function two(num) { + if (num < 10) return "0" + num; + return num; + } + + DERNode.prototype._encodeTime = function encodeTime(time, tag) { + var str; + var date = new Date(time); + + if (tag === "gentime") { + str = [ + two(date.getFullYear()), + two(date.getUTCMonth() + 1), + two(date.getUTCDate()), + two(date.getUTCHours()), + two(date.getUTCMinutes()), + two(date.getUTCSeconds()), + "Z", + ].join(""); + } else if (tag === "utctime") { + str = [ + two(date.getFullYear() % 100), + two(date.getUTCMonth() + 1), + two(date.getUTCDate()), + two(date.getUTCHours()), + two(date.getUTCMinutes()), + two(date.getUTCSeconds()), + "Z", + ].join(""); + } else { + this.reporter.error( + "Encoding " + tag + " time is not supported yet" + ); + } + + return this._encodeStr(str, "octstr"); + }; + + DERNode.prototype._encodeNull = function encodeNull() { + return this._createEncoderBuffer(""); + }; + + DERNode.prototype._encodeInt = function encodeInt(num, values) { + if (typeof num === "string") { + if (!values) + return this.reporter.error( + "String int or enum given, but no values map" + ); + + if (!values.hasOwnProperty(num)) { + return this.reporter.error( + "Values map doesn't contain: " + JSON.stringify(num) + ); + } + + num = values[num]; + } // Bignum, assume big endian + + if (typeof num !== "number" && !Buffer.isBuffer(num)) { + var numArray = num.toArray(); + + if (!num.sign && numArray[0] & 0x80) { + numArray.unshift(0); + } + + num = new Buffer(numArray); + } + + if (Buffer.isBuffer(num)) { + var size = num.length; + if (num.length === 0) size++; + var out = new Buffer(size); + num.copy(out); + if (num.length === 0) out[0] = 0; + return this._createEncoderBuffer(out); + } + + if (num < 0x80) return this._createEncoderBuffer(num); + if (num < 0x100) return this._createEncoderBuffer([0, num]); + var size = 1; + + for (var i = num; i >= 0x100; i >>= 8) { + size++; + } + + var out = new Array(size); + + for (var i = out.length - 1; i >= 0; i--) { + out[i] = num & 0xff; + num >>= 8; + } + + if (out[0] & 0x80) { + out.unshift(0); + } + + return this._createEncoderBuffer(new Buffer(out)); + }; + + DERNode.prototype._encodeBool = function encodeBool(value) { + return this._createEncoderBuffer(value ? 0xff : 0); + }; + + DERNode.prototype._use = function use(entity, obj) { + if (typeof entity === "function") entity = entity(obj); + return entity._getEncoder("der").tree; + }; + + DERNode.prototype._skipDefault = function skipDefault( + dataBuffer, + reporter, + parent + ) { + var state = this._baseState; + var i; + if (state.default === null) return false; + var data = dataBuffer.join(); + if (state.defaultBuffer === undefined) + state.defaultBuffer = this._encodeValue( + state.default, + reporter, + parent + ).join(); + if (data.length !== state.defaultBuffer.length) return false; + + for (i = 0; i < data.length; i++) { + if (data[i] !== state.defaultBuffer[i]) return false; + } + + return true; + }; // Utility methods + + function encodeTag(tag, primitive, cls, reporter) { + var res; + if (tag === "seqof") tag = "seq"; + else if (tag === "setof") tag = "set"; + if (der.tagByName.hasOwnProperty(tag)) res = der.tagByName[tag]; + else if (typeof tag === "number" && (tag | 0) === tag) + res = tag; + else return reporter.error("Unknown tag: " + tag); + if (res >= 0x1f) + return reporter.error( + "Multi-octet tag encoding unsupported" + ); + if (!primitive) res |= 0x20; + res |= der.tagClassByName[cls || "universal"] << 6; + return res; + } + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/encoders/index.js": + /* !*********************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/encoders/index.js ***! + \*********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var encoders = exports; + encoders.der = __webpack_require__( + /* ! ./der */ "./node_modules/asn1.js/lib/asn1/encoders/der.js" + ); + encoders.pem = __webpack_require__( + /* ! ./pem */ "./node_modules/asn1.js/lib/asn1/encoders/pem.js" + ); + + /***/ + }, + + /***/ "./node_modules/asn1.js/lib/asn1/encoders/pem.js": + /* !*******************************************************!*\ + !*** ./node_modules/asn1.js/lib/asn1/encoders/pem.js ***! + \*******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var DEREncoder = __webpack_require__( + /* ! ./der */ "./node_modules/asn1.js/lib/asn1/encoders/der.js" + ); + + function PEMEncoder(entity) { + DEREncoder.call(this, entity); + this.enc = "pem"; + } + + inherits(PEMEncoder, DEREncoder); + module.exports = PEMEncoder; + + PEMEncoder.prototype.encode = function encode(data, options) { + var buf = DEREncoder.prototype.encode.call(this, data); + var p = buf.toString("base64"); + var out = ["-----BEGIN " + options.label + "-----"]; + + for (var i = 0; i < p.length; i += 64) { + out.push(p.slice(i, i + 64)); + } + + out.push("-----END " + options.label + "-----"); + return out.join("\n"); + }; + + /***/ + }, + + /***/ "./node_modules/base64-js/index.js": + /* !*****************************************!*\ + !*** ./node_modules/base64-js/index.js ***! + \*****************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + exports.byteLength = byteLength; + exports.toByteArray = toByteArray; + exports.fromByteArray = fromByteArray; + var lookup = []; + var revLookup = []; + var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array; + var code = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i]; + revLookup[code.charCodeAt(i)] = i; + } // Support decoding URL-safe base64 strings, as Node.js does. + // See: https://en.wikipedia.org/wiki/Base64#URL_applications + + revLookup["-".charCodeAt(0)] = 62; + revLookup["_".charCodeAt(0)] = 63; + + function getLens(b64) { + var len = b64.length; + + if (len % 4 > 0) { + throw new Error( + "Invalid string. Length must be a multiple of 4" + ); + } // Trim off extra bytes after placeholder bytes are found + // See: https://github.com/beatgammit/base64-js/issues/42 + + var validLen = b64.indexOf("="); + if (validLen === -1) validLen = len; + var placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4); + return [validLen, placeHoldersLen]; + } // Base64 is 4/3 + up to two characters of the original data + + function byteLength(b64) { + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen; + } + + function _byteLength(b64, validLen, placeHoldersLen) { + return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen; + } + + function toByteArray(b64) { + var tmp; + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)); + var curByte = 0; // If there are placeholders, only get up to the last complete 4 chars + + var len = placeHoldersLen > 0 ? validLen - 4 : validLen; + var i; + + for (i = 0; i < len; i += 4) { + tmp = + (revLookup[b64.charCodeAt(i)] << 18) | + (revLookup[b64.charCodeAt(i + 1)] << 12) | + (revLookup[b64.charCodeAt(i + 2)] << 6) | + revLookup[b64.charCodeAt(i + 3)]; + arr[curByte++] = (tmp >> 16) & 0xff; + arr[curByte++] = (tmp >> 8) & 0xff; + arr[curByte++] = tmp & 0xff; + } + + if (placeHoldersLen === 2) { + tmp = + (revLookup[b64.charCodeAt(i)] << 2) | + (revLookup[b64.charCodeAt(i + 1)] >> 4); + arr[curByte++] = tmp & 0xff; + } + + if (placeHoldersLen === 1) { + tmp = + (revLookup[b64.charCodeAt(i)] << 10) | + (revLookup[b64.charCodeAt(i + 1)] << 4) | + (revLookup[b64.charCodeAt(i + 2)] >> 2); + arr[curByte++] = (tmp >> 8) & 0xff; + arr[curByte++] = tmp & 0xff; + } + + return arr; + } + + function tripletToBase64(num) { + return ( + lookup[(num >> 18) & 0x3f] + + lookup[(num >> 12) & 0x3f] + + lookup[(num >> 6) & 0x3f] + + lookup[num & 0x3f] + ); + } + + function encodeChunk(uint8, start, end) { + var tmp; + var output = []; + + for (var i = start; i < end; i += 3) { + tmp = + ((uint8[i] << 16) & 0xff0000) + + ((uint8[i + 1] << 8) & 0xff00) + + (uint8[i + 2] & 0xff); + output.push(tripletToBase64(tmp)); + } + + return output.join(""); + } + + function fromByteArray(uint8) { + var tmp; + var len = uint8.length; + var extraBytes = len % 3; // If we have 1 byte left, pad 2 bytes + + var parts = []; + var maxChunkLength = 16383; // Must be multiple of 3 + // go through the array every three bytes, we'll deal with trailing stuff later + + for ( + var i = 0, len2 = len - extraBytes; + i < len2; + i += maxChunkLength + ) { + parts.push( + encodeChunk( + uint8, + i, + i + maxChunkLength > len2 + ? len2 + : i + maxChunkLength + ) + ); + } // Pad the end with zeros, but make sure to not forget the extra bytes + + if (extraBytes === 1) { + tmp = uint8[len - 1]; + parts.push( + lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f] + "==" + ); + } else if (extraBytes === 2) { + tmp = (uint8[len - 2] << 8) + uint8[len - 1]; + parts.push( + lookup[tmp >> 10] + + lookup[(tmp >> 4) & 0x3f] + + lookup[(tmp << 2) & 0x3f] + + "=" + ); + } + + return parts.join(""); + } + + /***/ + }, + + /***/ "./node_modules/bn.js/lib/bn.js": + /* !**************************************!*\ + !*** ./node_modules/bn.js/lib/bn.js ***! + \**************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (module) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + (function (module, exports) { + "use strict"; // Utils + + function assert(val, msg) { + if (!val) throw new Error(msg || "Assertion failed"); + } // Could use `inherits` module, but don't want to move from single file + // architecture yet. + + function inherits(ctor, superCtor) { + ctor.super_ = superCtor; + + var TempCtor = function TempCtor() {}; + + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } // BN + + function BN(number, base, endian) { + if (BN.isBN(number)) { + return number; + } + + this.negative = 0; + this.words = null; + this.length = 0; // Reduction context + + this.red = null; + + if (number !== null) { + if (base === "le" || base === "be") { + endian = base; + base = 10; + } + + this._init(number || 0, base || 10, endian || "be"); + } + } + + if (_typeof(module) === "object") { + module.exports = BN; + } else { + exports.BN = BN; + } + + BN.BN = BN; + BN.wordSize = 26; + var Buffer; + + try { + Buffer = __webpack_require__(/* ! buffer */ 2).Buffer; + } catch (e) {} + + BN.isBN = function isBN(num) { + if (num instanceof BN) { + return true; + } + + return ( + num !== null && + _typeof(num) === "object" && + num.constructor.wordSize === BN.wordSize && + Array.isArray(num.words) + ); + }; + + BN.max = function max(left, right) { + if (left.cmp(right) > 0) return left; + return right; + }; + + BN.min = function min(left, right) { + if (left.cmp(right) < 0) return left; + return right; + }; + + BN.prototype._init = function init(number, base, endian) { + if (typeof number === "number") { + return this._initNumber(number, base, endian); + } + + if (_typeof(number) === "object") { + return this._initArray(number, base, endian); + } + + if (base === "hex") { + base = 16; + } + + assert(base === (base | 0) && base >= 2 && base <= 36); + number = number.toString().replace(/\s+/g, ""); + var start = 0; + + if (number[0] === "-") { + start++; + } + + if (base === 16) { + this._parseHex(number, start); + } else { + this._parseBase(number, base, start); + } + + if (number[0] === "-") { + this.negative = 1; + } + + this.strip(); + if (endian !== "le") return; + + this._initArray(this.toArray(), base, endian); + }; + + BN.prototype._initNumber = function _initNumber( + number, + base, + endian + ) { + if (number < 0) { + this.negative = 1; + number = -number; + } + + if (number < 0x4000000) { + this.words = [number & 0x3ffffff]; + this.length = 1; + } else if (number < 0x10000000000000) { + this.words = [ + number & 0x3ffffff, + (number / 0x4000000) & 0x3ffffff, + ]; + this.length = 2; + } else { + assert(number < 0x20000000000000); // 2 ^ 53 (unsafe) + + this.words = [ + number & 0x3ffffff, + (number / 0x4000000) & 0x3ffffff, + 1, + ]; + this.length = 3; + } + + if (endian !== "le") return; // Reverse the bytes + + this._initArray(this.toArray(), base, endian); + }; + + BN.prototype._initArray = function _initArray( + number, + base, + endian + ) { + // Perhaps a Uint8Array + assert(typeof number.length === "number"); + + if (number.length <= 0) { + this.words = [0]; + this.length = 1; + return this; + } + + this.length = Math.ceil(number.length / 3); + this.words = new Array(this.length); + + for (var i = 0; i < this.length; i++) { + this.words[i] = 0; + } + + var j, w; + var off = 0; + + if (endian === "be") { + for (i = number.length - 1, j = 0; i >= 0; i -= 3) { + w = + number[i] | + (number[i - 1] << 8) | + (number[i - 2] << 16); + this.words[j] |= (w << off) & 0x3ffffff; + this.words[j + 1] = + (w >>> (26 - off)) & 0x3ffffff; + off += 24; + + if (off >= 26) { + off -= 26; + j++; + } + } + } else if (endian === "le") { + for (i = 0, j = 0; i < number.length; i += 3) { + w = + number[i] | + (number[i + 1] << 8) | + (number[i + 2] << 16); + this.words[j] |= (w << off) & 0x3ffffff; + this.words[j + 1] = + (w >>> (26 - off)) & 0x3ffffff; + off += 24; + + if (off >= 26) { + off -= 26; + j++; + } + } + } + + return this.strip(); + }; + + function parseHex(str, start, end) { + var r = 0; + var len = Math.min(str.length, end); + + for (var i = start; i < len; i++) { + var c = str.charCodeAt(i) - 48; + r <<= 4; // 'a' - 'f' + + if (c >= 49 && c <= 54) { + r |= c - 49 + 0xa; // 'A' - 'F' + } else if (c >= 17 && c <= 22) { + r |= c - 17 + 0xa; // '0' - '9' + } else { + r |= c & 0xf; + } + } + + return r; + } + + BN.prototype._parseHex = function _parseHex(number, start) { + // Create possibly bigger array to ensure that it fits the number + this.length = Math.ceil((number.length - start) / 6); + this.words = new Array(this.length); + + for (var i = 0; i < this.length; i++) { + this.words[i] = 0; + } + + var j, w; // Scan 24-bit chunks and add them to the number + + var off = 0; + + for (i = number.length - 6, j = 0; i >= start; i -= 6) { + w = parseHex(number, i, i + 6); + this.words[j] |= (w << off) & 0x3ffffff; // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb + + this.words[j + 1] |= (w >>> (26 - off)) & 0x3fffff; + off += 24; + + if (off >= 26) { + off -= 26; + j++; + } + } + + if (i + 6 !== start) { + w = parseHex(number, start, i + 6); + this.words[j] |= (w << off) & 0x3ffffff; + this.words[j + 1] |= (w >>> (26 - off)) & 0x3fffff; + } + + this.strip(); + }; + + function parseBase(str, start, end, mul) { + var r = 0; + var len = Math.min(str.length, end); + + for (var i = start; i < len; i++) { + var c = str.charCodeAt(i) - 48; + r *= mul; // 'a' + + if (c >= 49) { + r += c - 49 + 0xa; // 'A' + } else if (c >= 17) { + r += c - 17 + 0xa; // '0' - '9' + } else { + r += c; + } + } + + return r; + } + + BN.prototype._parseBase = function _parseBase( + number, + base, + start + ) { + // Initialize as zero + this.words = [0]; + this.length = 1; // Find length of limb in base + + for ( + var limbLen = 0, limbPow = 1; + limbPow <= 0x3ffffff; + limbPow *= base + ) { + limbLen++; + } + + limbLen--; + limbPow = (limbPow / base) | 0; + var total = number.length - start; + var mod = total % limbLen; + var end = Math.min(total, total - mod) + start; + var word = 0; + + for (var i = start; i < end; i += limbLen) { + word = parseBase(number, i, i + limbLen, base); + this.imuln(limbPow); + + if (this.words[0] + word < 0x4000000) { + this.words[0] += word; + } else { + this._iaddn(word); + } + } + + if (mod !== 0) { + var pow = 1; + word = parseBase(number, i, number.length, base); + + for (i = 0; i < mod; i++) { + pow *= base; + } + + this.imuln(pow); + + if (this.words[0] + word < 0x4000000) { + this.words[0] += word; + } else { + this._iaddn(word); + } + } + }; + + BN.prototype.copy = function copy(dest) { + dest.words = new Array(this.length); + + for (var i = 0; i < this.length; i++) { + dest.words[i] = this.words[i]; + } + + dest.length = this.length; + dest.negative = this.negative; + dest.red = this.red; + }; + + BN.prototype.clone = function clone() { + var r = new BN(null); + this.copy(r); + return r; + }; + + BN.prototype._expand = function _expand(size) { + while (this.length < size) { + this.words[this.length++] = 0; + } + + return this; + }; // Remove leading `0` from `this` + + BN.prototype.strip = function strip() { + while ( + this.length > 1 && + this.words[this.length - 1] === 0 + ) { + this.length--; + } + + return this._normSign(); + }; + + BN.prototype._normSign = function _normSign() { + // -0 = 0 + if (this.length === 1 && this.words[0] === 0) { + this.negative = 0; + } + + return this; + }; + + BN.prototype.inspect = function inspect() { + return ( + (this.red ? "" + ); + }; + /* + Var zeros = []; + var groupSizes = []; + var groupBases = []; + var s = ''; + var i = -1; + while (++i < BN.wordSize) { + zeros[i] = s; + s += '0'; + } + groupSizes[0] = 0; + groupSizes[1] = 0; + groupBases[0] = 0; + groupBases[1] = 0; + var base = 2 - 1; + while (++base < 36 + 1) { + var groupSize = 0; + var groupBase = 1; + while (groupBase < (1 << BN.wordSize) / base) { + groupBase *= base; + groupSize += 1; + } + groupSizes[base] = groupSize; + groupBases[base] = groupBase; + } + */ + + var zeros = [ + "", + "0", + "00", + "000", + "0000", + "00000", + "000000", + "0000000", + "00000000", + "000000000", + "0000000000", + "00000000000", + "000000000000", + "0000000000000", + "00000000000000", + "000000000000000", + "0000000000000000", + "00000000000000000", + "000000000000000000", + "0000000000000000000", + "00000000000000000000", + "000000000000000000000", + "0000000000000000000000", + "00000000000000000000000", + "000000000000000000000000", + "0000000000000000000000000", + ]; + var groupSizes = [ + 0, + 0, + 25, + 16, + 12, + 11, + 10, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + ]; + var groupBases = [ + 0, + 0, + 33554432, + 43046721, + 16777216, + 48828125, + 60466176, + 40353607, + 16777216, + 43046721, + 10000000, + 19487171, + 35831808, + 62748517, + 7529536, + 11390625, + 16777216, + 24137569, + 34012224, + 47045881, + 64000000, + 4084101, + 5153632, + 6436343, + 7962624, + 9765625, + 11881376, + 14348907, + 17210368, + 20511149, + 24300000, + 28629151, + 33554432, + 39135393, + 45435424, + 52521875, + 60466176, + ]; + + BN.prototype.toString = function toString(base, padding) { + base = base || 10; + padding = padding | 0 || 1; + var out; + + if (base === 16 || base === "hex") { + out = ""; + var off = 0; + var carry = 0; + + for (var i = 0; i < this.length; i++) { + var w = this.words[i]; + var word = ( + ((w << off) | carry) & + 0xffffff + ).toString(16); + carry = (w >>> (24 - off)) & 0xffffff; + + if (carry !== 0 || i !== this.length - 1) { + out = zeros[6 - word.length] + word + out; + } else { + out = word + out; + } + + off += 2; + + if (off >= 26) { + off -= 26; + i--; + } + } + + if (carry !== 0) { + out = carry.toString(16) + out; + } + + while (out.length % padding !== 0) { + out = "0" + out; + } + + if (this.negative !== 0) { + out = "-" + out; + } + + return out; + } + + if (base === (base | 0) && base >= 2 && base <= 36) { + // Var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base)); + var groupSize = groupSizes[base]; // Var groupBase = Math.pow(base, groupSize); + + var groupBase = groupBases[base]; + out = ""; + var c = this.clone(); + c.negative = 0; + + while (!c.isZero()) { + var r = c.modn(groupBase).toString(base); + c = c.idivn(groupBase); + + if (!c.isZero()) { + out = zeros[groupSize - r.length] + r + out; + } else { + out = r + out; + } + } + + if (this.isZero()) { + out = "0" + out; + } + + while (out.length % padding !== 0) { + out = "0" + out; + } + + if (this.negative !== 0) { + out = "-" + out; + } + + return out; + } + + assert(false, "Base should be between 2 and 36"); + }; + + BN.prototype.toNumber = function toNumber() { + var ret = this.words[0]; + + if (this.length === 2) { + ret += this.words[1] * 0x4000000; + } else if ( + this.length === 3 && + this.words[2] === 0x01 + ) { + // NOTE: at this stage it is known that the top bit is set + ret += 0x10000000000000 + this.words[1] * 0x4000000; + } else if (this.length > 2) { + assert( + false, + "Number can only safely store up to 53 bits" + ); + } + + return this.negative !== 0 ? -ret : ret; + }; + + BN.prototype.toJSON = function toJSON() { + return this.toString(16); + }; + + BN.prototype.toBuffer = function toBuffer(endian, length) { + assert(typeof Buffer !== "undefined"); + return this.toArrayLike(Buffer, endian, length); + }; + + BN.prototype.toArray = function toArray(endian, length) { + return this.toArrayLike(Array, endian, length); + }; + + BN.prototype.toArrayLike = function toArrayLike( + ArrayType, + endian, + length + ) { + var byteLength = this.byteLength(); + var reqLength = length || Math.max(1, byteLength); + assert( + byteLength <= reqLength, + "byte array longer than desired length" + ); + assert(reqLength > 0, "Requested array length <= 0"); + this.strip(); + var littleEndian = endian === "le"; + var res = new ArrayType(reqLength); + var b, i; + var q = this.clone(); + + if (!littleEndian) { + // Assume big-endian + for (i = 0; i < reqLength - byteLength; i++) { + res[i] = 0; + } + + for (i = 0; !q.isZero(); i++) { + b = q.andln(0xff); + q.iushrn(8); + res[reqLength - i - 1] = b; + } + } else { + for (i = 0; !q.isZero(); i++) { + b = q.andln(0xff); + q.iushrn(8); + res[i] = b; + } + + for (; i < reqLength; i++) { + res[i] = 0; + } + } + + return res; + }; + + if (Math.clz32) { + BN.prototype._countBits = function _countBits(w) { + return 32 - Math.clz32(w); + }; + } else { + BN.prototype._countBits = function _countBits(w) { + var t = w; + var r = 0; + + if (t >= 0x1000) { + r += 13; + t >>>= 13; + } + + if (t >= 0x40) { + r += 7; + t >>>= 7; + } + + if (t >= 0x8) { + r += 4; + t >>>= 4; + } + + if (t >= 0x02) { + r += 2; + t >>>= 2; + } + + return r + t; + }; + } + + BN.prototype._zeroBits = function _zeroBits(w) { + // Short-cut + if (w === 0) return 26; + var t = w; + var r = 0; + + if ((t & 0x1fff) === 0) { + r += 13; + t >>>= 13; + } + + if ((t & 0x7f) === 0) { + r += 7; + t >>>= 7; + } + + if ((t & 0xf) === 0) { + r += 4; + t >>>= 4; + } + + if ((t & 0x3) === 0) { + r += 2; + t >>>= 2; + } + + if ((t & 0x1) === 0) { + r++; + } + + return r; + }; // Return number of used bits in a BN + + BN.prototype.bitLength = function bitLength() { + var w = this.words[this.length - 1]; + + var hi = this._countBits(w); + + return (this.length - 1) * 26 + hi; + }; + + function toBitArray(num) { + var w = new Array(num.bitLength()); + + for (var bit = 0; bit < w.length; bit++) { + var off = (bit / 26) | 0; + var wbit = bit % 26; + w[bit] = (num.words[off] & (1 << wbit)) >>> wbit; + } + + return w; + } // Number of trailing zero bits + + BN.prototype.zeroBits = function zeroBits() { + if (this.isZero()) return 0; + var r = 0; + + for (var i = 0; i < this.length; i++) { + var b = this._zeroBits(this.words[i]); + + r += b; + if (b !== 26) break; + } + + return r; + }; + + BN.prototype.byteLength = function byteLength() { + return Math.ceil(this.bitLength() / 8); + }; + + BN.prototype.toTwos = function toTwos(width) { + if (this.negative !== 0) { + return this.abs().inotn(width).iaddn(1); + } + + return this.clone(); + }; + + BN.prototype.fromTwos = function fromTwos(width) { + if (this.testn(width - 1)) { + return this.notn(width).iaddn(1).ineg(); + } + + return this.clone(); + }; + + BN.prototype.isNeg = function isNeg() { + return this.negative !== 0; + }; // Return negative clone of `this` + + BN.prototype.neg = function neg() { + return this.clone().ineg(); + }; + + BN.prototype.ineg = function ineg() { + if (!this.isZero()) { + this.negative ^= 1; + } + + return this; + }; // Or `num` with `this` in-place + + BN.prototype.iuor = function iuor(num) { + while (this.length < num.length) { + this.words[this.length++] = 0; + } + + for (var i = 0; i < num.length; i++) { + this.words[i] = this.words[i] | num.words[i]; + } + + return this.strip(); + }; + + BN.prototype.ior = function ior(num) { + assert((this.negative | num.negative) === 0); + return this.iuor(num); + }; // Or `num` with `this` + + BN.prototype.or = function or(num) { + if (this.length > num.length) + return this.clone().ior(num); + return num.clone().ior(this); + }; + + BN.prototype.uor = function uor(num) { + if (this.length > num.length) + return this.clone().iuor(num); + return num.clone().iuor(this); + }; // And `num` with `this` in-place + + BN.prototype.iuand = function iuand(num) { + // B = min-length(num, this) + var b; + + if (this.length > num.length) { + b = num; + } else { + b = this; + } + + for (var i = 0; i < b.length; i++) { + this.words[i] = this.words[i] & num.words[i]; + } + + this.length = b.length; + return this.strip(); + }; + + BN.prototype.iand = function iand(num) { + assert((this.negative | num.negative) === 0); + return this.iuand(num); + }; // And `num` with `this` + + BN.prototype.and = function and(num) { + if (this.length > num.length) + return this.clone().iand(num); + return num.clone().iand(this); + }; + + BN.prototype.uand = function uand(num) { + if (this.length > num.length) + return this.clone().iuand(num); + return num.clone().iuand(this); + }; // Xor `num` with `this` in-place + + BN.prototype.iuxor = function iuxor(num) { + // A.length > b.length + var a; + var b; + + if (this.length > num.length) { + a = this; + b = num; + } else { + a = num; + b = this; + } + + for (var i = 0; i < b.length; i++) { + this.words[i] = a.words[i] ^ b.words[i]; + } + + if (this !== a) { + for (; i < a.length; i++) { + this.words[i] = a.words[i]; + } + } + + this.length = a.length; + return this.strip(); + }; + + BN.prototype.ixor = function ixor(num) { + assert((this.negative | num.negative) === 0); + return this.iuxor(num); + }; // Xor `num` with `this` + + BN.prototype.xor = function xor(num) { + if (this.length > num.length) + return this.clone().ixor(num); + return num.clone().ixor(this); + }; + + BN.prototype.uxor = function uxor(num) { + if (this.length > num.length) + return this.clone().iuxor(num); + return num.clone().iuxor(this); + }; // Not ``this`` with ``width`` bitwidth + + BN.prototype.inotn = function inotn(width) { + assert(typeof width === "number" && width >= 0); + var bytesNeeded = Math.ceil(width / 26) | 0; + var bitsLeft = width % 26; // Extend the buffer with leading zeroes + + this._expand(bytesNeeded); + + if (bitsLeft > 0) { + bytesNeeded--; + } // Handle complete words + + for (var i = 0; i < bytesNeeded; i++) { + this.words[i] = ~this.words[i] & 0x3ffffff; + } // Handle the residue + + if (bitsLeft > 0) { + this.words[i] = + ~this.words[i] & (0x3ffffff >> (26 - bitsLeft)); + } // And remove leading zeroes + + return this.strip(); + }; + + BN.prototype.notn = function notn(width) { + return this.clone().inotn(width); + }; // Set `bit` of `this` + + BN.prototype.setn = function setn(bit, val) { + assert(typeof bit === "number" && bit >= 0); + var off = (bit / 26) | 0; + var wbit = bit % 26; + + this._expand(off + 1); + + if (val) { + this.words[off] = this.words[off] | (1 << wbit); + } else { + this.words[off] = this.words[off] & ~(1 << wbit); + } + + return this.strip(); + }; // Add `num` to `this` in-place + + BN.prototype.iadd = function iadd(num) { + var r; // Negative + positive + + if (this.negative !== 0 && num.negative === 0) { + this.negative = 0; + r = this.isub(num); + this.negative ^= 1; + return this._normSign(); // Positive + negative + } else if (this.negative === 0 && num.negative !== 0) { + num.negative = 0; + r = this.isub(num); + num.negative = 1; + return r._normSign(); + } // A.length > b.length + + var a, b; + + if (this.length > num.length) { + a = this; + b = num; + } else { + a = num; + b = this; + } + + var carry = 0; + + for (var i = 0; i < b.length; i++) { + r = (a.words[i] | 0) + (b.words[i] | 0) + carry; + this.words[i] = r & 0x3ffffff; + carry = r >>> 26; + } + + for (; carry !== 0 && i < a.length; i++) { + r = (a.words[i] | 0) + carry; + this.words[i] = r & 0x3ffffff; + carry = r >>> 26; + } + + this.length = a.length; + + if (carry !== 0) { + this.words[this.length] = carry; + this.length++; // Copy the rest of the words + } else if (a !== this) { + for (; i < a.length; i++) { + this.words[i] = a.words[i]; + } + } + + return this; + }; // Add `num` to `this` + + BN.prototype.add = function add(num) { + var res; + + if (num.negative !== 0 && this.negative === 0) { + num.negative = 0; + res = this.sub(num); + num.negative ^= 1; + return res; + } else if (num.negative === 0 && this.negative !== 0) { + this.negative = 0; + res = num.sub(this); + this.negative = 1; + return res; + } + + if (this.length > num.length) + return this.clone().iadd(num); + return num.clone().iadd(this); + }; // Subtract `num` from `this` in-place + + BN.prototype.isub = function isub(num) { + // This - (-num) = this + num + if (num.negative !== 0) { + num.negative = 0; + var r = this.iadd(num); + num.negative = 1; + return r._normSign(); // -this - num = -(this + num) + } else if (this.negative !== 0) { + this.negative = 0; + this.iadd(num); + this.negative = 1; + return this._normSign(); + } // At this point both numbers are positive + + var cmp = this.cmp(num); // Optimization - zeroify + + if (cmp === 0) { + this.negative = 0; + this.length = 1; + this.words[0] = 0; + return this; + } // A > b + + var a, b; + + if (cmp > 0) { + a = this; + b = num; + } else { + a = num; + b = this; + } + + var carry = 0; + + for (var i = 0; i < b.length; i++) { + r = (a.words[i] | 0) - (b.words[i] | 0) + carry; + carry = r >> 26; + this.words[i] = r & 0x3ffffff; + } + + for (; carry !== 0 && i < a.length; i++) { + r = (a.words[i] | 0) + carry; + carry = r >> 26; + this.words[i] = r & 0x3ffffff; + } // Copy rest of the words + + if (carry === 0 && i < a.length && a !== this) { + for (; i < a.length; i++) { + this.words[i] = a.words[i]; + } + } + + this.length = Math.max(this.length, i); + + if (a !== this) { + this.negative = 1; + } + + return this.strip(); + }; // Subtract `num` from `this` + + BN.prototype.sub = function sub(num) { + return this.clone().isub(num); + }; + + function smallMulTo(self, num, out) { + out.negative = num.negative ^ self.negative; + var len = (self.length + num.length) | 0; + out.length = len; + len = (len - 1) | 0; // Peel one iteration (compiler can't do it, because of code complexity) + + var a = self.words[0] | 0; + var b = num.words[0] | 0; + var r = a * b; + var lo = r & 0x3ffffff; + var carry = (r / 0x4000000) | 0; + out.words[0] = lo; + + for (var k = 1; k < len; k++) { + // Sum all words with the same `i + j = k` and accumulate `ncarry`, + // note that ncarry could be >= 0x3ffffff + var ncarry = carry >>> 26; + var rword = carry & 0x3ffffff; + var maxJ = Math.min(k, num.length - 1); + + for ( + var j = Math.max(0, k - self.length + 1); + j <= maxJ; + j++ + ) { + var i = (k - j) | 0; + a = self.words[i] | 0; + b = num.words[j] | 0; + r = a * b + rword; + ncarry += (r / 0x4000000) | 0; + rword = r & 0x3ffffff; + } + + out.words[k] = rword | 0; + carry = ncarry | 0; + } + + if (carry !== 0) { + out.words[k] = carry | 0; + } else { + out.length--; + } + + return out.strip(); + } // TODO(indutny): it may be reasonable to omit it for users who don't need + // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit + // multiplication (like elliptic secp256k1). + + var comb10MulTo = function comb10MulTo(self, num, out) { + var a = self.words; + var b = num.words; + var o = out.words; + var c = 0; + var lo; + var mid; + var hi; + var a0 = a[0] | 0; + var al0 = a0 & 0x1fff; + var ah0 = a0 >>> 13; + var a1 = a[1] | 0; + var al1 = a1 & 0x1fff; + var ah1 = a1 >>> 13; + var a2 = a[2] | 0; + var al2 = a2 & 0x1fff; + var ah2 = a2 >>> 13; + var a3 = a[3] | 0; + var al3 = a3 & 0x1fff; + var ah3 = a3 >>> 13; + var a4 = a[4] | 0; + var al4 = a4 & 0x1fff; + var ah4 = a4 >>> 13; + var a5 = a[5] | 0; + var al5 = a5 & 0x1fff; + var ah5 = a5 >>> 13; + var a6 = a[6] | 0; + var al6 = a6 & 0x1fff; + var ah6 = a6 >>> 13; + var a7 = a[7] | 0; + var al7 = a7 & 0x1fff; + var ah7 = a7 >>> 13; + var a8 = a[8] | 0; + var al8 = a8 & 0x1fff; + var ah8 = a8 >>> 13; + var a9 = a[9] | 0; + var al9 = a9 & 0x1fff; + var ah9 = a9 >>> 13; + var b0 = b[0] | 0; + var bl0 = b0 & 0x1fff; + var bh0 = b0 >>> 13; + var b1 = b[1] | 0; + var bl1 = b1 & 0x1fff; + var bh1 = b1 >>> 13; + var b2 = b[2] | 0; + var bl2 = b2 & 0x1fff; + var bh2 = b2 >>> 13; + var b3 = b[3] | 0; + var bl3 = b3 & 0x1fff; + var bh3 = b3 >>> 13; + var b4 = b[4] | 0; + var bl4 = b4 & 0x1fff; + var bh4 = b4 >>> 13; + var b5 = b[5] | 0; + var bl5 = b5 & 0x1fff; + var bh5 = b5 >>> 13; + var b6 = b[6] | 0; + var bl6 = b6 & 0x1fff; + var bh6 = b6 >>> 13; + var b7 = b[7] | 0; + var bl7 = b7 & 0x1fff; + var bh7 = b7 >>> 13; + var b8 = b[8] | 0; + var bl8 = b8 & 0x1fff; + var bh8 = b8 >>> 13; + var b9 = b[9] | 0; + var bl9 = b9 & 0x1fff; + var bh9 = b9 >>> 13; + out.negative = self.negative ^ num.negative; + out.length = 19; + /* K = 0 */ + + lo = Math.imul(al0, bl0); + mid = Math.imul(al0, bh0); + mid = (mid + Math.imul(ah0, bl0)) | 0; + hi = Math.imul(ah0, bh0); + var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0; + w0 &= 0x3ffffff; + /* K = 1 */ + + lo = Math.imul(al1, bl0); + mid = Math.imul(al1, bh0); + mid = (mid + Math.imul(ah1, bl0)) | 0; + hi = Math.imul(ah1, bh0); + lo = (lo + Math.imul(al0, bl1)) | 0; + mid = (mid + Math.imul(al0, bh1)) | 0; + mid = (mid + Math.imul(ah0, bl1)) | 0; + hi = (hi + Math.imul(ah0, bh1)) | 0; + var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0; + w1 &= 0x3ffffff; + /* K = 2 */ + + lo = Math.imul(al2, bl0); + mid = Math.imul(al2, bh0); + mid = (mid + Math.imul(ah2, bl0)) | 0; + hi = Math.imul(ah2, bh0); + lo = (lo + Math.imul(al1, bl1)) | 0; + mid = (mid + Math.imul(al1, bh1)) | 0; + mid = (mid + Math.imul(ah1, bl1)) | 0; + hi = (hi + Math.imul(ah1, bh1)) | 0; + lo = (lo + Math.imul(al0, bl2)) | 0; + mid = (mid + Math.imul(al0, bh2)) | 0; + mid = (mid + Math.imul(ah0, bl2)) | 0; + hi = (hi + Math.imul(ah0, bh2)) | 0; + var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0; + w2 &= 0x3ffffff; + /* K = 3 */ + + lo = Math.imul(al3, bl0); + mid = Math.imul(al3, bh0); + mid = (mid + Math.imul(ah3, bl0)) | 0; + hi = Math.imul(ah3, bh0); + lo = (lo + Math.imul(al2, bl1)) | 0; + mid = (mid + Math.imul(al2, bh1)) | 0; + mid = (mid + Math.imul(ah2, bl1)) | 0; + hi = (hi + Math.imul(ah2, bh1)) | 0; + lo = (lo + Math.imul(al1, bl2)) | 0; + mid = (mid + Math.imul(al1, bh2)) | 0; + mid = (mid + Math.imul(ah1, bl2)) | 0; + hi = (hi + Math.imul(ah1, bh2)) | 0; + lo = (lo + Math.imul(al0, bl3)) | 0; + mid = (mid + Math.imul(al0, bh3)) | 0; + mid = (mid + Math.imul(ah0, bl3)) | 0; + hi = (hi + Math.imul(ah0, bh3)) | 0; + var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0; + w3 &= 0x3ffffff; + /* K = 4 */ + + lo = Math.imul(al4, bl0); + mid = Math.imul(al4, bh0); + mid = (mid + Math.imul(ah4, bl0)) | 0; + hi = Math.imul(ah4, bh0); + lo = (lo + Math.imul(al3, bl1)) | 0; + mid = (mid + Math.imul(al3, bh1)) | 0; + mid = (mid + Math.imul(ah3, bl1)) | 0; + hi = (hi + Math.imul(ah3, bh1)) | 0; + lo = (lo + Math.imul(al2, bl2)) | 0; + mid = (mid + Math.imul(al2, bh2)) | 0; + mid = (mid + Math.imul(ah2, bl2)) | 0; + hi = (hi + Math.imul(ah2, bh2)) | 0; + lo = (lo + Math.imul(al1, bl3)) | 0; + mid = (mid + Math.imul(al1, bh3)) | 0; + mid = (mid + Math.imul(ah1, bl3)) | 0; + hi = (hi + Math.imul(ah1, bh3)) | 0; + lo = (lo + Math.imul(al0, bl4)) | 0; + mid = (mid + Math.imul(al0, bh4)) | 0; + mid = (mid + Math.imul(ah0, bl4)) | 0; + hi = (hi + Math.imul(ah0, bh4)) | 0; + var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0; + w4 &= 0x3ffffff; + /* K = 5 */ + + lo = Math.imul(al5, bl0); + mid = Math.imul(al5, bh0); + mid = (mid + Math.imul(ah5, bl0)) | 0; + hi = Math.imul(ah5, bh0); + lo = (lo + Math.imul(al4, bl1)) | 0; + mid = (mid + Math.imul(al4, bh1)) | 0; + mid = (mid + Math.imul(ah4, bl1)) | 0; + hi = (hi + Math.imul(ah4, bh1)) | 0; + lo = (lo + Math.imul(al3, bl2)) | 0; + mid = (mid + Math.imul(al3, bh2)) | 0; + mid = (mid + Math.imul(ah3, bl2)) | 0; + hi = (hi + Math.imul(ah3, bh2)) | 0; + lo = (lo + Math.imul(al2, bl3)) | 0; + mid = (mid + Math.imul(al2, bh3)) | 0; + mid = (mid + Math.imul(ah2, bl3)) | 0; + hi = (hi + Math.imul(ah2, bh3)) | 0; + lo = (lo + Math.imul(al1, bl4)) | 0; + mid = (mid + Math.imul(al1, bh4)) | 0; + mid = (mid + Math.imul(ah1, bl4)) | 0; + hi = (hi + Math.imul(ah1, bh4)) | 0; + lo = (lo + Math.imul(al0, bl5)) | 0; + mid = (mid + Math.imul(al0, bh5)) | 0; + mid = (mid + Math.imul(ah0, bl5)) | 0; + hi = (hi + Math.imul(ah0, bh5)) | 0; + var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0; + w5 &= 0x3ffffff; + /* K = 6 */ + + lo = Math.imul(al6, bl0); + mid = Math.imul(al6, bh0); + mid = (mid + Math.imul(ah6, bl0)) | 0; + hi = Math.imul(ah6, bh0); + lo = (lo + Math.imul(al5, bl1)) | 0; + mid = (mid + Math.imul(al5, bh1)) | 0; + mid = (mid + Math.imul(ah5, bl1)) | 0; + hi = (hi + Math.imul(ah5, bh1)) | 0; + lo = (lo + Math.imul(al4, bl2)) | 0; + mid = (mid + Math.imul(al4, bh2)) | 0; + mid = (mid + Math.imul(ah4, bl2)) | 0; + hi = (hi + Math.imul(ah4, bh2)) | 0; + lo = (lo + Math.imul(al3, bl3)) | 0; + mid = (mid + Math.imul(al3, bh3)) | 0; + mid = (mid + Math.imul(ah3, bl3)) | 0; + hi = (hi + Math.imul(ah3, bh3)) | 0; + lo = (lo + Math.imul(al2, bl4)) | 0; + mid = (mid + Math.imul(al2, bh4)) | 0; + mid = (mid + Math.imul(ah2, bl4)) | 0; + hi = (hi + Math.imul(ah2, bh4)) | 0; + lo = (lo + Math.imul(al1, bl5)) | 0; + mid = (mid + Math.imul(al1, bh5)) | 0; + mid = (mid + Math.imul(ah1, bl5)) | 0; + hi = (hi + Math.imul(ah1, bh5)) | 0; + lo = (lo + Math.imul(al0, bl6)) | 0; + mid = (mid + Math.imul(al0, bh6)) | 0; + mid = (mid + Math.imul(ah0, bl6)) | 0; + hi = (hi + Math.imul(ah0, bh6)) | 0; + var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0; + w6 &= 0x3ffffff; + /* K = 7 */ + + lo = Math.imul(al7, bl0); + mid = Math.imul(al7, bh0); + mid = (mid + Math.imul(ah7, bl0)) | 0; + hi = Math.imul(ah7, bh0); + lo = (lo + Math.imul(al6, bl1)) | 0; + mid = (mid + Math.imul(al6, bh1)) | 0; + mid = (mid + Math.imul(ah6, bl1)) | 0; + hi = (hi + Math.imul(ah6, bh1)) | 0; + lo = (lo + Math.imul(al5, bl2)) | 0; + mid = (mid + Math.imul(al5, bh2)) | 0; + mid = (mid + Math.imul(ah5, bl2)) | 0; + hi = (hi + Math.imul(ah5, bh2)) | 0; + lo = (lo + Math.imul(al4, bl3)) | 0; + mid = (mid + Math.imul(al4, bh3)) | 0; + mid = (mid + Math.imul(ah4, bl3)) | 0; + hi = (hi + Math.imul(ah4, bh3)) | 0; + lo = (lo + Math.imul(al3, bl4)) | 0; + mid = (mid + Math.imul(al3, bh4)) | 0; + mid = (mid + Math.imul(ah3, bl4)) | 0; + hi = (hi + Math.imul(ah3, bh4)) | 0; + lo = (lo + Math.imul(al2, bl5)) | 0; + mid = (mid + Math.imul(al2, bh5)) | 0; + mid = (mid + Math.imul(ah2, bl5)) | 0; + hi = (hi + Math.imul(ah2, bh5)) | 0; + lo = (lo + Math.imul(al1, bl6)) | 0; + mid = (mid + Math.imul(al1, bh6)) | 0; + mid = (mid + Math.imul(ah1, bl6)) | 0; + hi = (hi + Math.imul(ah1, bh6)) | 0; + lo = (lo + Math.imul(al0, bl7)) | 0; + mid = (mid + Math.imul(al0, bh7)) | 0; + mid = (mid + Math.imul(ah0, bl7)) | 0; + hi = (hi + Math.imul(ah0, bh7)) | 0; + var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0; + w7 &= 0x3ffffff; + /* K = 8 */ + + lo = Math.imul(al8, bl0); + mid = Math.imul(al8, bh0); + mid = (mid + Math.imul(ah8, bl0)) | 0; + hi = Math.imul(ah8, bh0); + lo = (lo + Math.imul(al7, bl1)) | 0; + mid = (mid + Math.imul(al7, bh1)) | 0; + mid = (mid + Math.imul(ah7, bl1)) | 0; + hi = (hi + Math.imul(ah7, bh1)) | 0; + lo = (lo + Math.imul(al6, bl2)) | 0; + mid = (mid + Math.imul(al6, bh2)) | 0; + mid = (mid + Math.imul(ah6, bl2)) | 0; + hi = (hi + Math.imul(ah6, bh2)) | 0; + lo = (lo + Math.imul(al5, bl3)) | 0; + mid = (mid + Math.imul(al5, bh3)) | 0; + mid = (mid + Math.imul(ah5, bl3)) | 0; + hi = (hi + Math.imul(ah5, bh3)) | 0; + lo = (lo + Math.imul(al4, bl4)) | 0; + mid = (mid + Math.imul(al4, bh4)) | 0; + mid = (mid + Math.imul(ah4, bl4)) | 0; + hi = (hi + Math.imul(ah4, bh4)) | 0; + lo = (lo + Math.imul(al3, bl5)) | 0; + mid = (mid + Math.imul(al3, bh5)) | 0; + mid = (mid + Math.imul(ah3, bl5)) | 0; + hi = (hi + Math.imul(ah3, bh5)) | 0; + lo = (lo + Math.imul(al2, bl6)) | 0; + mid = (mid + Math.imul(al2, bh6)) | 0; + mid = (mid + Math.imul(ah2, bl6)) | 0; + hi = (hi + Math.imul(ah2, bh6)) | 0; + lo = (lo + Math.imul(al1, bl7)) | 0; + mid = (mid + Math.imul(al1, bh7)) | 0; + mid = (mid + Math.imul(ah1, bl7)) | 0; + hi = (hi + Math.imul(ah1, bh7)) | 0; + lo = (lo + Math.imul(al0, bl8)) | 0; + mid = (mid + Math.imul(al0, bh8)) | 0; + mid = (mid + Math.imul(ah0, bl8)) | 0; + hi = (hi + Math.imul(ah0, bh8)) | 0; + var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0; + w8 &= 0x3ffffff; + /* K = 9 */ + + lo = Math.imul(al9, bl0); + mid = Math.imul(al9, bh0); + mid = (mid + Math.imul(ah9, bl0)) | 0; + hi = Math.imul(ah9, bh0); + lo = (lo + Math.imul(al8, bl1)) | 0; + mid = (mid + Math.imul(al8, bh1)) | 0; + mid = (mid + Math.imul(ah8, bl1)) | 0; + hi = (hi + Math.imul(ah8, bh1)) | 0; + lo = (lo + Math.imul(al7, bl2)) | 0; + mid = (mid + Math.imul(al7, bh2)) | 0; + mid = (mid + Math.imul(ah7, bl2)) | 0; + hi = (hi + Math.imul(ah7, bh2)) | 0; + lo = (lo + Math.imul(al6, bl3)) | 0; + mid = (mid + Math.imul(al6, bh3)) | 0; + mid = (mid + Math.imul(ah6, bl3)) | 0; + hi = (hi + Math.imul(ah6, bh3)) | 0; + lo = (lo + Math.imul(al5, bl4)) | 0; + mid = (mid + Math.imul(al5, bh4)) | 0; + mid = (mid + Math.imul(ah5, bl4)) | 0; + hi = (hi + Math.imul(ah5, bh4)) | 0; + lo = (lo + Math.imul(al4, bl5)) | 0; + mid = (mid + Math.imul(al4, bh5)) | 0; + mid = (mid + Math.imul(ah4, bl5)) | 0; + hi = (hi + Math.imul(ah4, bh5)) | 0; + lo = (lo + Math.imul(al3, bl6)) | 0; + mid = (mid + Math.imul(al3, bh6)) | 0; + mid = (mid + Math.imul(ah3, bl6)) | 0; + hi = (hi + Math.imul(ah3, bh6)) | 0; + lo = (lo + Math.imul(al2, bl7)) | 0; + mid = (mid + Math.imul(al2, bh7)) | 0; + mid = (mid + Math.imul(ah2, bl7)) | 0; + hi = (hi + Math.imul(ah2, bh7)) | 0; + lo = (lo + Math.imul(al1, bl8)) | 0; + mid = (mid + Math.imul(al1, bh8)) | 0; + mid = (mid + Math.imul(ah1, bl8)) | 0; + hi = (hi + Math.imul(ah1, bh8)) | 0; + lo = (lo + Math.imul(al0, bl9)) | 0; + mid = (mid + Math.imul(al0, bh9)) | 0; + mid = (mid + Math.imul(ah0, bl9)) | 0; + hi = (hi + Math.imul(ah0, bh9)) | 0; + var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0; + w9 &= 0x3ffffff; + /* K = 10 */ + + lo = Math.imul(al9, bl1); + mid = Math.imul(al9, bh1); + mid = (mid + Math.imul(ah9, bl1)) | 0; + hi = Math.imul(ah9, bh1); + lo = (lo + Math.imul(al8, bl2)) | 0; + mid = (mid + Math.imul(al8, bh2)) | 0; + mid = (mid + Math.imul(ah8, bl2)) | 0; + hi = (hi + Math.imul(ah8, bh2)) | 0; + lo = (lo + Math.imul(al7, bl3)) | 0; + mid = (mid + Math.imul(al7, bh3)) | 0; + mid = (mid + Math.imul(ah7, bl3)) | 0; + hi = (hi + Math.imul(ah7, bh3)) | 0; + lo = (lo + Math.imul(al6, bl4)) | 0; + mid = (mid + Math.imul(al6, bh4)) | 0; + mid = (mid + Math.imul(ah6, bl4)) | 0; + hi = (hi + Math.imul(ah6, bh4)) | 0; + lo = (lo + Math.imul(al5, bl5)) | 0; + mid = (mid + Math.imul(al5, bh5)) | 0; + mid = (mid + Math.imul(ah5, bl5)) | 0; + hi = (hi + Math.imul(ah5, bh5)) | 0; + lo = (lo + Math.imul(al4, bl6)) | 0; + mid = (mid + Math.imul(al4, bh6)) | 0; + mid = (mid + Math.imul(ah4, bl6)) | 0; + hi = (hi + Math.imul(ah4, bh6)) | 0; + lo = (lo + Math.imul(al3, bl7)) | 0; + mid = (mid + Math.imul(al3, bh7)) | 0; + mid = (mid + Math.imul(ah3, bl7)) | 0; + hi = (hi + Math.imul(ah3, bh7)) | 0; + lo = (lo + Math.imul(al2, bl8)) | 0; + mid = (mid + Math.imul(al2, bh8)) | 0; + mid = (mid + Math.imul(ah2, bl8)) | 0; + hi = (hi + Math.imul(ah2, bh8)) | 0; + lo = (lo + Math.imul(al1, bl9)) | 0; + mid = (mid + Math.imul(al1, bh9)) | 0; + mid = (mid + Math.imul(ah1, bl9)) | 0; + hi = (hi + Math.imul(ah1, bh9)) | 0; + var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0; + w10 &= 0x3ffffff; + /* K = 11 */ + + lo = Math.imul(al9, bl2); + mid = Math.imul(al9, bh2); + mid = (mid + Math.imul(ah9, bl2)) | 0; + hi = Math.imul(ah9, bh2); + lo = (lo + Math.imul(al8, bl3)) | 0; + mid = (mid + Math.imul(al8, bh3)) | 0; + mid = (mid + Math.imul(ah8, bl3)) | 0; + hi = (hi + Math.imul(ah8, bh3)) | 0; + lo = (lo + Math.imul(al7, bl4)) | 0; + mid = (mid + Math.imul(al7, bh4)) | 0; + mid = (mid + Math.imul(ah7, bl4)) | 0; + hi = (hi + Math.imul(ah7, bh4)) | 0; + lo = (lo + Math.imul(al6, bl5)) | 0; + mid = (mid + Math.imul(al6, bh5)) | 0; + mid = (mid + Math.imul(ah6, bl5)) | 0; + hi = (hi + Math.imul(ah6, bh5)) | 0; + lo = (lo + Math.imul(al5, bl6)) | 0; + mid = (mid + Math.imul(al5, bh6)) | 0; + mid = (mid + Math.imul(ah5, bl6)) | 0; + hi = (hi + Math.imul(ah5, bh6)) | 0; + lo = (lo + Math.imul(al4, bl7)) | 0; + mid = (mid + Math.imul(al4, bh7)) | 0; + mid = (mid + Math.imul(ah4, bl7)) | 0; + hi = (hi + Math.imul(ah4, bh7)) | 0; + lo = (lo + Math.imul(al3, bl8)) | 0; + mid = (mid + Math.imul(al3, bh8)) | 0; + mid = (mid + Math.imul(ah3, bl8)) | 0; + hi = (hi + Math.imul(ah3, bh8)) | 0; + lo = (lo + Math.imul(al2, bl9)) | 0; + mid = (mid + Math.imul(al2, bh9)) | 0; + mid = (mid + Math.imul(ah2, bl9)) | 0; + hi = (hi + Math.imul(ah2, bh9)) | 0; + var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0; + w11 &= 0x3ffffff; + /* K = 12 */ + + lo = Math.imul(al9, bl3); + mid = Math.imul(al9, bh3); + mid = (mid + Math.imul(ah9, bl3)) | 0; + hi = Math.imul(ah9, bh3); + lo = (lo + Math.imul(al8, bl4)) | 0; + mid = (mid + Math.imul(al8, bh4)) | 0; + mid = (mid + Math.imul(ah8, bl4)) | 0; + hi = (hi + Math.imul(ah8, bh4)) | 0; + lo = (lo + Math.imul(al7, bl5)) | 0; + mid = (mid + Math.imul(al7, bh5)) | 0; + mid = (mid + Math.imul(ah7, bl5)) | 0; + hi = (hi + Math.imul(ah7, bh5)) | 0; + lo = (lo + Math.imul(al6, bl6)) | 0; + mid = (mid + Math.imul(al6, bh6)) | 0; + mid = (mid + Math.imul(ah6, bl6)) | 0; + hi = (hi + Math.imul(ah6, bh6)) | 0; + lo = (lo + Math.imul(al5, bl7)) | 0; + mid = (mid + Math.imul(al5, bh7)) | 0; + mid = (mid + Math.imul(ah5, bl7)) | 0; + hi = (hi + Math.imul(ah5, bh7)) | 0; + lo = (lo + Math.imul(al4, bl8)) | 0; + mid = (mid + Math.imul(al4, bh8)) | 0; + mid = (mid + Math.imul(ah4, bl8)) | 0; + hi = (hi + Math.imul(ah4, bh8)) | 0; + lo = (lo + Math.imul(al3, bl9)) | 0; + mid = (mid + Math.imul(al3, bh9)) | 0; + mid = (mid + Math.imul(ah3, bl9)) | 0; + hi = (hi + Math.imul(ah3, bh9)) | 0; + var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0; + w12 &= 0x3ffffff; + /* K = 13 */ + + lo = Math.imul(al9, bl4); + mid = Math.imul(al9, bh4); + mid = (mid + Math.imul(ah9, bl4)) | 0; + hi = Math.imul(ah9, bh4); + lo = (lo + Math.imul(al8, bl5)) | 0; + mid = (mid + Math.imul(al8, bh5)) | 0; + mid = (mid + Math.imul(ah8, bl5)) | 0; + hi = (hi + Math.imul(ah8, bh5)) | 0; + lo = (lo + Math.imul(al7, bl6)) | 0; + mid = (mid + Math.imul(al7, bh6)) | 0; + mid = (mid + Math.imul(ah7, bl6)) | 0; + hi = (hi + Math.imul(ah7, bh6)) | 0; + lo = (lo + Math.imul(al6, bl7)) | 0; + mid = (mid + Math.imul(al6, bh7)) | 0; + mid = (mid + Math.imul(ah6, bl7)) | 0; + hi = (hi + Math.imul(ah6, bh7)) | 0; + lo = (lo + Math.imul(al5, bl8)) | 0; + mid = (mid + Math.imul(al5, bh8)) | 0; + mid = (mid + Math.imul(ah5, bl8)) | 0; + hi = (hi + Math.imul(ah5, bh8)) | 0; + lo = (lo + Math.imul(al4, bl9)) | 0; + mid = (mid + Math.imul(al4, bh9)) | 0; + mid = (mid + Math.imul(ah4, bl9)) | 0; + hi = (hi + Math.imul(ah4, bh9)) | 0; + var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0; + w13 &= 0x3ffffff; + /* K = 14 */ + + lo = Math.imul(al9, bl5); + mid = Math.imul(al9, bh5); + mid = (mid + Math.imul(ah9, bl5)) | 0; + hi = Math.imul(ah9, bh5); + lo = (lo + Math.imul(al8, bl6)) | 0; + mid = (mid + Math.imul(al8, bh6)) | 0; + mid = (mid + Math.imul(ah8, bl6)) | 0; + hi = (hi + Math.imul(ah8, bh6)) | 0; + lo = (lo + Math.imul(al7, bl7)) | 0; + mid = (mid + Math.imul(al7, bh7)) | 0; + mid = (mid + Math.imul(ah7, bl7)) | 0; + hi = (hi + Math.imul(ah7, bh7)) | 0; + lo = (lo + Math.imul(al6, bl8)) | 0; + mid = (mid + Math.imul(al6, bh8)) | 0; + mid = (mid + Math.imul(ah6, bl8)) | 0; + hi = (hi + Math.imul(ah6, bh8)) | 0; + lo = (lo + Math.imul(al5, bl9)) | 0; + mid = (mid + Math.imul(al5, bh9)) | 0; + mid = (mid + Math.imul(ah5, bl9)) | 0; + hi = (hi + Math.imul(ah5, bh9)) | 0; + var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0; + w14 &= 0x3ffffff; + /* K = 15 */ + + lo = Math.imul(al9, bl6); + mid = Math.imul(al9, bh6); + mid = (mid + Math.imul(ah9, bl6)) | 0; + hi = Math.imul(ah9, bh6); + lo = (lo + Math.imul(al8, bl7)) | 0; + mid = (mid + Math.imul(al8, bh7)) | 0; + mid = (mid + Math.imul(ah8, bl7)) | 0; + hi = (hi + Math.imul(ah8, bh7)) | 0; + lo = (lo + Math.imul(al7, bl8)) | 0; + mid = (mid + Math.imul(al7, bh8)) | 0; + mid = (mid + Math.imul(ah7, bl8)) | 0; + hi = (hi + Math.imul(ah7, bh8)) | 0; + lo = (lo + Math.imul(al6, bl9)) | 0; + mid = (mid + Math.imul(al6, bh9)) | 0; + mid = (mid + Math.imul(ah6, bl9)) | 0; + hi = (hi + Math.imul(ah6, bh9)) | 0; + var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0; + w15 &= 0x3ffffff; + /* K = 16 */ + + lo = Math.imul(al9, bl7); + mid = Math.imul(al9, bh7); + mid = (mid + Math.imul(ah9, bl7)) | 0; + hi = Math.imul(ah9, bh7); + lo = (lo + Math.imul(al8, bl8)) | 0; + mid = (mid + Math.imul(al8, bh8)) | 0; + mid = (mid + Math.imul(ah8, bl8)) | 0; + hi = (hi + Math.imul(ah8, bh8)) | 0; + lo = (lo + Math.imul(al7, bl9)) | 0; + mid = (mid + Math.imul(al7, bh9)) | 0; + mid = (mid + Math.imul(ah7, bl9)) | 0; + hi = (hi + Math.imul(ah7, bh9)) | 0; + var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0; + w16 &= 0x3ffffff; + /* K = 17 */ + + lo = Math.imul(al9, bl8); + mid = Math.imul(al9, bh8); + mid = (mid + Math.imul(ah9, bl8)) | 0; + hi = Math.imul(ah9, bh8); + lo = (lo + Math.imul(al8, bl9)) | 0; + mid = (mid + Math.imul(al8, bh9)) | 0; + mid = (mid + Math.imul(ah8, bl9)) | 0; + hi = (hi + Math.imul(ah8, bh9)) | 0; + var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0; + w17 &= 0x3ffffff; + /* K = 18 */ + + lo = Math.imul(al9, bl9); + mid = Math.imul(al9, bh9); + mid = (mid + Math.imul(ah9, bl9)) | 0; + hi = Math.imul(ah9, bh9); + var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0; + c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0; + w18 &= 0x3ffffff; + o[0] = w0; + o[1] = w1; + o[2] = w2; + o[3] = w3; + o[4] = w4; + o[5] = w5; + o[6] = w6; + o[7] = w7; + o[8] = w8; + o[9] = w9; + o[10] = w10; + o[11] = w11; + o[12] = w12; + o[13] = w13; + o[14] = w14; + o[15] = w15; + o[16] = w16; + o[17] = w17; + o[18] = w18; + + if (c !== 0) { + o[19] = c; + out.length++; + } + + return out; + }; // Polyfill comb + + if (!Math.imul) { + comb10MulTo = smallMulTo; + } + + function bigMulTo(self, num, out) { + out.negative = num.negative ^ self.negative; + out.length = self.length + num.length; + var carry = 0; + var hncarry = 0; + + for (var k = 0; k < out.length - 1; k++) { + // Sum all words with the same `i + j = k` and accumulate `ncarry`, + // note that ncarry could be >= 0x3ffffff + var ncarry = hncarry; + hncarry = 0; + var rword = carry & 0x3ffffff; + var maxJ = Math.min(k, num.length - 1); + + for ( + var j = Math.max(0, k - self.length + 1); + j <= maxJ; + j++ + ) { + var i = k - j; + var a = self.words[i] | 0; + var b = num.words[j] | 0; + var r = a * b; + var lo = r & 0x3ffffff; + ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0; + lo = (lo + rword) | 0; + rword = lo & 0x3ffffff; + ncarry = (ncarry + (lo >>> 26)) | 0; + hncarry += ncarry >>> 26; + ncarry &= 0x3ffffff; + } + + out.words[k] = rword; + carry = ncarry; + ncarry = hncarry; + } + + if (carry !== 0) { + out.words[k] = carry; + } else { + out.length--; + } + + return out.strip(); + } + + function jumboMulTo(self, num, out) { + var fftm = new FFTM(); + return fftm.mulp(self, num, out); + } + + BN.prototype.mulTo = function mulTo(num, out) { + var res; + var len = this.length + num.length; + + if (this.length === 10 && num.length === 10) { + res = comb10MulTo(this, num, out); + } else if (len < 63) { + res = smallMulTo(this, num, out); + } else if (len < 1024) { + res = bigMulTo(this, num, out); + } else { + res = jumboMulTo(this, num, out); + } + + return res; + }; // Cooley-Tukey algorithm for FFT + // slightly revisited to rely on looping instead of recursion + + function FFTM(x, y) { + this.x = x; + this.y = y; + } + + FFTM.prototype.makeRBT = function makeRBT(N) { + var t = new Array(N); + var l = BN.prototype._countBits(N) - 1; + + for (var i = 0; i < N; i++) { + t[i] = this.revBin(i, l, N); + } + + return t; + }; // Returns binary-reversed representation of `x` + + FFTM.prototype.revBin = function revBin(x, l, N) { + if (x === 0 || x === N - 1) return x; + var rb = 0; + + for (var i = 0; i < l; i++) { + rb |= (x & 1) << (l - i - 1); + x >>= 1; + } + + return rb; + }; // Performs "tweedling" phase, therefore 'emulating' + // behaviour of the recursive algorithm + + FFTM.prototype.permute = function permute( + rbt, + rws, + iws, + rtws, + itws, + N + ) { + for (var i = 0; i < N; i++) { + rtws[i] = rws[rbt[i]]; + itws[i] = iws[rbt[i]]; + } + }; + + FFTM.prototype.transform = function transform( + rws, + iws, + rtws, + itws, + N, + rbt + ) { + this.permute(rbt, rws, iws, rtws, itws, N); + + for (var s = 1; s < N; s <<= 1) { + var l = s << 1; + var rtwdf = Math.cos((2 * Math.PI) / l); + var itwdf = Math.sin((2 * Math.PI) / l); + + for (var p = 0; p < N; p += l) { + var rtwdf_ = rtwdf; + var itwdf_ = itwdf; + + for (var j = 0; j < s; j++) { + var re = rtws[p + j]; + var ie = itws[p + j]; + var ro = rtws[p + j + s]; + var io = itws[p + j + s]; + var rx = rtwdf_ * ro - itwdf_ * io; + io = rtwdf_ * io + itwdf_ * ro; + ro = rx; + rtws[p + j] = re + ro; + itws[p + j] = ie + io; + rtws[p + j + s] = re - ro; + itws[p + j + s] = ie - io; + /* jshint maxdepth : false */ + + if (j !== l) { + rx = rtwdf * rtwdf_ - itwdf * itwdf_; + itwdf_ = + rtwdf * itwdf_ + itwdf * rtwdf_; + rtwdf_ = rx; + } + } + } + } + }; + + FFTM.prototype.guessLen13b = function guessLen13b(n, m) { + var N = Math.max(m, n) | 1; + var odd = N & 1; + var i = 0; + + for (N = (N / 2) | 0; N; N >>>= 1) { + i++; + } + + return 1 << (i + 1 + odd); + }; + + FFTM.prototype.conjugate = function conjugate(rws, iws, N) { + if (N <= 1) return; + + for (var i = 0; i < N / 2; i++) { + var t = rws[i]; + rws[i] = rws[N - i - 1]; + rws[N - i - 1] = t; + t = iws[i]; + iws[i] = -iws[N - i - 1]; + iws[N - i - 1] = -t; + } + }; + + FFTM.prototype.normalize13b = function normalize13b(ws, N) { + var carry = 0; + + for (var i = 0; i < N / 2; i++) { + var w = + Math.round(ws[2 * i + 1] / N) * 0x2000 + + Math.round(ws[2 * i] / N) + + carry; + ws[i] = w & 0x3ffffff; + + if (w < 0x4000000) { + carry = 0; + } else { + carry = (w / 0x4000000) | 0; + } + } + + return ws; + }; + + FFTM.prototype.convert13b = function convert13b( + ws, + len, + rws, + N + ) { + var carry = 0; + + for (var i = 0; i < len; i++) { + carry += (ws[i] | 0); + rws[2 * i] = carry & 0x1fff; + carry >>>= 13; + rws[2 * i + 1] = carry & 0x1fff; + carry >>>= 13; + } // Pad with zeroes + + for (i = 2 * len; i < N; ++i) { + rws[i] = 0; + } + + assert(carry === 0); + assert((carry & ~0x1fff) === 0); + }; + + FFTM.prototype.stub = function stub(N) { + var ph = new Array(N); + + for (var i = 0; i < N; i++) { + ph[i] = 0; + } + + return ph; + }; + + FFTM.prototype.mulp = function mulp(x, y, out) { + var N = 2 * this.guessLen13b(x.length, y.length); + var rbt = this.makeRBT(N); + + var _ = this.stub(N); + + var rws = new Array(N); + var rwst = new Array(N); + var iwst = new Array(N); + var nrws = new Array(N); + var nrwst = new Array(N); + var niwst = new Array(N); + var rmws = out.words; + rmws.length = N; + this.convert13b(x.words, x.length, rws, N); + this.convert13b(y.words, y.length, nrws, N); + this.transform(rws, _, rwst, iwst, N, rbt); + this.transform(nrws, _, nrwst, niwst, N, rbt); + + for (var i = 0; i < N; i++) { + var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i]; + iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i]; + rwst[i] = rx; + } + + this.conjugate(rwst, iwst, N); + this.transform(rwst, iwst, rmws, _, N, rbt); + this.conjugate(rmws, _, N); + this.normalize13b(rmws, N); + out.negative = x.negative ^ y.negative; + out.length = x.length + y.length; + return out.strip(); + }; // Multiply `this` by `num` + + BN.prototype.mul = function mul(num) { + var out = new BN(null); + out.words = new Array(this.length + num.length); + return this.mulTo(num, out); + }; // Multiply employing FFT + + BN.prototype.mulf = function mulf(num) { + var out = new BN(null); + out.words = new Array(this.length + num.length); + return jumboMulTo(this, num, out); + }; // In-place Multiplication + + BN.prototype.imul = function imul(num) { + return this.clone().mulTo(num, this); + }; + + BN.prototype.imuln = function imuln(num) { + assert(typeof num === "number"); + assert(num < 0x4000000); // Carry + + var carry = 0; + + for (var i = 0; i < this.length; i++) { + var w = (this.words[i] | 0) * num; + var lo = (w & 0x3ffffff) + (carry & 0x3ffffff); + carry >>= 26; + carry += (w / 0x4000000) | 0; // NOTE: lo is 27bit maximum + + carry += lo >>> 26; + this.words[i] = lo & 0x3ffffff; + } + + if (carry !== 0) { + this.words[i] = carry; + this.length++; + } + + return this; + }; + + BN.prototype.muln = function muln(num) { + return this.clone().imuln(num); + }; // `this` * `this` + + BN.prototype.sqr = function sqr() { + return this.mul(this); + }; // `this` * `this` in-place + + BN.prototype.isqr = function isqr() { + return this.imul(this.clone()); + }; // Math.pow(`this`, `num`) + + BN.prototype.pow = function pow(num) { + var w = toBitArray(num); + if (w.length === 0) return new BN(1); // Skip leading zeroes + + var res = this; + + for (var i = 0; i < w.length; i++, res = res.sqr()) { + if (w[i] !== 0) break; + } + + if (++i < w.length) { + for ( + var q = res.sqr(); + i < w.length; + i++, q = q.sqr() + ) { + if (w[i] === 0) continue; + res = res.mul(q); + } + } + + return res; + }; // Shift-left in-place + + BN.prototype.iushln = function iushln(bits) { + assert(typeof bits === "number" && bits >= 0); + var r = bits % 26; + var s = (bits - r) / 26; + var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r); + var i; + + if (r !== 0) { + var carry = 0; + + for (i = 0; i < this.length; i++) { + var newCarry = this.words[i] & carryMask; + var c = ((this.words[i] | 0) - newCarry) << r; + this.words[i] = c | carry; + carry = newCarry >>> (26 - r); + } + + if (carry) { + this.words[i] = carry; + this.length++; + } + } + + if (s !== 0) { + for (i = this.length - 1; i >= 0; i--) { + this.words[i + s] = this.words[i]; + } + + for (i = 0; i < s; i++) { + this.words[i] = 0; + } + + this.length += s; + } + + return this.strip(); + }; + + BN.prototype.ishln = function ishln(bits) { + // TODO(indutny): implement me + assert(this.negative === 0); + return this.iushln(bits); + }; // Shift-right in-place + // NOTE: `hint` is a lowest bit before trailing zeroes + // NOTE: if `extended` is present - it will be filled with destroyed bits + + BN.prototype.iushrn = function iushrn( + bits, + hint, + extended + ) { + assert(typeof bits === "number" && bits >= 0); + var h; + + if (hint) { + h = (hint - (hint % 26)) / 26; + } else { + h = 0; + } + + var r = bits % 26; + var s = Math.min((bits - r) / 26, this.length); + var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r); + var maskedWords = extended; + h -= s; + h = Math.max(0, h); // Extended mode, copy masked part + + if (maskedWords) { + for (var i = 0; i < s; i++) { + maskedWords.words[i] = this.words[i]; + } + + maskedWords.length = s; + } + + if (s === 0) { + // No-op, we should not move anything at all + } else if (this.length > s) { + this.length -= s; + + for (i = 0; i < this.length; i++) { + this.words[i] = this.words[i + s]; + } + } else { + this.words[0] = 0; + this.length = 1; + } + + var carry = 0; + + for ( + i = this.length - 1; + i >= 0 && (carry !== 0 || i >= h); + i-- + ) { + var word = this.words[i] | 0; + this.words[i] = (carry << (26 - r)) | (word >>> r); + carry = word & mask; + } // Push carried bits as a mask + + if (maskedWords && carry !== 0) { + maskedWords.words[maskedWords.length++] = carry; + } + + if (this.length === 0) { + this.words[0] = 0; + this.length = 1; + } + + return this.strip(); + }; + + BN.prototype.ishrn = function ishrn(bits, hint, extended) { + // TODO(indutny): implement me + assert(this.negative === 0); + return this.iushrn(bits, hint, extended); + }; // Shift-left + + BN.prototype.shln = function shln(bits) { + return this.clone().ishln(bits); + }; + + BN.prototype.ushln = function ushln(bits) { + return this.clone().iushln(bits); + }; // Shift-right + + BN.prototype.shrn = function shrn(bits) { + return this.clone().ishrn(bits); + }; + + BN.prototype.ushrn = function ushrn(bits) { + return this.clone().iushrn(bits); + }; // Test if n bit is set + + BN.prototype.testn = function testn(bit) { + assert(typeof bit === "number" && bit >= 0); + var r = bit % 26; + var s = (bit - r) / 26; + var q = 1 << r; // Fast case: bit is much higher than all existing words + + if (this.length <= s) return false; // Check bit and return + + var w = this.words[s]; + return Boolean(w & q); + }; // Return only lowers bits of number (in-place) + + BN.prototype.imaskn = function imaskn(bits) { + assert(typeof bits === "number" && bits >= 0); + var r = bits % 26; + var s = (bits - r) / 26; + assert( + this.negative === 0, + "imaskn works only with positive numbers" + ); + + if (this.length <= s) { + return this; + } + + if (r !== 0) { + s++; + } + + this.length = Math.min(s, this.length); + + if (r !== 0) { + var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r); + this.words[this.length - 1] &= mask; + } + + return this.strip(); + }; // Return only lowers bits of number + + BN.prototype.maskn = function maskn(bits) { + return this.clone().imaskn(bits); + }; // Add plain number `num` to `this` + + BN.prototype.iaddn = function iaddn(num) { + assert(typeof num === "number"); + assert(num < 0x4000000); + if (num < 0) return this.isubn(-num); // Possible sign change + + if (this.negative !== 0) { + if ( + this.length === 1 && + (this.words[0] | 0) < num + ) { + this.words[0] = num - (this.words[0] | 0); + this.negative = 0; + return this; + } + + this.negative = 0; + this.isubn(num); + this.negative = 1; + return this; + } // Add without checks + + return this._iaddn(num); + }; + + BN.prototype._iaddn = function _iaddn(num) { + this.words[0] += num; // Carry + + for ( + var i = 0; + i < this.length && this.words[i] >= 0x4000000; + i++ + ) { + this.words[i] -= 0x4000000; + + if (i === this.length - 1) { + this.words[i + 1] = 1; + } else { + this.words[i + 1]++; + } + } + + this.length = Math.max(this.length, i + 1); + return this; + }; // Subtract plain number `num` from `this` + + BN.prototype.isubn = function isubn(num) { + assert(typeof num === "number"); + assert(num < 0x4000000); + if (num < 0) return this.iaddn(-num); + + if (this.negative !== 0) { + this.negative = 0; + this.iaddn(num); + this.negative = 1; + return this; + } + + this.words[0] -= num; + + if (this.length === 1 && this.words[0] < 0) { + this.words[0] = -this.words[0]; + this.negative = 1; + } else { + // Carry + for ( + var i = 0; + i < this.length && this.words[i] < 0; + i++ + ) { + this.words[i] += 0x4000000; + this.words[i + 1] -= 1; + } + } + + return this.strip(); + }; + + BN.prototype.addn = function addn(num) { + return this.clone().iaddn(num); + }; + + BN.prototype.subn = function subn(num) { + return this.clone().isubn(num); + }; + + BN.prototype.iabs = function iabs() { + this.negative = 0; + return this; + }; + + BN.prototype.abs = function abs() { + return this.clone().iabs(); + }; + + BN.prototype._ishlnsubmul = function _ishlnsubmul( + num, + mul, + shift + ) { + var len = num.length + shift; + var i; + + this._expand(len); + + var w; + var carry = 0; + + for (i = 0; i < num.length; i++) { + w = (this.words[i + shift] | 0) + carry; + var right = (num.words[i] | 0) * mul; + w -= right & 0x3ffffff; + carry = (w >> 26) - ((right / 0x4000000) | 0); + this.words[i + shift] = w & 0x3ffffff; + } + + for (; i < this.length - shift; i++) { + w = (this.words[i + shift] | 0) + carry; + carry = w >> 26; + this.words[i + shift] = w & 0x3ffffff; + } + + if (carry === 0) return this.strip(); // Subtraction overflow + + assert(carry === -1); + carry = 0; + + for (i = 0; i < this.length; i++) { + w = -(this.words[i] | 0) + carry; + carry = w >> 26; + this.words[i] = w & 0x3ffffff; + } + + this.negative = 1; + return this.strip(); + }; + + BN.prototype._wordDiv = function _wordDiv(num, mode) { + var shift = this.length - num.length; + var a = this.clone(); + var b = num; // Normalize + + var bhi = b.words[b.length - 1] | 0; + + var bhiBits = this._countBits(bhi); + + shift = 26 - bhiBits; + + if (shift !== 0) { + b = b.ushln(shift); + a.iushln(shift); + bhi = b.words[b.length - 1] | 0; + } // Initialize quotient + + var m = a.length - b.length; + var q; + + if (mode !== "mod") { + q = new BN(null); + q.length = m + 1; + q.words = new Array(q.length); + + for (var i = 0; i < q.length; i++) { + q.words[i] = 0; + } + } + + var diff = a.clone()._ishlnsubmul(b, 1, m); + + if (diff.negative === 0) { + a = diff; + + if (q) { + q.words[m] = 1; + } + } + + for (var j = m - 1; j >= 0; j--) { + var qj = + (a.words[b.length + j] | 0) * 0x4000000 + + (a.words[b.length + j - 1] | 0); // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max + // (0x7ffffff) + + qj = Math.min((qj / bhi) | 0, 0x3ffffff); + + a._ishlnsubmul(b, qj, j); + + while (a.negative !== 0) { + qj--; + a.negative = 0; + + a._ishlnsubmul(b, 1, j); + + if (!a.isZero()) { + a.negative ^= 1; + } + } + + if (q) { + q.words[j] = qj; + } + } + + if (q) { + q.strip(); + } + + a.strip(); // Denormalize + + if (mode !== "div" && shift !== 0) { + a.iushrn(shift); + } + + return { + div: q || null, + mod: a, + }; + }; // NOTE: 1) `mode` can be set to `mod` to request mod only, + // to `div` to request div only, or be absent to + // request both div & mod + // 2) `positive` is true if unsigned mod is requested + + BN.prototype.divmod = function divmod(num, mode, positive) { + assert(!num.isZero()); + + if (this.isZero()) { + return { + div: new BN(0), + mod: new BN(0), + }; + } + + var div, mod, res; + + if (this.negative !== 0 && num.negative === 0) { + res = this.neg().divmod(num, mode); + + if (mode !== "mod") { + div = res.div.neg(); + } + + if (mode !== "div") { + mod = res.mod.neg(); + + if (positive && mod.negative !== 0) { + mod.iadd(num); + } + } + + return { + div: div, + mod: mod, + }; + } + + if (this.negative === 0 && num.negative !== 0) { + res = this.divmod(num.neg(), mode); + + if (mode !== "mod") { + div = res.div.neg(); + } + + return { + div: div, + mod: res.mod, + }; + } + + if ((this.negative & num.negative) !== 0) { + res = this.neg().divmod(num.neg(), mode); + + if (mode !== "div") { + mod = res.mod.neg(); + + if (positive && mod.negative !== 0) { + mod.isub(num); + } + } + + return { + div: res.div, + mod: mod, + }; + } // Both numbers are positive at this point + // Strip both numbers to approximate shift value + + if (num.length > this.length || this.cmp(num) < 0) { + return { + div: new BN(0), + mod: this, + }; + } // Very short reduction + + if (num.length === 1) { + if (mode === "div") { + return { + div: this.divn(num.words[0]), + mod: null, + }; + } + + if (mode === "mod") { + return { + div: null, + mod: new BN(this.modn(num.words[0])), + }; + } + + return { + div: this.divn(num.words[0]), + mod: new BN(this.modn(num.words[0])), + }; + } + + return this._wordDiv(num, mode); + }; // Find `this` / `num` + + BN.prototype.div = function div(num) { + return this.divmod(num, "div", false).div; + }; // Find `this` % `num` + + BN.prototype.mod = function mod(num) { + return this.divmod(num, "mod", false).mod; + }; + + BN.prototype.umod = function umod(num) { + return this.divmod(num, "mod", true).mod; + }; // Find Round(`this` / `num`) + + BN.prototype.divRound = function divRound(num) { + var dm = this.divmod(num); // Fast case - exact division + + if (dm.mod.isZero()) return dm.div; + var mod = + dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod; + var half = num.ushrn(1); + var r2 = num.andln(1); + var cmp = mod.cmp(half); // Round down + + if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div; // Round up + + return dm.div.negative !== 0 + ? dm.div.isubn(1) + : dm.div.iaddn(1); + }; + + BN.prototype.modn = function modn(num) { + assert(num <= 0x3ffffff); + var p = (1 << 26) % num; + var acc = 0; + + for (var i = this.length - 1; i >= 0; i--) { + acc = (p * acc + (this.words[i] | 0)) % num; + } + + return acc; + }; // In-place division by number + + BN.prototype.idivn = function idivn(num) { + assert(num <= 0x3ffffff); + var carry = 0; + + for (var i = this.length - 1; i >= 0; i--) { + var w = (this.words[i] | 0) + carry * 0x4000000; + this.words[i] = (w / num) | 0; + carry = w % num; + } + + return this.strip(); + }; + + BN.prototype.divn = function divn(num) { + return this.clone().idivn(num); + }; + + BN.prototype.egcd = function egcd(p) { + assert(p.negative === 0); + assert(!p.isZero()); + var x = this; + var y = p.clone(); + + if (x.negative !== 0) { + x = x.umod(p); + } else { + x = x.clone(); + } // A * x + B * y = x + + var A = new BN(1); + var B = new BN(0); // C * x + D * y = y + + var C = new BN(0); + var D = new BN(1); + var g = 0; + + while (x.isEven() && y.isEven()) { + x.iushrn(1); + y.iushrn(1); + ++g; + } + + var yp = y.clone(); + var xp = x.clone(); + + while (!x.isZero()) { + for ( + var i = 0, im = 1; + (x.words[0] & im) === 0 && i < 26; + ++i, im <<= 1 + ) {} + + if (i > 0) { + x.iushrn(i); + + while (i-- > 0) { + if (A.isOdd() || B.isOdd()) { + A.iadd(yp); + B.isub(xp); + } + + A.iushrn(1); + B.iushrn(1); + } + } + + for ( + var j = 0, jm = 1; + (y.words[0] & jm) === 0 && j < 26; + ++j, jm <<= 1 + ) {} + + if (j > 0) { + y.iushrn(j); + + while (j-- > 0) { + if (C.isOdd() || D.isOdd()) { + C.iadd(yp); + D.isub(xp); + } + + C.iushrn(1); + D.iushrn(1); + } + } + + if (x.cmp(y) >= 0) { + x.isub(y); + A.isub(C); + B.isub(D); + } else { + y.isub(x); + C.isub(A); + D.isub(B); + } + } + + return { + a: C, + b: D, + gcd: y.iushln(g), + }; + }; // This is reduced incarnation of the binary EEA + // above, designated to invert members of the + // _prime_ fields F(p) at a maximal speed + + BN.prototype._invmp = function _invmp(p) { + assert(p.negative === 0); + assert(!p.isZero()); + var a = this; + var b = p.clone(); + + if (a.negative !== 0) { + a = a.umod(p); + } else { + a = a.clone(); + } + + var x1 = new BN(1); + var x2 = new BN(0); + var delta = b.clone(); + + while (a.cmpn(1) > 0 && b.cmpn(1) > 0) { + for ( + var i = 0, im = 1; + (a.words[0] & im) === 0 && i < 26; + ++i, im <<= 1 + ) {} + + if (i > 0) { + a.iushrn(i); + + while (i-- > 0) { + if (x1.isOdd()) { + x1.iadd(delta); + } + + x1.iushrn(1); + } + } + + for ( + var j = 0, jm = 1; + (b.words[0] & jm) === 0 && j < 26; + ++j, jm <<= 1 + ) {} + + if (j > 0) { + b.iushrn(j); + + while (j-- > 0) { + if (x2.isOdd()) { + x2.iadd(delta); + } + + x2.iushrn(1); + } + } + + if (a.cmp(b) >= 0) { + a.isub(b); + x1.isub(x2); + } else { + b.isub(a); + x2.isub(x1); + } + } + + var res; + + if (a.cmpn(1) === 0) { + res = x1; + } else { + res = x2; + } + + if (res.cmpn(0) < 0) { + res.iadd(p); + } + + return res; + }; + + BN.prototype.gcd = function gcd(num) { + if (this.isZero()) return num.abs(); + if (num.isZero()) return this.abs(); + var a = this.clone(); + var b = num.clone(); + a.negative = 0; + b.negative = 0; // Remove common factor of two + + for (var shift = 0; a.isEven() && b.isEven(); shift++) { + a.iushrn(1); + b.iushrn(1); + } + + do { + while (a.isEven()) { + a.iushrn(1); + } + + while (b.isEven()) { + b.iushrn(1); + } + + var r = a.cmp(b); + + if (r < 0) { + // Swap `a` and `b` to make `a` always bigger than `b` + var t = a; + a = b; + b = t; + } else if (r === 0 || b.cmpn(1) === 0) { + break; + } + + a.isub(b); + } while (true); + + return b.iushln(shift); + }; // Invert number in the field F(num) + + BN.prototype.invm = function invm(num) { + return this.egcd(num).a.umod(num); + }; + + BN.prototype.isEven = function isEven() { + return (this.words[0] & 1) === 0; + }; + + BN.prototype.isOdd = function isOdd() { + return (this.words[0] & 1) === 1; + }; // And first word and num + + BN.prototype.andln = function andln(num) { + return this.words[0] & num; + }; // Increment at the bit position in-line + + BN.prototype.bincn = function bincn(bit) { + assert(typeof bit === "number"); + var r = bit % 26; + var s = (bit - r) / 26; + var q = 1 << r; // Fast case: bit is much higher than all existing words + + if (this.length <= s) { + this._expand(s + 1); + + this.words[s] |= q; + return this; + } // Add bit and propagate, if needed + + var carry = q; + + for (var i = s; carry !== 0 && i < this.length; i++) { + var w = this.words[i] | 0; + w += carry; + carry = w >>> 26; + w &= 0x3ffffff; + this.words[i] = w; + } + + if (carry !== 0) { + this.words[i] = carry; + this.length++; + } + + return this; + }; + + BN.prototype.isZero = function isZero() { + return this.length === 1 && this.words[0] === 0; + }; + + BN.prototype.cmpn = function cmpn(num) { + var negative = num < 0; + if (this.negative !== 0 && !negative) return -1; + if (this.negative === 0 && negative) return 1; + this.strip(); + var res; + + if (this.length > 1) { + res = 1; + } else { + if (negative) { + num = -num; + } + + assert(num <= 0x3ffffff, "Number is too big"); + var w = this.words[0] | 0; + res = w === num ? 0 : w < num ? -1 : 1; + } + + if (this.negative !== 0) return -res | 0; + return res; + }; // Compare two numbers and return: + // 1 - if `this` > `num` + // 0 - if `this` == `num` + // -1 - if `this` < `num` + + BN.prototype.cmp = function cmp(num) { + if (this.negative !== 0 && num.negative === 0) + return -1; + if (this.negative === 0 && num.negative !== 0) return 1; + var res = this.ucmp(num); + if (this.negative !== 0) return -res | 0; + return res; + }; // Unsigned comparison + + BN.prototype.ucmp = function ucmp(num) { + // At this point both numbers have the same sign + if (this.length > num.length) return 1; + if (this.length < num.length) return -1; + var res = 0; + + for (var i = this.length - 1; i >= 0; i--) { + var a = this.words[i] | 0; + var b = num.words[i] | 0; + if (a === b) continue; + + if (a < b) { + res = -1; + } else if (a > b) { + res = 1; + } + + break; + } + + return res; + }; + + BN.prototype.gtn = function gtn(num) { + return this.cmpn(num) === 1; + }; + + BN.prototype.gt = function gt(num) { + return this.cmp(num) === 1; + }; + + BN.prototype.gten = function gten(num) { + return this.cmpn(num) >= 0; + }; + + BN.prototype.gte = function gte(num) { + return this.cmp(num) >= 0; + }; + + BN.prototype.ltn = function ltn(num) { + return this.cmpn(num) === -1; + }; + + BN.prototype.lt = function lt(num) { + return this.cmp(num) === -1; + }; + + BN.prototype.lten = function lten(num) { + return this.cmpn(num) <= 0; + }; + + BN.prototype.lte = function lte(num) { + return this.cmp(num) <= 0; + }; + + BN.prototype.eqn = function eqn(num) { + return this.cmpn(num) === 0; + }; + + BN.prototype.eq = function eq(num) { + return this.cmp(num) === 0; + }; // + // A reduce context, could be using montgomery or something better, depending + // on the `m` itself. + // + + BN.red = function red(num) { + return new Red(num); + }; + + BN.prototype.toRed = function toRed(ctx) { + assert( + !this.red, + "Already a number in reduction context" + ); + assert( + this.negative === 0, + "red works only with positives" + ); + return ctx.convertTo(this)._forceRed(ctx); + }; + + BN.prototype.fromRed = function fromRed() { + assert( + this.red, + "fromRed works only with numbers in reduction context" + ); + return this.red.convertFrom(this); + }; + + BN.prototype._forceRed = function _forceRed(ctx) { + this.red = ctx; + return this; + }; + + BN.prototype.forceRed = function forceRed(ctx) { + assert( + !this.red, + "Already a number in reduction context" + ); + return this._forceRed(ctx); + }; + + BN.prototype.redAdd = function redAdd(num) { + assert(this.red, "redAdd works only with red numbers"); + return this.red.add(this, num); + }; + + BN.prototype.redIAdd = function redIAdd(num) { + assert(this.red, "redIAdd works only with red numbers"); + return this.red.iadd(this, num); + }; + + BN.prototype.redSub = function redSub(num) { + assert(this.red, "redSub works only with red numbers"); + return this.red.sub(this, num); + }; + + BN.prototype.redISub = function redISub(num) { + assert(this.red, "redISub works only with red numbers"); + return this.red.isub(this, num); + }; + + BN.prototype.redShl = function redShl(num) { + assert(this.red, "redShl works only with red numbers"); + return this.red.shl(this, num); + }; + + BN.prototype.redMul = function redMul(num) { + assert(this.red, "redMul works only with red numbers"); + + this.red._verify2(this, num); + + return this.red.mul(this, num); + }; + + BN.prototype.redIMul = function redIMul(num) { + assert(this.red, "redMul works only with red numbers"); + + this.red._verify2(this, num); + + return this.red.imul(this, num); + }; + + BN.prototype.redSqr = function redSqr() { + assert(this.red, "redSqr works only with red numbers"); + + this.red._verify1(this); + + return this.red.sqr(this); + }; + + BN.prototype.redISqr = function redISqr() { + assert(this.red, "redISqr works only with red numbers"); + + this.red._verify1(this); + + return this.red.isqr(this); + }; // Square root over p + + BN.prototype.redSqrt = function redSqrt() { + assert(this.red, "redSqrt works only with red numbers"); + + this.red._verify1(this); + + return this.red.sqrt(this); + }; + + BN.prototype.redInvm = function redInvm() { + assert(this.red, "redInvm works only with red numbers"); + + this.red._verify1(this); + + return this.red.invm(this); + }; // Return negative clone of `this` % `red modulo` + + BN.prototype.redNeg = function redNeg() { + assert(this.red, "redNeg works only with red numbers"); + + this.red._verify1(this); + + return this.red.neg(this); + }; + + BN.prototype.redPow = function redPow(num) { + assert(this.red && !num.red, "redPow(normalNum)"); + + this.red._verify1(this); + + return this.red.pow(this, num); + }; // Prime numbers with efficient reduction + + var primes = { + k256: null, + p224: null, + p192: null, + p25519: null, + }; // Pseudo-Mersenne prime + + function MPrime(name, p) { + // P = 2 ^ N - K + this.name = name; + this.p = new BN(p, 16); + this.n = this.p.bitLength(); + this.k = new BN(1).iushln(this.n).isub(this.p); + this.tmp = this._tmp(); + } + + MPrime.prototype._tmp = function _tmp() { + var tmp = new BN(null); + tmp.words = new Array(Math.ceil(this.n / 13)); + return tmp; + }; + + MPrime.prototype.ireduce = function ireduce(num) { + // Assumes that `num` is less than `P^2` + // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P) + var r = num; + var rlen; + + do { + this.split(r, this.tmp); + r = this.imulK(r); + r = r.iadd(this.tmp); + rlen = r.bitLength(); + } while (rlen > this.n); + + var cmp = rlen < this.n ? -1 : r.ucmp(this.p); + + if (cmp === 0) { + r.words[0] = 0; + r.length = 1; + } else if (cmp > 0) { + r.isub(this.p); + } else { + r.strip(); + } + + return r; + }; + + MPrime.prototype.split = function split(input, out) { + input.iushrn(this.n, 0, out); + }; + + MPrime.prototype.imulK = function imulK(num) { + return num.imul(this.k); + }; + + function K256() { + MPrime.call( + this, + "k256", + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" + ); + } + + inherits(K256, MPrime); + + K256.prototype.split = function split(input, output) { + // 256 = 9 * 26 + 22 + var mask = 0x3fffff; + var outLen = Math.min(input.length, 9); + + for (var i = 0; i < outLen; i++) { + output.words[i] = input.words[i]; + } + + output.length = outLen; + + if (input.length <= 9) { + input.words[0] = 0; + input.length = 1; + return; + } // Shift by 9 limbs + + var prev = input.words[9]; + output.words[output.length++] = prev & mask; + + for (i = 10; i < input.length; i++) { + var next = input.words[i] | 0; + input.words[i - 10] = + ((next & mask) << 4) | (prev >>> 22); + prev = next; + } + + prev >>>= 22; + input.words[i - 10] = prev; + + if (prev === 0 && input.length > 10) { + input.length -= 10; + } else { + input.length -= 9; + } + }; + + K256.prototype.imulK = function imulK(num) { + // K = 0x1000003d1 = [ 0x40, 0x3d1 ] + num.words[num.length] = 0; + num.words[num.length + 1] = 0; + num.length += 2; // Bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390 + + var lo = 0; + + for (var i = 0; i < num.length; i++) { + var w = num.words[i] | 0; + lo += w * 0x3d1; + num.words[i] = lo & 0x3ffffff; + lo = w * 0x40 + ((lo / 0x4000000) | 0); + } // Fast length reduction + + if (num.words[num.length - 1] === 0) { + num.length--; + + if (num.words[num.length - 1] === 0) { + num.length--; + } + } + + return num; + }; + + function P224() { + MPrime.call( + this, + "p224", + "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" + ); + } + + inherits(P224, MPrime); + + function P192() { + MPrime.call( + this, + "p192", + "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" + ); + } + + inherits(P192, MPrime); + + function P25519() { + // 2 ^ 255 - 19 + MPrime.call( + this, + "25519", + "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" + ); + } + + inherits(P25519, MPrime); + + P25519.prototype.imulK = function imulK(num) { + // K = 0x13 + var carry = 0; + + for (var i = 0; i < num.length; i++) { + var hi = (num.words[i] | 0) * 0x13 + carry; + var lo = hi & 0x3ffffff; + hi >>>= 26; + num.words[i] = lo; + carry = hi; + } + + if (carry !== 0) { + num.words[num.length++] = carry; + } + + return num; + }; // Exported mostly for testing purposes, use plain name instead + + BN._prime = function prime(name) { + // Cached version of prime + if (primes[name]) return primes[name]; + var prime; + + if (name === "k256") { + prime = new K256(); + } else if (name === "p224") { + prime = new P224(); + } else if (name === "p192") { + prime = new P192(); + } else if (name === "p25519") { + prime = new P25519(); + } else { + throw new Error("Unknown prime " + name); + } + + primes[name] = prime; + return prime; + }; // + // Base reduction engine + // + + function Red(m) { + if (typeof m === "string") { + var prime = BN._prime(m); + + this.m = prime.p; + this.prime = prime; + } else { + assert(m.gtn(1), "modulus must be greater than 1"); + this.m = m; + this.prime = null; + } + } + + Red.prototype._verify1 = function _verify1(a) { + assert( + a.negative === 0, + "red works only with positives" + ); + assert(a.red, "red works only with red numbers"); + }; + + Red.prototype._verify2 = function _verify2(a, b) { + assert( + (a.negative | b.negative) === 0, + "red works only with positives" + ); + assert( + a.red && a.red === b.red, + "red works only with red numbers" + ); + }; + + Red.prototype.imod = function imod(a) { + if (this.prime) + return this.prime.ireduce(a)._forceRed(this); + return a.umod(this.m)._forceRed(this); + }; + + Red.prototype.neg = function neg(a) { + if (a.isZero()) { + return a.clone(); + } + + return this.m.sub(a)._forceRed(this); + }; + + Red.prototype.add = function add(a, b) { + this._verify2(a, b); + + var res = a.add(b); + + if (res.cmp(this.m) >= 0) { + res.isub(this.m); + } + + return res._forceRed(this); + }; + + Red.prototype.iadd = function iadd(a, b) { + this._verify2(a, b); + + var res = a.iadd(b); + + if (res.cmp(this.m) >= 0) { + res.isub(this.m); + } + + return res; + }; + + Red.prototype.sub = function sub(a, b) { + this._verify2(a, b); + + var res = a.sub(b); + + if (res.cmpn(0) < 0) { + res.iadd(this.m); + } + + return res._forceRed(this); + }; + + Red.prototype.isub = function isub(a, b) { + this._verify2(a, b); + + var res = a.isub(b); + + if (res.cmpn(0) < 0) { + res.iadd(this.m); + } + + return res; + }; + + Red.prototype.shl = function shl(a, num) { + this._verify1(a); + + return this.imod(a.ushln(num)); + }; + + Red.prototype.imul = function imul(a, b) { + this._verify2(a, b); + + return this.imod(a.imul(b)); + }; + + Red.prototype.mul = function mul(a, b) { + this._verify2(a, b); + + return this.imod(a.mul(b)); + }; + + Red.prototype.isqr = function isqr(a) { + return this.imul(a, a.clone()); + }; + + Red.prototype.sqr = function sqr(a) { + return this.mul(a, a); + }; + + Red.prototype.sqrt = function sqrt(a) { + if (a.isZero()) return a.clone(); + var mod3 = this.m.andln(3); + assert(mod3 % 2 === 1); // Fast case + + if (mod3 === 3) { + var pow = this.m.add(new BN(1)).iushrn(2); + return this.pow(a, pow); + } // Tonelli-Shanks algorithm (Totally unoptimized and slow) + // + // Find Q and S, that Q * 2 ^ S = (P - 1) + + var q = this.m.subn(1); + var s = 0; + + while (!q.isZero() && q.andln(1) === 0) { + s++; + q.iushrn(1); + } + + assert(!q.isZero()); + var one = new BN(1).toRed(this); + var nOne = one.redNeg(); // Find quadratic non-residue + // NOTE: Max is such because of generalized Riemann hypothesis. + + var lpow = this.m.subn(1).iushrn(1); + var z = this.m.bitLength(); + z = new BN(2 * z * z).toRed(this); + + while (this.pow(z, lpow).cmp(nOne) !== 0) { + z.redIAdd(nOne); + } + + var c = this.pow(z, q); + var r = this.pow(a, q.addn(1).iushrn(1)); + var t = this.pow(a, q); + var m = s; + + while (t.cmp(one) !== 0) { + var tmp = t; + + for (var i = 0; tmp.cmp(one) !== 0; i++) { + tmp = tmp.redSqr(); + } + + assert(i < m); + var b = this.pow(c, new BN(1).iushln(m - i - 1)); + r = r.redMul(b); + c = b.redSqr(); + t = t.redMul(c); + m = i; + } + + return r; + }; + + Red.prototype.invm = function invm(a) { + var inv = a._invmp(this.m); + + if (inv.negative !== 0) { + inv.negative = 0; + return this.imod(inv).redNeg(); + } + return this.imod(inv); + + }; + + Red.prototype.pow = function pow(a, num) { + if (num.isZero()) return new BN(1).toRed(this); + if (num.cmpn(1) === 0) return a.clone(); + var windowSize = 4; + var wnd = new Array(1 << windowSize); + wnd[0] = new BN(1).toRed(this); + wnd[1] = a; + + for (var i = 2; i < wnd.length; i++) { + wnd[i] = this.mul(wnd[i - 1], a); + } + + var res = wnd[0]; + var current = 0; + var currentLen = 0; + var start = num.bitLength() % 26; + + if (start === 0) { + start = 26; + } + + for (i = num.length - 1; i >= 0; i--) { + var word = num.words[i]; + + for (var j = start - 1; j >= 0; j--) { + var bit = (word >> j) & 1; + + if (res !== wnd[0]) { + res = this.sqr(res); + } + + if (bit === 0 && current === 0) { + currentLen = 0; + continue; + } + + current <<= 1; + current |= bit; + currentLen++; + if ( + currentLen !== windowSize && + (i !== 0 || j !== 0) + ) + continue; + res = this.mul(res, wnd[current]); + currentLen = 0; + current = 0; + } + + start = 26; + } + + return res; + }; + + Red.prototype.convertTo = function convertTo(num) { + var r = num.umod(this.m); + return r === num ? r.clone() : r; + }; + + Red.prototype.convertFrom = function convertFrom(num) { + var res = num.clone(); + res.red = null; + return res; + }; // + // Montgomery method engine + // + + BN.mont = function mont(num) { + return new Mont(num); + }; + + function Mont(m) { + Red.call(this, m); + this.shift = this.m.bitLength(); + + if (this.shift % 26 !== 0) { + this.shift += 26 - (this.shift % 26); + } + + this.r = new BN(1).iushln(this.shift); + this.r2 = this.imod(this.r.sqr()); + this.rinv = this.r._invmp(this.m); + this.minv = this.rinv.mul(this.r).isubn(1).div(this.m); + this.minv = this.minv.umod(this.r); + this.minv = this.r.sub(this.minv); + } + + inherits(Mont, Red); + + Mont.prototype.convertTo = function convertTo(num) { + return this.imod(num.ushln(this.shift)); + }; + + Mont.prototype.convertFrom = function convertFrom(num) { + var r = this.imod(num.mul(this.rinv)); + r.red = null; + return r; + }; + + Mont.prototype.imul = function imul(a, b) { + if (a.isZero() || b.isZero()) { + a.words[0] = 0; + a.length = 1; + return a; + } + + var t = a.imul(b); + var c = t + .maskn(this.shift) + .mul(this.minv) + .imaskn(this.shift) + .mul(this.m); + var u = t.isub(c).iushrn(this.shift); + var res = u; + + if (u.cmp(this.m) >= 0) { + res = u.isub(this.m); + } else if (u.cmpn(0) < 0) { + res = u.iadd(this.m); + } + + return res._forceRed(this); + }; + + Mont.prototype.mul = function mul(a, b) { + if (a.isZero() || b.isZero()) + return new BN(0)._forceRed(this); + var t = a.mul(b); + var c = t + .maskn(this.shift) + .mul(this.minv) + .imaskn(this.shift) + .mul(this.m); + var u = t.isub(c).iushrn(this.shift); + var res = u; + + if (u.cmp(this.m) >= 0) { + res = u.isub(this.m); + } else if (u.cmpn(0) < 0) { + res = u.iadd(this.m); + } + + return res._forceRed(this); + }; + + Mont.prototype.invm = function invm(a) { + // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R + var res = this.imod(a._invmp(this.m).mul(this.r2)); + return res._forceRed(this); + }; + })(false || module, this); + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js" + )(module) + )); + + /***/ + }, + + /***/ "./node_modules/brorand/index.js": + /* !***************************************!*\ + !*** ./node_modules/brorand/index.js ***! + \***************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + var r; + + module.exports = function rand(len) { + if (!r) r = new Rand(null); + return r.generate(len); + }; + + function Rand(rand) { + this.rand = rand; + } + + module.exports.Rand = Rand; + + Rand.prototype.generate = function generate(len) { + return this._rand(len); + }; // Emulate crypto API using randy + + Rand.prototype._rand = function _rand(n) { + if (this.rand.getBytes) return this.rand.getBytes(n); + var res = new Uint8Array(n); + + for (var i = 0; i < res.length; i++) { + res[i] = this.rand.getByte(); + } + + return res; + }; + + if ( + (typeof self === "undefined" ? "undefined" : _typeof(self)) === + "object" + ) { + if (self.crypto && self.crypto.getRandomValues) { + // Modern browsers + Rand.prototype._rand = function _rand(n) { + var arr = new Uint8Array(n); + self.crypto.getRandomValues(arr); + return arr; + }; + } else if (self.msCrypto && self.msCrypto.getRandomValues) { + // IE + Rand.prototype._rand = function _rand(n) { + var arr = new Uint8Array(n); + self.msCrypto.getRandomValues(arr); + return arr; + }; // Safari's WebWorkers do not have `crypto` + } else if ( + (typeof window === "undefined" + ? "undefined" + : _typeof(window)) === "object" + ) { + // Old junk + Rand.prototype._rand = function () { + throw new Error("Not implemented yet"); + }; + } + } else { + // Node.js or Web worker with no crypto support + try { + var crypto = __webpack_require__(/* ! crypto */ 3); + + if (typeof crypto.randomBytes !== "function") + throw new Error("Not supported"); + + Rand.prototype._rand = function _rand(n) { + return crypto.randomBytes(n); + }; + } catch (e) {} + } + + /***/ + }, + + /***/ "./node_modules/browserify-aes/aes.js": + /* !********************************************!*\ + !*** ./node_modules/browserify-aes/aes.js ***! + \********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + // Based on the aes implimentation in triple sec + // https://github.com/keybase/triplesec + // which is in turn based on the one from crypto-js + // https://code.google.com/p/crypto-js/ + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + function asUInt32Array(buf) { + if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf); + var len = (buf.length / 4) | 0; + var out = new Array(len); + + for (var i = 0; i < len; i++) { + out[i] = buf.readUInt32BE(i * 4); + } + + return out; + } + + function scrubVec(v) { + for (var i = 0; i < v.length; v++) { + v[i] = 0; + } + } + + function cryptBlock(M, keySchedule, SUB_MIX, SBOX, nRounds) { + var SUB_MIX0 = SUB_MIX[0]; + var SUB_MIX1 = SUB_MIX[1]; + var SUB_MIX2 = SUB_MIX[2]; + var SUB_MIX3 = SUB_MIX[3]; + var s0 = M[0] ^ keySchedule[0]; + var s1 = M[1] ^ keySchedule[1]; + var s2 = M[2] ^ keySchedule[2]; + var s3 = M[3] ^ keySchedule[3]; + var t0, t1, t2, t3; + var ksRow = 4; + + for (var round = 1; round < nRounds; round++) { + t0 = + SUB_MIX0[s0 >>> 24] ^ + SUB_MIX1[(s1 >>> 16) & 0xff] ^ + SUB_MIX2[(s2 >>> 8) & 0xff] ^ + SUB_MIX3[s3 & 0xff] ^ + keySchedule[ksRow++]; + t1 = + SUB_MIX0[s1 >>> 24] ^ + SUB_MIX1[(s2 >>> 16) & 0xff] ^ + SUB_MIX2[(s3 >>> 8) & 0xff] ^ + SUB_MIX3[s0 & 0xff] ^ + keySchedule[ksRow++]; + t2 = + SUB_MIX0[s2 >>> 24] ^ + SUB_MIX1[(s3 >>> 16) & 0xff] ^ + SUB_MIX2[(s0 >>> 8) & 0xff] ^ + SUB_MIX3[s1 & 0xff] ^ + keySchedule[ksRow++]; + t3 = + SUB_MIX0[s3 >>> 24] ^ + SUB_MIX1[(s0 >>> 16) & 0xff] ^ + SUB_MIX2[(s1 >>> 8) & 0xff] ^ + SUB_MIX3[s2 & 0xff] ^ + keySchedule[ksRow++]; + s0 = t0; + s1 = t1; + s2 = t2; + s3 = t3; + } + + t0 = + ((SBOX[s0 >>> 24] << 24) | + (SBOX[(s1 >>> 16) & 0xff] << 16) | + (SBOX[(s2 >>> 8) & 0xff] << 8) | + SBOX[s3 & 0xff]) ^ + keySchedule[ksRow++]; + t1 = + ((SBOX[s1 >>> 24] << 24) | + (SBOX[(s2 >>> 16) & 0xff] << 16) | + (SBOX[(s3 >>> 8) & 0xff] << 8) | + SBOX[s0 & 0xff]) ^ + keySchedule[ksRow++]; + t2 = + ((SBOX[s2 >>> 24] << 24) | + (SBOX[(s3 >>> 16) & 0xff] << 16) | + (SBOX[(s0 >>> 8) & 0xff] << 8) | + SBOX[s1 & 0xff]) ^ + keySchedule[ksRow++]; + t3 = + ((SBOX[s3 >>> 24] << 24) | + (SBOX[(s0 >>> 16) & 0xff] << 16) | + (SBOX[(s1 >>> 8) & 0xff] << 8) | + SBOX[s2 & 0xff]) ^ + keySchedule[ksRow++]; + t0 >>>= 0; + t1 >>>= 0; + t2 >>>= 0; + t3 >>>= 0; + return [t0, t1, t2, t3]; + } // AES constants + + var RCON = [ + 0x00, + 0x01, + 0x02, + 0x04, + 0x08, + 0x10, + 0x20, + 0x40, + 0x80, + 0x1b, + 0x36, + ]; + + var G = (function () { + // Compute double table + var d = new Array(256); + + for (var j = 0; j < 256; j++) { + if (j < 128) { + d[j] = j << 1; + } else { + d[j] = (j << 1) ^ 0x11b; + } + } + + var SBOX = []; + var INV_SBOX = []; + var SUB_MIX = [[], [], [], []]; + var INV_SUB_MIX = [[], [], [], []]; // Walk GF(2^8) + + var x = 0; + var xi = 0; + + for (var i = 0; i < 256; ++i) { + // Compute sbox + var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4); + sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63; + SBOX[x] = sx; + INV_SBOX[sx] = x; // Compute multiplication + + var x2 = d[x]; + var x4 = d[x2]; + var x8 = d[x4]; // Compute sub bytes, mix columns tables + + var t = (d[sx] * 0x101) ^ (sx * 0x1010100); + SUB_MIX[0][x] = (t << 24) | (t >>> 8); + SUB_MIX[1][x] = (t << 16) | (t >>> 16); + SUB_MIX[2][x] = (t << 8) | (t >>> 24); + SUB_MIX[3][x] = t; // Compute inv sub bytes, inv mix columns tables + + t = + (x8 * 0x1010101) ^ + (x4 * 0x10001) ^ + (x2 * 0x101) ^ + (x * 0x1010100); + INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8); + INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16); + INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24); + INV_SUB_MIX[3][sx] = t; + + if (x === 0) { + x = xi = 1; + } else { + x = x2 ^ d[d[d[x8 ^ x2]]]; + xi ^= d[d[xi]]; + } + } + + return { + SBOX: SBOX, + INV_SBOX: INV_SBOX, + SUB_MIX: SUB_MIX, + INV_SUB_MIX: INV_SUB_MIX, + }; + })(); + + function AES(key) { + this._key = asUInt32Array(key); + + this._reset(); + } + + AES.blockSize = 4 * 4; + AES.keySize = 256 / 8; + AES.prototype.blockSize = AES.blockSize; + AES.prototype.keySize = AES.keySize; + + AES.prototype._reset = function () { + var keyWords = this._key; + var keySize = keyWords.length; + var nRounds = keySize + 6; + var ksRows = (nRounds + 1) * 4; + var keySchedule = []; + + for (var k = 0; k < keySize; k++) { + keySchedule[k] = keyWords[k]; + } + + for (k = keySize; k < ksRows; k++) { + var t = keySchedule[k - 1]; + + if (k % keySize === 0) { + t = (t << 8) | (t >>> 24); + t = + (G.SBOX[t >>> 24] << 24) | + (G.SBOX[(t >>> 16) & 0xff] << 16) | + (G.SBOX[(t >>> 8) & 0xff] << 8) | + G.SBOX[t & 0xff]; + t ^= RCON[(k / keySize) | 0] << 24; + } else if (keySize > 6 && k % keySize === 4) { + t = + (G.SBOX[t >>> 24] << 24) | + (G.SBOX[(t >>> 16) & 0xff] << 16) | + (G.SBOX[(t >>> 8) & 0xff] << 8) | + G.SBOX[t & 0xff]; + } + + keySchedule[k] = keySchedule[k - keySize] ^ t; + } + + var invKeySchedule = []; + + for (var ik = 0; ik < ksRows; ik++) { + var ksR = ksRows - ik; + var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)]; + + if (ik < 4 || ksR <= 4) { + invKeySchedule[ik] = tt; + } else { + invKeySchedule[ik] = + G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^ + G.INV_SUB_MIX[1][G.SBOX[(tt >>> 16) & 0xff]] ^ + G.INV_SUB_MIX[2][G.SBOX[(tt >>> 8) & 0xff]] ^ + G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]]; + } + } + + this._nRounds = nRounds; + this._keySchedule = keySchedule; + this._invKeySchedule = invKeySchedule; + }; + + AES.prototype.encryptBlockRaw = function (M) { + M = asUInt32Array(M); + return cryptBlock( + M, + this._keySchedule, + G.SUB_MIX, + G.SBOX, + this._nRounds + ); + }; + + AES.prototype.encryptBlock = function (M) { + var out = this.encryptBlockRaw(M); + var buf = Buffer.allocUnsafe(16); + buf.writeUInt32BE(out[0], 0); + buf.writeUInt32BE(out[1], 4); + buf.writeUInt32BE(out[2], 8); + buf.writeUInt32BE(out[3], 12); + return buf; + }; + + AES.prototype.decryptBlock = function (M) { + M = asUInt32Array(M); // Swap + + var m1 = M[1]; + M[1] = M[3]; + M[3] = m1; + var out = cryptBlock( + M, + this._invKeySchedule, + G.INV_SUB_MIX, + G.INV_SBOX, + this._nRounds + ); + var buf = Buffer.allocUnsafe(16); + buf.writeUInt32BE(out[0], 0); + buf.writeUInt32BE(out[3], 4); + buf.writeUInt32BE(out[2], 8); + buf.writeUInt32BE(out[1], 12); + return buf; + }; + + AES.prototype.scrub = function () { + scrubVec(this._keySchedule); + scrubVec(this._invKeySchedule); + scrubVec(this._key); + }; + + module.exports.AES = AES; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/authCipher.js": + /* !***************************************************!*\ + !*** ./node_modules/browserify-aes/authCipher.js ***! + \***************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var aes = __webpack_require__( + /* ! ./aes */ "./node_modules/browserify-aes/aes.js" + ); + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var Transform = __webpack_require__( + /* ! cipher-base */ "./node_modules/cipher-base/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var GHASH = __webpack_require__( + /* ! ./ghash */ "./node_modules/browserify-aes/ghash.js" + ); + + var xor = __webpack_require__( + /* ! buffer-xor */ "./node_modules/buffer-xor/index.js" + ); + + var incr32 = __webpack_require__( + /* ! ./incr32 */ "./node_modules/browserify-aes/incr32.js" + ); + + function xorTest(a, b) { + var out = 0; + if (a.length !== b.length) out++; + var len = Math.min(a.length, b.length); + + for (var i = 0; i < len; ++i) { + out += a[i] ^ b[i]; + } + + return out; + } + + function calcIv(self, iv, ck) { + if (iv.length === 12) { + self._finID = Buffer.concat([ + iv, + Buffer.from([0, 0, 0, 1]), + ]); + return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])]); + } + + var ghash = new GHASH(ck); + var len = iv.length; + var toPad = len % 16; + ghash.update(iv); + + if (toPad) { + toPad = 16 - toPad; + ghash.update(Buffer.alloc(toPad, 0)); + } + + ghash.update(Buffer.alloc(8, 0)); + var ivBits = len * 8; + var tail = Buffer.alloc(8); + tail.writeUIntBE(ivBits, 0, 8); + ghash.update(tail); + self._finID = ghash.state; + var out = Buffer.from(self._finID); + incr32(out); + return out; + } + + function StreamCipher(mode, key, iv, decrypt) { + Transform.call(this); + var h = Buffer.alloc(4, 0); + this._cipher = new aes.AES(key); + + var ck = this._cipher.encryptBlock(h); + + this._ghash = new GHASH(ck); + iv = calcIv(this, iv, ck); + this._prev = Buffer.from(iv); + this._cache = Buffer.allocUnsafe(0); + this._secCache = Buffer.allocUnsafe(0); + this._decrypt = decrypt; + this._alen = 0; + this._len = 0; + this._mode = mode; + this._authTag = null; + this._called = false; + } + + inherits(StreamCipher, Transform); + + StreamCipher.prototype._update = function (chunk) { + if (!this._called && this._alen) { + var rump = 16 - (this._alen % 16); + + if (rump < 16) { + rump = Buffer.alloc(rump, 0); + + this._ghash.update(rump); + } + } + + this._called = true; + + var out = this._mode.encrypt(this, chunk); + + if (this._decrypt) { + this._ghash.update(chunk); + } else { + this._ghash.update(out); + } + + this._len += chunk.length; + return out; + }; + + StreamCipher.prototype._final = function () { + if (this._decrypt && !this._authTag) + throw new Error( + "Unsupported state or unable to authenticate data" + ); + var tag = xor( + this._ghash.final(this._alen * 8, this._len * 8), + this._cipher.encryptBlock(this._finID) + ); + if (this._decrypt && xorTest(tag, this._authTag)) + throw new Error( + "Unsupported state or unable to authenticate data" + ); + this._authTag = tag; + + this._cipher.scrub(); + }; + + StreamCipher.prototype.getAuthTag = function getAuthTag() { + if (this._decrypt || !Buffer.isBuffer(this._authTag)) + throw new Error( + "Attempting to get auth tag in unsupported state" + ); + return this._authTag; + }; + + StreamCipher.prototype.setAuthTag = function setAuthTag(tag) { + if (!this._decrypt) + throw new Error( + "Attempting to set auth tag in unsupported state" + ); + this._authTag = tag; + }; + + StreamCipher.prototype.setAAD = function setAAD(buf) { + if (this._called) + throw new Error( + "Attempting to set AAD in unsupported state" + ); + + this._ghash.update(buf); + + this._alen += buf.length; + }; + + module.exports = StreamCipher; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/browser.js": + /* !************************************************!*\ + !*** ./node_modules/browserify-aes/browser.js ***! + \************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var ciphers = __webpack_require__( + /* ! ./encrypter */ "./node_modules/browserify-aes/encrypter.js" + ); + + var deciphers = __webpack_require__( + /* ! ./decrypter */ "./node_modules/browserify-aes/decrypter.js" + ); + + var modes = __webpack_require__( + /* ! ./modes/list.json */ "./node_modules/browserify-aes/modes/list.json" + ); + + function getCiphers() { + return Object.keys(modes); + } + + exports.createCipher = exports.Cipher = ciphers.createCipher; + exports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv; + exports.createDecipher = exports.Decipher = + deciphers.createDecipher; + exports.createDecipheriv = exports.Decipheriv = + deciphers.createDecipheriv; + exports.listCiphers = exports.getCiphers = getCiphers; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/decrypter.js": + /* !**************************************************!*\ + !*** ./node_modules/browserify-aes/decrypter.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var AuthCipher = __webpack_require__( + /* ! ./authCipher */ "./node_modules/browserify-aes/authCipher.js" + ); + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var MODES = __webpack_require__( + /* ! ./modes */ "./node_modules/browserify-aes/modes/index.js" + ); + + var StreamCipher = __webpack_require__( + /* ! ./streamCipher */ "./node_modules/browserify-aes/streamCipher.js" + ); + + var Transform = __webpack_require__( + /* ! cipher-base */ "./node_modules/cipher-base/index.js" + ); + + var aes = __webpack_require__( + /* ! ./aes */ "./node_modules/browserify-aes/aes.js" + ); + + var ebtk = __webpack_require__( + /* ! evp_bytestokey */ "./node_modules/evp_bytestokey/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + function Decipher(mode, key, iv) { + Transform.call(this); + this._cache = new Splitter(); + this._last = void 0; + this._cipher = new aes.AES(key); + this._prev = Buffer.from(iv); + this._mode = mode; + this._autopadding = true; + } + + inherits(Decipher, Transform); + + Decipher.prototype._update = function (data) { + this._cache.add(data); + + var chunk; + var thing; + var out = []; + + while ((chunk = this._cache.get(this._autopadding))) { + thing = this._mode.decrypt(this, chunk); + out.push(thing); + } + + return Buffer.concat(out); + }; + + Decipher.prototype._final = function () { + var chunk = this._cache.flush(); + + if (this._autopadding) { + return unpad(this._mode.decrypt(this, chunk)); + } else if (chunk) { + throw new Error("data not multiple of block length"); + } + }; + + Decipher.prototype.setAutoPadding = function (setTo) { + this._autopadding = Boolean(setTo); + return this; + }; + + function Splitter() { + this.cache = Buffer.allocUnsafe(0); + } + + Splitter.prototype.add = function (data) { + this.cache = Buffer.concat([this.cache, data]); + }; + + Splitter.prototype.get = function (autoPadding) { + var out; + + if (autoPadding) { + if (this.cache.length > 16) { + out = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + return out; + } + } else if (this.cache.length >= 16) { + out = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + return out; + } + + return null; + }; + + Splitter.prototype.flush = function () { + if (this.cache.length) return this.cache; + }; + + function unpad(last) { + var padded = last[15]; + + if (padded < 1 || padded > 16) { + throw new Error("unable to decrypt data"); + } + + var i = -1; + + while (++i < padded) { + if (last[i + (16 - padded)] !== padded) { + throw new Error("unable to decrypt data"); + } + } + + if (padded === 16) return; + return last.slice(0, 16 - padded); + } + + function createDecipheriv(suite, password, iv) { + var config = MODES[suite.toLowerCase()]; + if (!config) throw new TypeError("invalid suite type"); + if (typeof iv === "string") iv = Buffer.from(iv); + if (config.mode !== "GCM" && iv.length !== config.iv) + throw new TypeError("invalid iv length " + iv.length); + if (typeof password === "string") + password = Buffer.from(password); + if (password.length !== config.key / 8) + throw new TypeError( + "invalid key length " + password.length + ); + + if (config.type === "stream") { + return new StreamCipher(config.module, password, iv, true); + } else if (config.type === "auth") { + return new AuthCipher(config.module, password, iv, true); + } + + return new Decipher(config.module, password, iv); + } + + function createDecipher(suite, password) { + var config = MODES[suite.toLowerCase()]; + if (!config) throw new TypeError("invalid suite type"); + var keys = ebtk(password, false, config.key, config.iv); + return createDecipheriv(suite, keys.key, keys.iv); + } + + exports.createDecipher = createDecipher; + exports.createDecipheriv = createDecipheriv; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/encrypter.js": + /* !**************************************************!*\ + !*** ./node_modules/browserify-aes/encrypter.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var MODES = __webpack_require__( + /* ! ./modes */ "./node_modules/browserify-aes/modes/index.js" + ); + + var AuthCipher = __webpack_require__( + /* ! ./authCipher */ "./node_modules/browserify-aes/authCipher.js" + ); + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var StreamCipher = __webpack_require__( + /* ! ./streamCipher */ "./node_modules/browserify-aes/streamCipher.js" + ); + + var Transform = __webpack_require__( + /* ! cipher-base */ "./node_modules/cipher-base/index.js" + ); + + var aes = __webpack_require__( + /* ! ./aes */ "./node_modules/browserify-aes/aes.js" + ); + + var ebtk = __webpack_require__( + /* ! evp_bytestokey */ "./node_modules/evp_bytestokey/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + function Cipher(mode, key, iv) { + Transform.call(this); + this._cache = new Splitter(); + this._cipher = new aes.AES(key); + this._prev = Buffer.from(iv); + this._mode = mode; + this._autopadding = true; + } + + inherits(Cipher, Transform); + + Cipher.prototype._update = function (data) { + this._cache.add(data); + + var chunk; + var thing; + var out = []; + + while ((chunk = this._cache.get())) { + thing = this._mode.encrypt(this, chunk); + out.push(thing); + } + + return Buffer.concat(out); + }; + + var PADDING = Buffer.alloc(16, 0x10); + + Cipher.prototype._final = function () { + var chunk = this._cache.flush(); + + if (this._autopadding) { + chunk = this._mode.encrypt(this, chunk); + + this._cipher.scrub(); + + return chunk; + } + + if (!chunk.equals(PADDING)) { + this._cipher.scrub(); + + throw new Error("data not multiple of block length"); + } + }; + + Cipher.prototype.setAutoPadding = function (setTo) { + this._autopadding = Boolean(setTo); + return this; + }; + + function Splitter() { + this.cache = Buffer.allocUnsafe(0); + } + + Splitter.prototype.add = function (data) { + this.cache = Buffer.concat([this.cache, data]); + }; + + Splitter.prototype.get = function () { + if (this.cache.length > 15) { + var out = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + return out; + } + + return null; + }; + + Splitter.prototype.flush = function () { + var len = 16 - this.cache.length; + var padBuff = Buffer.allocUnsafe(len); + var i = -1; + + while (++i < len) { + padBuff.writeUInt8(len, i); + } + + return Buffer.concat([this.cache, padBuff]); + }; + + function createCipheriv(suite, password, iv) { + var config = MODES[suite.toLowerCase()]; + if (!config) throw new TypeError("invalid suite type"); + if (typeof password === "string") + password = Buffer.from(password); + if (password.length !== config.key / 8) + throw new TypeError( + "invalid key length " + password.length + ); + if (typeof iv === "string") iv = Buffer.from(iv); + if (config.mode !== "GCM" && iv.length !== config.iv) + throw new TypeError("invalid iv length " + iv.length); + + if (config.type === "stream") { + return new StreamCipher(config.module, password, iv); + } else if (config.type === "auth") { + return new AuthCipher(config.module, password, iv); + } + + return new Cipher(config.module, password, iv); + } + + function createCipher(suite, password) { + var config = MODES[suite.toLowerCase()]; + if (!config) throw new TypeError("invalid suite type"); + var keys = ebtk(password, false, config.key, config.iv); + return createCipheriv(suite, keys.key, keys.iv); + } + + exports.createCipheriv = createCipheriv; + exports.createCipher = createCipher; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/ghash.js": + /* !**********************************************!*\ + !*** ./node_modules/browserify-aes/ghash.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var ZEROES = Buffer.alloc(16, 0); + + function toArray(buf) { + return [ + buf.readUInt32BE(0), + buf.readUInt32BE(4), + buf.readUInt32BE(8), + buf.readUInt32BE(12), + ]; + } + + function fromArray(out) { + var buf = Buffer.allocUnsafe(16); + buf.writeUInt32BE(out[0] >>> 0, 0); + buf.writeUInt32BE(out[1] >>> 0, 4); + buf.writeUInt32BE(out[2] >>> 0, 8); + buf.writeUInt32BE(out[3] >>> 0, 12); + return buf; + } + + function GHASH(key) { + this.h = key; + this.state = Buffer.alloc(16, 0); + this.cache = Buffer.allocUnsafe(0); + } // From http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html + // by Juho Vähä-Herttua + + GHASH.prototype.ghash = function (block) { + var i = -1; + + while (++i < block.length) { + this.state[i] ^= block[i]; + } + + this._multiply(); + }; + + GHASH.prototype._multiply = function () { + var Vi = toArray(this.h); + var Zi = [0, 0, 0, 0]; + var j, xi, lsbVi; + var i = -1; + + while (++i < 128) { + xi = (this.state[~~(i / 8)] & (1 << (7 - (i % 8)))) !== 0; + + if (xi) { + // Z_i+1 = Z_i ^ V_i + Zi[0] ^= Vi[0]; + Zi[1] ^= Vi[1]; + Zi[2] ^= Vi[2]; + Zi[3] ^= Vi[3]; + } // Store the value of LSB(V_i) + + lsbVi = (Vi[3] & 1) !== 0; // V_i+1 = V_i >> 1 + + for (j = 3; j > 0; j--) { + Vi[j] = (Vi[j] >>> 1) | ((Vi[j - 1] & 1) << 31); + } + + Vi[0] >>>= 1; // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R + + if (lsbVi) { + Vi[0] ^= (0xe1 << 24); + } + } + + this.state = fromArray(Zi); + }; + + GHASH.prototype.update = function (buf) { + this.cache = Buffer.concat([this.cache, buf]); + var chunk; + + while (this.cache.length >= 16) { + chunk = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + this.ghash(chunk); + } + }; + + GHASH.prototype.final = function (abl, bl) { + if (this.cache.length) { + this.ghash(Buffer.concat([this.cache, ZEROES], 16)); + } + + this.ghash(fromArray([0, abl, 0, bl])); + return this.state; + }; + + module.exports = GHASH; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/incr32.js": + /* !***********************************************!*\ + !*** ./node_modules/browserify-aes/incr32.js ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + function incr32(iv) { + var len = iv.length; + var item; + + while (len--) { + item = iv.readUInt8(len); + + if (item === 255) { + iv.writeUInt8(0, len); + } else { + item++; + iv.writeUInt8(item, len); + break; + } + } + } + + module.exports = incr32; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/cbc.js": + /* !**************************************************!*\ + !*** ./node_modules/browserify-aes/modes/cbc.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var xor = __webpack_require__( + /* ! buffer-xor */ "./node_modules/buffer-xor/index.js" + ); + + exports.encrypt = function (self, block) { + var data = xor(block, self._prev); + self._prev = self._cipher.encryptBlock(data); + return self._prev; + }; + + exports.decrypt = function (self, block) { + var pad = self._prev; + self._prev = block; + + var out = self._cipher.decryptBlock(block); + + return xor(out, pad); + }; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/cfb.js": + /* !**************************************************!*\ + !*** ./node_modules/browserify-aes/modes/cfb.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var xor = __webpack_require__( + /* ! buffer-xor */ "./node_modules/buffer-xor/index.js" + ); + + function encryptStart(self, data, decrypt) { + var len = data.length; + var out = xor(data, self._cache); + self._cache = self._cache.slice(len); + self._prev = Buffer.concat([self._prev, decrypt ? data : out]); + return out; + } + + exports.encrypt = function (self, data, decrypt) { + var out = Buffer.allocUnsafe(0); + var len; + + while (data.length) { + if (self._cache.length === 0) { + self._cache = self._cipher.encryptBlock(self._prev); + self._prev = Buffer.allocUnsafe(0); + } + + if (self._cache.length <= data.length) { + len = self._cache.length; + out = Buffer.concat([ + out, + encryptStart(self, data.slice(0, len), decrypt), + ]); + data = data.slice(len); + } else { + out = Buffer.concat([ + out, + encryptStart(self, data, decrypt), + ]); + break; + } + } + + return out; + }; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/cfb1.js": + /* !***************************************************!*\ + !*** ./node_modules/browserify-aes/modes/cfb1.js ***! + \***************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + function encryptByte(self, byteParam, decrypt) { + var pad; + var i = -1; + var len = 8; + var out = 0; + var bit, value; + + while (++i < len) { + pad = self._cipher.encryptBlock(self._prev); + bit = byteParam & (1 << (7 - i)) ? 0x80 : 0; + value = pad[0] ^ bit; + out += (value & 0x80) >> i % 8; + self._prev = shiftIn(self._prev, decrypt ? bit : value); + } + + return out; + } + + function shiftIn(buffer, value) { + var len = buffer.length; + var i = -1; + var out = Buffer.allocUnsafe(buffer.length); + buffer = Buffer.concat([buffer, Buffer.from([value])]); + + while (++i < len) { + out[i] = (buffer[i] << 1) | (buffer[i + 1] >> 7); + } + + return out; + } + + exports.encrypt = function (self, chunk, decrypt) { + var len = chunk.length; + var out = Buffer.allocUnsafe(len); + var i = -1; + + while (++i < len) { + out[i] = encryptByte(self, chunk[i], decrypt); + } + + return out; + }; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/cfb8.js": + /* !***************************************************!*\ + !*** ./node_modules/browserify-aes/modes/cfb8.js ***! + \***************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + function encryptByte(self, byteParam, decrypt) { + var pad = self._cipher.encryptBlock(self._prev); + + var out = pad[0] ^ byteParam; + self._prev = Buffer.concat([ + self._prev.slice(1), + Buffer.from([decrypt ? byteParam : out]), + ]); + return out; + } + + exports.encrypt = function (self, chunk, decrypt) { + var len = chunk.length; + var out = Buffer.allocUnsafe(len); + var i = -1; + + while (++i < len) { + out[i] = encryptByte(self, chunk[i], decrypt); + } + + return out; + }; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/ctr.js": + /* !**************************************************!*\ + !*** ./node_modules/browserify-aes/modes/ctr.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var xor = __webpack_require__( + /* ! buffer-xor */ "./node_modules/buffer-xor/index.js" + ); + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var incr32 = __webpack_require__( + /* ! ../incr32 */ "./node_modules/browserify-aes/incr32.js" + ); + + function getBlock(self) { + var out = self._cipher.encryptBlockRaw(self._prev); + + incr32(self._prev); + return out; + } + + var blockSize = 16; + + exports.encrypt = function (self, chunk) { + var chunkNum = Math.ceil(chunk.length / blockSize); + var start = self._cache.length; + self._cache = Buffer.concat([ + self._cache, + Buffer.allocUnsafe(chunkNum * blockSize), + ]); + + for (var i = 0; i < chunkNum; i++) { + var out = getBlock(self); + var offset = start + i * blockSize; + + self._cache.writeUInt32BE(out[0], offset + 0); + + self._cache.writeUInt32BE(out[1], offset + 4); + + self._cache.writeUInt32BE(out[2], offset + 8); + + self._cache.writeUInt32BE(out[3], offset + 12); + } + + var pad = self._cache.slice(0, chunk.length); + + self._cache = self._cache.slice(chunk.length); + return xor(chunk, pad); + }; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/ecb.js": + /* !**************************************************!*\ + !*** ./node_modules/browserify-aes/modes/ecb.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + exports.encrypt = function (self, block) { + return self._cipher.encryptBlock(block); + }; + + exports.decrypt = function (self, block) { + return self._cipher.decryptBlock(block); + }; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/index.js": + /* !****************************************************!*\ + !*** ./node_modules/browserify-aes/modes/index.js ***! + \****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var modeModules = { + ECB: __webpack_require__( + /* ! ./ecb */ "./node_modules/browserify-aes/modes/ecb.js" + ), + CBC: __webpack_require__( + /* ! ./cbc */ "./node_modules/browserify-aes/modes/cbc.js" + ), + CFB: __webpack_require__( + /* ! ./cfb */ "./node_modules/browserify-aes/modes/cfb.js" + ), + CFB8: __webpack_require__( + /* ! ./cfb8 */ "./node_modules/browserify-aes/modes/cfb8.js" + ), + CFB1: __webpack_require__( + /* ! ./cfb1 */ "./node_modules/browserify-aes/modes/cfb1.js" + ), + OFB: __webpack_require__( + /* ! ./ofb */ "./node_modules/browserify-aes/modes/ofb.js" + ), + CTR: __webpack_require__( + /* ! ./ctr */ "./node_modules/browserify-aes/modes/ctr.js" + ), + GCM: __webpack_require__( + /* ! ./ctr */ "./node_modules/browserify-aes/modes/ctr.js" + ), + }; + + var modes = __webpack_require__( + /* ! ./list.json */ "./node_modules/browserify-aes/modes/list.json" + ); + + for (var key in modes) { + modes[key].module = modeModules[modes[key].mode]; + } + + module.exports = modes; + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/list.json": + /* !*****************************************************!*\ + !*** ./node_modules/browserify-aes/modes/list.json ***! + \*****************************************************/ + /* ! exports provided: aes-128-ecb, aes-192-ecb, aes-256-ecb, aes-128-cbc, aes-192-cbc, aes-256-cbc, aes128, aes192, aes256, aes-128-cfb, aes-192-cfb, aes-256-cfb, aes-128-cfb8, aes-192-cfb8, aes-256-cfb8, aes-128-cfb1, aes-192-cfb1, aes-256-cfb1, aes-128-ofb, aes-192-ofb, aes-256-ofb, aes-128-ctr, aes-192-ctr, aes-256-ctr, aes-128-gcm, aes-192-gcm, aes-256-gcm, default */ + /***/ function (module) { + module.exports = JSON.parse( + '{"aes-128-ecb":{"cipher":"AES","key":128,"iv":0,"mode":"ECB","type":"block"},"aes-192-ecb":{"cipher":"AES","key":192,"iv":0,"mode":"ECB","type":"block"},"aes-256-ecb":{"cipher":"AES","key":256,"iv":0,"mode":"ECB","type":"block"},"aes-128-cbc":{"cipher":"AES","key":128,"iv":16,"mode":"CBC","type":"block"},"aes-192-cbc":{"cipher":"AES","key":192,"iv":16,"mode":"CBC","type":"block"},"aes-256-cbc":{"cipher":"AES","key":256,"iv":16,"mode":"CBC","type":"block"},"aes128":{"cipher":"AES","key":128,"iv":16,"mode":"CBC","type":"block"},"aes192":{"cipher":"AES","key":192,"iv":16,"mode":"CBC","type":"block"},"aes256":{"cipher":"AES","key":256,"iv":16,"mode":"CBC","type":"block"},"aes-128-cfb":{"cipher":"AES","key":128,"iv":16,"mode":"CFB","type":"stream"},"aes-192-cfb":{"cipher":"AES","key":192,"iv":16,"mode":"CFB","type":"stream"},"aes-256-cfb":{"cipher":"AES","key":256,"iv":16,"mode":"CFB","type":"stream"},"aes-128-cfb8":{"cipher":"AES","key":128,"iv":16,"mode":"CFB8","type":"stream"},"aes-192-cfb8":{"cipher":"AES","key":192,"iv":16,"mode":"CFB8","type":"stream"},"aes-256-cfb8":{"cipher":"AES","key":256,"iv":16,"mode":"CFB8","type":"stream"},"aes-128-cfb1":{"cipher":"AES","key":128,"iv":16,"mode":"CFB1","type":"stream"},"aes-192-cfb1":{"cipher":"AES","key":192,"iv":16,"mode":"CFB1","type":"stream"},"aes-256-cfb1":{"cipher":"AES","key":256,"iv":16,"mode":"CFB1","type":"stream"},"aes-128-ofb":{"cipher":"AES","key":128,"iv":16,"mode":"OFB","type":"stream"},"aes-192-ofb":{"cipher":"AES","key":192,"iv":16,"mode":"OFB","type":"stream"},"aes-256-ofb":{"cipher":"AES","key":256,"iv":16,"mode":"OFB","type":"stream"},"aes-128-ctr":{"cipher":"AES","key":128,"iv":16,"mode":"CTR","type":"stream"},"aes-192-ctr":{"cipher":"AES","key":192,"iv":16,"mode":"CTR","type":"stream"},"aes-256-ctr":{"cipher":"AES","key":256,"iv":16,"mode":"CTR","type":"stream"},"aes-128-gcm":{"cipher":"AES","key":128,"iv":12,"mode":"GCM","type":"auth"},"aes-192-gcm":{"cipher":"AES","key":192,"iv":12,"mode":"GCM","type":"auth"},"aes-256-gcm":{"cipher":"AES","key":256,"iv":12,"mode":"GCM","type":"auth"}}' + ); + + /***/ + }, + + /***/ "./node_modules/browserify-aes/modes/ofb.js": + /* !**************************************************!*\ + !*** ./node_modules/browserify-aes/modes/ofb.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + var xor = __webpack_require__( + /* ! buffer-xor */ "./node_modules/buffer-xor/index.js" + ); + + function getBlock(self) { + self._prev = self._cipher.encryptBlock(self._prev); + return self._prev; + } + + exports.encrypt = function (self, chunk) { + while (self._cache.length < chunk.length) { + self._cache = Buffer.concat([ + self._cache, + getBlock(self), + ]); + } + + var pad = self._cache.slice(0, chunk.length); + + self._cache = self._cache.slice(chunk.length); + return xor(chunk, pad); + }; + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/browserify-aes/streamCipher.js": + /* !*****************************************************!*\ + !*** ./node_modules/browserify-aes/streamCipher.js ***! + \*****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var aes = __webpack_require__( + /* ! ./aes */ "./node_modules/browserify-aes/aes.js" + ); + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var Transform = __webpack_require__( + /* ! cipher-base */ "./node_modules/cipher-base/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + function StreamCipher(mode, key, iv, decrypt) { + Transform.call(this); + this._cipher = new aes.AES(key); + this._prev = Buffer.from(iv); + this._cache = Buffer.allocUnsafe(0); + this._secCache = Buffer.allocUnsafe(0); + this._decrypt = decrypt; + this._mode = mode; + } + + inherits(StreamCipher, Transform); + + StreamCipher.prototype._update = function (chunk) { + return this._mode.encrypt(this, chunk, this._decrypt); + }; + + StreamCipher.prototype._final = function () { + this._cipher.scrub(); + }; + + module.exports = StreamCipher; + + /***/ + }, + + /***/ "./node_modules/browserify-cipher/browser.js": + /* !***************************************************!*\ + !*** ./node_modules/browserify-cipher/browser.js ***! + \***************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var DES = __webpack_require__( + /* ! browserify-des */ "./node_modules/browserify-des/index.js" + ); + + var aes = __webpack_require__( + /* ! browserify-aes/browser */ "./node_modules/browserify-aes/browser.js" + ); + + var aesModes = __webpack_require__( + /* ! browserify-aes/modes */ "./node_modules/browserify-aes/modes/index.js" + ); + + var desModes = __webpack_require__( + /* ! browserify-des/modes */ "./node_modules/browserify-des/modes.js" + ); + + var ebtk = __webpack_require__( + /* ! evp_bytestokey */ "./node_modules/evp_bytestokey/index.js" + ); + + function createCipher(suite, password) { + suite = suite.toLowerCase(); + var keyLen, ivLen; + + if (aesModes[suite]) { + keyLen = aesModes[suite].key; + ivLen = aesModes[suite].iv; + } else if (desModes[suite]) { + keyLen = desModes[suite].key * 8; + ivLen = desModes[suite].iv; + } else { + throw new TypeError("invalid suite type"); + } + + var keys = ebtk(password, false, keyLen, ivLen); + return createCipheriv(suite, keys.key, keys.iv); + } + + function createDecipher(suite, password) { + suite = suite.toLowerCase(); + var keyLen, ivLen; + + if (aesModes[suite]) { + keyLen = aesModes[suite].key; + ivLen = aesModes[suite].iv; + } else if (desModes[suite]) { + keyLen = desModes[suite].key * 8; + ivLen = desModes[suite].iv; + } else { + throw new TypeError("invalid suite type"); + } + + var keys = ebtk(password, false, keyLen, ivLen); + return createDecipheriv(suite, keys.key, keys.iv); + } + + function createCipheriv(suite, key, iv) { + suite = suite.toLowerCase(); + if (aesModes[suite]) return aes.createCipheriv(suite, key, iv); + if (desModes[suite]) + return new DES({ + key: key, + iv: iv, + mode: suite, + }); + throw new TypeError("invalid suite type"); + } + + function createDecipheriv(suite, key, iv) { + suite = suite.toLowerCase(); + if (aesModes[suite]) + return aes.createDecipheriv(suite, key, iv); + if (desModes[suite]) + return new DES({ + key: key, + iv: iv, + mode: suite, + decrypt: true, + }); + throw new TypeError("invalid suite type"); + } + + function getCiphers() { + return Object.keys(desModes).concat(aes.getCiphers()); + } + + exports.createCipher = exports.Cipher = createCipher; + exports.createCipheriv = exports.Cipheriv = createCipheriv; + exports.createDecipher = exports.Decipher = createDecipher; + exports.createDecipheriv = exports.Decipheriv = createDecipheriv; + exports.listCiphers = exports.getCiphers = getCiphers; + + /***/ + }, + + /***/ "./node_modules/browserify-des/index.js": + /* !**********************************************!*\ + !*** ./node_modules/browserify-des/index.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var CipherBase = __webpack_require__( + /* ! cipher-base */ "./node_modules/cipher-base/index.js" + ); + + var des = __webpack_require__( + /* ! des.js */ "./node_modules/des.js/lib/des.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var modes = { + "des-ede3-cbc": des.CBC.instantiate(des.EDE), + "des-ede3": des.EDE, + "des-ede-cbc": des.CBC.instantiate(des.EDE), + "des-ede": des.EDE, + "des-cbc": des.CBC.instantiate(des.DES), + "des-ecb": des.DES, + }; + modes.des = modes["des-cbc"]; + modes.des3 = modes["des-ede3-cbc"]; + module.exports = DES; + inherits(DES, CipherBase); + + function DES(opts) { + CipherBase.call(this); + var modeName = opts.mode.toLowerCase(); + var mode = modes[modeName]; + var type; + + if (opts.decrypt) { + type = "decrypt"; + } else { + type = "encrypt"; + } + + var key = opts.key; + + if (!Buffer.isBuffer(key)) { + key = Buffer.from(key); + } + + if (modeName === "des-ede" || modeName === "des-ede-cbc") { + key = Buffer.concat([key, key.slice(0, 8)]); + } + + var iv = opts.iv; + + if (!Buffer.isBuffer(iv)) { + iv = Buffer.from(iv); + } + + this._des = mode.create({ + key: key, + iv: iv, + type: type, + }); + } + + DES.prototype._update = function (data) { + return Buffer.from(this._des.update(data)); + }; + + DES.prototype._final = function () { + return Buffer.from(this._des.final()); + }; + + /***/ + }, + + /***/ "./node_modules/browserify-des/modes.js": + /* !**********************************************!*\ + !*** ./node_modules/browserify-des/modes.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + exports["des-ecb"] = { + key: 8, + iv: 0, + }; + exports["des-cbc"] = exports.des = { + key: 8, + iv: 8, + }; + exports["des-ede3-cbc"] = exports.des3 = { + key: 24, + iv: 8, + }; + exports["des-ede3"] = { + key: 24, + iv: 0, + }; + exports["des-ede-cbc"] = { + key: 16, + iv: 8, + }; + exports["des-ede"] = { + key: 16, + iv: 0, + }; + + /***/ + }, + + /***/ "./node_modules/browserify-rsa/index.js": + /* !**********************************************!*\ + !*** ./node_modules/browserify-rsa/index.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + var bn = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var randomBytes = __webpack_require__( + /* ! randombytes */ "./node_modules/randombytes/browser.js" + ); + + module.exports = crt; + + function blind(priv) { + var r = getr(priv); + var blinder = r + .toRed(bn.mont(priv.modulus)) + .redPow(new bn(priv.publicExponent)) + .fromRed(); + return { + blinder: blinder, + unblinder: r.invm(priv.modulus), + }; + } + + function crt(msg, priv) { + var blinds = blind(priv); + var len = priv.modulus.byteLength(); + var mod = bn.mont(priv.modulus); + var blinded = new bn(msg) + .mul(blinds.blinder) + .umod(priv.modulus); + var c1 = blinded.toRed(bn.mont(priv.prime1)); + var c2 = blinded.toRed(bn.mont(priv.prime2)); + var qinv = priv.coefficient; + var p = priv.prime1; + var q = priv.prime2; + var m1 = c1.redPow(priv.exponent1); + var m2 = c2.redPow(priv.exponent2); + m1 = m1.fromRed(); + m2 = m2.fromRed(); + var h = m1.isub(m2).imul(qinv).umod(p); + h.imul(q); + m2.iadd(h); + return new Buffer( + m2 + .imul(blinds.unblinder) + .umod(priv.modulus) + .toArray(false, len) + ); + } + + crt.getr = getr; + + function getr(priv) { + var len = priv.modulus.byteLength(); + var r = new bn(randomBytes(len)); + + while ( + r.cmp(priv.modulus) >= 0 || + !r.umod(priv.prime1) || + !r.umod(priv.prime2) + ) { + r = new bn(randomBytes(len)); + } + + return r; + } + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/browserify-sign/algos.js": + /* !***********************************************!*\ + !*** ./node_modules/browserify-sign/algos.js ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + module.exports = __webpack_require__( + /* ! ./browser/algorithms.json */ "./node_modules/browserify-sign/browser/algorithms.json" + ); + + /***/ + }, + + /***/ "./node_modules/browserify-sign/browser/algorithms.json": + /* !**************************************************************!*\ + !*** ./node_modules/browserify-sign/browser/algorithms.json ***! + \**************************************************************/ + /* ! exports provided: sha224WithRSAEncryption, RSA-SHA224, sha256WithRSAEncryption, RSA-SHA256, sha384WithRSAEncryption, RSA-SHA384, sha512WithRSAEncryption, RSA-SHA512, RSA-SHA1, ecdsa-with-SHA1, sha256, sha224, sha384, sha512, DSA-SHA, DSA-SHA1, DSA, DSA-WITH-SHA224, DSA-SHA224, DSA-WITH-SHA256, DSA-SHA256, DSA-WITH-SHA384, DSA-SHA384, DSA-WITH-SHA512, DSA-SHA512, DSA-RIPEMD160, ripemd160WithRSA, RSA-RIPEMD160, md5WithRSAEncryption, RSA-MD5, default */ + /***/ function (module) { + module.exports = JSON.parse( + '{"sha224WithRSAEncryption":{"sign":"rsa","hash":"sha224","id":"302d300d06096086480165030402040500041c"},"RSA-SHA224":{"sign":"ecdsa/rsa","hash":"sha224","id":"302d300d06096086480165030402040500041c"},"sha256WithRSAEncryption":{"sign":"rsa","hash":"sha256","id":"3031300d060960864801650304020105000420"},"RSA-SHA256":{"sign":"ecdsa/rsa","hash":"sha256","id":"3031300d060960864801650304020105000420"},"sha384WithRSAEncryption":{"sign":"rsa","hash":"sha384","id":"3041300d060960864801650304020205000430"},"RSA-SHA384":{"sign":"ecdsa/rsa","hash":"sha384","id":"3041300d060960864801650304020205000430"},"sha512WithRSAEncryption":{"sign":"rsa","hash":"sha512","id":"3051300d060960864801650304020305000440"},"RSA-SHA512":{"sign":"ecdsa/rsa","hash":"sha512","id":"3051300d060960864801650304020305000440"},"RSA-SHA1":{"sign":"rsa","hash":"sha1","id":"3021300906052b0e03021a05000414"},"ecdsa-with-SHA1":{"sign":"ecdsa","hash":"sha1","id":""},"sha256":{"sign":"ecdsa","hash":"sha256","id":""},"sha224":{"sign":"ecdsa","hash":"sha224","id":""},"sha384":{"sign":"ecdsa","hash":"sha384","id":""},"sha512":{"sign":"ecdsa","hash":"sha512","id":""},"DSA-SHA":{"sign":"dsa","hash":"sha1","id":""},"DSA-SHA1":{"sign":"dsa","hash":"sha1","id":""},"DSA":{"sign":"dsa","hash":"sha1","id":""},"DSA-WITH-SHA224":{"sign":"dsa","hash":"sha224","id":""},"DSA-SHA224":{"sign":"dsa","hash":"sha224","id":""},"DSA-WITH-SHA256":{"sign":"dsa","hash":"sha256","id":""},"DSA-SHA256":{"sign":"dsa","hash":"sha256","id":""},"DSA-WITH-SHA384":{"sign":"dsa","hash":"sha384","id":""},"DSA-SHA384":{"sign":"dsa","hash":"sha384","id":""},"DSA-WITH-SHA512":{"sign":"dsa","hash":"sha512","id":""},"DSA-SHA512":{"sign":"dsa","hash":"sha512","id":""},"DSA-RIPEMD160":{"sign":"dsa","hash":"rmd160","id":""},"ripemd160WithRSA":{"sign":"rsa","hash":"rmd160","id":"3021300906052b2403020105000414"},"RSA-RIPEMD160":{"sign":"rsa","hash":"rmd160","id":"3021300906052b2403020105000414"},"md5WithRSAEncryption":{"sign":"rsa","hash":"md5","id":"3020300c06082a864886f70d020505000410"},"RSA-MD5":{"sign":"rsa","hash":"md5","id":"3020300c06082a864886f70d020505000410"}}' + ); + + /***/ + }, + + /***/ "./node_modules/browserify-sign/browser/curves.json": + /* !**********************************************************!*\ + !*** ./node_modules/browserify-sign/browser/curves.json ***! + \**********************************************************/ + /* ! exports provided: 1.3.132.0.10, 1.3.132.0.33, 1.2.840.10045.3.1.1, 1.2.840.10045.3.1.7, 1.3.132.0.34, 1.3.132.0.35, default */ + /***/ function (module) { + module.exports = JSON.parse( + '{"1.3.132.0.10":"secp256k1","1.3.132.0.33":"p224","1.2.840.10045.3.1.1":"p192","1.2.840.10045.3.1.7":"p256","1.3.132.0.34":"p384","1.3.132.0.35":"p521"}' + ); + + /***/ + }, + + /***/ "./node_modules/browserify-sign/browser/index.js": + /* !*******************************************************!*\ + !*** ./node_modules/browserify-sign/browser/index.js ***! + \*******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + var createHash = __webpack_require__( + /* ! create-hash */ "./node_modules/create-hash/browser.js" + ); + + var stream = __webpack_require__( + /* ! stream */ "./node_modules/stream-browserify/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var sign = __webpack_require__( + /* ! ./sign */ "./node_modules/browserify-sign/browser/sign.js" + ); + + var verify = __webpack_require__( + /* ! ./verify */ "./node_modules/browserify-sign/browser/verify.js" + ); + + var algorithms = __webpack_require__( + /* ! ./algorithms.json */ "./node_modules/browserify-sign/browser/algorithms.json" + ); + + Object.keys(algorithms).forEach(function (key) { + algorithms[key].id = new Buffer(algorithms[key].id, "hex"); + algorithms[key.toLowerCase()] = algorithms[key]; + }); + + function Sign(algorithm) { + stream.Writable.call(this); + var data = algorithms[algorithm]; + if (!data) throw new Error("Unknown message digest"); + this._hashType = data.hash; + this._hash = createHash(data.hash); + this._tag = data.id; + this._signType = data.sign; + } + + inherits(Sign, stream.Writable); + + Sign.prototype._write = function _write(data, _, done) { + this._hash.update(data); + + done(); + }; + + Sign.prototype.update = function update(data, enc) { + if (typeof data === "string") data = new Buffer(data, enc); + + this._hash.update(data); + + return this; + }; + + Sign.prototype.sign = function signMethod(key, enc) { + this.end(); + + var hash = this._hash.digest(); + + var sig = sign( + hash, + key, + this._hashType, + this._signType, + this._tag + ); + return enc ? sig.toString(enc) : sig; + }; + + function Verify(algorithm) { + stream.Writable.call(this); + var data = algorithms[algorithm]; + if (!data) throw new Error("Unknown message digest"); + this._hash = createHash(data.hash); + this._tag = data.id; + this._signType = data.sign; + } + + inherits(Verify, stream.Writable); + + Verify.prototype._write = function _write(data, _, done) { + this._hash.update(data); + + done(); + }; + + Verify.prototype.update = function update(data, enc) { + if (typeof data === "string") data = new Buffer(data, enc); + + this._hash.update(data); + + return this; + }; + + Verify.prototype.verify = function verifyMethod(key, sig, enc) { + if (typeof sig === "string") sig = new Buffer(sig, enc); + this.end(); + + var hash = this._hash.digest(); + + return verify(sig, hash, key, this._signType, this._tag); + }; + + function createSign(algorithm) { + return new Sign(algorithm); + } + + function createVerify(algorithm) { + return new Verify(algorithm); + } + + module.exports = { + Sign: createSign, + Verify: createVerify, + createSign: createSign, + createVerify: createVerify, + }; + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/browserify-sign/browser/sign.js": + /* !******************************************************!*\ + !*** ./node_modules/browserify-sign/browser/sign.js ***! + \******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + // Much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js + var createHmac = __webpack_require__( + /* ! create-hmac */ "./node_modules/create-hmac/browser.js" + ); + + var crt = __webpack_require__( + /* ! browserify-rsa */ "./node_modules/browserify-rsa/index.js" + ); + + var EC = __webpack_require__( + /* ! elliptic */ "./node_modules/elliptic/lib/elliptic.js" + ).ec; + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var parseKeys = __webpack_require__( + /* ! parse-asn1 */ "./node_modules/parse-asn1/index.js" + ); + + var curves = __webpack_require__( + /* ! ./curves.json */ "./node_modules/browserify-sign/browser/curves.json" + ); + + function sign(hash, key, hashType, signType, tag) { + var priv = parseKeys(key); + + if (priv.curve) { + // Rsa keys can be interpreted as ecdsa ones in openssl + if (signType !== "ecdsa" && signType !== "ecdsa/rsa") + throw new Error("wrong private key type"); + return ecSign(hash, priv); + } else if (priv.type === "dsa") { + if (signType !== "dsa") + throw new Error("wrong private key type"); + return dsaSign(hash, priv, hashType); + } + if (signType !== "rsa" && signType !== "ecdsa/rsa") + throw new Error("wrong private key type"); + + + hash = Buffer.concat([tag, hash]); + var len = priv.modulus.byteLength(); + var pad = [0, 1]; + + while (hash.length + pad.length + 1 < len) { + pad.push(0xff); + } + + pad.push(0x00); + var i = -1; + + while (++i < hash.length) { + pad.push(hash[i]); + } + + var out = crt(pad, priv); + return out; + } + + function ecSign(hash, priv) { + var curveId = curves[priv.curve.join(".")]; + if (!curveId) + throw new Error( + "unknown curve " + priv.curve.join(".") + ); + var curve = new EC(curveId); + var key = curve.keyFromPrivate(priv.privateKey); + var out = key.sign(hash); + return new Buffer(out.toDER()); + } + + function dsaSign(hash, priv, algo) { + var x = priv.params.priv_key; + var p = priv.params.p; + var q = priv.params.q; + var g = priv.params.g; + var r = new BN(0); + var k; + var H = bits2int(hash, q).mod(q); + var s = false; + var kv = getKey(x, q, hash, algo); + + while (s === false) { + k = makeKey(q, kv, algo); + r = makeR(g, k, p, q); + s = k + .invm(q) + .imul(H.add(x.mul(r))) + .mod(q); + + if (s.cmpn(0) === 0) { + s = false; + r = new BN(0); + } + } + + return toDER(r, s); + } + + function toDER(r, s) { + r = r.toArray(); + s = s.toArray(); // Pad values + + if (r[0] & 0x80) r = [0].concat(r); + if (s[0] & 0x80) s = [0].concat(s); + var total = r.length + s.length + 4; + var res = [0x30, total, 0x02, r.length]; + res = res.concat(r, [0x02, s.length], s); + return new Buffer(res); + } + + function getKey(x, q, hash, algo) { + x = new Buffer(x.toArray()); + + if (x.length < q.byteLength()) { + var zeros = new Buffer(q.byteLength() - x.length); + zeros.fill(0); + x = Buffer.concat([zeros, x]); + } + + var hlen = hash.length; + var hbits = bits2octets(hash, q); + var v = new Buffer(hlen); + v.fill(1); + var k = new Buffer(hlen); + k.fill(0); + k = createHmac(algo, k) + .update(v) + .update(new Buffer([0])) + .update(x) + .update(hbits) + .digest(); + v = createHmac(algo, k).update(v).digest(); + k = createHmac(algo, k) + .update(v) + .update(new Buffer([1])) + .update(x) + .update(hbits) + .digest(); + v = createHmac(algo, k).update(v).digest(); + return { + k: k, + v: v, + }; + } + + function bits2int(obits, q) { + var bits = new BN(obits); + var shift = (obits.length << 3) - q.bitLength(); + if (shift > 0) bits.ishrn(shift); + return bits; + } + + function bits2octets(bits, q) { + bits = bits2int(bits, q); + bits = bits.mod(q); + var out = new Buffer(bits.toArray()); + + if (out.length < q.byteLength()) { + var zeros = new Buffer(q.byteLength() - out.length); + zeros.fill(0); + out = Buffer.concat([zeros, out]); + } + + return out; + } + + function makeKey(q, kv, algo) { + var t; + var k; + + do { + t = new Buffer(0); + + while (t.length * 8 < q.bitLength()) { + kv.v = createHmac(algo, kv.k).update(kv.v).digest(); + t = Buffer.concat([t, kv.v]); + } + + k = bits2int(t, q); + kv.k = createHmac(algo, kv.k) + .update(kv.v) + .update(new Buffer([0])) + .digest(); + kv.v = createHmac(algo, kv.k).update(kv.v).digest(); + } while (k.cmp(q) !== -1); + + return k; + } + + function makeR(g, k, p, q) { + return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q); + } + + module.exports = sign; + module.exports.getKey = getKey; + module.exports.makeKey = makeKey; + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/browserify-sign/browser/verify.js": + /* !********************************************************!*\ + !*** ./node_modules/browserify-sign/browser/verify.js ***! + \********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + // Much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var EC = __webpack_require__( + /* ! elliptic */ "./node_modules/elliptic/lib/elliptic.js" + ).ec; + + var parseKeys = __webpack_require__( + /* ! parse-asn1 */ "./node_modules/parse-asn1/index.js" + ); + + var curves = __webpack_require__( + /* ! ./curves.json */ "./node_modules/browserify-sign/browser/curves.json" + ); + + function verify(sig, hash, key, signType, tag) { + var pub = parseKeys(key); + + if (pub.type === "ec") { + // Rsa keys can be interpreted as ecdsa ones in openssl + if (signType !== "ecdsa" && signType !== "ecdsa/rsa") + throw new Error("wrong public key type"); + return ecVerify(sig, hash, pub); + } else if (pub.type === "dsa") { + if (signType !== "dsa") + throw new Error("wrong public key type"); + return dsaVerify(sig, hash, pub); + } + if (signType !== "rsa" && signType !== "ecdsa/rsa") + throw new Error("wrong public key type"); + + + hash = Buffer.concat([tag, hash]); + var len = pub.modulus.byteLength(); + var pad = [1]; + var padNum = 0; + + while (hash.length + pad.length + 2 < len) { + pad.push(0xff); + padNum++; + } + + pad.push(0x00); + var i = -1; + + while (++i < hash.length) { + pad.push(hash[i]); + } + + pad = new Buffer(pad); + var red = BN.mont(pub.modulus); + sig = new BN(sig).toRed(red); + sig = sig.redPow(new BN(pub.publicExponent)); + sig = new Buffer(sig.fromRed().toArray()); + var out = padNum < 8 ? 1 : 0; + len = Math.min(sig.length, pad.length); + if (sig.length !== pad.length) out = 1; + i = -1; + + while (++i < len) { + out |= sig[i] ^ pad[i]; + } + + return out === 0; + } + + function ecVerify(sig, hash, pub) { + var curveId = curves[pub.data.algorithm.curve.join(".")]; + if (!curveId) + throw new Error( + "unknown curve " + + pub.data.algorithm.curve.join(".") + ); + var curve = new EC(curveId); + var pubkey = pub.data.subjectPrivateKey.data; + return curve.verify(hash, sig, pubkey); + } + + function dsaVerify(sig, hash, pub) { + var p = pub.data.p; + var q = pub.data.q; + var g = pub.data.g; + var y = pub.data.pub_key; + var unpacked = parseKeys.signature.decode(sig, "der"); + var s = unpacked.s; + var r = unpacked.r; + checkValue(s, q); + checkValue(r, q); + var montp = BN.mont(p); + var w = s.invm(q); + var v = g + .toRed(montp) + .redPow(new BN(hash).mul(w).mod(q)) + .fromRed() + .mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed()) + .mod(p) + .mod(q); + return v.cmp(r) === 0; + } + + function checkValue(b, q) { + if (b.cmpn(0) <= 0) throw new Error("invalid sig"); + if (b.cmp(q) >= q) throw new Error("invalid sig"); + } + + module.exports = verify; + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/buffer-xor/index.js": + /* !******************************************!*\ + !*** ./node_modules/buffer-xor/index.js ***! + \******************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + module.exports = function xor(a, b) { + var length = Math.min(a.length, b.length); + var buffer = new Buffer(length); + + for (var i = 0; i < length; ++i) { + buffer[i] = a[i] ^ b[i]; + } + + return buffer; + }; + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/buffer/index.js": + /* !**************************************!*\ + !*** ./node_modules/buffer/index.js ***! + \**************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + /* WEBPACK VAR INJECTION */ (function (global) { + /* ! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ + + /* eslint-disable no-proto */ + + var base64 = __webpack_require__( + /* ! base64-js */ "./node_modules/base64-js/index.js" + ); + + var ieee754 = __webpack_require__( + /* ! ieee754 */ "./node_modules/ieee754/index.js" + ); + + var isArray = __webpack_require__( + /* ! isarray */ "./node_modules/isarray/index.js" + ); + + exports.Buffer = Buffer; + exports.SlowBuffer = SlowBuffer; + exports.INSPECT_MAX_BYTES = 50; + /** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Use Object implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, + * Opera 11.6+, iOS 4.2+. + * + * Due to various browser bugs, sometimes the Object implementation will be used even + * when the browser supports typed arrays. + * + * Note: + * + * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, + * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. + * + * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. + * + * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of + * incorrect length in some situations. + + * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they + * get the Object implementation, which is slower but behaves correctly. + */ + + Buffer.TYPED_ARRAY_SUPPORT = + global.TYPED_ARRAY_SUPPORT !== undefined + ? global.TYPED_ARRAY_SUPPORT + : typedArraySupport(); + /* + * Export kMaxLength after typed array support is determined. + */ + + exports.kMaxLength = kMaxLength(); + + function typedArraySupport() { + try { + var arr = new Uint8Array(1); + arr.__proto__ = { + __proto__: Uint8Array.prototype, + foo: function foo() { + return 42; + }, + }; + return ( + arr.foo() === 42 && // Typed array instances can be augmented + typeof arr.subarray === "function" && // Chrome 9-10 lack `subarray` + arr.subarray(1, 1).byteLength === 0 + ); // Ie10 has broken `subarray` + } catch (e) { + return false; + } + } + + function kMaxLength() { + return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff; + } + + function createBuffer(that, length) { + if (kMaxLength() < length) { + throw new RangeError("Invalid typed array length"); + } + + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = new Uint8Array(length); + that.__proto__ = Buffer.prototype; + } else { + // Fallback: Return an object instance of the Buffer class + if (that === null) { + that = new Buffer(length); + } + + that.length = length; + } + + return that; + } + /** + * The Buffer constructor returns instances of `Uint8Array` that have their + * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of + * `Uint8Array`, so the returned instances will have all the node `Buffer` methods + * and the `Uint8Array` methods. Square bracket notation works as expected -- it + * returns a single octet. + * + * The `Uint8Array` prototype remains unmodified. + */ + + function Buffer(arg, encodingOrOffset, length) { + if ( + !Buffer.TYPED_ARRAY_SUPPORT && + !(this instanceof Buffer) + ) { + return new Buffer(arg, encodingOrOffset, length); + } // Common case. + + if (typeof arg === "number") { + if (typeof encodingOrOffset === "string") { + throw new Error( + "If encoding is specified then the first argument must be a string" + ); + } + + return allocUnsafe(this, arg); + } + + return from(this, arg, encodingOrOffset, length); + } + + Buffer.poolSize = 8192; // Not used by this implementation + // TODO: Legacy, not needed anymore. Remove in next major version. + + Buffer._augment = function (arr) { + arr.__proto__ = Buffer.prototype; + return arr; + }; + + function from(that, value, encodingOrOffset, length) { + if (typeof value === "number") { + throw new TypeError( + '"value" argument must not be a number' + ); + } + + if ( + typeof ArrayBuffer !== "undefined" && + value instanceof ArrayBuffer + ) { + return fromArrayBuffer( + that, + value, + encodingOrOffset, + length + ); + } + + if (typeof value === "string") { + return fromString(that, value, encodingOrOffset); + } + + return fromObject(that, value); + } + /** + * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError + * if value is a number. + * Buffer.from(str[, encoding]) + * Buffer.from(array) + * Buffer.from(buffer) + * Buffer.from(arrayBuffer[, byteOffset[, length]]) + **/ + + Buffer.from = function (value, encodingOrOffset, length) { + return from(null, value, encodingOrOffset, length); + }; + + if (Buffer.TYPED_ARRAY_SUPPORT) { + Buffer.prototype.__proto__ = Uint8Array.prototype; + Buffer.__proto__ = Uint8Array; + + if ( + typeof Symbol !== "undefined" && + Symbol.species && + Buffer[Symbol.species] === Buffer + ) { + // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 + Object.defineProperty(Buffer, Symbol.species, { + value: null, + configurable: true, + }); + } + } + + function assertSize(size) { + if (typeof size !== "number") { + throw new TypeError('"size" argument must be a number'); + } else if (size < 0) { + throw new RangeError( + '"size" argument must not be negative' + ); + } + } + + function alloc(that, size, fill, encoding) { + assertSize(size); + + if (size <= 0) { + return createBuffer(that, size); + } + + if (fill !== undefined) { + // Only pay attention to encoding if it's a string. This + // prevents accidentally sending in a number that would + // be interpretted as a start offset. + return typeof encoding === "string" + ? createBuffer(that, size).fill(fill, encoding) + : createBuffer(that, size).fill(fill); + } + + return createBuffer(that, size); + } + /** + * Creates a new filled Buffer instance. + * alloc(size[, fill[, encoding]]) + **/ + + Buffer.alloc = function (size, fill, encoding) { + return alloc(null, size, fill, encoding); + }; + + function allocUnsafe(that, size) { + assertSize(size); + that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); + + if (!Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < size; ++i) { + that[i] = 0; + } + } + + return that; + } + /** + * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. + * */ + + Buffer.allocUnsafe = function (size) { + return allocUnsafe(null, size); + }; + /** + * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. + */ + + Buffer.allocUnsafeSlow = function (size) { + return allocUnsafe(null, size); + }; + + function fromString(that, string, encoding) { + if (typeof encoding !== "string" || encoding === "") { + encoding = "utf8"; + } + + if (!Buffer.isEncoding(encoding)) { + throw new TypeError( + '"encoding" must be a valid string encoding' + ); + } + + var length = byteLength(string, encoding) | 0; + that = createBuffer(that, length); + var actual = that.write(string, encoding); + + if (actual !== length) { + // Writing a hex string, for example, that contains invalid characters will + // cause everything after the first invalid character to be ignored. (e.g. + // 'abxxcd' will be treated as 'ab') + that = that.slice(0, actual); + } + + return that; + } + + function fromArrayLike(that, array) { + var length = + array.length < 0 ? 0 : checked(array.length) | 0; + that = createBuffer(that, length); + + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255; + } + + return that; + } + + function fromArrayBuffer(that, array, byteOffset, length) { + array.byteLength; // This throws if `array` is not a valid ArrayBuffer + + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError("'offset' is out of bounds"); + } + + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError("'length' is out of bounds"); + } + + if (byteOffset === undefined && length === undefined) { + array = new Uint8Array(array); + } else if (length === undefined) { + array = new Uint8Array(array, byteOffset); + } else { + array = new Uint8Array(array, byteOffset, length); + } + + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = array; + that.__proto__ = Buffer.prototype; + } else { + // Fallback: Return an object instance of the Buffer class + that = fromArrayLike(that, array); + } + + return that; + } + + function fromObject(that, obj) { + if (Buffer.isBuffer(obj)) { + var len = checked(obj.length) | 0; + that = createBuffer(that, len); + + if (that.length === 0) { + return that; + } + + obj.copy(that, 0, 0, len); + return that; + } + + if (obj) { + if ( + (typeof ArrayBuffer !== "undefined" && + obj.buffer instanceof ArrayBuffer) || + "length" in obj + ) { + if ( + typeof obj.length !== "number" || + isnan(obj.length) + ) { + return createBuffer(that, 0); + } + + return fromArrayLike(that, obj); + } + + if (obj.type === "Buffer" && isArray(obj.data)) { + return fromArrayLike(that, obj.data); + } + } + + throw new TypeError( + "First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object." + ); + } + + function checked(length) { + // Note: cannot use `length < kMaxLength()` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= kMaxLength()) { + throw new RangeError( + "Attempt to allocate Buffer larger than maximum " + + "size: 0x" + + kMaxLength().toString(16) + + " bytes" + ); + } + + return length | 0; + } + + function SlowBuffer(length) { + if (Number(length) != length) { + // eslint-disable-line eqeqeq + length = 0; + } + + return Buffer.alloc(Number(length)); + } + + Buffer.isBuffer = function isBuffer(b) { + return Boolean(b != null && b._isBuffer); + }; + + Buffer.compare = function compare(a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError("Arguments must be Buffers"); + } + + if (a === b) return 0; + var x = a.length; + var y = b.length; + + for (var i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i]; + y = b[i]; + break; + } + } + + if (x < y) return -1; + if (y < x) return 1; + return 0; + }; + + Buffer.isEncoding = function isEncoding(encoding) { + switch (String(encoding).toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "latin1": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return true; + + default: + return false; + } + }; + + Buffer.concat = function concat(list, length) { + if (!isArray(list)) { + throw new TypeError( + '"list" argument must be an Array of Buffers' + ); + } + + if (list.length === 0) { + return Buffer.alloc(0); + } + + var i; + + if (length === undefined) { + length = 0; + + for (i = 0; i < list.length; ++i) { + length += list[i].length; + } + } + + var buffer = Buffer.allocUnsafe(length); + var pos = 0; + + for (i = 0; i < list.length; ++i) { + var buf = list[i]; + + if (!Buffer.isBuffer(buf)) { + throw new TypeError( + '"list" argument must be an Array of Buffers' + ); + } + + buf.copy(buffer, pos); + pos += buf.length; + } + + return buffer; + }; + + function byteLength(string, encoding) { + if (Buffer.isBuffer(string)) { + return string.length; + } + + if ( + typeof ArrayBuffer !== "undefined" && + typeof ArrayBuffer.isView === "function" && + (ArrayBuffer.isView(string) || + string instanceof ArrayBuffer) + ) { + return string.byteLength; + } + + if (typeof string !== "string") { + string = String(string); + } + + var len = string.length; + if (len === 0) return 0; // Use a for loop to avoid recursion + + var loweredCase = false; + + for (;;) { + switch (encoding) { + case "ascii": + case "latin1": + case "binary": + return len; + + case "utf8": + case "utf-8": + case undefined: + return utf8ToBytes(string).length; + + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return len * 2; + + case "hex": + return len >>> 1; + + case "base64": + return base64ToBytes(string).length; + + default: + if (loweredCase) + return utf8ToBytes(string).length; // Assume utf8 + + encoding = (String(encoding)).toLowerCase(); + loweredCase = true; + } + } + } + + Buffer.byteLength = byteLength; + + function slowToString(encoding, start, end) { + var loweredCase = false; // No need to verify that "this.length <= MAX_UINT32" since it's a read-only + // property of a typed array. + // This behaves neither like String nor Uint8Array in that we set start/end + // to their upper/lower bounds if the value passed is out of range. + // undefined is handled specially as per ECMA-262 6th Edition, + // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. + + if (start === undefined || start < 0) { + start = 0; + } // Return early if start > this.length. Done here to prevent potential uint32 + // coercion fail below. + + if (start > this.length) { + return ""; + } + + if (end === undefined || end > this.length) { + end = this.length; + } + + if (end <= 0) { + return ""; + } // Force coersion to uint32. This will also coerce falsey/NaN values to 0. + + end >>>= 0; + start >>>= 0; + + if (end <= start) { + return ""; + } + + if (!encoding) encoding = "utf8"; + + while (true) { + switch (encoding) { + case "hex": + return hexSlice(this, start, end); + + case "utf8": + case "utf-8": + return utf8Slice(this, start, end); + + case "ascii": + return asciiSlice(this, start, end); + + case "latin1": + case "binary": + return latin1Slice(this, start, end); + + case "base64": + return base64Slice(this, start, end); + + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return utf16leSlice(this, start, end); + + default: + if (loweredCase) + throw new TypeError( + "Unknown encoding: " + encoding + ); + encoding = (String(encoding)).toLowerCase(); + loweredCase = true; + } + } + } // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect + // Buffer instances. + + Buffer.prototype._isBuffer = true; + + function swap(b, n, m) { + var i = b[n]; + b[n] = b[m]; + b[m] = i; + } + + Buffer.prototype.swap16 = function swap16() { + var len = this.length; + + if (len % 2 !== 0) { + throw new RangeError( + "Buffer size must be a multiple of 16-bits" + ); + } + + for (var i = 0; i < len; i += 2) { + swap(this, i, i + 1); + } + + return this; + }; + + Buffer.prototype.swap32 = function swap32() { + var len = this.length; + + if (len % 4 !== 0) { + throw new RangeError( + "Buffer size must be a multiple of 32-bits" + ); + } + + for (var i = 0; i < len; i += 4) { + swap(this, i, i + 3); + swap(this, i + 1, i + 2); + } + + return this; + }; + + Buffer.prototype.swap64 = function swap64() { + var len = this.length; + + if (len % 8 !== 0) { + throw new RangeError( + "Buffer size must be a multiple of 64-bits" + ); + } + + for (var i = 0; i < len; i += 8) { + swap(this, i, i + 7); + swap(this, i + 1, i + 6); + swap(this, i + 2, i + 5); + swap(this, i + 3, i + 4); + } + + return this; + }; + + Buffer.prototype.toString = function toString() { + var length = this.length | 0; + if (length === 0) return ""; + if (arguments.length === 0) + return utf8Slice(this, 0, length); + return slowToString.apply(this, arguments); + }; + + Buffer.prototype.equals = function equals(b) { + if (!Buffer.isBuffer(b)) + throw new TypeError("Argument must be a Buffer"); + if (this === b) return true; + return Buffer.compare(this, b) === 0; + }; + + Buffer.prototype.inspect = function inspect() { + var str = ""; + var max = exports.INSPECT_MAX_BYTES; + + if (this.length > 0) { + str = this.toString("hex", 0, max) + .match(/.{2}/g) + .join(" "); + if (this.length > max) str += " ... "; + } + + return ""; + }; + + Buffer.prototype.compare = function compare( + target, + start, + end, + thisStart, + thisEnd + ) { + if (!Buffer.isBuffer(target)) { + throw new TypeError("Argument must be a Buffer"); + } + + if (start === undefined) { + start = 0; + } + + if (end === undefined) { + end = target ? target.length : 0; + } + + if (thisStart === undefined) { + thisStart = 0; + } + + if (thisEnd === undefined) { + thisEnd = this.length; + } + + if ( + start < 0 || + end > target.length || + thisStart < 0 || + thisEnd > this.length + ) { + throw new RangeError("out of range index"); + } + + if (thisStart >= thisEnd && start >= end) { + return 0; + } + + if (thisStart >= thisEnd) { + return -1; + } + + if (start >= end) { + return 1; + } + + start >>>= 0; + end >>>= 0; + thisStart >>>= 0; + thisEnd >>>= 0; + if (this === target) return 0; + var x = thisEnd - thisStart; + var y = end - start; + var len = Math.min(x, y); + var thisCopy = this.slice(thisStart, thisEnd); + var targetCopy = target.slice(start, end); + + for (var i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i]; + y = targetCopy[i]; + break; + } + } + + if (x < y) return -1; + if (y < x) return 1; + return 0; + }; // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, + // OR the last index of `val` in `buffer` at offset <= `byteOffset`. + // + // Arguments: + // - buffer - a Buffer to search + // - val - a string, Buffer, or number + // - byteOffset - an index into `buffer`; will be clamped to an int32 + // - encoding - an optional encoding, relevant is val is a string + // - dir - true for indexOf, false for lastIndexOf + + function bidirectionalIndexOf( + buffer, + val, + byteOffset, + encoding, + dir + ) { + // Empty buffer means no match + if (buffer.length === 0) return -1; // Normalize byteOffset + + if (typeof byteOffset === "string") { + encoding = byteOffset; + byteOffset = 0; + } else if (byteOffset > 0x7fffffff) { + byteOffset = 0x7fffffff; + } else if (byteOffset < -0x80000000) { + byteOffset = -0x80000000; + } + + byteOffset = Number(byteOffset); // Coerce to Number. + + if (isNaN(byteOffset)) { + // ByteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer + byteOffset = dir ? 0 : buffer.length - 1; + } // Normalize byteOffset: negative offsets start from the end of the buffer + + if (byteOffset < 0) byteOffset = buffer.length + byteOffset; + + if (byteOffset >= buffer.length) { + if (dir) return -1; + byteOffset = buffer.length - 1; + } else if (byteOffset < 0) { + if (dir) byteOffset = 0; + else return -1; + } // Normalize val + + if (typeof val === "string") { + val = Buffer.from(val, encoding); + } // Finally, search either indexOf (if dir is true) or lastIndexOf + + if (Buffer.isBuffer(val)) { + // Special case: looking for empty string/buffer always fails + if (val.length === 0) { + return -1; + } + + return arrayIndexOf( + buffer, + val, + byteOffset, + encoding, + dir + ); + } else if (typeof val === "number") { + val &= 0xff; // Search for a byte value [0-255] + + if ( + Buffer.TYPED_ARRAY_SUPPORT && + typeof Uint8Array.prototype.indexOf === "function" + ) { + if (dir) { + return Uint8Array.prototype.indexOf.call( + buffer, + val, + byteOffset + ); + } + return Uint8Array.prototype.lastIndexOf.call( + buffer, + val, + byteOffset + ); + + } + + return arrayIndexOf( + buffer, + [val], + byteOffset, + encoding, + dir + ); + } + + throw new TypeError("val must be string, number or Buffer"); + } + + function arrayIndexOf(arr, val, byteOffset, encoding, dir) { + var indexSize = 1; + var arrLength = arr.length; + var valLength = val.length; + + if (encoding !== undefined) { + encoding = String(encoding).toLowerCase(); + + if ( + encoding === "ucs2" || + encoding === "ucs-2" || + encoding === "utf16le" || + encoding === "utf-16le" + ) { + if (arr.length < 2 || val.length < 2) { + return -1; + } + + indexSize = 2; + arrLength /= 2; + valLength /= 2; + byteOffset /= 2; + } + } + + function read(buf, i) { + if (indexSize === 1) { + return buf[i]; + } + return buf.readUInt16BE(i * indexSize); + + } + + var i; + + if (dir) { + var foundIndex = -1; + + for (i = byteOffset; i < arrLength; i++) { + if ( + read(arr, i) === + read( + val, + foundIndex === -1 ? 0 : i - foundIndex + ) + ) { + if (foundIndex === -1) foundIndex = i; + if (i - foundIndex + 1 === valLength) + return foundIndex * indexSize; + } else { + if (foundIndex !== -1) i -= i - foundIndex; + foundIndex = -1; + } + } + } else { + if (byteOffset + valLength > arrLength) + byteOffset = arrLength - valLength; + + for (i = byteOffset; i >= 0; i--) { + var found = true; + + for (var j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false; + break; + } + } + + if (found) return i; + } + } + + return -1; + } + + Buffer.prototype.includes = function includes( + val, + byteOffset, + encoding + ) { + return this.indexOf(val, byteOffset, encoding) !== -1; + }; + + Buffer.prototype.indexOf = function indexOf( + val, + byteOffset, + encoding + ) { + return bidirectionalIndexOf( + this, + val, + byteOffset, + encoding, + true + ); + }; + + Buffer.prototype.lastIndexOf = function lastIndexOf( + val, + byteOffset, + encoding + ) { + return bidirectionalIndexOf( + this, + val, + byteOffset, + encoding, + false + ); + }; + + function hexWrite(buf, string, offset, length) { + offset = Number(offset) || 0; + var remaining = buf.length - offset; + + if (!length) { + length = remaining; + } else { + length = Number(length); + + if (length > remaining) { + length = remaining; + } + } // Must be an even number of digits + + var strLen = string.length; + if (strLen % 2 !== 0) + throw new TypeError("Invalid hex string"); + + if (length > strLen / 2) { + length = strLen / 2; + } + + for (var i = 0; i < length; ++i) { + var parsed = parseInt(string.substr(i * 2, 2), 16); + if (isNaN(parsed)) return i; + buf[offset + i] = parsed; + } + + return i; + } + + function utf8Write(buf, string, offset, length) { + return blitBuffer( + utf8ToBytes(string, buf.length - offset), + buf, + offset, + length + ); + } + + function asciiWrite(buf, string, offset, length) { + return blitBuffer( + asciiToBytes(string), + buf, + offset, + length + ); + } + + function latin1Write(buf, string, offset, length) { + return asciiWrite(buf, string, offset, length); + } + + function base64Write(buf, string, offset, length) { + return blitBuffer( + base64ToBytes(string), + buf, + offset, + length + ); + } + + function ucs2Write(buf, string, offset, length) { + return blitBuffer( + utf16leToBytes(string, buf.length - offset), + buf, + offset, + length + ); + } + + Buffer.prototype.write = function write( + string, + offset, + length, + encoding + ) { + // Buffer#write(string) + if (offset === undefined) { + encoding = "utf8"; + length = this.length; + offset = 0; // Buffer#write(string, encoding) + } else if ( + length === undefined && + typeof offset === "string" + ) { + encoding = offset; + length = this.length; + offset = 0; // Buffer#write(string, offset[, length][, encoding]) + } else if (isFinite(offset)) { + offset |= 0; + + if (isFinite(length)) { + length |= 0; + if (encoding === undefined) encoding = "utf8"; + } else { + encoding = length; + length = undefined; + } // Legacy write(string, encoding, offset, length) - remove in v0.13 + } else { + throw new Error( + "Buffer.write(string, encoding, offset[, length]) is no longer supported" + ); + } + + var remaining = this.length - offset; + if (length === undefined || length > remaining) + length = remaining; + + if ( + (string.length > 0 && (length < 0 || offset < 0)) || + offset > this.length + ) { + throw new RangeError( + "Attempt to write outside buffer bounds" + ); + } + + if (!encoding) encoding = "utf8"; + var loweredCase = false; + + for (;;) { + switch (encoding) { + case "hex": + return hexWrite(this, string, offset, length); + + case "utf8": + case "utf-8": + return utf8Write(this, string, offset, length); + + case "ascii": + return asciiWrite(this, string, offset, length); + + case "latin1": + case "binary": + return latin1Write( + this, + string, + offset, + length + ); + + case "base64": + // Warning: maxLength not taken into account in base64Write + return base64Write( + this, + string, + offset, + length + ); + + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return ucs2Write(this, string, offset, length); + + default: + if (loweredCase) + throw new TypeError( + "Unknown encoding: " + encoding + ); + encoding = (String(encoding)).toLowerCase(); + loweredCase = true; + } + } + }; + + Buffer.prototype.toJSON = function toJSON() { + return { + type: "Buffer", + data: Array.prototype.slice.call(this._arr || this, 0), + }; + }; + + function base64Slice(buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf); + } + return base64.fromByteArray(buf.slice(start, end)); + + } + + function utf8Slice(buf, start, end) { + end = Math.min(buf.length, end); + var res = []; + var i = start; + + while (i < end) { + var firstByte = buf[i]; + var codePoint = null; + var bytesPerSequence = + firstByte > 0xef + ? 4 + : firstByte > 0xdf + ? 3 + : firstByte > 0xbf + ? 2 + : 1; + + if (i + bytesPerSequence <= end) { + var secondByte, + thirdByte, + fourthByte, + tempCodePoint; + + switch (bytesPerSequence) { + case 1: + if (firstByte < 0x80) { + codePoint = firstByte; + } + + break; + + case 2: + secondByte = buf[i + 1]; + + if ((secondByte & 0xc0) === 0x80) { + tempCodePoint = + ((firstByte & 0x1f) << 0x6) | + (secondByte & 0x3f); + + if (tempCodePoint > 0x7f) { + codePoint = tempCodePoint; + } + } + + break; + + case 3: + secondByte = buf[i + 1]; + thirdByte = buf[i + 2]; + + if ( + (secondByte & 0xc0) === 0x80 && + (thirdByte & 0xc0) === 0x80 + ) { + tempCodePoint = + ((firstByte & 0xf) << 0xc) | + ((secondByte & 0x3f) << 0x6) | + (thirdByte & 0x3f); + + if ( + tempCodePoint > 0x7ff && + (tempCodePoint < 0xd800 || + tempCodePoint > 0xdfff) + ) { + codePoint = tempCodePoint; + } + } + + break; + + case 4: + secondByte = buf[i + 1]; + thirdByte = buf[i + 2]; + fourthByte = buf[i + 3]; + + if ( + (secondByte & 0xc0) === 0x80 && + (thirdByte & 0xc0) === 0x80 && + (fourthByte & 0xc0) === 0x80 + ) { + tempCodePoint = + ((firstByte & 0xf) << 0x12) | + ((secondByte & 0x3f) << 0xc) | + ((thirdByte & 0x3f) << 0x6) | + (fourthByte & 0x3f); + + if ( + tempCodePoint > 0xffff && + tempCodePoint < 0x110000 + ) { + codePoint = tempCodePoint; + } + } + } + } + + if (codePoint === null) { + // We did not generate a valid codePoint so insert a + // replacement char (U+FFFD) and advance only 1 byte + codePoint = 0xfffd; + bytesPerSequence = 1; + } else if (codePoint > 0xffff) { + // Encode to utf16 (surrogate pair dance) + codePoint -= 0x10000; + res.push(((codePoint >>> 10) & 0x3ff) | 0xd800); + codePoint = 0xdc00 | (codePoint & 0x3ff); + } + + res.push(codePoint); + i += bytesPerSequence; + } + + return decodeCodePointsArray(res); + } // Based on http://stackoverflow.com/a/22747272/680742, the browser with + // the lowest limit is Chrome, with 0x10000 args. + // We go 1 magnitude less, for safety + + var MAX_ARGUMENTS_LENGTH = 0x1000; + + function decodeCodePointsArray(codePoints) { + var len = codePoints.length; + + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints); // Avoid extra slice() + } // Decode in chunks to avoid "call stack size exceeded". + + var res = ""; + var i = 0; + + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, (i += MAX_ARGUMENTS_LENGTH)) + ); + } + + return res; + } + + function asciiSlice(buf, start, end) { + var ret = ""; + end = Math.min(buf.length, end); + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 0x7f); + } + + return ret; + } + + function latin1Slice(buf, start, end) { + var ret = ""; + end = Math.min(buf.length, end); + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]); + } + + return ret; + } + + function hexSlice(buf, start, end) { + var len = buf.length; + if (!start || start < 0) start = 0; + if (!end || end < 0 || end > len) end = len; + var out = ""; + + for (var i = start; i < end; ++i) { + out += toHex(buf[i]); + } + + return out; + } + + function utf16leSlice(buf, start, end) { + var bytes = buf.slice(start, end); + var res = ""; + + for (var i = 0; i < bytes.length; i += 2) { + res += String.fromCharCode( + bytes[i] + bytes[i + 1] * 256 + ); + } + + return res; + } + + Buffer.prototype.slice = function slice(start, end) { + var len = this.length; + start = ~~start; + end = end === undefined ? len : ~~end; + + if (start < 0) { + start += len; + if (start < 0) start = 0; + } else if (start > len) { + start = len; + } + + if (end < 0) { + end += len; + if (end < 0) end = 0; + } else if (end > len) { + end = len; + } + + if (end < start) end = start; + var newBuf; + + if (Buffer.TYPED_ARRAY_SUPPORT) { + newBuf = this.subarray(start, end); + newBuf.__proto__ = Buffer.prototype; + } else { + var sliceLen = end - start; + newBuf = new Buffer(sliceLen, undefined); + + for (var i = 0; i < sliceLen; ++i) { + newBuf[i] = this[i + start]; + } + } + + return newBuf; + }; + /* + * Need to make sure that buffer isn't trying to write out of bounds. + */ + + function checkOffset(offset, ext, length) { + if (offset % 1 !== 0 || offset < 0) + throw new RangeError("offset is not uint"); + if (offset + ext > length) + throw new RangeError( + "Trying to access beyond buffer length" + ); + } + + Buffer.prototype.readUIntLE = function readUIntLE( + offset, + byteLength, + noAssert + ) { + offset |= 0; + byteLength |= 0; + if (!noAssert) checkOffset(offset, byteLength, this.length); + var val = this[offset]; + var mul = 1; + var i = 0; + + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul; + } + + return val; + }; + + Buffer.prototype.readUIntBE = function readUIntBE( + offset, + byteLength, + noAssert + ) { + offset |= 0; + byteLength |= 0; + + if (!noAssert) { + checkOffset(offset, byteLength, this.length); + } + + var val = this[offset + --byteLength]; + var mul = 1; + + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul; + } + + return val; + }; + + Buffer.prototype.readUInt8 = function readUInt8( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 1, this.length); + return this[offset]; + }; + + Buffer.prototype.readUInt16LE = function readUInt16LE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 2, this.length); + return this[offset] | (this[offset + 1] << 8); + }; + + Buffer.prototype.readUInt16BE = function readUInt16BE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 2, this.length); + return (this[offset] << 8) | this[offset + 1]; + }; + + Buffer.prototype.readUInt32LE = function readUInt32LE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 4, this.length); + return ( + (this[offset] | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + this[offset + 3] * 0x1000000 + ); + }; + + Buffer.prototype.readUInt32BE = function readUInt32BE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 4, this.length); + return ( + this[offset] * 0x1000000 + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) + ); + }; + + Buffer.prototype.readIntLE = function readIntLE( + offset, + byteLength, + noAssert + ) { + offset |= 0; + byteLength |= 0; + if (!noAssert) checkOffset(offset, byteLength, this.length); + var val = this[offset]; + var mul = 1; + var i = 0; + + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul; + } + + mul *= 0x80; + if (val >= mul) val -= Math.pow(2, 8 * byteLength); + return val; + }; + + Buffer.prototype.readIntBE = function readIntBE( + offset, + byteLength, + noAssert + ) { + offset |= 0; + byteLength |= 0; + if (!noAssert) checkOffset(offset, byteLength, this.length); + var i = byteLength; + var mul = 1; + var val = this[offset + --i]; + + while (i > 0 && (mul *= 0x100)) { + val += this[offset + --i] * mul; + } + + mul *= 0x80; + if (val >= mul) val -= Math.pow(2, 8 * byteLength); + return val; + }; + + Buffer.prototype.readInt8 = function readInt8( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 1, this.length); + if (!(this[offset] & 0x80)) return this[offset]; + return (0xff - this[offset] + 1) * -1; + }; + + Buffer.prototype.readInt16LE = function readInt16LE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 2, this.length); + var val = this[offset] | (this[offset + 1] << 8); + return val & 0x8000 ? val | 0xffff0000 : val; + }; + + Buffer.prototype.readInt16BE = function readInt16BE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 2, this.length); + var val = this[offset + 1] | (this[offset] << 8); + return val & 0x8000 ? val | 0xffff0000 : val; + }; + + Buffer.prototype.readInt32LE = function readInt32LE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 4, this.length); + return ( + this[offset] | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) + ); + }; + + Buffer.prototype.readInt32BE = function readInt32BE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 4, this.length); + return ( + (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3] + ); + }; + + Buffer.prototype.readFloatLE = function readFloatLE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 4, this.length); + return ieee754.read(this, offset, true, 23, 4); + }; + + Buffer.prototype.readFloatBE = function readFloatBE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 4, this.length); + return ieee754.read(this, offset, false, 23, 4); + }; + + Buffer.prototype.readDoubleLE = function readDoubleLE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 8, this.length); + return ieee754.read(this, offset, true, 52, 8); + }; + + Buffer.prototype.readDoubleBE = function readDoubleBE( + offset, + noAssert + ) { + if (!noAssert) checkOffset(offset, 8, this.length); + return ieee754.read(this, offset, false, 52, 8); + }; + + function checkInt(buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) + throw new TypeError( + '"buffer" argument must be a Buffer instance' + ); + if (value > max || value < min) + throw new RangeError( + '"value" argument is out of bounds' + ); + if (offset + ext > buf.length) + throw new RangeError("Index out of range"); + } + + Buffer.prototype.writeUIntLE = function writeUIntLE( + value, + offset, + byteLength, + noAssert + ) { + value = Number(value); + offset |= 0; + byteLength |= 0; + + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1; + checkInt(this, value, offset, byteLength, maxBytes, 0); + } + + var mul = 1; + var i = 0; + this[offset] = value & 0xff; + + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xff; + } + + return offset + byteLength; + }; + + Buffer.prototype.writeUIntBE = function writeUIntBE( + value, + offset, + byteLength, + noAssert + ) { + value = Number(value); + offset |= 0; + byteLength |= 0; + + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1; + checkInt(this, value, offset, byteLength, maxBytes, 0); + } + + var i = byteLength - 1; + var mul = 1; + this[offset + i] = value & 0xff; + + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xff; + } + + return offset + byteLength; + }; + + Buffer.prototype.writeUInt8 = function writeUInt8( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); + this[offset] = value & 0xff; + return offset + 1; + }; + + function objectWriteUInt16(buf, value, offset, littleEndian) { + if (value < 0) value = 0xffff + value + 1; + + for ( + var i = 0, j = Math.min(buf.length - offset, 2); + i < j; + ++i + ) { + buf[offset + i] = + (value & + (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> + ((littleEndian ? i : 1 - i) * 8); + } + } + + Buffer.prototype.writeUInt16LE = function writeUInt16LE( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); + + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value & 0xff; + this[offset + 1] = value >>> 8; + } else { + objectWriteUInt16(this, value, offset, true); + } + + return offset + 2; + }; + + Buffer.prototype.writeUInt16BE = function writeUInt16BE( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); + + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value >>> 8; + this[offset + 1] = value & 0xff; + } else { + objectWriteUInt16(this, value, offset, false); + } + + return offset + 2; + }; + + function objectWriteUInt32(buf, value, offset, littleEndian) { + if (value < 0) value = 0xffffffff + value + 1; + + for ( + var i = 0, j = Math.min(buf.length - offset, 4); + i < j; + ++i + ) { + buf[offset + i] = + (value >>> ((littleEndian ? i : 3 - i) * 8)) & 0xff; + } + } + + Buffer.prototype.writeUInt32LE = function writeUInt32LE( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) + checkInt(this, value, offset, 4, 0xffffffff, 0); + + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset + 3] = value >>> 24; + this[offset + 2] = value >>> 16; + this[offset + 1] = value >>> 8; + this[offset] = value & 0xff; + } else { + objectWriteUInt32(this, value, offset, true); + } + + return offset + 4; + }; + + Buffer.prototype.writeUInt32BE = function writeUInt32BE( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) + checkInt(this, value, offset, 4, 0xffffffff, 0); + + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 0xff; + } else { + objectWriteUInt32(this, value, offset, false); + } + + return offset + 4; + }; + + Buffer.prototype.writeIntLE = function writeIntLE( + value, + offset, + byteLength, + noAssert + ) { + value = Number(value); + offset |= 0; + + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1); + checkInt( + this, + value, + offset, + byteLength, + limit - 1, + -limit + ); + } + + var i = 0; + var mul = 1; + var sub = 0; + this[offset] = value & 0xff; + + while (++i < byteLength && (mul *= 0x100)) { + if ( + value < 0 && + sub === 0 && + this[offset + i - 1] !== 0 + ) { + sub = 1; + } + + this[offset + i] = (((value / mul) >> 0) - sub) & 0xff; + } + + return offset + byteLength; + }; + + Buffer.prototype.writeIntBE = function writeIntBE( + value, + offset, + byteLength, + noAssert + ) { + value = Number(value); + offset |= 0; + + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1); + checkInt( + this, + value, + offset, + byteLength, + limit - 1, + -limit + ); + } + + var i = byteLength - 1; + var mul = 1; + var sub = 0; + this[offset + i] = value & 0xff; + + while (--i >= 0 && (mul *= 0x100)) { + if ( + value < 0 && + sub === 0 && + this[offset + i + 1] !== 0 + ) { + sub = 1; + } + + this[offset + i] = (((value / mul) >> 0) - sub) & 0xff; + } + + return offset + byteLength; + }; + + Buffer.prototype.writeInt8 = function writeInt8( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) + checkInt(this, value, offset, 1, 0x7f, -0x80); + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); + if (value < 0) value = 0xff + value + 1; + this[offset] = value & 0xff; + return offset + 1; + }; + + Buffer.prototype.writeInt16LE = function writeInt16LE( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) + checkInt(this, value, offset, 2, 0x7fff, -0x8000); + + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value & 0xff; + this[offset + 1] = value >>> 8; + } else { + objectWriteUInt16(this, value, offset, true); + } + + return offset + 2; + }; + + Buffer.prototype.writeInt16BE = function writeInt16BE( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) + checkInt(this, value, offset, 2, 0x7fff, -0x8000); + + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value >>> 8; + this[offset + 1] = value & 0xff; + } else { + objectWriteUInt16(this, value, offset, false); + } + + return offset + 2; + }; + + Buffer.prototype.writeInt32LE = function writeInt32LE( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) + checkInt( + this, + value, + offset, + 4, + 0x7fffffff, + -0x80000000 + ); + + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value & 0xff; + this[offset + 1] = value >>> 8; + this[offset + 2] = value >>> 16; + this[offset + 3] = value >>> 24; + } else { + objectWriteUInt32(this, value, offset, true); + } + + return offset + 4; + }; + + Buffer.prototype.writeInt32BE = function writeInt32BE( + value, + offset, + noAssert + ) { + value = Number(value); + offset |= 0; + if (!noAssert) + checkInt( + this, + value, + offset, + 4, + 0x7fffffff, + -0x80000000 + ); + if (value < 0) value = 0xffffffff + value + 1; + + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 0xff; + } else { + objectWriteUInt32(this, value, offset, false); + } + + return offset + 4; + }; + + function checkIEEE754(buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) + throw new RangeError("Index out of range"); + if (offset < 0) throw new RangeError("Index out of range"); + } + + function writeFloat( + buf, + value, + offset, + littleEndian, + noAssert + ) { + if (!noAssert) { + checkIEEE754( + buf, + value, + offset, + 4, + 3.4028234663852886e38, + -3.4028234663852886e38 + ); + } + + ieee754.write(buf, value, offset, littleEndian, 23, 4); + return offset + 4; + } + + Buffer.prototype.writeFloatLE = function writeFloatLE( + value, + offset, + noAssert + ) { + return writeFloat(this, value, offset, true, noAssert); + }; + + Buffer.prototype.writeFloatBE = function writeFloatBE( + value, + offset, + noAssert + ) { + return writeFloat(this, value, offset, false, noAssert); + }; + + function writeDouble( + buf, + value, + offset, + littleEndian, + noAssert + ) { + if (!noAssert) { + checkIEEE754( + buf, + value, + offset, + 8, + 1.7976931348623157e308, + -1.7976931348623157e308 + ); + } + + ieee754.write(buf, value, offset, littleEndian, 52, 8); + return offset + 8; + } + + Buffer.prototype.writeDoubleLE = function writeDoubleLE( + value, + offset, + noAssert + ) { + return writeDouble(this, value, offset, true, noAssert); + }; + + Buffer.prototype.writeDoubleBE = function writeDoubleBE( + value, + offset, + noAssert + ) { + return writeDouble(this, value, offset, false, noAssert); + }; // Copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) + + Buffer.prototype.copy = function copy( + target, + targetStart, + start, + end + ) { + if (!start) start = 0; + if (!end && end !== 0) end = this.length; + if (targetStart >= target.length) + targetStart = target.length; + if (!targetStart) targetStart = 0; + if (end > 0 && end < start) end = start; // Copy 0 bytes; we're done + + if (end === start) return 0; + if (target.length === 0 || this.length === 0) return 0; // Fatal error conditions + + if (targetStart < 0) { + throw new RangeError("targetStart out of bounds"); + } + + if (start < 0 || start >= this.length) + throw new RangeError("sourceStart out of bounds"); + if (end < 0) + throw new RangeError("sourceEnd out of bounds"); // Are we oob? + + if (end > this.length) end = this.length; + + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start; + } + + var len = end - start; + var i; + + if ( + this === target && + start < targetStart && + targetStart < end + ) { + // Descending copy from end + for (i = len - 1; i >= 0; --i) { + target[i + targetStart] = this[i + start]; + } + } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { + // Ascending copy from start + for (i = 0; i < len; ++i) { + target[i + targetStart] = this[i + start]; + } + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, start + len), + targetStart + ); + } + + return len; + }; // Usage: + // buffer.fill(number[, offset[, end]]) + // buffer.fill(buffer[, offset[, end]]) + // buffer.fill(string[, offset[, end]][, encoding]) + + Buffer.prototype.fill = function fill( + val, + start, + end, + encoding + ) { + // Handle string cases: + if (typeof val === "string") { + if (typeof start === "string") { + encoding = start; + start = 0; + end = this.length; + } else if (typeof end === "string") { + encoding = end; + end = this.length; + } + + if (val.length === 1) { + var code = val.charCodeAt(0); + + if (code < 256) { + val = code; + } + } + + if ( + encoding !== undefined && + typeof encoding !== "string" + ) { + throw new TypeError("encoding must be a string"); + } + + if ( + typeof encoding === "string" && + !Buffer.isEncoding(encoding) + ) { + throw new TypeError( + "Unknown encoding: " + encoding + ); + } + } else if (typeof val === "number") { + val &= 255; + } // Invalid ranges are not set to a default, so can range check early. + + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError("Out of range index"); + } + + if (end <= start) { + return this; + } + + start >>>= 0; + end = end === undefined ? this.length : end >>> 0; + if (!val) val = 0; + var i; + + if (typeof val === "number") { + for (i = start; i < end; ++i) { + this[i] = val; + } + } else { + var bytes = Buffer.isBuffer(val) + ? val + : utf8ToBytes(new Buffer(val, encoding).toString()); + var len = bytes.length; + + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len]; + } + } + + return this; + }; // HELPER FUNCTIONS + // ================ + + var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; + + function base64clean(str) { + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = stringtrim(str).replace(INVALID_BASE64_RE, ""); // Node converts strings with length < 2 to '' + + if (str.length < 2) return ""; // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + + while (str.length % 4 !== 0) { + str += "="; + } + + return str; + } + + function stringtrim(str) { + if (str.trim) return str.trim(); + return str.replace(/^\s+|\s+$/g, ""); + } + + function toHex(n) { + if (n < 16) return "0" + n.toString(16); + return n.toString(16); + } + + function utf8ToBytes(string, units) { + units = units || Infinity; + var codePoint; + var length = string.length; + var leadSurrogate = null; + var bytes = []; + + for (var i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i); // Is surrogate component + + if (codePoint > 0xd7ff && codePoint < 0xe000) { + // Last char was a lead + if (!leadSurrogate) { + // No lead yet + if (codePoint > 0xdbff) { + // Unexpected trail + if ((units -= 3) > -1) + bytes.push(0xef, 0xbf, 0xbd); + continue; + } else if (i + 1 === length) { + // Unpaired lead + if ((units -= 3) > -1) + bytes.push(0xef, 0xbf, 0xbd); + continue; + } // Valid lead + + leadSurrogate = codePoint; + continue; + } // 2 leads in a row + + if (codePoint < 0xdc00) { + if ((units -= 3) > -1) + bytes.push(0xef, 0xbf, 0xbd); + leadSurrogate = codePoint; + continue; + } // Valid surrogate pair + + codePoint = + (((leadSurrogate - 0xd800) << 10) | + (codePoint - 0xdc00)) + + 0x10000; + } else if (leadSurrogate) { + // Valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd); + } + + leadSurrogate = null; // Encode utf8 + + if (codePoint < 0x80) { + if ((units -= 1) < 0) break; + bytes.push(codePoint); + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break; + bytes.push( + (codePoint >> 0x6) | 0xc0, + (codePoint & 0x3f) | 0x80 + ); + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break; + bytes.push( + (codePoint >> 0xc) | 0xe0, + ((codePoint >> 0x6) & 0x3f) | 0x80, + (codePoint & 0x3f) | 0x80 + ); + } else if (codePoint < 0x110000) { + if ((units -= 4) < 0) break; + bytes.push( + (codePoint >> 0x12) | 0xf0, + ((codePoint >> 0xc) & 0x3f) | 0x80, + ((codePoint >> 0x6) & 0x3f) | 0x80, + (codePoint & 0x3f) | 0x80 + ); + } else { + throw new Error("Invalid code point"); + } + } + + return bytes; + } + + function asciiToBytes(str) { + var byteArray = []; + + for (var i = 0; i < str.length; ++i) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xff); + } + + return byteArray; + } + + function utf16leToBytes(str, units) { + var c, hi, lo; + var byteArray = []; + + for (var i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break; + c = str.charCodeAt(i); + hi = c >> 8; + lo = c % 256; + byteArray.push(lo); + byteArray.push(hi); + } + + return byteArray; + } + + function base64ToBytes(str) { + return base64.toByteArray(base64clean(str)); + } + + function blitBuffer(src, dst, offset, length) { + for (var i = 0; i < length; ++i) { + if (i + offset >= dst.length || i >= src.length) break; + dst[i + offset] = src[i]; + } + + return i; + } + + function isnan(val) { + return val !== val; // eslint-disable-line no-self-compare + } + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js" + ) + )); + + /***/ + }, + + /***/ "./node_modules/cipher-base/index.js": + /* !*******************************************!*\ + !*** ./node_modules/cipher-base/index.js ***! + \*******************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var Transform = __webpack_require__( + /* ! stream */ "./node_modules/stream-browserify/index.js" + ).Transform; + + var StringDecoder = __webpack_require__( + /* ! string_decoder */ "./node_modules/node-libs-browser/node_modules/string_decoder/lib/string_decoder.js" + ).StringDecoder; + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + function CipherBase(hashMode) { + Transform.call(this); + this.hashMode = typeof hashMode === "string"; + + if (this.hashMode) { + this[hashMode] = this._finalOrDigest; + } else { + this.final = this._finalOrDigest; + } + + if (this._final) { + this.__final = this._final; + this._final = null; + } + + this._decoder = null; + this._encoding = null; + } + + inherits(CipherBase, Transform); + + CipherBase.prototype.update = function (data, inputEnc, outputEnc) { + if (typeof data === "string") { + data = Buffer.from(data, inputEnc); + } + + var outData = this._update(data); + + if (this.hashMode) return this; + + if (outputEnc) { + outData = this._toString(outData, outputEnc); + } + + return outData; + }; + + CipherBase.prototype.setAutoPadding = function () {}; + + CipherBase.prototype.getAuthTag = function () { + throw new Error("trying to get auth tag in unsupported state"); + }; + + CipherBase.prototype.setAuthTag = function () { + throw new Error("trying to set auth tag in unsupported state"); + }; + + CipherBase.prototype.setAAD = function () { + throw new Error("trying to set aad in unsupported state"); + }; + + CipherBase.prototype._transform = function (data, _, next) { + var err; + + try { + if (this.hashMode) { + this._update(data); + } else { + this.push(this._update(data)); + } + } catch (e) { + err = e; + } finally { + next(err); + } + }; + + CipherBase.prototype._flush = function (done) { + var err; + + try { + this.push(this.__final()); + } catch (e) { + err = e; + } + + done(err); + }; + + CipherBase.prototype._finalOrDigest = function (outputEnc) { + var outData = this.__final() || Buffer.alloc(0); + + if (outputEnc) { + outData = this._toString(outData, outputEnc, true); + } + + return outData; + }; + + CipherBase.prototype._toString = function (value, enc, fin) { + if (!this._decoder) { + this._decoder = new StringDecoder(enc); + this._encoding = enc; + } + + if (this._encoding !== enc) + throw new Error("can't switch encodings"); + + var out = this._decoder.write(value); + + if (fin) { + out += this._decoder.end(); + } + + return out; + }; + + module.exports = CipherBase; + + /***/ + }, + + /***/ "./node_modules/core-util-is/lib/util.js": + /* !***********************************************!*\ + !*** ./node_modules/core-util-is/lib/util.js ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + // Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. + // NOTE: These type checking functions intentionally don't use `instanceof` + // because it is fragile and can be easily faked with `Object.create()`. + function isArray(arg) { + if (Array.isArray) { + return Array.isArray(arg); + } + + return objectToString(arg) === "[object Array]"; + } + + exports.isArray = isArray; + + function isBoolean(arg) { + return typeof arg === "boolean"; + } + + exports.isBoolean = isBoolean; + + function isNull(arg) { + return arg === null; + } + + exports.isNull = isNull; + + function isNullOrUndefined(arg) { + return arg == null; + } + + exports.isNullOrUndefined = isNullOrUndefined; + + function isNumber(arg) { + return typeof arg === "number"; + } + + exports.isNumber = isNumber; + + function isString(arg) { + return typeof arg === "string"; + } + + exports.isString = isString; + + function isSymbol(arg) { + return _typeof(arg) === "symbol"; + } + + exports.isSymbol = isSymbol; + + function isUndefined(arg) { + return arg === void 0; + } + + exports.isUndefined = isUndefined; + + function isRegExp(re) { + return objectToString(re) === "[object RegExp]"; + } + + exports.isRegExp = isRegExp; + + function isObject(arg) { + return _typeof(arg) === "object" && arg !== null; + } + + exports.isObject = isObject; + + function isDate(d) { + return objectToString(d) === "[object Date]"; + } + + exports.isDate = isDate; + + function isError(e) { + return ( + objectToString(e) === "[object Error]" || + e instanceof Error + ); + } + + exports.isError = isError; + + function isFunction(arg) { + return typeof arg === "function"; + } + + exports.isFunction = isFunction; + + function isPrimitive(arg) { + return ( + arg === null || + typeof arg === "boolean" || + typeof arg === "number" || + typeof arg === "string" || + _typeof(arg) === "symbol" || // ES6 symbol + typeof arg === "undefined" + ); + } + + exports.isPrimitive = isPrimitive; + exports.isBuffer = Buffer.isBuffer; + + function objectToString(o) { + return Object.prototype.toString.call(o); + } + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/create-ecdh/browser.js": + /* !*********************************************!*\ + !*** ./node_modules/create-ecdh/browser.js ***! + \*********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + var elliptic = __webpack_require__( + /* ! elliptic */ "./node_modules/elliptic/lib/elliptic.js" + ); + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + module.exports = function createECDH(curve) { + return new ECDH(curve); + }; + + var aliases = { + secp256k1: { + name: "secp256k1", + byteLength: 32, + }, + secp224r1: { + name: "p224", + byteLength: 28, + }, + prime256v1: { + name: "p256", + byteLength: 32, + }, + prime192v1: { + name: "p192", + byteLength: 24, + }, + ed25519: { + name: "ed25519", + byteLength: 32, + }, + secp384r1: { + name: "p384", + byteLength: 48, + }, + secp521r1: { + name: "p521", + byteLength: 66, + }, + }; + aliases.p224 = aliases.secp224r1; + aliases.p256 = aliases.secp256r1 = aliases.prime256v1; + aliases.p192 = aliases.secp192r1 = aliases.prime192v1; + aliases.p384 = aliases.secp384r1; + aliases.p521 = aliases.secp521r1; + + function ECDH(curve) { + this.curveType = aliases[curve]; + + if (!this.curveType) { + this.curveType = { + name: curve, + }; + } + + this.curve = new elliptic.ec(this.curveType.name); // eslint-disable-line new-cap + + this.keys = void 0; + } + + ECDH.prototype.generateKeys = function (enc, format) { + this.keys = this.curve.genKeyPair(); + return this.getPublicKey(enc, format); + }; + + ECDH.prototype.computeSecret = function (other, inenc, enc) { + inenc = inenc || "utf8"; + + if (!Buffer.isBuffer(other)) { + other = new Buffer(other, inenc); + } + + var otherPub = this.curve.keyFromPublic(other).getPublic(); + var out = otherPub.mul(this.keys.getPrivate()).getX(); + return formatReturnValue( + out, + enc, + this.curveType.byteLength + ); + }; + + ECDH.prototype.getPublicKey = function (enc, format) { + var key = this.keys.getPublic( + format === "compressed", + true + ); + + if (format === "hybrid") { + if (key[key.length - 1] % 2) { + key[0] = 7; + } else { + key[0] = 6; + } + } + + return formatReturnValue(key, enc); + }; + + ECDH.prototype.getPrivateKey = function (enc) { + return formatReturnValue(this.keys.getPrivate(), enc); + }; + + ECDH.prototype.setPublicKey = function (pub, enc) { + enc = enc || "utf8"; + + if (!Buffer.isBuffer(pub)) { + pub = new Buffer(pub, enc); + } + + this.keys._importPublic(pub); + + return this; + }; + + ECDH.prototype.setPrivateKey = function (priv, enc) { + enc = enc || "utf8"; + + if (!Buffer.isBuffer(priv)) { + priv = new Buffer(priv, enc); + } + + var _priv = new BN(priv); + + _priv = _priv.toString(16); + this.keys = this.curve.genKeyPair(); + + this.keys._importPrivate(_priv); + + return this; + }; + + function formatReturnValue(bn, enc, len) { + if (!Array.isArray(bn)) { + bn = bn.toArray(); + } + + var buf = new Buffer(bn); + + if (len && buf.length < len) { + var zeros = new Buffer(len - buf.length); + zeros.fill(0); + buf = Buffer.concat([zeros, buf]); + } + + if (!enc) { + return buf; + } + return buf.toString(enc); + + } + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/create-hash/browser.js": + /* !*********************************************!*\ + !*** ./node_modules/create-hash/browser.js ***! + \*********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var MD5 = __webpack_require__( + /* ! md5.js */ "./node_modules/md5.js/index.js" + ); + + var RIPEMD160 = __webpack_require__( + /* ! ripemd160 */ "./node_modules/ripemd160/index.js" + ); + + var sha = __webpack_require__( + /* ! sha.js */ "./node_modules/sha.js/index.js" + ); + + var Base = __webpack_require__( + /* ! cipher-base */ "./node_modules/cipher-base/index.js" + ); + + function Hash(hash) { + Base.call(this, "digest"); + this._hash = hash; + } + + inherits(Hash, Base); + + Hash.prototype._update = function (data) { + this._hash.update(data); + }; + + Hash.prototype._final = function () { + return this._hash.digest(); + }; + + module.exports = function createHash(alg) { + alg = alg.toLowerCase(); + if (alg === "md5") return new MD5(); + if (alg === "rmd160" || alg === "ripemd160") + return new RIPEMD160(); + return new Hash(sha(alg)); + }; + + /***/ + }, + + /***/ "./node_modules/create-hash/md5.js": + /* !*****************************************!*\ + !*** ./node_modules/create-hash/md5.js ***! + \*****************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var MD5 = __webpack_require__( + /* ! md5.js */ "./node_modules/md5.js/index.js" + ); + + module.exports = function (buffer) { + return new MD5().update(buffer).digest(); + }; + + /***/ + }, + + /***/ "./node_modules/create-hmac/browser.js": + /* !*********************************************!*\ + !*** ./node_modules/create-hmac/browser.js ***! + \*********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Legacy = __webpack_require__( + /* ! ./legacy */ "./node_modules/create-hmac/legacy.js" + ); + + var Base = __webpack_require__( + /* ! cipher-base */ "./node_modules/cipher-base/index.js" + ); + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var md5 = __webpack_require__( + /* ! create-hash/md5 */ "./node_modules/create-hash/md5.js" + ); + + var RIPEMD160 = __webpack_require__( + /* ! ripemd160 */ "./node_modules/ripemd160/index.js" + ); + + var sha = __webpack_require__( + /* ! sha.js */ "./node_modules/sha.js/index.js" + ); + + var ZEROS = Buffer.alloc(128); + + function Hmac(alg, key) { + Base.call(this, "digest"); + + if (typeof key === "string") { + key = Buffer.from(key); + } + + var blocksize = alg === "sha512" || alg === "sha384" ? 128 : 64; + this._alg = alg; + this._key = key; + + if (key.length > blocksize) { + var hash = alg === "rmd160" ? new RIPEMD160() : sha(alg); + key = hash.update(key).digest(); + } else if (key.length < blocksize) { + key = Buffer.concat([key, ZEROS], blocksize); + } + + var ipad = (this._ipad = Buffer.allocUnsafe(blocksize)); + var opad = (this._opad = Buffer.allocUnsafe(blocksize)); + + for (var i = 0; i < blocksize; i++) { + ipad[i] = key[i] ^ 0x36; + opad[i] = key[i] ^ 0x5c; + } + + this._hash = alg === "rmd160" ? new RIPEMD160() : sha(alg); + + this._hash.update(ipad); + } + + inherits(Hmac, Base); + + Hmac.prototype._update = function (data) { + this._hash.update(data); + }; + + Hmac.prototype._final = function () { + var h = this._hash.digest(); + + var hash = + this._alg === "rmd160" ? new RIPEMD160() : sha(this._alg); + return hash.update(this._opad).update(h).digest(); + }; + + module.exports = function createHmac(alg, key) { + alg = alg.toLowerCase(); + + if (alg === "rmd160" || alg === "ripemd160") { + return new Hmac("rmd160", key); + } + + if (alg === "md5") { + return new Legacy(md5, key); + } + + return new Hmac(alg, key); + }; + + /***/ + }, + + /***/ "./node_modules/create-hmac/legacy.js": + /* !********************************************!*\ + !*** ./node_modules/create-hmac/legacy.js ***! + \********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var Base = __webpack_require__( + /* ! cipher-base */ "./node_modules/cipher-base/index.js" + ); + + var ZEROS = Buffer.alloc(128); + var blocksize = 64; + + function Hmac(alg, key) { + Base.call(this, "digest"); + + if (typeof key === "string") { + key = Buffer.from(key); + } + + this._alg = alg; + this._key = key; + + if (key.length > blocksize) { + key = alg(key); + } else if (key.length < blocksize) { + key = Buffer.concat([key, ZEROS], blocksize); + } + + var ipad = (this._ipad = Buffer.allocUnsafe(blocksize)); + var opad = (this._opad = Buffer.allocUnsafe(blocksize)); + + for (var i = 0; i < blocksize; i++) { + ipad[i] = key[i] ^ 0x36; + opad[i] = key[i] ^ 0x5c; + } + + this._hash = [ipad]; + } + + inherits(Hmac, Base); + + Hmac.prototype._update = function (data) { + this._hash.push(data); + }; + + Hmac.prototype._final = function () { + var h = this._alg(Buffer.concat(this._hash)); + + return this._alg(Buffer.concat([this._opad, h])); + }; + + module.exports = Hmac; + + /***/ + }, + + /***/ "./node_modules/crypto-browserify/index.js": + /* !*************************************************!*\ + !*** ./node_modules/crypto-browserify/index.js ***! + \*************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = __webpack_require__( + /* ! randombytes */ "./node_modules/randombytes/browser.js" + ); + exports.createHash = exports.Hash = __webpack_require__( + /* ! create-hash */ "./node_modules/create-hash/browser.js" + ); + exports.createHmac = exports.Hmac = __webpack_require__( + /* ! create-hmac */ "./node_modules/create-hmac/browser.js" + ); + + var algos = __webpack_require__( + /* ! browserify-sign/algos */ "./node_modules/browserify-sign/algos.js" + ); + + var algoKeys = Object.keys(algos); + var hashes = [ + "sha1", + "sha224", + "sha256", + "sha384", + "sha512", + "md5", + "rmd160", + ].concat(algoKeys); + + exports.getHashes = function () { + return hashes; + }; + + var p = __webpack_require__( + /* ! pbkdf2 */ "./node_modules/pbkdf2/browser.js" + ); + + exports.pbkdf2 = p.pbkdf2; + exports.pbkdf2Sync = p.pbkdf2Sync; + + var aes = __webpack_require__( + /* ! browserify-cipher */ "./node_modules/browserify-cipher/browser.js" + ); + + exports.Cipher = aes.Cipher; + exports.createCipher = aes.createCipher; + exports.Cipheriv = aes.Cipheriv; + exports.createCipheriv = aes.createCipheriv; + exports.Decipher = aes.Decipher; + exports.createDecipher = aes.createDecipher; + exports.Decipheriv = aes.Decipheriv; + exports.createDecipheriv = aes.createDecipheriv; + exports.getCiphers = aes.getCiphers; + exports.listCiphers = aes.listCiphers; + + var dh = __webpack_require__( + /* ! diffie-hellman */ "./node_modules/diffie-hellman/browser.js" + ); + + exports.DiffieHellmanGroup = dh.DiffieHellmanGroup; + exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup; + exports.getDiffieHellman = dh.getDiffieHellman; + exports.createDiffieHellman = dh.createDiffieHellman; + exports.DiffieHellman = dh.DiffieHellman; + + var sign = __webpack_require__( + /* ! browserify-sign */ "./node_modules/browserify-sign/browser/index.js" + ); + + exports.createSign = sign.createSign; + exports.Sign = sign.Sign; + exports.createVerify = sign.createVerify; + exports.Verify = sign.Verify; + exports.createECDH = __webpack_require__( + /* ! create-ecdh */ "./node_modules/create-ecdh/browser.js" + ); + + var publicEncrypt = __webpack_require__( + /* ! public-encrypt */ "./node_modules/public-encrypt/browser.js" + ); + + exports.publicEncrypt = publicEncrypt.publicEncrypt; + exports.privateEncrypt = publicEncrypt.privateEncrypt; + exports.publicDecrypt = publicEncrypt.publicDecrypt; + exports.privateDecrypt = publicEncrypt.privateDecrypt; // The least I can do is make error messages for the rest of the node.js/crypto api. + // ;[ + // 'createCredentials' + // ].forEach(function (name) { + // exports[name] = function () { + // throw new Error([ + // 'sorry, ' + name + ' is not implemented yet', + // 'we accept pull requests', + // 'https://github.com/crypto-browserify/crypto-browserify' + // ].join('\n')) + // } + // }) + + var rf = __webpack_require__( + /* ! randomfill */ "./node_modules/randomfill/browser.js" + ); + + exports.randomFill = rf.randomFill; + exports.randomFillSync = rf.randomFillSync; + + exports.createCredentials = function () { + throw new Error( + [ + "sorry, createCredentials is not implemented yet", + "we accept pull requests", + "https://github.com/crypto-browserify/crypto-browserify", + ].join("\n") + ); + }; + + exports.constants = { + DH_CHECK_P_NOT_SAFE_PRIME: 2, + DH_CHECK_P_NOT_PRIME: 1, + DH_UNABLE_TO_CHECK_GENERATOR: 4, + DH_NOT_SUITABLE_GENERATOR: 8, + NPN_ENABLED: 1, + ALPN_ENABLED: 1, + RSA_PKCS1_PADDING: 1, + RSA_SSLV23_PADDING: 2, + RSA_NO_PADDING: 3, + RSA_PKCS1_OAEP_PADDING: 4, + RSA_X931_PADDING: 5, + RSA_PKCS1_PSS_PADDING: 6, + POINT_CONVERSION_COMPRESSED: 2, + POINT_CONVERSION_UNCOMPRESSED: 4, + POINT_CONVERSION_HYBRID: 6, + }; + + /***/ + }, + + /***/ "./node_modules/crypto-random-string/index.js": + /* !****************************************************!*\ + !*** ./node_modules/crypto-random-string/index.js ***! + \****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var crypto = __webpack_require__( + /* ! crypto */ "./node_modules/crypto-browserify/index.js" + ); + + var urlSafeCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~".split( + "" + ); + + var generateForCustomCharacters = function generateForCustomCharacters( + length, + characters + ) { + // Generating entropy is faster than complex math operations, so we use the simplest way + var characterCount = characters.length; + var maxValidSelector = + Math.floor(0x10000 / characterCount) * characterCount - 1; // Using values above this will ruin distribution when using modular division + + var entropyLength = 2 * Math.ceil(1.1 * length); // Generating a bit more than required so chances we need more than one pass will be really low + + var string = ""; + var stringLength = 0; + + while (stringLength < length) { + // In case we had many bad values, which may happen for character sets of size above 0x8000 but close to it + var entropy = crypto.randomBytes(entropyLength); + var entropyPosition = 0; + + while ( + entropyPosition < entropyLength && + stringLength < length + ) { + var entropyValue = entropy.readUInt16LE( + entropyPosition + ); + entropyPosition += 2; + + if (entropyValue > maxValidSelector) { + // Skip values which will ruin distribution when using modular division + continue; + } + + string += characters[entropyValue % characterCount]; + stringLength++; + } + } + + return string; + }; + + var allowedTypes = [undefined, "hex", "base64", "url-safe"]; + + module.exports = function (_ref) { + var length = _ref.length, + type = _ref.type, + characters = _ref.characters; + + if (!(length >= 0 && Number.isFinite(length))) { + throw new TypeError( + "Expected a `length` to be a non-negative finite number" + ); + } + + if (type !== undefined && characters !== undefined) { + throw new TypeError( + "Expected either `type` or `characters`" + ); + } + + if ( + characters !== undefined && + typeof characters !== "string" + ) { + throw new TypeError("Expected `characters` to be string"); + } + + if (!allowedTypes.includes(type)) { + throw new TypeError("Unknown type: ".concat(type)); + } + + if (type === undefined && characters === undefined) { + type = "hex"; + } + + if ( + type === "hex" || + (type === undefined && characters === undefined) + ) { + return crypto + .randomBytes(Math.ceil(length * 0.5)) + .toString("hex") + .slice(0, length); // Need 0.5 byte entropy per character + } + + if (type === "base64") { + return crypto + .randomBytes(Math.ceil(length * 0.75)) + .toString("base64") + .slice(0, length); // Need 0.75 byte of entropy per character + } + + if (type === "url-safe") { + return generateForCustomCharacters( + length, + urlSafeCharacters + ); + } + + if (characters.length === 0) { + throw new TypeError( + "Expected `characters` string length to be greater than or equal to 1" + ); + } + + if (characters.length > 0x10000) { + throw new TypeError( + "Expected `characters` string length to be less or equal to 65536" + ); + } + + return generateForCustomCharacters( + length, + characters.split("") + ); + }; + + /***/ + }, + + /***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/dark/index.scss": + /* !*****************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/dark/index.scss ***! + \*****************************************************************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + exports = module.exports = __webpack_require__( + /* ! ../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js" + )(false); + // Module + exports.push([ + module.i, + "/* Flowchart variables */\n/* Sequence Diagram variables */\n/* Gantt chart variables */\n/* state colors */\n.label {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n color: #333; }\n\n.label text {\n fill: #333; }\n\n.node rect,\n.node circle,\n.node ellipse,\n.node polygon {\n fill: #BDD5EA;\n stroke: purple;\n stroke-width: 1px; }\n\n.node .label {\n text-align: center; }\n\n.node.clickable {\n cursor: pointer; }\n\n.arrowheadPath {\n fill: lightgrey; }\n\n.edgePath .path {\n stroke: lightgrey;\n stroke-width: 1.5px; }\n\n.edgeLabel {\n background-color: #e8e8e8;\n text-align: center; }\n\n.cluster rect {\n fill: #6D6D65;\n stroke: rgba(255, 255, 255, 0.25);\n stroke-width: 1px; }\n\n.cluster text {\n fill: #F9FFFE; }\n\ndiv.mermaidTooltip {\n position: absolute;\n text-align: center;\n max-width: 200px;\n padding: 2px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 12px;\n background: #6D6D65;\n border: 1px solid rgba(255, 255, 255, 0.25);\n border-radius: 2px;\n pointer-events: none;\n z-index: 100; }\n\n.actor {\n stroke: #81B1DB;\n fill: #BDD5EA; }\n\ntext.actor {\n fill: black;\n stroke: none; }\n\n.actor-line {\n stroke: lightgrey; }\n\n.messageLine0 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: lightgrey; }\n\n.messageLine1 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: lightgrey; }\n\n#arrowhead {\n fill: lightgrey; }\n\n.sequenceNumber {\n fill: white; }\n\n#sequencenumber {\n fill: lightgrey; }\n\n#crosshead path {\n fill: lightgrey !important;\n stroke: lightgrey !important; }\n\n.messageText {\n fill: lightgrey;\n stroke: none; }\n\n.labelBox {\n stroke: #81B1DB;\n fill: #BDD5EA; }\n\n.labelText {\n fill: #323D47;\n stroke: none; }\n\n.loopText {\n fill: lightgrey;\n stroke: none; }\n\n.loopLine {\n stroke-width: 2;\n stroke-dasharray: '2 2';\n stroke: #81B1DB; }\n\n.note {\n stroke: rgba(255, 255, 255, 0.25);\n fill: #fff5ad; }\n\n.noteText {\n fill: black;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 14px; }\n\n.activation0 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation1 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation2 {\n fill: #f4f4f4;\n stroke: #666; }\n\n/** Section styling */\n.mermaid-main-font {\n font-family: \"trebuchet ms\", verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.section {\n stroke: none;\n opacity: 0.2; }\n\n.section0 {\n fill: rgba(255, 255, 255, 0.3); }\n\n.section2 {\n fill: #EAE8B9; }\n\n.section1,\n.section3 {\n fill: white;\n opacity: 0.2; }\n\n.sectionTitle0 {\n fill: #F9FFFE; }\n\n.sectionTitle1 {\n fill: #F9FFFE; }\n\n.sectionTitle2 {\n fill: #F9FFFE; }\n\n.sectionTitle3 {\n fill: #F9FFFE; }\n\n.sectionTitle {\n text-anchor: start;\n font-size: 11px;\n text-height: 14px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n/* Grid and axis */\n.grid .tick {\n stroke: lightgrey;\n opacity: 0.3;\n shape-rendering: crispEdges; }\n .grid .tick text {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.grid path {\n stroke-width: 0; }\n\n/* Today line */\n.today {\n fill: none;\n stroke: #DB5757;\n stroke-width: 2px; }\n\n/* Task styling */\n/* Default task */\n.task {\n stroke-width: 2; }\n\n.taskText {\n text-anchor: middle;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.taskText:not([font-size]) {\n font-size: 11px; }\n\n.taskTextOutsideRight {\n fill: #323D47;\n text-anchor: start;\n font-size: 11px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.taskTextOutsideLeft {\n fill: #323D47;\n text-anchor: end;\n font-size: 11px; }\n\n/* Special case clickable */\n.task.clickable {\n cursor: pointer; }\n\n.taskText.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideLeft.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideRight.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n/* Specific task settings for the sections*/\n.taskText0,\n.taskText1,\n.taskText2,\n.taskText3 {\n fill: #323D47; }\n\n.task0,\n.task1,\n.task2,\n.task3 {\n fill: #BDD5EA;\n stroke: rgba(255, 255, 255, 0.5); }\n\n.taskTextOutside0,\n.taskTextOutside2 {\n fill: lightgrey; }\n\n.taskTextOutside1,\n.taskTextOutside3 {\n fill: lightgrey; }\n\n/* Active task */\n.active0,\n.active1,\n.active2,\n.active3 {\n fill: #81B1DB;\n stroke: rgba(255, 255, 255, 0.5); }\n\n.activeText0,\n.activeText1,\n.activeText2,\n.activeText3 {\n fill: #323D47 !important; }\n\n/* Completed task */\n.done0,\n.done1,\n.done2,\n.done3 {\n stroke: grey;\n fill: lightgrey;\n stroke-width: 2; }\n\n.doneText0,\n.doneText1,\n.doneText2,\n.doneText3 {\n fill: #323D47 !important; }\n\n/* Tasks on the critical line */\n.crit0,\n.crit1,\n.crit2,\n.crit3 {\n stroke: #E83737;\n fill: #E83737;\n stroke-width: 2; }\n\n.activeCrit0,\n.activeCrit1,\n.activeCrit2,\n.activeCrit3 {\n stroke: #E83737;\n fill: #81B1DB;\n stroke-width: 2; }\n\n.doneCrit0,\n.doneCrit1,\n.doneCrit2,\n.doneCrit3 {\n stroke: #E83737;\n fill: lightgrey;\n stroke-width: 2;\n cursor: pointer;\n shape-rendering: crispEdges; }\n\n.milestone {\n transform: rotate(45deg) scale(0.8, 0.8); }\n\n.milestoneText {\n font-style: italic; }\n\n.doneCritText0,\n.doneCritText1,\n.doneCritText2,\n.doneCritText3 {\n fill: #323D47 !important; }\n\n.activeCritText0,\n.activeCritText1,\n.activeCritText2,\n.activeCritText3 {\n fill: #323D47 !important; }\n\n.titleText {\n text-anchor: middle;\n font-size: 18px;\n fill: #323D47;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.classGroup text {\n fill: purple;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 10px; }\n g.classGroup text .title {\n font-weight: bolder; }\n\ng.classGroup rect {\n fill: #BDD5EA;\n stroke: purple; }\n\ng.classGroup line {\n stroke: purple;\n stroke-width: 1; }\n\n.classLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #BDD5EA;\n opacity: 0.5; }\n\n.classLabel .label {\n fill: purple;\n font-size: 10px; }\n\n.relation {\n stroke: purple;\n stroke-width: 1;\n fill: none; }\n\n#compositionStart {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#compositionEnd {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#aggregationStart {\n fill: #BDD5EA;\n stroke: purple;\n stroke-width: 1; }\n\n#aggregationEnd {\n fill: #BDD5EA;\n stroke: purple;\n stroke-width: 1; }\n\n#dependencyStart {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#dependencyEnd {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#extensionStart {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#extensionEnd {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n.commit-id,\n.commit-msg,\n.branch-label {\n fill: lightgrey;\n color: lightgrey;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.pieTitleText {\n text-anchor: middle;\n font-size: 25px;\n fill: #323D47;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.slice {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.stateGroup text {\n fill: purple;\n stroke: none;\n font-size: 10px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.stateGroup text {\n fill: purple;\n stroke: none;\n font-size: 10px; }\n\ng.stateGroup .state-title {\n font-weight: bolder;\n fill: black; }\n\ng.stateGroup rect {\n fill: #BDD5EA;\n stroke: purple; }\n\ng.stateGroup line {\n stroke: purple;\n stroke-width: 1; }\n\n.transition {\n stroke: purple;\n stroke-width: 1;\n fill: none; }\n\n.stateGroup .composit {\n fill: white;\n border-bottom: 1px; }\n\n.state-note {\n stroke: rgba(255, 255, 255, 0.25);\n fill: #fff5ad; }\n .state-note text {\n fill: black;\n stroke: none;\n font-size: 10px; }\n\n.stateLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #BDD5EA;\n opacity: 0.5; }\n\n.stateLabel text {\n fill: black;\n font-size: 10px;\n font-weight: bold;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n:root {\n --mermaid-font-family: '\"trebuchet ms\", verdana, arial';\n --mermaid-font-family: \"Comic Sans MS\", \"Comic Sans\", cursive; }\n", + "", + ]); + + /***/ + }, + + /***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/default/index.scss": + /* !********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/default/index.scss ***! + \********************************************************************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + exports = module.exports = __webpack_require__( + /* ! ../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js" + )(false); + // Module + exports.push([ + module.i, + "/* Flowchart variables */\n/* Sequence Diagram variables */\n/* Gantt chart variables */\n/* state colors */\n.label {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n color: #333; }\n\n.label text {\n fill: #333; }\n\n.node rect,\n.node circle,\n.node ellipse,\n.node polygon {\n fill: #ECECFF;\n stroke: #9370DB;\n stroke-width: 1px; }\n\n.node .label {\n text-align: center; }\n\n.node.clickable {\n cursor: pointer; }\n\n.arrowheadPath {\n fill: #333333; }\n\n.edgePath .path {\n stroke: #333333;\n stroke-width: 1.5px; }\n\n.edgeLabel {\n background-color: #e8e8e8;\n text-align: center; }\n\n.cluster rect {\n fill: #ffffde;\n stroke: #aaaa33;\n stroke-width: 1px; }\n\n.cluster text {\n fill: #333; }\n\ndiv.mermaidTooltip {\n position: absolute;\n text-align: center;\n max-width: 200px;\n padding: 2px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 12px;\n background: #ffffde;\n border: 1px solid #aaaa33;\n border-radius: 2px;\n pointer-events: none;\n z-index: 100; }\n\n.actor {\n stroke: #CCCCFF;\n fill: #ECECFF; }\n\ntext.actor {\n fill: black;\n stroke: none; }\n\n.actor-line {\n stroke: grey; }\n\n.messageLine0 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n.messageLine1 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n#arrowhead {\n fill: #333; }\n\n.sequenceNumber {\n fill: white; }\n\n#sequencenumber {\n fill: #333; }\n\n#crosshead path {\n fill: #333 !important;\n stroke: #333 !important; }\n\n.messageText {\n fill: #333;\n stroke: none; }\n\n.labelBox {\n stroke: #CCCCFF;\n fill: #ECECFF; }\n\n.labelText {\n fill: black;\n stroke: none; }\n\n.loopText {\n fill: black;\n stroke: none; }\n\n.loopLine {\n stroke-width: 2;\n stroke-dasharray: '2 2';\n stroke: #CCCCFF; }\n\n.note {\n stroke: #aaaa33;\n fill: #fff5ad; }\n\n.noteText {\n fill: black;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 14px; }\n\n.activation0 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation1 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation2 {\n fill: #f4f4f4;\n stroke: #666; }\n\n/** Section styling */\n.mermaid-main-font {\n font-family: \"trebuchet ms\", verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.section {\n stroke: none;\n opacity: 0.2; }\n\n.section0 {\n fill: rgba(102, 102, 255, 0.49); }\n\n.section2 {\n fill: #fff400; }\n\n.section1,\n.section3 {\n fill: white;\n opacity: 0.2; }\n\n.sectionTitle0 {\n fill: #333; }\n\n.sectionTitle1 {\n fill: #333; }\n\n.sectionTitle2 {\n fill: #333; }\n\n.sectionTitle3 {\n fill: #333; }\n\n.sectionTitle {\n text-anchor: start;\n font-size: 11px;\n text-height: 14px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n/* Grid and axis */\n.grid .tick {\n stroke: lightgrey;\n opacity: 0.3;\n shape-rendering: crispEdges; }\n .grid .tick text {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.grid path {\n stroke-width: 0; }\n\n/* Today line */\n.today {\n fill: none;\n stroke: red;\n stroke-width: 2px; }\n\n/* Task styling */\n/* Default task */\n.task {\n stroke-width: 2; }\n\n.taskText {\n text-anchor: middle;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.taskText:not([font-size]) {\n font-size: 11px; }\n\n.taskTextOutsideRight {\n fill: black;\n text-anchor: start;\n font-size: 11px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.taskTextOutsideLeft {\n fill: black;\n text-anchor: end;\n font-size: 11px; }\n\n/* Special case clickable */\n.task.clickable {\n cursor: pointer; }\n\n.taskText.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideLeft.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideRight.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n/* Specific task settings for the sections*/\n.taskText0,\n.taskText1,\n.taskText2,\n.taskText3 {\n fill: white; }\n\n.task0,\n.task1,\n.task2,\n.task3 {\n fill: #8a90dd;\n stroke: #534fbc; }\n\n.taskTextOutside0,\n.taskTextOutside2 {\n fill: black; }\n\n.taskTextOutside1,\n.taskTextOutside3 {\n fill: black; }\n\n/* Active task */\n.active0,\n.active1,\n.active2,\n.active3 {\n fill: #bfc7ff;\n stroke: #534fbc; }\n\n.activeText0,\n.activeText1,\n.activeText2,\n.activeText3 {\n fill: black !important; }\n\n/* Completed task */\n.done0,\n.done1,\n.done2,\n.done3 {\n stroke: grey;\n fill: lightgrey;\n stroke-width: 2; }\n\n.doneText0,\n.doneText1,\n.doneText2,\n.doneText3 {\n fill: black !important; }\n\n/* Tasks on the critical line */\n.crit0,\n.crit1,\n.crit2,\n.crit3 {\n stroke: #ff8888;\n fill: red;\n stroke-width: 2; }\n\n.activeCrit0,\n.activeCrit1,\n.activeCrit2,\n.activeCrit3 {\n stroke: #ff8888;\n fill: #bfc7ff;\n stroke-width: 2; }\n\n.doneCrit0,\n.doneCrit1,\n.doneCrit2,\n.doneCrit3 {\n stroke: #ff8888;\n fill: lightgrey;\n stroke-width: 2;\n cursor: pointer;\n shape-rendering: crispEdges; }\n\n.milestone {\n transform: rotate(45deg) scale(0.8, 0.8); }\n\n.milestoneText {\n font-style: italic; }\n\n.doneCritText0,\n.doneCritText1,\n.doneCritText2,\n.doneCritText3 {\n fill: black !important; }\n\n.activeCritText0,\n.activeCritText1,\n.activeCritText2,\n.activeCritText3 {\n fill: black !important; }\n\n.titleText {\n text-anchor: middle;\n font-size: 18px;\n fill: black;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.classGroup text {\n fill: #9370DB;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 10px; }\n g.classGroup text .title {\n font-weight: bolder; }\n\ng.classGroup rect {\n fill: #ECECFF;\n stroke: #9370DB; }\n\ng.classGroup line {\n stroke: #9370DB;\n stroke-width: 1; }\n\n.classLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #ECECFF;\n opacity: 0.5; }\n\n.classLabel .label {\n fill: #9370DB;\n font-size: 10px; }\n\n.relation {\n stroke: #9370DB;\n stroke-width: 1;\n fill: none; }\n\n#compositionStart {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#compositionEnd {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#aggregationStart {\n fill: #ECECFF;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#aggregationEnd {\n fill: #ECECFF;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#dependencyStart {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#dependencyEnd {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#extensionStart {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#extensionEnd {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n.commit-id,\n.commit-msg,\n.branch-label {\n fill: lightgrey;\n color: lightgrey;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.pieTitleText {\n text-anchor: middle;\n font-size: 25px;\n fill: black;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.slice {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.stateGroup text {\n fill: #9370DB;\n stroke: none;\n font-size: 10px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.stateGroup text {\n fill: #9370DB;\n stroke: none;\n font-size: 10px; }\n\ng.stateGroup .state-title {\n font-weight: bolder;\n fill: black; }\n\ng.stateGroup rect {\n fill: #ECECFF;\n stroke: #9370DB; }\n\ng.stateGroup line {\n stroke: #9370DB;\n stroke-width: 1; }\n\n.transition {\n stroke: #9370DB;\n stroke-width: 1;\n fill: none; }\n\n.stateGroup .composit {\n fill: white;\n border-bottom: 1px; }\n\n.state-note {\n stroke: #aaaa33;\n fill: #fff5ad; }\n .state-note text {\n fill: black;\n stroke: none;\n font-size: 10px; }\n\n.stateLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #ECECFF;\n opacity: 0.5; }\n\n.stateLabel text {\n fill: black;\n font-size: 10px;\n font-weight: bold;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n:root {\n --mermaid-font-family: '\"trebuchet ms\", verdana, arial';\n --mermaid-font-family: \"Comic Sans MS\", \"Comic Sans\", cursive; }\n", + "", + ]); + + /***/ + }, + + /***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/forest/index.scss": + /* !*******************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/forest/index.scss ***! + \*******************************************************************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + exports = module.exports = __webpack_require__( + /* ! ../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js" + )(false); + // Module + exports.push([ + module.i, + "/* Flowchart variables */\n/* Sequence Diagram variables */\n/* Gantt chart variables */\n/* state colors */\n.label {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n color: #333; }\n\n.label text {\n fill: #333; }\n\n.node rect,\n.node circle,\n.node ellipse,\n.node polygon {\n fill: #cde498;\n stroke: #13540c;\n stroke-width: 1px; }\n\n.node .label {\n text-align: center; }\n\n.node.clickable {\n cursor: pointer; }\n\n.arrowheadPath {\n fill: green; }\n\n.edgePath .path {\n stroke: green;\n stroke-width: 1.5px; }\n\n.edgeLabel {\n background-color: #e8e8e8;\n text-align: center; }\n\n.cluster rect {\n fill: #cdffb2;\n stroke: #6eaa49;\n stroke-width: 1px; }\n\n.cluster text {\n fill: #333; }\n\ndiv.mermaidTooltip {\n position: absolute;\n text-align: center;\n max-width: 200px;\n padding: 2px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 12px;\n background: #cdffb2;\n border: 1px solid #6eaa49;\n border-radius: 2px;\n pointer-events: none;\n z-index: 100; }\n\n.actor {\n stroke: #13540c;\n fill: #cde498; }\n\ntext.actor {\n fill: black;\n stroke: none; }\n\n.actor-line {\n stroke: grey; }\n\n.messageLine0 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n.messageLine1 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n#arrowhead {\n fill: #333; }\n\n.sequenceNumber {\n fill: white; }\n\n#sequencenumber {\n fill: #333; }\n\n#crosshead path {\n fill: #333 !important;\n stroke: #333 !important; }\n\n.messageText {\n fill: #333;\n stroke: none; }\n\n.labelBox {\n stroke: #326932;\n fill: #cde498; }\n\n.labelText {\n fill: black;\n stroke: none; }\n\n.loopText {\n fill: black;\n stroke: none; }\n\n.loopLine {\n stroke-width: 2;\n stroke-dasharray: '2 2';\n stroke: #326932; }\n\n.note {\n stroke: #6eaa49;\n fill: #fff5ad; }\n\n.noteText {\n fill: black;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 14px; }\n\n.activation0 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation1 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation2 {\n fill: #f4f4f4;\n stroke: #666; }\n\n/** Section styling */\n.mermaid-main-font {\n font-family: \"trebuchet ms\", verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.section {\n stroke: none;\n opacity: 0.2; }\n\n.section0 {\n fill: #6eaa49; }\n\n.section2 {\n fill: #6eaa49; }\n\n.section1,\n.section3 {\n fill: white;\n opacity: 0.2; }\n\n.sectionTitle0 {\n fill: #333; }\n\n.sectionTitle1 {\n fill: #333; }\n\n.sectionTitle2 {\n fill: #333; }\n\n.sectionTitle3 {\n fill: #333; }\n\n.sectionTitle {\n text-anchor: start;\n font-size: 11px;\n text-height: 14px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n/* Grid and axis */\n.grid .tick {\n stroke: lightgrey;\n opacity: 0.3;\n shape-rendering: crispEdges; }\n .grid .tick text {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.grid path {\n stroke-width: 0; }\n\n/* Today line */\n.today {\n fill: none;\n stroke: red;\n stroke-width: 2px; }\n\n/* Task styling */\n/* Default task */\n.task {\n stroke-width: 2; }\n\n.taskText {\n text-anchor: middle;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.taskText:not([font-size]) {\n font-size: 11px; }\n\n.taskTextOutsideRight {\n fill: black;\n text-anchor: start;\n font-size: 11px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.taskTextOutsideLeft {\n fill: black;\n text-anchor: end;\n font-size: 11px; }\n\n/* Special case clickable */\n.task.clickable {\n cursor: pointer; }\n\n.taskText.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideLeft.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideRight.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n/* Specific task settings for the sections*/\n.taskText0,\n.taskText1,\n.taskText2,\n.taskText3 {\n fill: white; }\n\n.task0,\n.task1,\n.task2,\n.task3 {\n fill: #487e3a;\n stroke: #13540c; }\n\n.taskTextOutside0,\n.taskTextOutside2 {\n fill: black; }\n\n.taskTextOutside1,\n.taskTextOutside3 {\n fill: black; }\n\n/* Active task */\n.active0,\n.active1,\n.active2,\n.active3 {\n fill: #cde498;\n stroke: #13540c; }\n\n.activeText0,\n.activeText1,\n.activeText2,\n.activeText3 {\n fill: black !important; }\n\n/* Completed task */\n.done0,\n.done1,\n.done2,\n.done3 {\n stroke: grey;\n fill: lightgrey;\n stroke-width: 2; }\n\n.doneText0,\n.doneText1,\n.doneText2,\n.doneText3 {\n fill: black !important; }\n\n/* Tasks on the critical line */\n.crit0,\n.crit1,\n.crit2,\n.crit3 {\n stroke: #ff8888;\n fill: red;\n stroke-width: 2; }\n\n.activeCrit0,\n.activeCrit1,\n.activeCrit2,\n.activeCrit3 {\n stroke: #ff8888;\n fill: #cde498;\n stroke-width: 2; }\n\n.doneCrit0,\n.doneCrit1,\n.doneCrit2,\n.doneCrit3 {\n stroke: #ff8888;\n fill: lightgrey;\n stroke-width: 2;\n cursor: pointer;\n shape-rendering: crispEdges; }\n\n.milestone {\n transform: rotate(45deg) scale(0.8, 0.8); }\n\n.milestoneText {\n font-style: italic; }\n\n.doneCritText0,\n.doneCritText1,\n.doneCritText2,\n.doneCritText3 {\n fill: black !important; }\n\n.activeCritText0,\n.activeCritText1,\n.activeCritText2,\n.activeCritText3 {\n fill: black !important; }\n\n.titleText {\n text-anchor: middle;\n font-size: 18px;\n fill: black;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.classGroup text {\n fill: #13540c;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 10px; }\n g.classGroup text .title {\n font-weight: bolder; }\n\ng.classGroup rect {\n fill: #cde498;\n stroke: #13540c; }\n\ng.classGroup line {\n stroke: #13540c;\n stroke-width: 1; }\n\n.classLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #cde498;\n opacity: 0.5; }\n\n.classLabel .label {\n fill: #13540c;\n font-size: 10px; }\n\n.relation {\n stroke: #13540c;\n stroke-width: 1;\n fill: none; }\n\n#compositionStart {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#compositionEnd {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#aggregationStart {\n fill: #cde498;\n stroke: #13540c;\n stroke-width: 1; }\n\n#aggregationEnd {\n fill: #cde498;\n stroke: #13540c;\n stroke-width: 1; }\n\n#dependencyStart {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#dependencyEnd {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#extensionStart {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#extensionEnd {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n.commit-id,\n.commit-msg,\n.branch-label {\n fill: lightgrey;\n color: lightgrey;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.pieTitleText {\n text-anchor: middle;\n font-size: 25px;\n fill: black;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.slice {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.stateGroup text {\n fill: #13540c;\n stroke: none;\n font-size: 10px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.stateGroup text {\n fill: #13540c;\n stroke: none;\n font-size: 10px; }\n\ng.stateGroup .state-title {\n font-weight: bolder;\n fill: black; }\n\ng.stateGroup rect {\n fill: #cde498;\n stroke: #13540c; }\n\ng.stateGroup line {\n stroke: #13540c;\n stroke-width: 1; }\n\n.transition {\n stroke: #13540c;\n stroke-width: 1;\n fill: none; }\n\n.stateGroup .composit {\n fill: white;\n border-bottom: 1px; }\n\n.state-note {\n stroke: #6eaa49;\n fill: #fff5ad; }\n .state-note text {\n fill: black;\n stroke: none;\n font-size: 10px; }\n\n.stateLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #cde498;\n opacity: 0.5; }\n\n.stateLabel text {\n fill: black;\n font-size: 10px;\n font-weight: bold;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n:root {\n --mermaid-font-family: '\"trebuchet ms\", verdana, arial';\n --mermaid-font-family: \"Comic Sans MS\", \"Comic Sans\", cursive; }\n", + "", + ]); + + /***/ + }, + + /***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/neutral/index.scss": + /* !********************************************************************************************************************!*\ + !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/neutral/index.scss ***! + \********************************************************************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + exports = module.exports = __webpack_require__( + /* ! ../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js" + )(false); + // Module + exports.push([ + module.i, + "/* Flowchart variables */\n/* Sequence Diagram variables */\n/* Gantt chart variables */\n/* state colors */\n.label {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n color: #333; }\n\n.label text {\n fill: #333; }\n\n.node rect,\n.node circle,\n.node ellipse,\n.node polygon {\n fill: #eee;\n stroke: #999;\n stroke-width: 1px; }\n\n.node .label {\n text-align: center; }\n\n.node.clickable {\n cursor: pointer; }\n\n.arrowheadPath {\n fill: #333333; }\n\n.edgePath .path {\n stroke: #666;\n stroke-width: 1.5px; }\n\n.edgeLabel {\n background-color: white;\n text-align: center; }\n\n.cluster rect {\n fill: #eaf2fb;\n stroke: #26a;\n stroke-width: 1px; }\n\n.cluster text {\n fill: #333; }\n\ndiv.mermaidTooltip {\n position: absolute;\n text-align: center;\n max-width: 200px;\n padding: 2px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 12px;\n background: #eaf2fb;\n border: 1px solid #26a;\n border-radius: 2px;\n pointer-events: none;\n z-index: 100; }\n\n.actor {\n stroke: #999;\n fill: #eee; }\n\ntext.actor {\n fill: #333;\n stroke: none; }\n\n.actor-line {\n stroke: #666; }\n\n.messageLine0 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n.messageLine1 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n#arrowhead {\n fill: #333; }\n\n.sequenceNumber {\n fill: white; }\n\n#sequencenumber {\n fill: #333; }\n\n#crosshead path {\n fill: #333 !important;\n stroke: #333 !important; }\n\n.messageText {\n fill: #333;\n stroke: none; }\n\n.labelBox {\n stroke: #999;\n fill: #eee; }\n\n.labelText {\n fill: #333;\n stroke: none; }\n\n.loopText {\n fill: #333;\n stroke: none; }\n\n.loopLine {\n stroke-width: 2;\n stroke-dasharray: '2 2';\n stroke: #999; }\n\n.note {\n stroke: #777700;\n fill: #ffa; }\n\n.noteText {\n fill: black;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 14px; }\n\n.activation0 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation1 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation2 {\n fill: #f4f4f4;\n stroke: #666; }\n\n/** Section styling */\n.mermaid-main-font {\n font-family: \"trebuchet ms\", verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.section {\n stroke: none;\n opacity: 0.2; }\n\n.section0 {\n fill: #80b3e6; }\n\n.section2 {\n fill: #80b3e6; }\n\n.section1,\n.section3 {\n fill: white;\n opacity: 0.2; }\n\n.sectionTitle0 {\n fill: #333; }\n\n.sectionTitle1 {\n fill: #333; }\n\n.sectionTitle2 {\n fill: #333; }\n\n.sectionTitle3 {\n fill: #333; }\n\n.sectionTitle {\n text-anchor: start;\n font-size: 11px;\n text-height: 14px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n/* Grid and axis */\n.grid .tick {\n stroke: #e6e6e6;\n opacity: 0.3;\n shape-rendering: crispEdges; }\n .grid .tick text {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.grid path {\n stroke-width: 0; }\n\n/* Today line */\n.today {\n fill: none;\n stroke: #d42;\n stroke-width: 2px; }\n\n/* Task styling */\n/* Default task */\n.task {\n stroke-width: 2; }\n\n.taskText {\n text-anchor: middle;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.taskText:not([font-size]) {\n font-size: 11px; }\n\n.taskTextOutsideRight {\n fill: #333;\n text-anchor: start;\n font-size: 11px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.taskTextOutsideLeft {\n fill: #333;\n text-anchor: end;\n font-size: 11px; }\n\n/* Special case clickable */\n.task.clickable {\n cursor: pointer; }\n\n.taskText.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideLeft.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideRight.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n/* Specific task settings for the sections*/\n.taskText0,\n.taskText1,\n.taskText2,\n.taskText3 {\n fill: white; }\n\n.task0,\n.task1,\n.task2,\n.task3 {\n fill: #26a;\n stroke: #1a4d80; }\n\n.taskTextOutside0,\n.taskTextOutside2 {\n fill: #333; }\n\n.taskTextOutside1,\n.taskTextOutside3 {\n fill: #333; }\n\n/* Active task */\n.active0,\n.active1,\n.active2,\n.active3 {\n fill: #eee;\n stroke: #1a4d80; }\n\n.activeText0,\n.activeText1,\n.activeText2,\n.activeText3 {\n fill: #333 !important; }\n\n/* Completed task */\n.done0,\n.done1,\n.done2,\n.done3 {\n stroke: #666;\n fill: #bbb;\n stroke-width: 2; }\n\n.doneText0,\n.doneText1,\n.doneText2,\n.doneText3 {\n fill: #333 !important; }\n\n/* Tasks on the critical line */\n.crit0,\n.crit1,\n.crit2,\n.crit3 {\n stroke: #b1361b;\n fill: #d42;\n stroke-width: 2; }\n\n.activeCrit0,\n.activeCrit1,\n.activeCrit2,\n.activeCrit3 {\n stroke: #b1361b;\n fill: #eee;\n stroke-width: 2; }\n\n.doneCrit0,\n.doneCrit1,\n.doneCrit2,\n.doneCrit3 {\n stroke: #b1361b;\n fill: #bbb;\n stroke-width: 2;\n cursor: pointer;\n shape-rendering: crispEdges; }\n\n.milestone {\n transform: rotate(45deg) scale(0.8, 0.8); }\n\n.milestoneText {\n font-style: italic; }\n\n.doneCritText0,\n.doneCritText1,\n.doneCritText2,\n.doneCritText3 {\n fill: #333 !important; }\n\n.activeCritText0,\n.activeCritText1,\n.activeCritText2,\n.activeCritText3 {\n fill: #333 !important; }\n\n.titleText {\n text-anchor: middle;\n font-size: 18px;\n fill: #333;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.classGroup text {\n fill: #999;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family);\n font-size: 10px; }\n g.classGroup text .title {\n font-weight: bolder; }\n\ng.classGroup rect {\n fill: #eee;\n stroke: #999; }\n\ng.classGroup line {\n stroke: #999;\n stroke-width: 1; }\n\n.classLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #eee;\n opacity: 0.5; }\n\n.classLabel .label {\n fill: #999;\n font-size: 10px; }\n\n.relation {\n stroke: #999;\n stroke-width: 1;\n fill: none; }\n\n#compositionStart {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#compositionEnd {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#aggregationStart {\n fill: #eee;\n stroke: #999;\n stroke-width: 1; }\n\n#aggregationEnd {\n fill: #eee;\n stroke: #999;\n stroke-width: 1; }\n\n#dependencyStart {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#dependencyEnd {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#extensionStart {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#extensionEnd {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n.commit-id,\n.commit-msg,\n.branch-label {\n fill: lightgrey;\n color: lightgrey;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.pieTitleText {\n text-anchor: middle;\n font-size: 25px;\n fill: #333;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n.slice {\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.stateGroup text {\n fill: #999;\n stroke: none;\n font-size: 10px;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\ng.stateGroup text {\n fill: #999;\n stroke: none;\n font-size: 10px; }\n\ng.stateGroup .state-title {\n font-weight: bolder;\n fill: black; }\n\ng.stateGroup rect {\n fill: #eee;\n stroke: #999; }\n\ng.stateGroup line {\n stroke: #999;\n stroke-width: 1; }\n\n.transition {\n stroke: #999;\n stroke-width: 1;\n fill: none; }\n\n.stateGroup .composit {\n fill: white;\n border-bottom: 1px; }\n\n.state-note {\n stroke: #777700;\n fill: #ffa; }\n .state-note text {\n fill: black;\n stroke: none;\n font-size: 10px; }\n\n.stateLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #eee;\n opacity: 0.5; }\n\n.stateLabel text {\n fill: black;\n font-size: 10px;\n font-weight: bold;\n font-family: 'trebuchet ms', verdana, arial;\n font-family: var(--mermaid-font-family); }\n\n:root {\n --mermaid-font-family: '\"trebuchet ms\", verdana, arial';\n --mermaid-font-family: \"Comic Sans MS\", \"Comic Sans\", cursive; }\n", + "", + ]); + + /***/ + }, + + /***/ "./node_modules/css-loader/dist/runtime/api.js": + /* !*****************************************************!*\ + !*** ./node_modules/css-loader/dist/runtime/api.js ***! + \*****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + /* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + // css base code, injected by the css-loader + + module.exports = function (useSourceMap) { + var list = []; // Return the list of modules as css string + + list.toString = function toString() { + return this.map(function (item) { + var content = cssWithMappingToString( + item, + useSourceMap + ); + + if (item[2]) { + return "@media " + item[2] + "{" + content + "}"; + } + return content; + + }).join(""); + }; // Import a list of modules into the list + + list.i = function (modules, mediaQuery) { + if (typeof modules === "string") { + modules = [[null, modules, ""]]; + } + + var alreadyImportedModules = {}; + + for (var i = 0; i < this.length; i++) { + var id = this[i][0]; + + if (id != null) { + alreadyImportedModules[id] = true; + } + } + + for (i = 0; i < modules.length; i++) { + var item = modules[i]; // Skip already imported module + // this implementation is not 100% perfect for weird media query combinations + // when a module is imported multiple times with different media queries. + // I hope this will never occur (Hey this way we have smaller bundles) + + if ( + item[0] == null || + !alreadyImportedModules[item[0]] + ) { + if (mediaQuery && !item[2]) { + item[2] = mediaQuery; + } else if (mediaQuery) { + item[2] = + "(" + + item[2] + + ") and (" + + mediaQuery + + ")"; + } + + list.push(item); + } + } + }; + + return list; + }; + + function cssWithMappingToString(item, useSourceMap) { + var content = item[1] || ""; + var cssMapping = item[3]; + + if (!cssMapping) { + return content; + } + + if (useSourceMap && typeof btoa === "function") { + var sourceMapping = toComment(cssMapping); + var sourceURLs = cssMapping.sources.map(function (source) { + return ( + "/*# sourceURL=" + + cssMapping.sourceRoot + + source + + " */" + ); + }); + return [content] + .concat(sourceURLs) + .concat([sourceMapping]) + .join("\n"); + } + + return [content].join("\n"); + } // Adapted from convert-source-map (MIT) + + function toComment(sourceMap) { + // eslint-disable-next-line no-undef + var base64 = btoa( + unescape(encodeURIComponent(JSON.stringify(sourceMap))) + ); + var data = + "sourceMappingURL=data:application/json;charset=utf-8;base64," + + base64; + return "/*# " + data + " */"; + } + + /***/ + }, + + /***/ "./node_modules/d3-array/src/array.js": + /* !********************************************!*\ + !*** ./node_modules/d3-array/src/array.js ***! + \********************************************/ + /* ! exports provided: slice, map */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "slice", + function () { + return slice; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "map", + function () { + return map; + } + ); + var array = Array.prototype; + var slice = array.slice; + var map = array.map; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/ascending.js": + /* !************************************************!*\ + !*** ./node_modules/d3-array/src/ascending.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/bisect.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-array/src/bisect.js ***! + \*********************************************/ + /* ! exports provided: bisectRight, bisectLeft, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "bisectRight", + function () { + return bisectRight; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "bisectLeft", + function () { + return bisectLeft; + } + ); + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./ascending */ "./node_modules/d3-array/src/ascending.js" + ); + /* Harmony import */ var _bisector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./bisector */ "./node_modules/d3-array/src/bisector.js" + ); + + var ascendingBisect = Object( + _bisector__WEBPACK_IMPORTED_MODULE_1__.default + )(_ascending__WEBPACK_IMPORTED_MODULE_0__.default); + var bisectRight = ascendingBisect.right; + var bisectLeft = ascendingBisect.left; + /* Harmony default export */ __webpack_exports__.default = bisectRight; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/bisector.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-array/src/bisector.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./ascending */ "./node_modules/d3-array/src/ascending.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (compare) { + if (compare.length === 1) + compare = ascendingComparator(compare); + return { + left: function left(a, x, lo, hi) { + if (lo == null) lo = 0; + if (hi == null) hi = a.length; + + while (lo < hi) { + var mid = (lo + hi) >>> 1; + if (compare(a[mid], x) < 0) lo = mid + 1; + else hi = mid; + } + + return lo; + }, + right: function right(a, x, lo, hi) { + if (lo == null) lo = 0; + if (hi == null) hi = a.length; + + while (lo < hi) { + var mid = (lo + hi) >>> 1; + if (compare(a[mid], x) > 0) hi = mid; + else lo = mid + 1; + } + + return lo; + }, + }; + }; + + function ascendingComparator(f) { + return function (d, x) { + return Object( + _ascending__WEBPACK_IMPORTED_MODULE_0__.default + )(f(d), x); + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-array/src/constant.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-array/src/constant.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/cross.js": + /* !********************************************!*\ + !*** ./node_modules/d3-array/src/cross.js ***! + \********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _pairs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./pairs */ "./node_modules/d3-array/src/pairs.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values0, values1, reduce) { + var n0 = values0.length, + n1 = values1.length, + values = new Array(n0 * n1), + i0, + i1, + i, + value0; + if (reduce == null) + reduce = _pairs__WEBPACK_IMPORTED_MODULE_0__.pair; + + for (i0 = i = 0; i0 < n0; ++i0) { + for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) { + values[i] = reduce(value0, values1[i1]); + } + } + + return values; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/descending.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-array/src/descending.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/deviation.js": + /* !************************************************!*\ + !*** ./node_modules/d3-array/src/deviation.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _variance__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./variance */ "./node_modules/d3-array/src/variance.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (array, f) { + var v = Object( + _variance__WEBPACK_IMPORTED_MODULE_0__.default + )(array, f); + return v ? Math.sqrt(v) : v; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/extent.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-array/src/extent.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (values, valueof) { + var n = values.length, + i = -1, + value, + min, + max; + + if (valueof == null) { + while (++i < n) { + // Find the first comparable value. + if ((value = values[i]) != null && value >= value) { + min = max = value; + + while (++i < n) { + // Compare the remaining values. + if ((value = values[i]) != null) { + if (min > value) min = value; + if (max < value) max = value; + } + } + } + } + } else { + while (++i < n) { + // Find the first comparable value. + if ( + (value = valueof(values[i], i, values)) != null && + value >= value + ) { + min = max = value; + + while (++i < n) { + // Compare the remaining values. + if ( + (value = valueof(values[i], i, values)) != + null + ) { + if (min > value) min = value; + if (max < value) max = value; + } + } + } + } + } + + return [min, max]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/histogram.js": + /* !************************************************!*\ + !*** ./node_modules/d3-array/src/histogram.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-array/src/array.js" + ); + /* Harmony import */ var _bisect__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./bisect */ "./node_modules/d3-array/src/bisect.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-array/src/constant.js" + ); + /* Harmony import */ var _extent__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./extent */ "./node_modules/d3-array/src/extent.js" + ); + /* Harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./identity */ "./node_modules/d3-array/src/identity.js" + ); + /* Harmony import */ var _range__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./range */ "./node_modules/d3-array/src/range.js" + ); + /* Harmony import */ var _ticks__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./ticks */ "./node_modules/d3-array/src/ticks.js" + ); + /* Harmony import */ var _threshold_sturges__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./threshold/sturges */ "./node_modules/d3-array/src/threshold/sturges.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var value = _identity__WEBPACK_IMPORTED_MODULE_4__.default, + domain = _extent__WEBPACK_IMPORTED_MODULE_3__.default, + threshold = + _threshold_sturges__WEBPACK_IMPORTED_MODULE_7__.default; + + function histogram(data) { + var i, + n = data.length, + x, + values = new Array(n); + + for (i = 0; i < n; ++i) { + values[i] = value(data[i], i, data); + } + + var xz = domain(values), + x0 = xz[0], + x1 = xz[1], + tz = threshold(values, x0, x1); // Convert number of thresholds into uniform thresholds. + + if (!Array.isArray(tz)) { + tz = Object( + _ticks__WEBPACK_IMPORTED_MODULE_6__.tickStep + )(x0, x1, tz); + tz = Object( + _range__WEBPACK_IMPORTED_MODULE_5__.default + )(Math.ceil(x0 / tz) * tz, x1, tz); // Exclusive + } // Remove any thresholds outside the domain. + + var m = tz.length; + + while (tz[0] <= x0) { + tz.shift(), --m; + } + + while (tz[m - 1] > x1) { + tz.pop(), --m; + } + + var bins = new Array(m + 1), + bin; // Initialize bins. + + for (i = 0; i <= m; ++i) { + bin = bins[i] = []; + bin.x0 = i > 0 ? tz[i - 1] : x0; + bin.x1 = i < m ? tz[i] : x1; + } // Assign data to bins by value, ignoring any outside the domain. + + for (i = 0; i < n; ++i) { + x = values[i]; + + if (x0 <= x && x <= x1) { + bins[ + Object( + _bisect__WEBPACK_IMPORTED_MODULE_1__.default + )(tz, x, 0, m) + ].push(data[i]); + } + } + + return bins; + } + + histogram.value = function (_) { + return arguments.length + ? ((value = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_2__.default + )(_)), + histogram) + : value; + }; + + histogram.domain = function (_) { + return arguments.length + ? ((domain = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_2__.default + )([_[0], _[1]])), + histogram) + : domain; + }; + + histogram.thresholds = function (_) { + return arguments.length + ? ((threshold = + typeof _ === "function" + ? _ + : Array.isArray(_) + ? Object( + _constant__WEBPACK_IMPORTED_MODULE_2__.default + )( + _array__WEBPACK_IMPORTED_MODULE_0__.slice.call(_) + ) + : Object( + _constant__WEBPACK_IMPORTED_MODULE_2__.default + )(_)), + histogram) + : threshold; + }; + + return histogram; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/identity.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-array/src/identity.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return x; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-array/src/index.js ***! + \********************************************/ + /* ! exports provided: bisect, bisectRight, bisectLeft, ascending, bisector, cross, descending, deviation, extent, histogram, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges, max, mean, median, merge, min, pairs, permute, quantile, range, scan, shuffle, sum, ticks, tickIncrement, tickStep, transpose, variance, zip */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _bisect__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./bisect */ "./node_modules/d3-array/src/bisect.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "bisect", + function () { + return _bisect__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "bisectRight", + function () { + return _bisect__WEBPACK_IMPORTED_MODULE_0__.bisectRight; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "bisectLeft", + function () { + return _bisect__WEBPACK_IMPORTED_MODULE_0__.bisectLeft; + } + ); + + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./ascending */ "./node_modules/d3-array/src/ascending.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "ascending", + function () { + return _ascending__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _bisector__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./bisector */ "./node_modules/d3-array/src/bisector.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "bisector", + function () { + return _bisector__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _cross__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./cross */ "./node_modules/d3-array/src/cross.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "cross", + function () { + return _cross__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _descending__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./descending */ "./node_modules/d3-array/src/descending.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "descending", + function () { + return _descending__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _deviation__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./deviation */ "./node_modules/d3-array/src/deviation.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "deviation", + function () { + return _deviation__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _extent__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./extent */ "./node_modules/d3-array/src/extent.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "extent", + function () { + return _extent__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony import */ var _histogram__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./histogram */ "./node_modules/d3-array/src/histogram.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "histogram", + function () { + return _histogram__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /* Harmony import */ var _threshold_freedmanDiaconis__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./threshold/freedmanDiaconis */ "./node_modules/d3-array/src/threshold/freedmanDiaconis.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "thresholdFreedmanDiaconis", + function () { + return _threshold_freedmanDiaconis__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony import */ var _threshold_scott__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./threshold/scott */ "./node_modules/d3-array/src/threshold/scott.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "thresholdScott", + function () { + return _threshold_scott__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony import */ var _threshold_sturges__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./threshold/sturges */ "./node_modules/d3-array/src/threshold/sturges.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "thresholdSturges", + function () { + return _threshold_sturges__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony import */ var _max__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./max */ "./node_modules/d3-array/src/max.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "max", + function () { + return _max__WEBPACK_IMPORTED_MODULE_11__.default; + } + ); + + /* Harmony import */ var _mean__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./mean */ "./node_modules/d3-array/src/mean.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "mean", + function () { + return _mean__WEBPACK_IMPORTED_MODULE_12__.default; + } + ); + + /* Harmony import */ var _median__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./median */ "./node_modules/d3-array/src/median.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "median", + function () { + return _median__WEBPACK_IMPORTED_MODULE_13__.default; + } + ); + + /* Harmony import */ var _merge__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./merge */ "./node_modules/d3-array/src/merge.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "merge", + function () { + return _merge__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /* Harmony import */ var _min__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./min */ "./node_modules/d3-array/src/min.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "min", + function () { + return _min__WEBPACK_IMPORTED_MODULE_15__.default; + } + ); + + /* Harmony import */ var _pairs__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! ./pairs */ "./node_modules/d3-array/src/pairs.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "pairs", + function () { + return _pairs__WEBPACK_IMPORTED_MODULE_16__.default; + } + ); + + /* Harmony import */ var _permute__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! ./permute */ "./node_modules/d3-array/src/permute.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "permute", + function () { + return _permute__WEBPACK_IMPORTED_MODULE_17__.default; + } + ); + + /* Harmony import */ var _quantile__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__( + /* ! ./quantile */ "./node_modules/d3-array/src/quantile.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "quantile", + function () { + return _quantile__WEBPACK_IMPORTED_MODULE_18__.default; + } + ); + + /* Harmony import */ var _range__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__( + /* ! ./range */ "./node_modules/d3-array/src/range.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "range", + function () { + return _range__WEBPACK_IMPORTED_MODULE_19__.default; + } + ); + + /* Harmony import */ var _scan__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__( + /* ! ./scan */ "./node_modules/d3-array/src/scan.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scan", + function () { + return _scan__WEBPACK_IMPORTED_MODULE_20__.default; + } + ); + + /* Harmony import */ var _shuffle__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__( + /* ! ./shuffle */ "./node_modules/d3-array/src/shuffle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "shuffle", + function () { + return _shuffle__WEBPACK_IMPORTED_MODULE_21__.default; + } + ); + + /* Harmony import */ var _sum__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__( + /* ! ./sum */ "./node_modules/d3-array/src/sum.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "sum", + function () { + return _sum__WEBPACK_IMPORTED_MODULE_22__.default; + } + ); + + /* Harmony import */ var _ticks__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__( + /* ! ./ticks */ "./node_modules/d3-array/src/ticks.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "ticks", + function () { + return _ticks__WEBPACK_IMPORTED_MODULE_23__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tickIncrement", + function () { + return _ticks__WEBPACK_IMPORTED_MODULE_23__.tickIncrement; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tickStep", + function () { + return _ticks__WEBPACK_IMPORTED_MODULE_23__.tickStep; + } + ); + + /* Harmony import */ var _transpose__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__( + /* ! ./transpose */ "./node_modules/d3-array/src/transpose.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "transpose", + function () { + return _transpose__WEBPACK_IMPORTED_MODULE_24__.default; + } + ); + + /* Harmony import */ var _variance__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__( + /* ! ./variance */ "./node_modules/d3-array/src/variance.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "variance", + function () { + return _variance__WEBPACK_IMPORTED_MODULE_25__.default; + } + ); + + /* Harmony import */ var _zip__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__( + /* ! ./zip */ "./node_modules/d3-array/src/zip.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "zip", + function () { + return _zip__WEBPACK_IMPORTED_MODULE_26__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-array/src/max.js": + /* !******************************************!*\ + !*** ./node_modules/d3-array/src/max.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (values, valueof) { + var n = values.length, + i = -1, + value, + max; + + if (valueof == null) { + while (++i < n) { + // Find the first comparable value. + if ((value = values[i]) != null && value >= value) { + max = value; + + while (++i < n) { + // Compare the remaining values. + if ( + (value = values[i]) != null && + value > max + ) { + max = value; + } + } + } + } + } else { + while (++i < n) { + // Find the first comparable value. + if ( + (value = valueof(values[i], i, values)) != null && + value >= value + ) { + max = value; + + while (++i < n) { + // Compare the remaining values. + if ( + (value = valueof(values[i], i, values)) != + null && + value > max + ) { + max = value; + } + } + } + } + } + + return max; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/mean.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-array/src/mean.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-array/src/number.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values, valueof) { + var n = values.length, + m = n, + i = -1, + value, + sum = 0; + + if (valueof == null) { + while (++i < n) { + if ( + !isNaN( + (value = Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(values[i])) + ) + ) + sum += value; + else --m; + } + } else { + while (++i < n) { + if ( + !isNaN( + (value = Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(valueof(values[i], i, values))) + ) + ) + sum += value; + else --m; + } + } + + if (m) return sum / m; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/median.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-array/src/median.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./ascending */ "./node_modules/d3-array/src/ascending.js" + ); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-array/src/number.js" + ); + /* Harmony import */ var _quantile__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./quantile */ "./node_modules/d3-array/src/quantile.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values, valueof) { + var n = values.length, + i = -1, + value, + numbers = []; + + if (valueof == null) { + while (++i < n) { + if ( + !isNaN( + (value = Object( + _number__WEBPACK_IMPORTED_MODULE_1__.default + )(values[i])) + ) + ) { + numbers.push(value); + } + } + } else { + while (++i < n) { + if ( + !isNaN( + (value = Object( + _number__WEBPACK_IMPORTED_MODULE_1__.default + )(valueof(values[i], i, values))) + ) + ) { + numbers.push(value); + } + } + } + + return Object( + _quantile__WEBPACK_IMPORTED_MODULE_2__.default + )( + numbers.sort( + _ascending__WEBPACK_IMPORTED_MODULE_0__.default + ), + 0.5 + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/merge.js": + /* !********************************************!*\ + !*** ./node_modules/d3-array/src/merge.js ***! + \********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (arrays) { + var n = arrays.length, + m, + i = -1, + j = 0, + merged, + array; + + while (++i < n) { + j += arrays[i].length; + } + + merged = new Array(j); + + while (--n >= 0) { + array = arrays[n]; + m = array.length; + + while (--m >= 0) { + merged[--j] = array[m]; + } + } + + return merged; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/min.js": + /* !******************************************!*\ + !*** ./node_modules/d3-array/src/min.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (values, valueof) { + var n = values.length, + i = -1, + value, + min; + + if (valueof == null) { + while (++i < n) { + // Find the first comparable value. + if ((value = values[i]) != null && value >= value) { + min = value; + + while (++i < n) { + // Compare the remaining values. + if ( + (value = values[i]) != null && + min > value + ) { + min = value; + } + } + } + } + } else { + while (++i < n) { + // Find the first comparable value. + if ( + (value = valueof(values[i], i, values)) != null && + value >= value + ) { + min = value; + + while (++i < n) { + // Compare the remaining values. + if ( + (value = valueof(values[i], i, values)) != + null && + min > value + ) { + min = value; + } + } + } + } + } + + return min; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/number.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-array/src/number.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return x === null ? NaN : Number(x); + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/pairs.js": + /* !********************************************!*\ + !*** ./node_modules/d3-array/src/pairs.js ***! + \********************************************/ + /* ! exports provided: default, pair */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "pair", + function () { + return pair; + } + ); + /* Harmony default export */ __webpack_exports__.default = function (array, f) { + if (f == null) f = pair; + var i = 0, + n = array.length - 1, + p = array[0], + pairs = new Array(n < 0 ? 0 : n); + + while (i < n) { + pairs[i] = f(p, (p = array[++i])); + } + + return pairs; + }; + function pair(a, b) { + return [a, b]; + } + + /***/ + }, + + /***/ "./node_modules/d3-array/src/permute.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-array/src/permute.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (array, indexes) { + var i = indexes.length, + permutes = new Array(i); + + while (i--) { + permutes[i] = array[indexes[i]]; + } + + return permutes; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/quantile.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-array/src/quantile.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-array/src/number.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values, p, valueof) { + if (valueof == null) + valueof = _number__WEBPACK_IMPORTED_MODULE_0__.default; + if (!(n = values.length)) return; + if ((p = Number(p)) <= 0 || n < 2) + return Number(valueof(values[0], 0, values)); + if (p >= 1) return Number(valueof(values[n - 1], n - 1, values)); + var n, + i = (n - 1) * p, + i0 = Math.floor(i), + value0 = Number(valueof(values[i0], i0, values)), + value1 = Number(valueof(values[i0 + 1], i0 + 1, values)); + return value0 + (value1 - value0) * (i - i0); + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/range.js": + /* !********************************************!*\ + !*** ./node_modules/d3-array/src/range.js ***! + \********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (start, stop, step) { + (start = Number(start)), + (stop = Number(stop)), + (step = + (n = arguments.length) < 2 + ? ((stop = start), (start = 0), 1) + : n < 3 + ? 1 + : Number(step)); + var i = -1, + n = Math.max(0, Math.ceil((stop - start) / step)) | 0, + range = new Array(n); + + while (++i < n) { + range[i] = start + i * step; + } + + return range; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/scan.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-array/src/scan.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./ascending */ "./node_modules/d3-array/src/ascending.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values, compare) { + if (!(n = values.length)) return; + var n, + i = 0, + j = 0, + xi, + xj = values[j]; + if (compare == null) + compare = + _ascending__WEBPACK_IMPORTED_MODULE_0__.default; + + while (++i < n) { + if ( + compare((xi = values[i]), xj) < 0 || + compare(xj, xj) !== 0 + ) { + (xj = xi), (j = i); + } + } + + if (compare(xj, xj) === 0) return j; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/shuffle.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-array/src/shuffle.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (array, i0, i1) { + var m = + (i1 == null ? array.length : i1) - + (i0 = i0 == null ? 0 : Number(i0)), + t, + i; + + while (m) { + i = (Math.random() * m--) | 0; + t = array[m + i0]; + array[m + i0] = array[i + i0]; + array[i + i0] = t; + } + + return array; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/sum.js": + /* !******************************************!*\ + !*** ./node_modules/d3-array/src/sum.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (values, valueof) { + var n = values.length, + i = -1, + value, + sum = 0; + + if (valueof == null) { + while (++i < n) { + if ((value = Number(values[i]))) sum += value; // Note: zero and null are equivalent. + } + } else { + while (++i < n) { + if ((value = Number(valueof(values[i], i, values)))) + sum += value; + } + } + + return sum; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/threshold/freedmanDiaconis.js": + /* !*****************************************************************!*\ + !*** ./node_modules/d3-array/src/threshold/freedmanDiaconis.js ***! + \*****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../array */ "./node_modules/d3-array/src/array.js" + ); + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ascending */ "./node_modules/d3-array/src/ascending.js" + ); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../number */ "./node_modules/d3-array/src/number.js" + ); + /* Harmony import */ var _quantile__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ../quantile */ "./node_modules/d3-array/src/quantile.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values, min, max) { + values = _array__WEBPACK_IMPORTED_MODULE_0__.map + .call( + values, + _number__WEBPACK_IMPORTED_MODULE_2__.default + ) + .sort(_ascending__WEBPACK_IMPORTED_MODULE_1__.default); + return Math.ceil( + (max - min) / + (2 * + (Object( + _quantile__WEBPACK_IMPORTED_MODULE_3__.default + )(values, 0.75) - + Object( + _quantile__WEBPACK_IMPORTED_MODULE_3__.default + )(values, 0.25)) * + Math.pow(values.length, -1 / 3)) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/threshold/scott.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-array/src/threshold/scott.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _deviation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../deviation */ "./node_modules/d3-array/src/deviation.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values, min, max) { + return Math.ceil( + (max - min) / + (3.5 * + Object( + _deviation__WEBPACK_IMPORTED_MODULE_0__.default + )(values) * + Math.pow(values.length, -1 / 3)) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/threshold/sturges.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-array/src/threshold/sturges.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (values) { + return Math.ceil(Math.log(values.length) / Math.LN2) + 1; + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/ticks.js": + /* !********************************************!*\ + !*** ./node_modules/d3-array/src/ticks.js ***! + \********************************************/ + /* ! exports provided: default, tickIncrement, tickStep */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tickIncrement", + function () { + return tickIncrement; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tickStep", + function () { + return tickStep; + } + ); + var e10 = Math.sqrt(50), + e5 = Math.sqrt(10), + e2 = Math.sqrt(2); + /* Harmony default export */ __webpack_exports__.default = function (start, stop, count) { + var reverse, + i = -1, + n, + ticks, + step; + (stop = Number(stop)), (start = Number(start)), (count = Number(count)); + if (start === stop && count > 0) return [start]; + if ((reverse = stop < start)) + (n = start), (start = stop), (stop = n); + if ( + (step = tickIncrement(start, stop, count)) === 0 || + !isFinite(step) + ) + return []; + + if (step > 0) { + start = Math.ceil(start / step); + stop = Math.floor(stop / step); + ticks = new Array((n = Math.ceil(stop - start + 1))); + + while (++i < n) { + ticks[i] = (start + i) * step; + } + } else { + start = Math.floor(start * step); + stop = Math.ceil(stop * step); + ticks = new Array((n = Math.ceil(start - stop + 1))); + + while (++i < n) { + ticks[i] = (start - i) / step; + } + } + + if (reverse) ticks.reverse(); + return ticks; + }; + function tickIncrement(start, stop, count) { + var step = (stop - start) / Math.max(0, count), + power = Math.floor(Math.log(step) / Math.LN10), + error = step / Math.pow(10, power); + return power >= 0 + ? (error >= e10 + ? 10 + : error >= e5 + ? 5 + : error >= e2 + ? 2 + : 1) * Math.pow(10, power) + : -Math.pow(10, -power) / + (error >= e10 + ? 10 + : error >= e5 + ? 5 + : error >= e2 + ? 2 + : 1); + } + function tickStep(start, stop, count) { + var step0 = Math.abs(stop - start) / Math.max(0, count), + step1 = Math.pow( + 10, + Math.floor(Math.log(step0) / Math.LN10) + ), + error = step0 / step1; + if (error >= e10) step1 *= 10; + else if (error >= e5) step1 *= 5; + else if (error >= e2) step1 *= 2; + return stop < start ? -step1 : step1; + } + + /***/ + }, + + /***/ "./node_modules/d3-array/src/transpose.js": + /* !************************************************!*\ + !*** ./node_modules/d3-array/src/transpose.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _min__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./min */ "./node_modules/d3-array/src/min.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (matrix) { + if (!(n = matrix.length)) return []; + + for ( + var i = -1, + m = Object( + _min__WEBPACK_IMPORTED_MODULE_0__.default + )(matrix, length), + transpose = new Array(m); + ++i < m; + + ) { + for ( + var j = -1, n, row = (transpose[i] = new Array(n)); + ++j < n; + + ) { + row[j] = matrix[j][i]; + } + } + + return transpose; + }; + + function length(d) { + return d.length; + } + + /***/ + }, + + /***/ "./node_modules/d3-array/src/variance.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-array/src/variance.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-array/src/number.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values, valueof) { + var n = values.length, + m = 0, + i = -1, + mean = 0, + value, + delta, + sum = 0; + + if (valueof == null) { + while (++i < n) { + if ( + !isNaN( + (value = Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(values[i])) + ) + ) { + delta = value - mean; + mean += delta / ++m; + sum += delta * (value - mean); + } + } + } else { + while (++i < n) { + if ( + !isNaN( + (value = Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(valueof(values[i], i, values))) + ) + ) { + delta = value - mean; + mean += delta / ++m; + sum += delta * (value - mean); + } + } + } + + if (m > 1) return sum / (m - 1); + }; + + /***/ + }, + + /***/ "./node_modules/d3-array/src/zip.js": + /* !******************************************!*\ + !*** ./node_modules/d3-array/src/zip.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _transpose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./transpose */ "./node_modules/d3-array/src/transpose.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + return Object( + _transpose__WEBPACK_IMPORTED_MODULE_0__.default + )(arguments); + }; + + /***/ + }, + + /***/ "./node_modules/d3-axis/src/array.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-axis/src/array.js ***! + \*******************************************/ + /* ! exports provided: slice */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "slice", + function () { + return slice; + } + ); + var slice = Array.prototype.slice; + + /***/ + }, + + /***/ "./node_modules/d3-axis/src/axis.js": + /* !******************************************!*\ + !*** ./node_modules/d3-axis/src/axis.js ***! + \******************************************/ + /* ! exports provided: axisTop, axisRight, axisBottom, axisLeft */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "axisTop", + function () { + return axisTop; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "axisRight", + function () { + return axisRight; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "axisBottom", + function () { + return axisBottom; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "axisLeft", + function () { + return axisLeft; + } + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-axis/src/array.js" + ); + /* Harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./identity */ "./node_modules/d3-axis/src/identity.js" + ); + + var top = 1, + right = 2, + bottom = 3, + left = 4, + epsilon = 1e-6; + + function translateX(x) { + return "translate(" + (x + 0.5) + ",0)"; + } + + function translateY(y) { + return "translate(0," + (y + 0.5) + ")"; + } + + function number(scale) { + return function (d) { + return Number(scale(d)); + }; + } + + function center(scale) { + var offset = Math.max(0, scale.bandwidth() - 1) / 2; // Adjust for 0.5px offset. + + if (scale.round()) offset = Math.round(offset); + return function (d) { + return Number(scale(d)) + offset; + }; + } + + function entering() { + return !this.__axis; + } + + function axis(orient, scale) { + var tickArguments = [], + tickValues = null, + tickFormat = null, + tickSizeInner = 6, + tickSizeOuter = 6, + tickPadding = 3, + k = orient === top || orient === left ? -1 : 1, + x = orient === left || orient === right ? "x" : "y", + transform = + orient === top || orient === bottom + ? translateX + : translateY; + + function axis(context) { + var values = + tickValues == null + ? scale.ticks + ? scale.ticks.apply(scale, tickArguments) + : scale.domain() + : tickValues, + format = + tickFormat == null + ? scale.tickFormat + ? scale.tickFormat.apply( + scale, + tickArguments + ) + : _identity__WEBPACK_IMPORTED_MODULE_1__.default + : tickFormat, + spacing = Math.max(tickSizeInner, 0) + tickPadding, + range = scale.range(), + range0 = Number(range[0]) + 0.5, + range1 = Number(range[range.length - 1]) + 0.5, + position = (scale.bandwidth ? center : number)( + scale.copy() + ), + selection = context.selection + ? context.selection() + : context, + path = selection.selectAll(".domain").data([null]), + tick = selection + .selectAll(".tick") + .data(values, scale) + .order(), + tickExit = tick.exit(), + tickEnter = tick + .enter() + .append("g") + .attr("class", "tick"), + line = tick.select("line"), + text = tick.select("text"); + path = path.merge( + path + .enter() + .insert("path", ".tick") + .attr("class", "domain") + .attr("stroke", "currentColor") + ); + tick = tick.merge(tickEnter); + line = line.merge( + tickEnter + .append("line") + .attr("stroke", "currentColor") + .attr(x + "2", k * tickSizeInner) + ); + text = text.merge( + tickEnter + .append("text") + .attr("fill", "currentColor") + .attr(x, k * spacing) + .attr( + "dy", + orient === top + ? "0em" + : orient === bottom + ? "0.71em" + : "0.32em" + ) + ); + + if (context !== selection) { + path = path.transition(context); + tick = tick.transition(context); + line = line.transition(context); + text = text.transition(context); + tickExit = tickExit + .transition(context) + .attr("opacity", epsilon) + .attr("transform", function (d) { + return isFinite((d = position(d))) + ? transform(d) + : this.getAttribute("transform"); + }); + tickEnter + .attr("opacity", epsilon) + .attr("transform", function (d) { + var p = this.parentNode.__axis; + return transform( + p && isFinite((p = p(d))) ? p : position(d) + ); + }); + } + + tickExit.remove(); + path.attr( + "d", + orient === left || orient == right + ? tickSizeOuter + ? "M" + + k * tickSizeOuter + + "," + + range0 + + "H0.5V" + + range1 + + "H" + + k * tickSizeOuter + : "M0.5," + range0 + "V" + range1 + : tickSizeOuter + ? "M" + + range0 + + "," + + k * tickSizeOuter + + "V0.5H" + + range1 + + "V" + + k * tickSizeOuter + : "M" + range0 + ",0.5H" + range1 + ); + tick.attr("opacity", 1).attr("transform", function (d) { + return transform(position(d)); + }); + line.attr(x + "2", k * tickSizeInner); + text.attr(x, k * spacing).text(format); + selection + .filter(entering) + .attr("fill", "none") + .attr("font-size", 10) + .attr("font-family", "sans-serif") + .attr( + "text-anchor", + orient === right + ? "start" + : orient === left + ? "end" + : "middle" + ); + selection.each(function () { + this.__axis = position; + }); + } + + axis.scale = function (_) { + return arguments.length ? ((scale = _), axis) : scale; + }; + + axis.ticks = function () { + return ( + (tickArguments = _array__WEBPACK_IMPORTED_MODULE_0__.slice.call(arguments)), + axis + ); + }; + + axis.tickArguments = function (_) { + return arguments.length + ? ((tickArguments = + _ == null + ? [] + : _array__WEBPACK_IMPORTED_MODULE_0__.slice.call(_)), + axis) + : tickArguments.slice(); + }; + + axis.tickValues = function (_) { + return arguments.length + ? ((tickValues = + _ == null + ? null + : _array__WEBPACK_IMPORTED_MODULE_0__.slice.call(_)), + axis) + : tickValues && tickValues.slice(); + }; + + axis.tickFormat = function (_) { + return arguments.length + ? ((tickFormat = _), axis) + : tickFormat; + }; + + axis.tickSize = function (_) { + return arguments.length + ? ((tickSizeInner = tickSizeOuter = Number(_)), axis) + : tickSizeInner; + }; + + axis.tickSizeInner = function (_) { + return arguments.length + ? ((tickSizeInner = Number(_)), axis) + : tickSizeInner; + }; + + axis.tickSizeOuter = function (_) { + return arguments.length + ? ((tickSizeOuter = Number(_)), axis) + : tickSizeOuter; + }; + + axis.tickPadding = function (_) { + return arguments.length + ? ((tickPadding = Number(_)), axis) + : tickPadding; + }; + + return axis; + } + + function axisTop(scale) { + return axis(top, scale); + } + function axisRight(scale) { + return axis(right, scale); + } + function axisBottom(scale) { + return axis(bottom, scale); + } + function axisLeft(scale) { + return axis(left, scale); + } + + /***/ + }, + + /***/ "./node_modules/d3-axis/src/identity.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-axis/src/identity.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return x; + }; + + /***/ + }, + + /***/ "./node_modules/d3-axis/src/index.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-axis/src/index.js ***! + \*******************************************/ + /* ! exports provided: axisTop, axisRight, axisBottom, axisLeft */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _axis__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./axis */ "./node_modules/d3-axis/src/axis.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "axisTop", + function () { + return _axis__WEBPACK_IMPORTED_MODULE_0__.axisTop; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "axisRight", + function () { + return _axis__WEBPACK_IMPORTED_MODULE_0__.axisRight; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "axisBottom", + function () { + return _axis__WEBPACK_IMPORTED_MODULE_0__.axisBottom; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "axisLeft", + function () { + return _axis__WEBPACK_IMPORTED_MODULE_0__.axisLeft; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-brush/src/brush.js": + /* !********************************************!*\ + !*** ./node_modules/d3-brush/src/brush.js ***! + \********************************************/ + /* ! exports provided: brushSelection, brushX, brushY, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "brushSelection", + function () { + return brushSelection; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "brushX", + function () { + return brushX; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "brushY", + function () { + return brushY; + } + ); + /* Harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js" + ); + /* Harmony import */ var d3_drag__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-drag */ "./node_modules/d3-drag/src/index.js" + ); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var d3_transition__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! d3-transition */ "./node_modules/d3-transition/src/index.js" + ); + /* Harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./constant.js */ "./node_modules/d3-brush/src/constant.js" + ); + /* Harmony import */ var _event_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./event.js */ "./node_modules/d3-brush/src/event.js" + ); + /* Harmony import */ var _noevent_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./noevent.js */ "./node_modules/d3-brush/src/noevent.js" + ); + + var MODE_DRAG = { + name: "drag", + }, + MODE_SPACE = { + name: "space", + }, + MODE_HANDLE = { + name: "handle", + }, + MODE_CENTER = { + name: "center", + }; + + function number1(e) { + return [Number(e[0]), Number(e[1])]; + } + + function number2(e) { + return [number1(e[0]), number1(e[1])]; + } + + function toucher(identifier) { + return function (target) { + return Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.touch + )( + target, + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .touches, + identifier + ); + }; + } + + var X = { + name: "x", + handles: ["w", "e"].map(type), + input: function input(x, e) { + return x == null + ? null + : [ + [Number(x[0]), e[0][1]], + [Number(x[1]), e[1][1]], + ]; + }, + output: function output(xy) { + return xy && [xy[0][0], xy[1][0]]; + }, + }; + var Y = { + name: "y", + handles: ["n", "s"].map(type), + input: function input(y, e) { + return y == null + ? null + : [ + [e[0][0], Number(y[0])], + [e[1][0], Number(y[1])], + ]; + }, + output: function output(xy) { + return xy && [xy[0][1], xy[1][1]]; + }, + }; + var XY = { + name: "xy", + handles: ["n", "w", "e", "s", "nw", "ne", "sw", "se"].map(type), + input: function input(xy) { + return xy == null ? null : number2(xy); + }, + output: function output(xy) { + return xy; + }, + }; + var cursors = { + overlay: "crosshair", + selection: "move", + n: "ns-resize", + e: "ew-resize", + s: "ns-resize", + w: "ew-resize", + nw: "nwse-resize", + ne: "nesw-resize", + se: "nwse-resize", + sw: "nesw-resize", + }; + var flipX = { + e: "w", + w: "e", + nw: "ne", + ne: "nw", + se: "sw", + sw: "se", + }; + var flipY = { + n: "s", + s: "n", + nw: "sw", + ne: "se", + se: "ne", + sw: "nw", + }; + var signsX = { + overlay: +1, + selection: +1, + n: null, + e: +1, + s: null, + w: -1, + nw: -1, + ne: +1, + se: +1, + sw: -1, + }; + var signsY = { + overlay: +1, + selection: +1, + n: -1, + e: null, + s: +1, + w: null, + nw: -1, + ne: -1, + se: +1, + sw: +1, + }; + + function type(t) { + return { + type: t, + }; + } // Ignore right-click, since that should open the context menu. + + function defaultFilter() { + return ( + !d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .ctrlKey && + !d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.button + ); + } + + function defaultExtent() { + var svg = this.ownerSVGElement || this; + + if (svg.hasAttribute("viewBox")) { + svg = svg.viewBox.baseVal; + return [ + [svg.x, svg.y], + [svg.x + svg.width, svg.y + svg.height], + ]; + } + + return [ + [0, 0], + [svg.width.baseVal.value, svg.height.baseVal.value], + ]; + } + + function defaultTouchable() { + return navigator.maxTouchPoints || "ontouchstart" in this; + } // Like d3.local, but with the name “__brush” rather than auto-generated. + + function local(node) { + while (!node.__brush) { + if (!(node = node.parentNode)) return; + } + + return node.__brush; + } + + function empty(extent) { + return ( + extent[0][0] === extent[1][0] || + extent[0][1] === extent[1][1] + ); + } + + function brushSelection(node) { + var state = node.__brush; + return state ? state.dim.output(state.selection) : null; + } + function brushX() { + return brush(X); + } + function brushY() { + return brush(Y); + } + /* Harmony default export */ __webpack_exports__.default = function () { + return brush(XY); + }; + + function brush(dim) { + var extent = defaultExtent, + filter = defaultFilter, + touchable = defaultTouchable, + keys = true, + listeners = Object( + d3_dispatch__WEBPACK_IMPORTED_MODULE_0__.dispatch + )(brush, "start", "brush", "end"), + handleSize = 6, + touchending; + + function brush(group) { + var overlay = group + .property("__brush", initialize) + .selectAll(".overlay") + .data([type("overlay")]); + overlay + .enter() + .append("rect") + .attr("class", "overlay") + .attr("pointer-events", "all") + .attr("cursor", cursors.overlay) + .merge(overlay) + .each(function () { + var extent = local(this).extent; + Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.select + )(this) + .attr("x", extent[0][0]) + .attr("y", extent[0][1]) + .attr("width", extent[1][0] - extent[0][0]) + .attr("height", extent[1][1] - extent[0][1]); + }); + group + .selectAll(".selection") + .data([type("selection")]) + .enter() + .append("rect") + .attr("class", "selection") + .attr("cursor", cursors.selection) + .attr("fill", "#777") + .attr("fill-opacity", 0.3) + .attr("stroke", "#fff") + .attr("shape-rendering", "crispEdges"); + var handle = group + .selectAll(".handle") + .data(dim.handles, function (d) { + return d.type; + }); + handle.exit().remove(); + handle + .enter() + .append("rect") + .attr("class", function (d) { + return "handle handle--" + d.type; + }) + .attr("cursor", function (d) { + return cursors[d.type]; + }); + group + .each(redraw) + .attr("fill", "none") + .attr("pointer-events", "all") + .on("mousedown.brush", started) + .filter(touchable) + .on("touchstart.brush", started) + .on("touchmove.brush", touchmoved) + .on("touchend.brush touchcancel.brush", touchended) + .style("touch-action", "none") + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); + } + + brush.move = function (group, selection) { + if (group.selection) { + group + .on("start.brush", function () { + emitter(this, arguments).beforestart().start(); + }) + .on("interrupt.brush end.brush", function () { + emitter(this, arguments).end(); + }) + .tween("brush", function () { + var that = this, + state = that.__brush, + emit = emitter(that, arguments), + selection0 = state.selection, + selection1 = dim.input( + typeof selection === "function" + ? selection.apply(this, arguments) + : selection, + state.extent + ), + i = Object( + d3_interpolate__WEBPACK_IMPORTED_MODULE_2__.interpolate + )(selection0, selection1); + + function tween(t) { + state.selection = + t === 1 && selection1 === null + ? null + : i(t); + redraw.call(that); + emit.brush(); + } + + return selection0 !== null && + selection1 !== null + ? tween + : tween(1); + }); + } else { + group.each(function () { + var that = this, + args = arguments, + state = that.__brush, + selection1 = dim.input( + typeof selection === "function" + ? selection.apply(that, args) + : selection, + state.extent + ), + emit = emitter(that, args).beforestart(); + Object( + d3_transition__WEBPACK_IMPORTED_MODULE_4__.interrupt + )(that); + state.selection = + selection1 === null ? null : selection1; + redraw.call(that); + emit.start().brush().end(); + }); + } + }; + + brush.clear = function (group) { + brush.move(group, null); + }; + + function redraw() { + var group = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.select + )(this), + selection = local(this).selection; + + if (selection) { + group + .selectAll(".selection") + .style("display", null) + .attr("x", selection[0][0]) + .attr("y", selection[0][1]) + .attr("width", selection[1][0] - selection[0][0]) + .attr("height", selection[1][1] - selection[0][1]); + group + .selectAll(".handle") + .style("display", null) + .attr("x", function (d) { + return d.type[d.type.length - 1] === "e" + ? selection[1][0] - handleSize / 2 + : selection[0][0] - handleSize / 2; + }) + .attr("y", function (d) { + return d.type[0] === "s" + ? selection[1][1] - handleSize / 2 + : selection[0][1] - handleSize / 2; + }) + .attr("width", function (d) { + return d.type === "n" || d.type === "s" + ? selection[1][0] - + selection[0][0] + + handleSize + : handleSize; + }) + .attr("height", function (d) { + return d.type === "e" || d.type === "w" + ? selection[1][1] - + selection[0][1] + + handleSize + : handleSize; + }); + } else { + group + .selectAll(".selection,.handle") + .style("display", "none") + .attr("x", null) + .attr("y", null) + .attr("width", null) + .attr("height", null); + } + } + + function emitter(that, args, clean) { + return ( + (!clean && that.__brush.emitter) || + new Emitter(that, args) + ); + } + + function Emitter(that, args) { + this.that = that; + this.args = args; + this.state = that.__brush; + this.active = 0; + } + + Emitter.prototype = { + beforestart: function beforestart() { + if (++this.active === 1) + (this.state.emitter = this), (this.starting = true); + return this; + }, + start: function start() { + if (this.starting) + (this.starting = false), this.emit("start"); + else this.emit("brush"); + return this; + }, + brush: function brush() { + this.emit("brush"); + return this; + }, + end: function end() { + if (--this.active === 0) + delete this.state.emitter, this.emit("end"); + return this; + }, + emit: function emit(type) { + Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.customEvent + )( + new _event_js__WEBPACK_IMPORTED_MODULE_6__.default(brush, type, dim.output(this.state.selection)), + listeners.apply, + listeners, + [type, this.that, this.args] + ); + }, + }; + + function started() { + if ( + touchending && + !d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .touches + ) + return; + if (!filter.apply(this, arguments)) return; + var that = this, + type = + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .target.__data__.type, + mode = + (keys && + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .metaKey + ? (type = "overlay") + : type) === "selection" + ? MODE_DRAG + : keys && + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.altKey + ? MODE_CENTER + : MODE_HANDLE, + signX = dim === Y ? null : signsX[type], + signY = dim === X ? null : signsY[type], + state = local(that), + extent = state.extent, + selection = state.selection, + W = extent[0][0], + w0, + w1, + N = extent[0][1], + n0, + n1, + E = extent[1][0], + e0, + e1, + S = extent[1][1], + s0, + s1, + dx = 0, + dy = 0, + moving, + shifting = + signX && + signY && + keys && + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .shiftKey, + lockX, + lockY, + pointer = d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.touches + ? toucher( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.changedTouches[0].identifier + ) + : d3_selection__WEBPACK_IMPORTED_MODULE_3__.mouse, + point0 = pointer(that), + point = point0, + emit = emitter(that, arguments, true).beforestart(); + + if (type === "overlay") { + if (selection) moving = true; + state.selection = selection = [ + [ + (w0 = dim === Y ? W : point0[0]), + (n0 = dim === X ? N : point0[1]), + ], + [ + (e0 = dim === Y ? E : w0), + (s0 = dim === X ? S : n0), + ], + ]; + } else { + w0 = selection[0][0]; + n0 = selection[0][1]; + e0 = selection[1][0]; + s0 = selection[1][1]; + } + + w1 = w0; + n1 = n0; + e1 = e0; + s1 = s0; + var group = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.select + )(that).attr("pointer-events", "none"); + var overlay = group + .selectAll(".overlay") + .attr("cursor", cursors[type]); + + if ( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .touches + ) { + emit.moved = moved; + emit.ended = ended; + } else { + var view = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.select + )( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .view + ) + .on("mousemove.brush", moved, true) + .on("mouseup.brush", ended, true); + if (keys) + view.on("keydown.brush", keydowned, true).on( + "keyup.brush", + keyupped, + true + ); + Object( + d3_drag__WEBPACK_IMPORTED_MODULE_1__.dragDisable + )( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .view + ); + } + + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_7__.nopropagation + )(); + Object( + d3_transition__WEBPACK_IMPORTED_MODULE_4__.interrupt + )(that); + redraw.call(that); + emit.start(); + + function moved() { + var point1 = pointer(that); + + if (shifting && !lockX && !lockY) { + if ( + Math.abs(point1[0] - point[0]) > + Math.abs(point1[1] - point[1]) + ) + lockY = true; + else lockX = true; + } + + point = point1; + moving = true; + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_7__.default + )(); + move(); + } + + function move() { + var t; + dx = point[0] - point0[0]; + dy = point[1] - point0[1]; + + switch (mode) { + case MODE_SPACE: + case MODE_DRAG: { + if (signX) + (dx = Math.max( + W - w0, + Math.min(E - e0, dx) + )), + (w1 = w0 + dx), + (e1 = e0 + dx); + if (signY) + (dy = Math.max( + N - n0, + Math.min(S - s0, dy) + )), + (n1 = n0 + dy), + (s1 = s0 + dy); + break; + } + + case MODE_HANDLE: { + if (signX < 0) + (dx = Math.max( + W - w0, + Math.min(E - w0, dx) + )), + (w1 = w0 + dx), + (e1 = e0); + else if (signX > 0) + (dx = Math.max( + W - e0, + Math.min(E - e0, dx) + )), + (w1 = w0), + (e1 = e0 + dx); + if (signY < 0) + (dy = Math.max( + N - n0, + Math.min(S - n0, dy) + )), + (n1 = n0 + dy), + (s1 = s0); + else if (signY > 0) + (dy = Math.max( + N - s0, + Math.min(S - s0, dy) + )), + (n1 = n0), + (s1 = s0 + dy); + break; + } + + case MODE_CENTER: { + if (signX) + (w1 = Math.max( + W, + Math.min(E, w0 - dx * signX) + )), + (e1 = Math.max( + W, + Math.min(E, e0 + dx * signX) + )); + if (signY) + (n1 = Math.max( + N, + Math.min(S, n0 - dy * signY) + )), + (s1 = Math.max( + N, + Math.min(S, s0 + dy * signY) + )); + break; + } + } + + if (e1 < w1) { + signX *= -1; + (t = w0), (w0 = e0), (e0 = t); + (t = w1), (w1 = e1), (e1 = t); + if (type in flipX) + overlay.attr( + "cursor", + cursors[(type = flipX[type])] + ); + } + + if (s1 < n1) { + signY *= -1; + (t = n0), (n0 = s0), (s0 = t); + (t = n1), (n1 = s1), (s1 = t); + if (type in flipY) + overlay.attr( + "cursor", + cursors[(type = flipY[type])] + ); + } + + if (state.selection) selection = state.selection; // May be set by brush.move! + + if (lockX) + (w1 = selection[0][0]), (e1 = selection[1][0]); + if (lockY) + (n1 = selection[0][1]), (s1 = selection[1][1]); + + if ( + selection[0][0] !== w1 || + selection[0][1] !== n1 || + selection[1][0] !== e1 || + selection[1][1] !== s1 + ) { + state.selection = [ + [w1, n1], + [e1, s1], + ]; + redraw.call(that); + emit.brush(); + } + } + + function ended() { + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_7__.nopropagation + )(); + + if ( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .touches + ) { + if ( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.touches.length + ) + return; + if (touchending) clearTimeout(touchending); + touchending = setTimeout(function () { + touchending = null; + }, 500); // Ghost clicks are delayed! + } else { + Object( + d3_drag__WEBPACK_IMPORTED_MODULE_1__.dragEnable + )( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.view, + moving + ); + view.on( + "keydown.brush keyup.brush mousemove.brush mouseup.brush", + null + ); + } + + group.attr("pointer-events", "all"); + overlay.attr("cursor", cursors.overlay); + if (state.selection) selection = state.selection; // May be set by brush.move (on start)! + + if (empty(selection)) + (state.selection = null), redraw.call(that); + emit.end(); + } + + function keydowned() { + switch ( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .keyCode + ) { + case 16: { + // SHIFT + shifting = signX && signY; + break; + } + + case 18: { + // ALT + if (mode === MODE_HANDLE) { + if (signX) + (e0 = e1 - dx * signX), + (w0 = w1 + dx * signX); + if (signY) + (s0 = s1 - dy * signY), + (n0 = n1 + dy * signY); + mode = MODE_CENTER; + move(); + } + + break; + } + + case 32: { + // SPACE; takes priority over ALT + if ( + mode === MODE_HANDLE || + mode === MODE_CENTER + ) { + if (signX < 0) e0 = e1 - dx; + else if (signX > 0) w0 = w1 - dx; + if (signY < 0) s0 = s1 - dy; + else if (signY > 0) n0 = n1 - dy; + mode = MODE_SPACE; + overlay.attr("cursor", cursors.selection); + move(); + } + + break; + } + + default: + return; + } + + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_7__.default + )(); + } + + function keyupped() { + switch ( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .keyCode + ) { + case 16: { + // SHIFT + if (shifting) { + lockX = lockY = shifting = false; + move(); + } + + break; + } + + case 18: { + // ALT + if (mode === MODE_CENTER) { + if (signX < 0) e0 = e1; + else if (signX > 0) w0 = w1; + if (signY < 0) s0 = s1; + else if (signY > 0) n0 = n1; + mode = MODE_HANDLE; + move(); + } + + break; + } + + case 32: { + // SPACE + if (mode === MODE_SPACE) { + if ( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.altKey + ) { + if (signX) + (e0 = e1 - dx * signX), + (w0 = w1 + dx * signX); + if (signY) + (s0 = s1 - dy * signY), + (n0 = n1 + dy * signY); + mode = MODE_CENTER; + } else { + if (signX < 0) e0 = e1; + else if (signX > 0) w0 = w1; + if (signY < 0) s0 = s1; + else if (signY > 0) n0 = n1; + mode = MODE_HANDLE; + } + + overlay.attr("cursor", cursors[type]); + move(); + } + + break; + } + + default: + return; + } + + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_7__.default + )(); + } + } + + function touchmoved() { + emitter(this, arguments).moved(); + } + + function touchended() { + emitter(this, arguments).ended(); + } + + function initialize() { + var state = this.__brush || { + selection: null, + }; + state.extent = number2(extent.apply(this, arguments)); + state.dim = dim; + return state; + } + + brush.extent = function (_) { + return arguments.length + ? ((extent = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_5__.default + )(number2(_))), + brush) + : extent; + }; + + brush.filter = function (_) { + return arguments.length + ? ((filter = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_5__.default + )(Boolean(_))), + brush) + : filter; + }; + + brush.handleSize = function (_) { + return arguments.length + ? ((handleSize = Number(_)), brush) + : handleSize; + }; + + brush.keyModifiers = function (_) { + return arguments.length ? ((keys = Boolean(_)), brush) : keys; + }; + + brush.on = function () { + var value = listeners.on.apply(listeners, arguments); + return value === listeners ? brush : value; + }; + + return brush; + } + + /***/ + }, + + /***/ "./node_modules/d3-brush/src/constant.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-brush/src/constant.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-brush/src/event.js": + /* !********************************************!*\ + !*** ./node_modules/d3-brush/src/event.js ***! + \********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (target, type, selection) { + this.target = target; + this.type = type; + this.selection = selection; + }; + + /***/ + }, + + /***/ "./node_modules/d3-brush/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-brush/src/index.js ***! + \********************************************/ + /* ! exports provided: brush, brushX, brushY, brushSelection */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _brush_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./brush.js */ "./node_modules/d3-brush/src/brush.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "brush", + function () { + return _brush_js__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "brushX", + function () { + return _brush_js__WEBPACK_IMPORTED_MODULE_0__.brushX; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "brushY", + function () { + return _brush_js__WEBPACK_IMPORTED_MODULE_0__.brushY; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "brushSelection", + function () { + return _brush_js__WEBPACK_IMPORTED_MODULE_0__.brushSelection; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-brush/src/noevent.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-brush/src/noevent.js ***! + \**********************************************/ + /* ! exports provided: nopropagation, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "nopropagation", + function () { + return nopropagation; + } + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + + function nopropagation() { + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.stopImmediatePropagation(); + } + /* Harmony default export */ __webpack_exports__.default = function () { + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.preventDefault(); + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.stopImmediatePropagation(); + }; + + /***/ + }, + + /***/ "./node_modules/d3-chord/src/array.js": + /* !********************************************!*\ + !*** ./node_modules/d3-chord/src/array.js ***! + \********************************************/ + /* ! exports provided: slice */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "slice", + function () { + return slice; + } + ); + var slice = Array.prototype.slice; + + /***/ + }, + + /***/ "./node_modules/d3-chord/src/chord.js": + /* !********************************************!*\ + !*** ./node_modules/d3-chord/src/chord.js ***! + \********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-chord/src/math.js" + ); + + function compareValue(compare) { + return function (a, b) { + return compare( + a.source.value + a.target.value, + b.source.value + b.target.value + ); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var padAngle = 0, + sortGroups = null, + sortSubgroups = null, + sortChords = null; + + function chord(matrix) { + var n = matrix.length, + groupSums = [], + groupIndex = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )(n), + subgroupIndex = [], + chords = [], + groups = (chords.groups = new Array(n)), + subgroups = new Array(n * n), + k, + x, + x0, + dx, + i, + j; // Compute the sum. + + (k = 0), (i = -1); + + while (++i < n) { + (x = 0), (j = -1); + + while (++j < n) { + x += matrix[i][j]; + } + + groupSums.push(x); + subgroupIndex.push( + Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )(n) + ); + k += x; + } // Sort groups… + + if (sortGroups) + groupIndex.sort(function (a, b) { + return sortGroups(groupSums[a], groupSums[b]); + }); // Sort subgroups… + + if (sortSubgroups) + subgroupIndex.forEach(function (d, i) { + d.sort(function (a, b) { + return sortSubgroups( + matrix[i][a], + matrix[i][b] + ); + }); + }); // Convert the sum to scaling factor for [0, 2pi]. + // TODO Allow start and end angle to be specified? + // TODO Allow padding to be specified as percentage? + + k = + Object(_math__WEBPACK_IMPORTED_MODULE_1__.max)( + 0, + _math__WEBPACK_IMPORTED_MODULE_1__.tau - + padAngle * n + ) / k; + dx = k + ? padAngle + : _math__WEBPACK_IMPORTED_MODULE_1__.tau / n; // Compute the start and end angle for each group and subgroup. + // Note: Opera has a bug reordering object literal properties! + + (x = 0), (i = -1); + + while (++i < n) { + (x0 = x), (j = -1); + + while (++j < n) { + var di = groupIndex[i], + dj = subgroupIndex[di][j], + v = matrix[di][dj], + a0 = x, + a1 = (x += v * k); + subgroups[dj * n + di] = { + index: di, + subindex: dj, + startAngle: a0, + endAngle: a1, + value: v, + }; + } + + groups[di] = { + index: di, + startAngle: x0, + endAngle: x, + value: groupSums[di], + }; + x += dx; + } // Generate chords for each (non-empty) subgroup-subgroup link. + + i = -1; + + while (++i < n) { + j = i - 1; + + while (++j < n) { + var source = subgroups[j * n + i], + target = subgroups[i * n + j]; + + if (source.value || target.value) { + chords.push( + source.value < target.value + ? { + source: target, + target: source, + } + : { + source: source, + target: target, + } + ); + } + } + } + + return sortChords ? chords.sort(sortChords) : chords; + } + + chord.padAngle = function (_) { + return arguments.length + ? ((padAngle = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.max + )(0, _)), + chord) + : padAngle; + }; + + chord.sortGroups = function (_) { + return arguments.length + ? ((sortGroups = _), chord) + : sortGroups; + }; + + chord.sortSubgroups = function (_) { + return arguments.length + ? ((sortSubgroups = _), chord) + : sortSubgroups; + }; + + chord.sortChords = function (_) { + return arguments.length + ? (_ == null + ? (sortChords = null) + : ((sortChords = compareValue(_))._ = _), + chord) + : sortChords && sortChords._; + }; + + return chord; + }; + + /***/ + }, + + /***/ "./node_modules/d3-chord/src/constant.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-chord/src/constant.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-chord/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-chord/src/index.js ***! + \********************************************/ + /* ! exports provided: chord, ribbon */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _chord__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./chord */ "./node_modules/d3-chord/src/chord.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "chord", + function () { + return _chord__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _ribbon__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./ribbon */ "./node_modules/d3-chord/src/ribbon.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "ribbon", + function () { + return _ribbon__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-chord/src/math.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-chord/src/math.js ***! + \*******************************************/ + /* ! exports provided: cos, sin, pi, halfPi, tau, max */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cos", + function () { + return cos; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sin", + function () { + return sin; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "pi", + function () { + return pi; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "halfPi", + function () { + return halfPi; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tau", + function () { + return tau; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "max", + function () { + return max; + } + ); + var cos = Math.cos; + var sin = Math.sin; + var pi = Math.PI; + var halfPi = pi / 2; + var tau = pi * 2; + var max = Math.max; + + /***/ + }, + + /***/ "./node_modules/d3-chord/src/ribbon.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-chord/src/ribbon.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-chord/src/array.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-chord/src/constant.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-chord/src/math.js" + ); + /* Harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! d3-path */ "./node_modules/d3-path/src/index.js" + ); + + function defaultSource(d) { + return d.source; + } + + function defaultTarget(d) { + return d.target; + } + + function defaultRadius(d) { + return d.radius; + } + + function defaultStartAngle(d) { + return d.startAngle; + } + + function defaultEndAngle(d) { + return d.endAngle; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var source = defaultSource, + target = defaultTarget, + radius = defaultRadius, + startAngle = defaultStartAngle, + endAngle = defaultEndAngle, + context = null; + + function ribbon() { + var buffer, + argv = _array__WEBPACK_IMPORTED_MODULE_0__.slice.call(arguments), + s = source.apply(this, argv), + t = target.apply(this, argv), + sr = Number(radius.apply(this, ((argv[0] = s), argv))), + sa0 = + startAngle.apply(this, argv) - + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi, + sa1 = + endAngle.apply(this, argv) - + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi, + sx0 = + sr * + Object(_math__WEBPACK_IMPORTED_MODULE_2__.cos)( + sa0 + ), + sy0 = + sr * + Object(_math__WEBPACK_IMPORTED_MODULE_2__.sin)( + sa0 + ), + tr = Number(radius.apply(this, ((argv[0] = t), argv))), + ta0 = + startAngle.apply(this, argv) - + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi, + ta1 = + endAngle.apply(this, argv) - + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi; + if (!context) + context = buffer = Object( + d3_path__WEBPACK_IMPORTED_MODULE_3__.path + )(); + context.moveTo(sx0, sy0); + context.arc(0, 0, sr, sa0, sa1); + + if (sa0 !== ta0 || sa1 !== ta1) { + // TODO sr !== tr? + context.quadraticCurveTo( + 0, + 0, + tr * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(ta0), + tr * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(ta0) + ); + context.arc(0, 0, tr, ta0, ta1); + } + + context.quadraticCurveTo(0, 0, sx0, sy0); + context.closePath(); + if (buffer) return (context = null), String(buffer) || null; + } + + ribbon.radius = function (_) { + return arguments.length + ? ((radius = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + ribbon) + : radius; + }; + + ribbon.startAngle = function (_) { + return arguments.length + ? ((startAngle = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + ribbon) + : startAngle; + }; + + ribbon.endAngle = function (_) { + return arguments.length + ? ((endAngle = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + ribbon) + : endAngle; + }; + + ribbon.source = function (_) { + return arguments.length ? ((source = _), ribbon) : source; + }; + + ribbon.target = function (_) { + return arguments.length ? ((target = _), ribbon) : target; + }; + + ribbon.context = function (_) { + return arguments.length + ? ((context = _ == null ? null : _), ribbon) + : context; + }; + + return ribbon; + }; + + /***/ + }, + + /***/ "./node_modules/d3-collection/src/entries.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-collection/src/entries.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (map) { + var entries = []; + + for (var key in map) { + entries.push({ + key: key, + value: map[key], + }); + } + + return entries; + }; + + /***/ + }, + + /***/ "./node_modules/d3-collection/src/index.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-collection/src/index.js ***! + \*************************************************/ + /* ! exports provided: nest, set, map, keys, values, entries */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _nest__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./nest */ "./node_modules/d3-collection/src/nest.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "nest", + function () { + return _nest__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _set__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./set */ "./node_modules/d3-collection/src/set.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "set", + function () { + return _set__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _map__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./map */ "./node_modules/d3-collection/src/map.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "map", + function () { + return _map__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _keys__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./keys */ "./node_modules/d3-collection/src/keys.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "keys", + function () { + return _keys__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _values__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./values */ "./node_modules/d3-collection/src/values.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "values", + function () { + return _values__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _entries__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./entries */ "./node_modules/d3-collection/src/entries.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "entries", + function () { + return _entries__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-collection/src/keys.js": + /* !************************************************!*\ + !*** ./node_modules/d3-collection/src/keys.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (map) { + var keys = []; + + for (var key in map) { + keys.push(key); + } + + return keys; + }; + + /***/ + }, + + /***/ "./node_modules/d3-collection/src/map.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-collection/src/map.js ***! + \***********************************************/ + /* ! exports provided: prefix, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "prefix", + function () { + return prefix; + } + ); + var prefix = "$"; + + function Map() {} + + Map.prototype = map.prototype = { + constructor: Map, + has: function has(key) { + return prefix + key in this; + }, + get: function get(key) { + return this[prefix + key]; + }, + set: function set(key, value) { + this[prefix + key] = value; + return this; + }, + remove: function remove(key) { + var property = prefix + key; + return property in this && delete this[property]; + }, + clear: function clear() { + for (var property in this) { + if (property[0] === prefix) delete this[property]; + } + }, + keys: function keys() { + var keys = []; + + for (var property in this) { + if (property[0] === prefix) + keys.push(property.slice(1)); + } + + return keys; + }, + values: function values() { + var values = []; + + for (var property in this) { + if (property[0] === prefix) values.push(this[property]); + } + + return values; + }, + entries: function entries() { + var entries = []; + + for (var property in this) { + if (property[0] === prefix) + entries.push({ + key: property.slice(1), + value: this[property], + }); + } + + return entries; + }, + size: function size() { + var size = 0; + + for (var property in this) { + if (property[0] === prefix) ++size; + } + + return size; + }, + empty: function empty() { + for (var property in this) { + if (property[0] === prefix) return false; + } + + return true; + }, + each: function each(f) { + for (var property in this) { + if (property[0] === prefix) + f(this[property], property.slice(1), this); + } + }, + }; + + function map(object, f) { + var map = new Map(); // Copy constructor. + + if (object instanceof Map) + object.each(function (value, key) { + map.set(key, value); + }); + // Index array by numeric index or specified key function. + else if (Array.isArray(object)) { + var i = -1, + n = object.length, + o; + if (f == null) + while (++i < n) { + map.set(i, object[i]); + } + else + while (++i < n) { + map.set(f((o = object[i]), i, object), o); + } + } // Convert object to map. + else if (object) + for (var key in object) { + map.set(key, object[key]); + } + return map; + } + + /* Harmony default export */ __webpack_exports__.default = map; + + /***/ + }, + + /***/ "./node_modules/d3-collection/src/nest.js": + /* !************************************************!*\ + !*** ./node_modules/d3-collection/src/nest.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _map__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./map */ "./node_modules/d3-collection/src/map.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var keys = [], + _sortKeys = [], + _sortValues, + _rollup, + nest; + + function apply(array, depth, createResult, setResult) { + if (depth >= keys.length) { + if (_sortValues != null) array.sort(_sortValues); + return _rollup != null ? _rollup(array) : array; + } + + var i = -1, + n = array.length, + key = keys[depth++], + keyValue, + value, + valuesByKey = Object( + _map__WEBPACK_IMPORTED_MODULE_0__.default + )(), + values, + result = createResult(); + + while (++i < n) { + if ( + (values = valuesByKey.get( + (keyValue = String(key((value = array[i])))) + )) + ) { + values.push(value); + } else { + valuesByKey.set(keyValue, [value]); + } + } + + valuesByKey.each(function (values, key) { + setResult( + result, + key, + apply(values, depth, createResult, setResult) + ); + }); + return result; + } + + function _entries(map, depth) { + if (++depth > keys.length) return map; + var array, + sortKey = _sortKeys[depth - 1]; + if (_rollup != null && depth >= keys.length) + array = map.entries(); + else + (array = []), + map.each(function (v, k) { + array.push({ + key: k, + values: _entries(v, depth), + }); + }); + return sortKey != null + ? array.sort(function (a, b) { + return sortKey(a.key, b.key); + }) + : array; + } + + return (nest = { + object: function object(array) { + return apply(array, 0, createObject, setObject); + }, + map: function map(array) { + return apply(array, 0, createMap, setMap); + }, + entries: function entries(array) { + return _entries(apply(array, 0, createMap, setMap), 0); + }, + key: function key(d) { + keys.push(d); + return nest; + }, + sortKeys: function sortKeys(order) { + _sortKeys[keys.length - 1] = order; + return nest; + }, + sortValues: function sortValues(order) { + _sortValues = order; + return nest; + }, + rollup: function rollup(f) { + _rollup = f; + return nest; + }, + }); + }; + + function createObject() { + return {}; + } + + function setObject(object, key, value) { + object[key] = value; + } + + function createMap() { + return Object(_map__WEBPACK_IMPORTED_MODULE_0__.default)(); + } + + function setMap(map, key, value) { + map.set(key, value); + } + + /***/ + }, + + /***/ "./node_modules/d3-collection/src/set.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-collection/src/set.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _map__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./map */ "./node_modules/d3-collection/src/map.js" + ); + + function Set() {} + + var proto = _map__WEBPACK_IMPORTED_MODULE_0__.default.prototype; + Set.prototype = set.prototype = { + constructor: Set, + has: proto.has, + add: function add(value) { + value = String(value); + this[ + _map__WEBPACK_IMPORTED_MODULE_0__.prefix + value + ] = value; + return this; + }, + remove: proto.remove, + clear: proto.clear, + values: proto.keys, + size: proto.size, + empty: proto.empty, + each: proto.each, + }; + + function set(object, f) { + var set = new Set(); // Copy constructor. + + if (object instanceof Set) + object.each(function (value) { + set.add(value); + }); + // Otherwise, assume it’s an array. + else if (object) { + var i = -1, + n = object.length; + if (f == null) + while (++i < n) { + set.add(object[i]); + } + else + while (++i < n) { + set.add(f(object[i], i, object)); + } + } + return set; + } + + /* Harmony default export */ __webpack_exports__.default = set; + + /***/ + }, + + /***/ "./node_modules/d3-collection/src/values.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-collection/src/values.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (map) { + var values = []; + + for (var key in map) { + values.push(map[key]); + } + + return values; + }; + + /***/ + }, + + /***/ "./node_modules/d3-color/src/color.js": + /* !********************************************!*\ + !*** ./node_modules/d3-color/src/color.js ***! + \********************************************/ + /* ! exports provided: Color, darker, brighter, default, rgbConvert, rgb, Rgb, hslConvert, hsl */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Color", + function () { + return Color; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "darker", + function () { + return _darker; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "brighter", + function () { + return _brighter; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return color; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "rgbConvert", + function () { + return rgbConvert; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "rgb", + function () { + return rgb; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Rgb", + function () { + return Rgb; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "hslConvert", + function () { + return hslConvert; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "hsl", + function () { + return hsl; + } + ); + /* Harmony import */ var _define_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./define.js */ "./node_modules/d3-color/src/define.js" + ); + + function Color() {} + var _darker = 0.7; + + var _brighter = 1 / _darker; + + var reI = "\\s*([+-]?\\d+)\\s*", + reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*", + reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*", + reHex = /^#([0-9a-f]{3,8})$/, + reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"), + reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"), + reRgbaInteger = new RegExp( + "^rgba\\(" + [reI, reI, reI, reN] + "\\)$" + ), + reRgbaPercent = new RegExp( + "^rgba\\(" + [reP, reP, reP, reN] + "\\)$" + ), + reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"), + reHslaPercent = new RegExp( + "^hsla\\(" + [reN, reP, reP, reN] + "\\)$" + ); + var named = { + aliceblue: 0xf0f8ff, + antiquewhite: 0xfaebd7, + aqua: 0x00ffff, + aquamarine: 0x7fffd4, + azure: 0xf0ffff, + beige: 0xf5f5dc, + bisque: 0xffe4c4, + black: 0x000000, + blanchedalmond: 0xffebcd, + blue: 0x0000ff, + blueviolet: 0x8a2be2, + brown: 0xa52a2a, + burlywood: 0xdeb887, + cadetblue: 0x5f9ea0, + chartreuse: 0x7fff00, + chocolate: 0xd2691e, + coral: 0xff7f50, + cornflowerblue: 0x6495ed, + cornsilk: 0xfff8dc, + crimson: 0xdc143c, + cyan: 0x00ffff, + darkblue: 0x00008b, + darkcyan: 0x008b8b, + darkgoldenrod: 0xb8860b, + darkgray: 0xa9a9a9, + darkgreen: 0x006400, + darkgrey: 0xa9a9a9, + darkkhaki: 0xbdb76b, + darkmagenta: 0x8b008b, + darkolivegreen: 0x556b2f, + darkorange: 0xff8c00, + darkorchid: 0x9932cc, + darkred: 0x8b0000, + darksalmon: 0xe9967a, + darkseagreen: 0x8fbc8f, + darkslateblue: 0x483d8b, + darkslategray: 0x2f4f4f, + darkslategrey: 0x2f4f4f, + darkturquoise: 0x00ced1, + darkviolet: 0x9400d3, + deeppink: 0xff1493, + deepskyblue: 0x00bfff, + dimgray: 0x696969, + dimgrey: 0x696969, + dodgerblue: 0x1e90ff, + firebrick: 0xb22222, + floralwhite: 0xfffaf0, + forestgreen: 0x228b22, + fuchsia: 0xff00ff, + gainsboro: 0xdcdcdc, + ghostwhite: 0xf8f8ff, + gold: 0xffd700, + goldenrod: 0xdaa520, + gray: 0x808080, + green: 0x008000, + greenyellow: 0xadff2f, + grey: 0x808080, + honeydew: 0xf0fff0, + hotpink: 0xff69b4, + indianred: 0xcd5c5c, + indigo: 0x4b0082, + ivory: 0xfffff0, + khaki: 0xf0e68c, + lavender: 0xe6e6fa, + lavenderblush: 0xfff0f5, + lawngreen: 0x7cfc00, + lemonchiffon: 0xfffacd, + lightblue: 0xadd8e6, + lightcoral: 0xf08080, + lightcyan: 0xe0ffff, + lightgoldenrodyellow: 0xfafad2, + lightgray: 0xd3d3d3, + lightgreen: 0x90ee90, + lightgrey: 0xd3d3d3, + lightpink: 0xffb6c1, + lightsalmon: 0xffa07a, + lightseagreen: 0x20b2aa, + lightskyblue: 0x87cefa, + lightslategray: 0x778899, + lightslategrey: 0x778899, + lightsteelblue: 0xb0c4de, + lightyellow: 0xffffe0, + lime: 0x00ff00, + limegreen: 0x32cd32, + linen: 0xfaf0e6, + magenta: 0xff00ff, + maroon: 0x800000, + mediumaquamarine: 0x66cdaa, + mediumblue: 0x0000cd, + mediumorchid: 0xba55d3, + mediumpurple: 0x9370db, + mediumseagreen: 0x3cb371, + mediumslateblue: 0x7b68ee, + mediumspringgreen: 0x00fa9a, + mediumturquoise: 0x48d1cc, + mediumvioletred: 0xc71585, + midnightblue: 0x191970, + mintcream: 0xf5fffa, + mistyrose: 0xffe4e1, + moccasin: 0xffe4b5, + navajowhite: 0xffdead, + navy: 0x000080, + oldlace: 0xfdf5e6, + olive: 0x808000, + olivedrab: 0x6b8e23, + orange: 0xffa500, + orangered: 0xff4500, + orchid: 0xda70d6, + palegoldenrod: 0xeee8aa, + palegreen: 0x98fb98, + paleturquoise: 0xafeeee, + palevioletred: 0xdb7093, + papayawhip: 0xffefd5, + peachpuff: 0xffdab9, + peru: 0xcd853f, + pink: 0xffc0cb, + plum: 0xdda0dd, + powderblue: 0xb0e0e6, + purple: 0x800080, + rebeccapurple: 0x663399, + red: 0xff0000, + rosybrown: 0xbc8f8f, + royalblue: 0x4169e1, + saddlebrown: 0x8b4513, + salmon: 0xfa8072, + sandybrown: 0xf4a460, + seagreen: 0x2e8b57, + seashell: 0xfff5ee, + sienna: 0xa0522d, + silver: 0xc0c0c0, + skyblue: 0x87ceeb, + slateblue: 0x6a5acd, + slategray: 0x708090, + slategrey: 0x708090, + snow: 0xfffafa, + springgreen: 0x00ff7f, + steelblue: 0x4682b4, + tan: 0xd2b48c, + teal: 0x008080, + thistle: 0xd8bfd8, + tomato: 0xff6347, + turquoise: 0x40e0d0, + violet: 0xee82ee, + wheat: 0xf5deb3, + white: 0xffffff, + whitesmoke: 0xf5f5f5, + yellow: 0xffff00, + yellowgreen: 0x9acd32, + }; + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.default)( + Color, + color, + { + copy: function copy(channels) { + return Object.assign( + new this.constructor(), + this, + channels + ); + }, + displayable: function displayable() { + return this.rgb().displayable(); + }, + hex: color_formatHex, + // Deprecated! Use color.formatHex. + formatHex: color_formatHex, + formatHsl: color_formatHsl, + formatRgb: color_formatRgb, + toString: color_formatRgb, + } + ); + + function color_formatHex() { + return this.rgb().formatHex(); + } + + function color_formatHsl() { + return hslConvert(this).formatHsl(); + } + + function color_formatRgb() { + return this.rgb().formatRgb(); + } + + function color(format) { + var m, l; + format = (String(format)).trim().toLowerCase(); + return (m = reHex.exec(format)) + ? ((l = m[1].length), + (m = parseInt(m[1], 16)), + l === 6 + ? rgbn(m) // #ff0000 + : l === 3 + ? new Rgb( + ((m >> 8) & 0xf) | ((m >> 4) & 0xf0), + ((m >> 4) & 0xf) | (m & 0xf0), + ((m & 0xf) << 4) | (m & 0xf), + 1 + ) // #f00 + : l === 8 + ? new Rgb( + (m >> 24) & 0xff, + (m >> 16) & 0xff, + (m >> 8) & 0xff, + (m & 0xff) / 0xff + ) // #ff000000 + : l === 4 + ? new Rgb( + ((m >> 12) & 0xf) | ((m >> 8) & 0xf0), + ((m >> 8) & 0xf) | ((m >> 4) & 0xf0), + ((m >> 4) & 0xf) | (m & 0xf0), + (((m & 0xf) << 4) | (m & 0xf)) / 0xff + ) // #f000 + : null) // Invalid hex + : (m = reRgbInteger.exec(format)) + ? new Rgb(m[1], m[2], m[3], 1) // Rgb(255, 0, 0) + : (m = reRgbPercent.exec(format)) + ? new Rgb( + (m[1] * 255) / 100, + (m[2] * 255) / 100, + (m[3] * 255) / 100, + 1 + ) // Rgb(100%, 0%, 0%) + : (m = reRgbaInteger.exec(format)) + ? rgba(m[1], m[2], m[3], m[4]) // Rgba(255, 0, 0, 1) + : (m = reRgbaPercent.exec(format)) + ? rgba( + (m[1] * 255) / 100, + (m[2] * 255) / 100, + (m[3] * 255) / 100, + m[4] + ) // Rgb(100%, 0%, 0%, 1) + : (m = reHslPercent.exec(format)) + ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // Hsl(120, 50%, 50%) + : (m = reHslaPercent.exec(format)) + ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // Hsla(120, 50%, 50%, 1) + : named.hasOwnProperty(format) + ? rgbn(named[format]) // eslint-disable-line no-prototype-builtins + : format === "transparent" + ? new Rgb(NaN, NaN, NaN, 0) + : null; + } + + function rgbn(n) { + return new Rgb((n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff, 1); + } + + function rgba(r, g, b, a) { + if (a <= 0) r = g = b = NaN; + return new Rgb(r, g, b, a); + } + + function rgbConvert(o) { + if (!(o instanceof Color)) o = color(o); + if (!o) return new Rgb(); + o = o.rgb(); + return new Rgb(o.r, o.g, o.b, o.opacity); + } + function rgb(r, g, b, opacity) { + return arguments.length === 1 + ? rgbConvert(r) + : new Rgb(r, g, b, opacity == null ? 1 : opacity); + } + function Rgb(r, g, b, opacity) { + this.r = Number(r); + this.g = Number(g); + this.b = Number(b); + this.opacity = Number(opacity); + } + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.default)( + Rgb, + rgb, + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.extend)( + Color, + { + brighter: function brighter(k) { + k = k == null ? _brighter : Math.pow(_brighter, k); + return new Rgb( + this.r * k, + this.g * k, + this.b * k, + this.opacity + ); + }, + darker: function darker(k) { + k = k == null ? _darker : Math.pow(_darker, k); + return new Rgb( + this.r * k, + this.g * k, + this.b * k, + this.opacity + ); + }, + rgb: function rgb() { + return this; + }, + displayable: function displayable() { + return ( + this.r >= -0.5 && + this.r < 255.5 && + this.g >= -0.5 && + this.g < 255.5 && + this.b >= -0.5 && + this.b < 255.5 && + this.opacity >= 0 && + this.opacity <= 1 + ); + }, + hex: rgb_formatHex, + // Deprecated! Use color.formatHex. + formatHex: rgb_formatHex, + formatRgb: rgb_formatRgb, + toString: rgb_formatRgb, + } + ) + ); + + function rgb_formatHex() { + return "#" + hex(this.r) + hex(this.g) + hex(this.b); + } + + function rgb_formatRgb() { + var a = this.opacity; + a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); + return ( + (a === 1 ? "rgb(" : "rgba(") + + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + + ", " + + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + + ", " + + Math.max(0, Math.min(255, Math.round(this.b) || 0)) + + (a === 1 ? ")" : ", " + a + ")") + ); + } + + function hex(value) { + value = Math.max(0, Math.min(255, Math.round(value) || 0)); + return (value < 16 ? "0" : "") + value.toString(16); + } + + function hsla(h, s, l, a) { + if (a <= 0) h = s = l = NaN; + else if (l <= 0 || l >= 1) h = s = NaN; + else if (s <= 0) h = NaN; + return new Hsl(h, s, l, a); + } + + function hslConvert(o) { + if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity); + if (!(o instanceof Color)) o = color(o); + if (!o) return new Hsl(); + if (o instanceof Hsl) return o; + o = o.rgb(); + var r = o.r / 255, + g = o.g / 255, + b = o.b / 255, + min = Math.min(r, g, b), + max = Math.max(r, g, b), + h = NaN, + s = max - min, + l = (max + min) / 2; + + if (s) { + if (r === max) h = (g - b) / s + (g < b) * 6; + else if (g === max) h = (b - r) / s + 2; + else h = (r - g) / s + 4; + s /= l < 0.5 ? max + min : 2 - max - min; + h *= 60; + } else { + s = l > 0 && l < 1 ? 0 : h; + } + + return new Hsl(h, s, l, o.opacity); + } + function hsl(h, s, l, opacity) { + return arguments.length === 1 + ? hslConvert(h) + : new Hsl(h, s, l, opacity == null ? 1 : opacity); + } + + function Hsl(h, s, l, opacity) { + this.h = Number(h); + this.s = Number(s); + this.l = Number(l); + this.opacity = Number(opacity); + } + + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.default)( + Hsl, + hsl, + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.extend)( + Color, + { + brighter: function brighter(k) { + k = k == null ? _brighter : Math.pow(_brighter, k); + return new Hsl( + this.h, + this.s, + this.l * k, + this.opacity + ); + }, + darker: function darker(k) { + k = k == null ? _darker : Math.pow(_darker, k); + return new Hsl( + this.h, + this.s, + this.l * k, + this.opacity + ); + }, + rgb: function rgb() { + var h = (this.h % 360) + (this.h < 0) * 360, + s = isNaN(h) || isNaN(this.s) ? 0 : this.s, + l = this.l, + m2 = l + (l < 0.5 ? l : 1 - l) * s, + m1 = 2 * l - m2; + return new Rgb( + hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), + hsl2rgb(h, m1, m2), + hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), + this.opacity + ); + }, + displayable: function displayable() { + return ( + ((this.s >= 0 && this.s <= 1) || + isNaN(this.s)) && + this.l >= 0 && + this.l <= 1 && + this.opacity >= 0 && + this.opacity <= 1 + ); + }, + formatHsl: function formatHsl() { + var a = this.opacity; + a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); + return ( + (a === 1 ? "hsl(" : "hsla(") + + (this.h || 0) + + ", " + + (this.s || 0) * 100 + + "%, " + + (this.l || 0) * 100 + + "%" + + (a === 1 ? ")" : ", " + a + ")") + ); + }, + } + ) + ); + /* From FvD 13.37, CSS Color Module Level 3 */ + + function hsl2rgb(h, m1, m2) { + return ( + (h < 60 + ? m1 + ((m2 - m1) * h) / 60 + : h < 180 + ? m2 + : h < 240 + ? m1 + ((m2 - m1) * (240 - h)) / 60 + : m1) * 255 + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-color/src/cubehelix.js": + /* !************************************************!*\ + !*** ./node_modules/d3-color/src/cubehelix.js ***! + \************************************************/ + /* ! exports provided: default, Cubehelix */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return cubehelix; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Cubehelix", + function () { + return Cubehelix; + } + ); + /* Harmony import */ var _define_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./define.js */ "./node_modules/d3-color/src/define.js" + ); + /* Harmony import */ var _color_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./color.js */ "./node_modules/d3-color/src/color.js" + ); + /* Harmony import */ var _math_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./math.js */ "./node_modules/d3-color/src/math.js" + ); + + var A = -0.14861, + B = +1.78277, + C = -0.29227, + D = -0.90649, + E = +1.97294, + ED = E * D, + EB = E * B, + BC_DA = B * C - D * A; + + function cubehelixConvert(o) { + if (o instanceof Cubehelix) + return new Cubehelix(o.h, o.s, o.l, o.opacity); + if ( + !( + o instanceof + _color_js__WEBPACK_IMPORTED_MODULE_1__.Rgb + ) + ) + o = Object( + _color_js__WEBPACK_IMPORTED_MODULE_1__.rgbConvert + )(o); + var r = o.r / 255, + g = o.g / 255, + b = o.b / 255, + l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB), + bl = b - l, + k = (E * (g - l) - C * bl) / D, + s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), + // NaN if l=0 or l=1 + h = s + ? Math.atan2(k, bl) * + _math_js__WEBPACK_IMPORTED_MODULE_2__.rad2deg - + 120 + : NaN; + return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity); + } + + function cubehelix(h, s, l, opacity) { + return arguments.length === 1 + ? cubehelixConvert(h) + : new Cubehelix(h, s, l, opacity == null ? 1 : opacity); + } + function Cubehelix(h, s, l, opacity) { + this.h = Number(h); + this.s = Number(s); + this.l = Number(l); + this.opacity = Number(opacity); + } + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.default)( + Cubehelix, + cubehelix, + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.extend)( + _color_js__WEBPACK_IMPORTED_MODULE_1__.Color, + { + brighter: function brighter(k) { + k = + k == null + ? _color_js__WEBPACK_IMPORTED_MODULE_1__.brighter + : Math.pow( + _color_js__WEBPACK_IMPORTED_MODULE_1__.brighter, + k + ); + return new Cubehelix( + this.h, + this.s, + this.l * k, + this.opacity + ); + }, + darker: function darker(k) { + k = + k == null + ? _color_js__WEBPACK_IMPORTED_MODULE_1__.darker + : Math.pow( + _color_js__WEBPACK_IMPORTED_MODULE_1__.darker, + k + ); + return new Cubehelix( + this.h, + this.s, + this.l * k, + this.opacity + ); + }, + rgb: function rgb() { + var h = isNaN(this.h) + ? 0 + : (this.h + 120) * + _math_js__WEBPACK_IMPORTED_MODULE_2__.deg2rad, + l = Number(this.l), + a = isNaN(this.s) ? 0 : this.s * l * (1 - l), + cosh = Math.cos(h), + sinh = Math.sin(h); + return new _color_js__WEBPACK_IMPORTED_MODULE_1__.Rgb( + 255 * (l + a * (A * cosh + B * sinh)), + 255 * (l + a * (C * cosh + D * sinh)), + 255 * (l + a * (E * cosh)), + this.opacity + ); + }, + } + ) + ); + + /***/ + }, + + /***/ "./node_modules/d3-color/src/define.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-color/src/define.js ***! + \*********************************************/ + /* ! exports provided: default, extend */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "extend", + function () { + return extend; + } + ); + /* Harmony default export */ __webpack_exports__.default = function (constructor, factory, prototype) { + constructor.prototype = factory.prototype = prototype; + prototype.constructor = constructor; + }; + function extend(parent, definition) { + var prototype = Object.create(parent.prototype); + + for (var key in definition) { + prototype[key] = definition[key]; + } + + return prototype; + } + + /***/ + }, + + /***/ "./node_modules/d3-color/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-color/src/index.js ***! + \********************************************/ + /* ! exports provided: color, rgb, hsl, lab, hcl, lch, gray, cubehelix */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _color_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./color.js */ "./node_modules/d3-color/src/color.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "color", + function () { + return _color_js__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "rgb", + function () { + return _color_js__WEBPACK_IMPORTED_MODULE_0__.rgb; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "hsl", + function () { + return _color_js__WEBPACK_IMPORTED_MODULE_0__.hsl; + } + ); + + /* Harmony import */ var _lab_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./lab.js */ "./node_modules/d3-color/src/lab.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "lab", + function () { + return _lab_js__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "hcl", + function () { + return _lab_js__WEBPACK_IMPORTED_MODULE_1__.hcl; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "lch", + function () { + return _lab_js__WEBPACK_IMPORTED_MODULE_1__.lch; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "gray", + function () { + return _lab_js__WEBPACK_IMPORTED_MODULE_1__.gray; + } + ); + + /* Harmony import */ var _cubehelix_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./cubehelix.js */ "./node_modules/d3-color/src/cubehelix.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "cubehelix", + function () { + return _cubehelix_js__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-color/src/lab.js": + /* !******************************************!*\ + !*** ./node_modules/d3-color/src/lab.js ***! + \******************************************/ + /* ! exports provided: gray, default, Lab, lch, hcl, Hcl */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "gray", + function () { + return gray; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return lab; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Lab", + function () { + return Lab; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "lch", + function () { + return lch; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "hcl", + function () { + return hcl; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Hcl", + function () { + return Hcl; + } + ); + /* Harmony import */ var _define_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./define.js */ "./node_modules/d3-color/src/define.js" + ); + /* Harmony import */ var _color_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./color.js */ "./node_modules/d3-color/src/color.js" + ); + /* Harmony import */ var _math_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./math.js */ "./node_modules/d3-color/src/math.js" + ); + + // https://observablehq.com/@mbostock/lab-and-rgb + + var K = 18, + Xn = 0.96422, + Yn = 1, + Zn = 0.82521, + t0 = 4 / 29, + t1 = 6 / 29, + t2 = 3 * t1 * t1, + t3 = t1 * t1 * t1; + + function labConvert(o) { + if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity); + if (o instanceof Hcl) return hcl2lab(o); + if ( + !( + o instanceof + _color_js__WEBPACK_IMPORTED_MODULE_1__.Rgb + ) + ) + o = Object( + _color_js__WEBPACK_IMPORTED_MODULE_1__.rgbConvert + )(o); + var r = rgb2lrgb(o.r), + g = rgb2lrgb(o.g), + b = rgb2lrgb(o.b), + y = xyz2lab( + (0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn + ), + x, + z; + if (r === g && g === b) x = z = y; + else { + x = xyz2lab( + (0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / Xn + ); + z = xyz2lab( + (0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / Zn + ); + } + return new Lab( + 116 * y - 16, + 500 * (x - y), + 200 * (y - z), + o.opacity + ); + } + + function gray(l, opacity) { + return new Lab(l, 0, 0, opacity == null ? 1 : opacity); + } + function lab(l, a, b, opacity) { + return arguments.length === 1 + ? labConvert(l) + : new Lab(l, a, b, opacity == null ? 1 : opacity); + } + function Lab(l, a, b, opacity) { + this.l = Number(l); + this.a = Number(a); + this.b = Number(b); + this.opacity = Number(opacity); + } + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.default)( + Lab, + lab, + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.extend)( + _color_js__WEBPACK_IMPORTED_MODULE_1__.Color, + { + brighter: function brighter(k) { + return new Lab( + this.l + K * (k == null ? 1 : k), + this.a, + this.b, + this.opacity + ); + }, + darker: function darker(k) { + return new Lab( + this.l - K * (k == null ? 1 : k), + this.a, + this.b, + this.opacity + ); + }, + rgb: function rgb() { + var y = (this.l + 16) / 116, + x = isNaN(this.a) ? y : y + this.a / 500, + z = isNaN(this.b) ? y : y - this.b / 200; + x = Xn * lab2xyz(x); + y = Yn * lab2xyz(y); + z = Zn * lab2xyz(z); + return new _color_js__WEBPACK_IMPORTED_MODULE_1__.Rgb( + lrgb2rgb( + 3.1338561 * x - + 1.6168667 * y - + 0.4906146 * z + ), + lrgb2rgb( + -0.9787684 * x + + 1.9161415 * y + + 0.033454 * z + ), + lrgb2rgb( + 0.0719453 * x - + 0.2289914 * y + + 1.4052427 * z + ), + this.opacity + ); + }, + } + ) + ); + + function xyz2lab(t) { + return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0; + } + + function lab2xyz(t) { + return t > t1 ? t * t * t : t2 * (t - t0); + } + + function lrgb2rgb(x) { + return ( + 255 * + (x <= 0.0031308 + ? 12.92 * x + : 1.055 * Math.pow(x, 1 / 2.4) - 0.055) + ); + } + + function rgb2lrgb(x) { + return (x /= 255) <= 0.04045 + ? x / 12.92 + : Math.pow((x + 0.055) / 1.055, 2.4); + } + + function hclConvert(o) { + if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity); + if (!(o instanceof Lab)) o = labConvert(o); + if (o.a === 0 && o.b === 0) + return new Hcl( + NaN, + o.l > 0 && o.l < 100 ? 0 : NaN, + o.l, + o.opacity + ); + var h = + Math.atan2(o.b, o.a) * + _math_js__WEBPACK_IMPORTED_MODULE_2__.rad2deg; + return new Hcl( + h < 0 ? h + 360 : h, + Math.sqrt(o.a * o.a + o.b * o.b), + o.l, + o.opacity + ); + } + + function lch(l, c, h, opacity) { + return arguments.length === 1 + ? hclConvert(l) + : new Hcl(h, c, l, opacity == null ? 1 : opacity); + } + function hcl(h, c, l, opacity) { + return arguments.length === 1 + ? hclConvert(h) + : new Hcl(h, c, l, opacity == null ? 1 : opacity); + } + function Hcl(h, c, l, opacity) { + this.h = Number(h); + this.c = Number(c); + this.l = Number(l); + this.opacity = Number(opacity); + } + + function hcl2lab(o) { + if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity); + var h = o.h * _math_js__WEBPACK_IMPORTED_MODULE_2__.deg2rad; + return new Lab( + o.l, + Math.cos(h) * o.c, + Math.sin(h) * o.c, + o.opacity + ); + } + + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.default)( + Hcl, + hcl, + Object(_define_js__WEBPACK_IMPORTED_MODULE_0__.extend)( + _color_js__WEBPACK_IMPORTED_MODULE_1__.Color, + { + brighter: function brighter(k) { + return new Hcl( + this.h, + this.c, + this.l + K * (k == null ? 1 : k), + this.opacity + ); + }, + darker: function darker(k) { + return new Hcl( + this.h, + this.c, + this.l - K * (k == null ? 1 : k), + this.opacity + ); + }, + rgb: function rgb() { + return hcl2lab(this).rgb(); + }, + } + ) + ); + + /***/ + }, + + /***/ "./node_modules/d3-color/src/math.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-color/src/math.js ***! + \*******************************************/ + /* ! exports provided: deg2rad, rad2deg */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "deg2rad", + function () { + return deg2rad; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "rad2deg", + function () { + return rad2deg; + } + ); + var deg2rad = Math.PI / 180; + var rad2deg = 180 / Math.PI; + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/area.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-contour/src/area.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (ring) { + var i = 0, + n = ring.length, + area = + ring[n - 1][1] * ring[0][0] - + ring[n - 1][0] * ring[0][1]; + + while (++i < n) { + area += + ring[i - 1][1] * ring[i][0] - + ring[i - 1][0] * ring[i][1]; + } + + return area; + }; + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/array.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-contour/src/array.js ***! + \**********************************************/ + /* ! exports provided: slice */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "slice", + function () { + return slice; + } + ); + var array = Array.prototype; + var slice = array.slice; + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/ascending.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-contour/src/ascending.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + return a - b; + }; + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/blur.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-contour/src/blur.js ***! + \*********************************************/ + /* ! exports provided: blurX, blurY */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "blurX", + function () { + return blurX; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "blurY", + function () { + return blurY; + } + ); + // TODO Optimize edge cases. + // TODO Optimize index calculation. + // TODO Optimize arguments. + function blurX(source, target, r) { + var n = source.width, + m = source.height, + w = (r << 1) + 1; + + for (var j = 0; j < m; ++j) { + for (var i = 0, sr = 0; i < n + r; ++i) { + if (i < n) { + sr += source.data[i + j * n]; + } + + if (i >= r) { + if (i >= w) { + sr -= source.data[i - w + j * n]; + } + + target.data[i - r + j * n] = + sr / Math.min(i + 1, n - 1 + w - i, w); + } + } + } + } // TODO Optimize edge cases. + // TODO Optimize index calculation. + // TODO Optimize arguments. + + function blurY(source, target, r) { + var n = source.width, + m = source.height, + w = (r << 1) + 1; + + for (var i = 0; i < n; ++i) { + for (var j = 0, sr = 0; j < m + r; ++j) { + if (j < m) { + sr += source.data[i + j * n]; + } + + if (j >= r) { + if (j >= w) { + sr -= source.data[i + (j - w) * n]; + } + + target.data[i + (j - r) * n] = + sr / Math.min(j + 1, m - 1 + w - j, w); + } + } + } + } + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/constant.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-contour/src/constant.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/contains.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-contour/src/contains.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (ring, hole) { + var i = -1, + n = hole.length, + c; + + while (++i < n) { + if ((c = ringContains(ring, hole[i]))) return c; + } + + return 0; + }; + + function ringContains(ring, point) { + var x = point[0], + y = point[1], + contains = -1; + + for (var i = 0, n = ring.length, j = n - 1; i < n; j = i++) { + var pi = ring[i], + xi = pi[0], + yi = pi[1], + pj = ring[j], + xj = pj[0], + yj = pj[1]; + if (segmentContains(pi, pj, point)) return 0; + if ( + yi > y !== yj > y && + x < ((xj - xi) * (y - yi)) / (yj - yi) + xi + ) + contains = -contains; + } + + return contains; + } + + function segmentContains(a, b, c) { + var i; + return ( + collinear(a, b, c) && + within(a[(i = Number(a[0] === b[0]))], c[i], b[i]) + ); + } + + function collinear(a, b, c) { + return ( + (b[0] - a[0]) * (c[1] - a[1]) === + (c[0] - a[0]) * (b[1] - a[1]) + ); + } + + function within(p, q, r) { + return (p <= q && q <= r) || (r <= q && q <= p); + } + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/contours.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-contour/src/contours.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-contour/src/array.js" + ); + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./ascending */ "./node_modules/d3-contour/src/ascending.js" + ); + /* Harmony import */ var _area__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./area */ "./node_modules/d3-contour/src/area.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-contour/src/constant.js" + ); + /* Harmony import */ var _contains__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./contains */ "./node_modules/d3-contour/src/contains.js" + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./noop */ "./node_modules/d3-contour/src/noop.js" + ); + + var cases = [ + [], + [ + [ + [1.0, 1.5], + [0.5, 1.0], + ], + ], + [ + [ + [1.5, 1.0], + [1.0, 1.5], + ], + ], + [ + [ + [1.5, 1.0], + [0.5, 1.0], + ], + ], + [ + [ + [1.0, 0.5], + [1.5, 1.0], + ], + ], + [ + [ + [1.0, 1.5], + [0.5, 1.0], + ], + [ + [1.0, 0.5], + [1.5, 1.0], + ], + ], + [ + [ + [1.0, 0.5], + [1.0, 1.5], + ], + ], + [ + [ + [1.0, 0.5], + [0.5, 1.0], + ], + ], + [ + [ + [0.5, 1.0], + [1.0, 0.5], + ], + ], + [ + [ + [1.0, 1.5], + [1.0, 0.5], + ], + ], + [ + [ + [0.5, 1.0], + [1.0, 0.5], + ], + [ + [1.5, 1.0], + [1.0, 1.5], + ], + ], + [ + [ + [1.5, 1.0], + [1.0, 0.5], + ], + ], + [ + [ + [0.5, 1.0], + [1.5, 1.0], + ], + ], + [ + [ + [1.0, 1.5], + [1.5, 1.0], + ], + ], + [ + [ + [0.5, 1.0], + [1.0, 1.5], + ], + ], + [], + ]; + /* Harmony default export */ __webpack_exports__.default = function () { + var dx = 1, + dy = 1, + threshold = + d3_array__WEBPACK_IMPORTED_MODULE_0__.thresholdSturges, + smooth = smoothLinear; + + function contours(values) { + var tz = threshold(values); // Convert number of thresholds into uniform thresholds. + + if (!Array.isArray(tz)) { + var domain = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.extent + )(values), + start = domain[0], + stop = domain[1]; + tz = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.tickStep + )(start, stop, tz); + tz = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )( + Math.floor(start / tz) * tz, + Math.floor(stop / tz) * tz, + tz + ); + } else { + tz = tz + .slice() + .sort( + _ascending__WEBPACK_IMPORTED_MODULE_2__.default + ); + } + + return tz.map(function (value) { + return contour(values, value); + }); + } // Accumulate, smooth contour rings, assign holes to exterior rings. + // Based on https://github.com/mbostock/shapefile/blob/v0.6.2/shp/polygon.js + + function contour(values, value) { + var polygons = [], + holes = []; + isorings(values, value, function (ring) { + smooth(ring, values, value); + if ( + Object( + _area__WEBPACK_IMPORTED_MODULE_3__.default + )(ring) > 0 + ) + polygons.push([ring]); + else holes.push(ring); + }); + holes.forEach(function (hole) { + for ( + var i = 0, n = polygons.length, polygon; + i < n; + ++i + ) { + if ( + Object( + _contains__WEBPACK_IMPORTED_MODULE_5__.default + )((polygon = polygons[i])[0], hole) !== -1 + ) { + polygon.push(hole); + return; + } + } + }); + return { + type: "MultiPolygon", + value: value, + coordinates: polygons, + }; + } // Marching squares with isolines stitched into rings. + // Based on https://github.com/topojson/topojson-client/blob/v3.0.0/src/stitch.js + + function isorings(values, value, callback) { + var fragmentByStart = new Array(), + fragmentByEnd = new Array(), + x, + y, + t0, + t1, + t2, + t3; // Special case for the first row (y = -1, t2 = t3 = 0). + + x = y = -1; + t1 = values[0] >= value; + cases[t1 << 1].forEach(stitch); + + while (++x < dx - 1) { + (t0 = t1), (t1 = values[x + 1] >= value); + cases[t0 | (t1 << 1)].forEach(stitch); + } + + cases[t1 << 0].forEach(stitch); // General case for the intermediate rows. + + while (++y < dy - 1) { + x = -1; + t1 = values[y * dx + dx] >= value; + t2 = values[y * dx] >= value; + cases[(t1 << 1) | (t2 << 2)].forEach(stitch); + + while (++x < dx - 1) { + (t0 = t1), + (t1 = values[y * dx + dx + x + 1] >= value); + (t3 = t2), (t2 = values[y * dx + x + 1] >= value); + cases[ + t0 | (t1 << 1) | (t2 << 2) | (t3 << 3) + ].forEach(stitch); + } + + cases[t1 | (t2 << 3)].forEach(stitch); + } // Special case for the last row (y = dy - 1, t0 = t1 = 0). + + x = -1; + t2 = values[y * dx] >= value; + cases[t2 << 2].forEach(stitch); + + while (++x < dx - 1) { + (t3 = t2), (t2 = values[y * dx + x + 1] >= value); + cases[(t2 << 2) | (t3 << 3)].forEach(stitch); + } + + cases[t2 << 3].forEach(stitch); + + function stitch(line) { + var start = [line[0][0] + x, line[0][1] + y], + end = [line[1][0] + x, line[1][1] + y], + startIndex = index(start), + endIndex = index(end), + f, + g; + + if ((f = fragmentByEnd[startIndex])) { + if ((g = fragmentByStart[endIndex])) { + delete fragmentByEnd[f.end]; + delete fragmentByStart[g.start]; + + if (f === g) { + f.ring.push(end); + callback(f.ring); + } else { + fragmentByStart[f.start] = fragmentByEnd[ + g.end + ] = { + start: f.start, + end: g.end, + ring: f.ring.concat(g.ring), + }; + } + } else { + delete fragmentByEnd[f.end]; + f.ring.push(end); + fragmentByEnd[(f.end = endIndex)] = f; + } + } else if ((f = fragmentByStart[endIndex])) { + if ((g = fragmentByEnd[startIndex])) { + delete fragmentByStart[f.start]; + delete fragmentByEnd[g.end]; + + if (f === g) { + f.ring.push(end); + callback(f.ring); + } else { + fragmentByStart[g.start] = fragmentByEnd[ + f.end + ] = { + start: g.start, + end: f.end, + ring: g.ring.concat(f.ring), + }; + } + } else { + delete fragmentByStart[f.start]; + f.ring.unshift(start); + fragmentByStart[(f.start = startIndex)] = f; + } + } else { + fragmentByStart[startIndex] = fragmentByEnd[ + endIndex + ] = { + start: startIndex, + end: endIndex, + ring: [start, end], + }; + } + } + } + + function index(point) { + return point[0] * 2 + point[1] * (dx + 1) * 4; + } + + function smoothLinear(ring, values, value) { + ring.forEach(function (point) { + var x = point[0], + y = point[1], + xt = x | 0, + yt = y | 0, + v0, + v1 = values[yt * dx + xt]; + + if (x > 0 && x < dx && xt === x) { + v0 = values[yt * dx + xt - 1]; + point[0] = x + (value - v0) / (v1 - v0) - 0.5; + } + + if (y > 0 && y < dy && yt === y) { + v0 = values[(yt - 1) * dx + xt]; + point[1] = y + (value - v0) / (v1 - v0) - 0.5; + } + }); + } + + contours.contour = contour; + + contours.size = function (_) { + if (!arguments.length) return [dx, dy]; + + var _0 = Math.ceil(_[0]), + _1 = Math.ceil(_[1]); + + if (!(_0 > 0) || !(_1 > 0)) throw new Error("invalid size"); + return (dx = _0), (dy = _1), contours; + }; + + contours.thresholds = function (_) { + return arguments.length + ? ((threshold = + typeof _ === "function" + ? _ + : Array.isArray(_) + ? Object( + _constant__WEBPACK_IMPORTED_MODULE_4__.default + )( + _array__WEBPACK_IMPORTED_MODULE_1__.slice.call(_) + ) + : Object( + _constant__WEBPACK_IMPORTED_MODULE_4__.default + )(_)), + contours) + : threshold; + }; + + contours.smooth = function (_) { + return arguments.length + ? ((smooth = _ + ? smoothLinear + : _noop__WEBPACK_IMPORTED_MODULE_6__.default), + contours) + : smooth === smoothLinear; + }; + + return contours; + }; + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/density.js": + /* !************************************************!*\ + !*** ./node_modules/d3-contour/src/density.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-contour/src/array.js" + ); + /* Harmony import */ var _blur__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./blur */ "./node_modules/d3-contour/src/blur.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-contour/src/constant.js" + ); + /* Harmony import */ var _contours__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./contours */ "./node_modules/d3-contour/src/contours.js" + ); + + function defaultX(d) { + return d[0]; + } + + function defaultY(d) { + return d[1]; + } + + function defaultWeight() { + return 1; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var x = defaultX, + y = defaultY, + weight = defaultWeight, + dx = 960, + dy = 500, + r = 20, + // Blur radius + k = 2, + // Log2(grid cell size) + o = r * 3, + // Grid offset, to pad for blur + n = (dx + o * 2) >> k, + // Grid width + m = (dy + o * 2) >> k, + // Grid height + threshold = Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(20); + + function density(data) { + var values0 = new Float32Array(n * m), + values1 = new Float32Array(n * m); + data.forEach(function (d, i, data) { + var xi = (Number(x(d, i, data)) + o) >> k, + yi = (Number(y(d, i, data)) + o) >> k, + wi = Number(weight(d, i, data)); + + if (xi >= 0 && xi < n && yi >= 0 && yi < m) { + values0[xi + yi * n] += wi; + } + }); // TODO Optimize. + + Object(_blur__WEBPACK_IMPORTED_MODULE_2__.blurX)( + { + width: n, + height: m, + data: values0, + }, + { + width: n, + height: m, + data: values1, + }, + r >> k + ); + Object(_blur__WEBPACK_IMPORTED_MODULE_2__.blurY)( + { + width: n, + height: m, + data: values1, + }, + { + width: n, + height: m, + data: values0, + }, + r >> k + ); + Object(_blur__WEBPACK_IMPORTED_MODULE_2__.blurX)( + { + width: n, + height: m, + data: values0, + }, + { + width: n, + height: m, + data: values1, + }, + r >> k + ); + Object(_blur__WEBPACK_IMPORTED_MODULE_2__.blurY)( + { + width: n, + height: m, + data: values1, + }, + { + width: n, + height: m, + data: values0, + }, + r >> k + ); + Object(_blur__WEBPACK_IMPORTED_MODULE_2__.blurX)( + { + width: n, + height: m, + data: values0, + }, + { + width: n, + height: m, + data: values1, + }, + r >> k + ); + Object(_blur__WEBPACK_IMPORTED_MODULE_2__.blurY)( + { + width: n, + height: m, + data: values1, + }, + { + width: n, + height: m, + data: values0, + }, + r >> k + ); + var tz = threshold(values0); // Convert number of thresholds into uniform thresholds. + + if (!Array.isArray(tz)) { + var stop = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.max + )(values0); + tz = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.tickStep + )(0, stop, tz); + tz = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )(0, Math.floor(stop / tz) * tz, tz); + tz.shift(); + } + + return Object( + _contours__WEBPACK_IMPORTED_MODULE_4__.default + )() + .thresholds(tz) + .size([n, m])(values0) + .map(transform); + } + + function transform(geometry) { + geometry.value *= Math.pow(2, -2 * k); // Density in points per square pixel. + + geometry.coordinates.forEach(transformPolygon); + return geometry; + } + + function transformPolygon(coordinates) { + coordinates.forEach(transformRing); + } + + function transformRing(coordinates) { + coordinates.forEach(transformPoint); + } // TODO Optimize. + + function transformPoint(coordinates) { + coordinates[0] = coordinates[0] * Math.pow(2, k) - o; + coordinates[1] = coordinates[1] * Math.pow(2, k) - o; + } + + function resize() { + o = r * 3; + n = (dx + o * 2) >> k; + m = (dy + o * 2) >> k; + return density; + } + + density.x = function (_) { + return arguments.length + ? ((x = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(Number(_))), + density) + : x; + }; + + density.y = function (_) { + return arguments.length + ? ((y = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(Number(_))), + density) + : y; + }; + + density.weight = function (_) { + return arguments.length + ? ((weight = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(Number(_))), + density) + : weight; + }; + + density.size = function (_) { + if (!arguments.length) return [dx, dy]; + + var _0 = Math.ceil(_[0]), + _1 = Math.ceil(_[1]); + + if (!(_0 >= 0) && !(_0 >= 0)) + throw new Error("invalid size"); + return (dx = _0), (dy = _1), resize(); + }; + + density.cellSize = function (_) { + if (!arguments.length) return 1 << k; + if (!((_ = Number(_)) >= 1)) throw new Error("invalid cell size"); + return (k = Math.floor(Math.log(_) / Math.LN2)), resize(); + }; + + density.thresholds = function (_) { + return arguments.length + ? ((threshold = + typeof _ === "function" + ? _ + : Array.isArray(_) + ? Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )( + _array__WEBPACK_IMPORTED_MODULE_1__.slice.call(_) + ) + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(_)), + density) + : threshold; + }; + + density.bandwidth = function (_) { + if (!arguments.length) return Math.sqrt(r * (r + 1)); + if (!((_ = Number(_)) >= 0)) throw new Error("invalid bandwidth"); + return ( + (r = Math.round((Math.sqrt(4 * _ * _ + 1) - 1) / 2)), + resize() + ); + }; + + return density; + }; + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/index.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-contour/src/index.js ***! + \**********************************************/ + /* ! exports provided: contours, contourDensity */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _contours__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./contours */ "./node_modules/d3-contour/src/contours.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "contours", + function () { + return _contours__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _density__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./density */ "./node_modules/d3-contour/src/density.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "contourDensity", + function () { + return _density__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-contour/src/noop.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-contour/src/noop.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () {}; + + /***/ + }, + + /***/ "./node_modules/d3-dispatch/src/dispatch.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-dispatch/src/dispatch.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + var noop = { + value: function value() {}, + }; + + function dispatch() { + for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) { + if (!(t = String(arguments[i])) || t in _) + throw new Error("illegal type: " + t); + _[t] = []; + } + + return new Dispatch(_); + } + + function Dispatch(_) { + this._ = _; + } + + function parseTypenames(typenames, types) { + return typenames + .trim() + .split(/^|\s+/) + .map(function (t) { + var name = "", + i = t.indexOf("."); + if (i >= 0) + (name = t.slice(i + 1)), (t = t.slice(0, i)); + if (t && !types.hasOwnProperty(t)) + throw new Error("unknown type: " + t); + return { + type: t, + name: name, + }; + }); + } + + Dispatch.prototype = dispatch.prototype = { + constructor: Dispatch, + on: function on(typename, callback) { + var _ = this._, + T = parseTypenames(String(typename), _), + t, + i = -1, + n = T.length; // If no callback was specified, return the callback of the given type and name. + + if (arguments.length < 2) { + while (++i < n) { + if ( + (t = (typename = T[i]).type) && + (t = get(_[t], typename.name)) + ) + return t; + } + + return; + } // If a type was specified, set the callback for the given type and name. + // Otherwise, if a null callback was specified, remove callbacks of the given name. + + if (callback != null && typeof callback !== "function") + throw new Error("invalid callback: " + callback); + + while (++i < n) { + if ((t = (typename = T[i]).type)) + _[t] = set(_[t], typename.name, callback); + else if (callback == null) + for (t in _) { + _[t] = set(_[t], typename.name, null); + } + } + + return this; + }, + copy: function copy() { + var copy = {}, + _ = this._; + + for (var t in _) { + copy[t] = _[t].slice(); + } + + return new Dispatch(copy); + }, + call: function call(type, that) { + if ((n = arguments.length - 2) > 0) + for (var args = new Array(n), i = 0, n, t; i < n; ++i) { + args[i] = arguments[i + 2]; + } + if (!this._.hasOwnProperty(type)) + throw new Error("unknown type: " + type); + + for (t = this._[type], i = 0, n = t.length; i < n; ++i) { + t[i].value.apply(that, args); + } + }, + apply: function apply(type, that, args) { + if (!this._.hasOwnProperty(type)) + throw new Error("unknown type: " + type); + + for ( + var t = this._[type], i = 0, n = t.length; + i < n; + ++i + ) { + t[i].value.apply(that, args); + } + }, + }; + + function get(type, name) { + for (var i = 0, n = type.length, c; i < n; ++i) { + if ((c = type[i]).name === name) { + return c.value; + } + } + } + + function set(type, name, callback) { + for (var i = 0, n = type.length; i < n; ++i) { + if (type[i].name === name) { + (type[i] = noop), + (type = type.slice(0, i).concat(type.slice(i + 1))); + break; + } + } + + if (callback != null) + type.push({ + name: name, + value: callback, + }); + return type; + } + + /* Harmony default export */ __webpack_exports__.default = dispatch; + + /***/ + }, + + /***/ "./node_modules/d3-dispatch/src/index.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-dispatch/src/index.js ***! + \***********************************************/ + /* ! exports provided: dispatch */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./dispatch */ "./node_modules/d3-dispatch/src/dispatch.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dispatch", + function () { + return _dispatch__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-drag/src/constant.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-drag/src/constant.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-drag/src/drag.js": + /* !******************************************!*\ + !*** ./node_modules/d3-drag/src/drag.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js" + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _nodrag_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./nodrag.js */ "./node_modules/d3-drag/src/nodrag.js" + ); + /* Harmony import */ var _noevent_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./noevent.js */ "./node_modules/d3-drag/src/noevent.js" + ); + /* Harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./constant.js */ "./node_modules/d3-drag/src/constant.js" + ); + /* Harmony import */ var _event_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./event.js */ "./node_modules/d3-drag/src/event.js" + ); + + // Ignore right-click, since that should open the context menu. + + function defaultFilter() { + return ( + !d3_selection__WEBPACK_IMPORTED_MODULE_1__.event + .ctrlKey && + !d3_selection__WEBPACK_IMPORTED_MODULE_1__.event.button + ); + } + + function defaultContainer() { + return this.parentNode; + } + + function defaultSubject(d) { + return d == null + ? { + x: + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event + .x, + y: + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event + .y, + } + : d; + } + + function defaultTouchable() { + return navigator.maxTouchPoints || "ontouchstart" in this; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var filter = defaultFilter, + container = defaultContainer, + subject = defaultSubject, + touchable = defaultTouchable, + gestures = {}, + listeners = Object( + d3_dispatch__WEBPACK_IMPORTED_MODULE_0__.dispatch + )("start", "drag", "end"), + active = 0, + mousedownx, + mousedowny, + mousemoving, + touchending, + clickDistance2 = 0; + + function drag(selection) { + selection + .on("mousedown.drag", mousedowned) + .filter(touchable) + .on("touchstart.drag", touchstarted) + .on("touchmove.drag", touchmoved) + .on("touchend.drag touchcancel.drag", touchended) + .style("touch-action", "none") + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); + } + + function mousedowned() { + if (touchending || !filter.apply(this, arguments)) return; + var gesture = beforestart( + "mouse", + container.apply(this, arguments), + d3_selection__WEBPACK_IMPORTED_MODULE_1__.mouse, + this, + arguments + ); + if (!gesture) return; + Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__.select)( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event.view + ) + .on("mousemove.drag", mousemoved, true) + .on("mouseup.drag", mouseupped, true); + Object(_nodrag_js__WEBPACK_IMPORTED_MODULE_2__.default)( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event.view + ); + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_3__.nopropagation + )(); + mousemoving = false; + mousedownx = + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event + .clientX; + mousedowny = + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event + .clientY; + gesture("start"); + } + + function mousemoved() { + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_3__.default + )(); + + if (!mousemoving) { + var dx = + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event.clientX - mousedownx, + dy = + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event.clientY - mousedowny; + mousemoving = dx * dx + dy * dy > clickDistance2; + } + + gestures.mouse("drag"); + } + + function mouseupped() { + Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__.select)( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event.view + ).on("mousemove.drag mouseup.drag", null); + Object(_nodrag_js__WEBPACK_IMPORTED_MODULE_2__.yesdrag)( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event.view, + mousemoving + ); + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_3__.default + )(); + gestures.mouse("end"); + } + + function touchstarted() { + if (!filter.apply(this, arguments)) return; + var touches = + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event + .changedTouches, + c = container.apply(this, arguments), + n = touches.length, + i, + gesture; + + for (i = 0; i < n; ++i) { + if ( + (gesture = beforestart( + touches[i].identifier, + c, + d3_selection__WEBPACK_IMPORTED_MODULE_1__.touch, + this, + arguments + )) + ) { + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_3__.nopropagation + )(); + gesture("start"); + } + } + } + + function touchmoved() { + var touches = + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event + .changedTouches, + n = touches.length, + i, + gesture; + + for (i = 0; i < n; ++i) { + if ((gesture = gestures[touches[i].identifier])) { + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_3__.default + )(); + gesture("drag"); + } + } + } + + function touchended() { + var touches = + d3_selection__WEBPACK_IMPORTED_MODULE_1__.event + .changedTouches, + n = touches.length, + i, + gesture; + if (touchending) clearTimeout(touchending); + touchending = setTimeout(function () { + touchending = null; + }, 500); // Ghost clicks are delayed! + + for (i = 0; i < n; ++i) { + if ((gesture = gestures[touches[i].identifier])) { + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_3__.nopropagation + )(); + gesture("end"); + } + } + } + + function beforestart(id, container, point, that, args) { + var p = point(container, id), + s, + dx, + dy, + sublisteners = listeners.copy(); + if ( + !Object( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.customEvent + )( + new _event_js__WEBPACK_IMPORTED_MODULE_5__.default( + drag, + "beforestart", + s, + id, + active, + p[0], + p[1], + 0, + 0, + sublisteners + ), + function () { + if ( + (d3_selection__WEBPACK_IMPORTED_MODULE_1__.event.subject = s = subject.apply( + that, + args + )) == null + ) + return false; + dx = s.x - p[0] || 0; + dy = s.y - p[1] || 0; + return true; + } + ) + ) + return; + return function gesture(type) { + var p0 = p, + n; + + switch (type) { + case "start": + (gestures[id] = gesture), (n = active++); + break; + + case "end": + delete gestures[id], --active; + // Nobreak + + case "drag": + (p = point(container, id)), (n = active); + break; + } + + Object( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.customEvent + )( + new _event_js__WEBPACK_IMPORTED_MODULE_5__.default( + drag, + type, + s, + id, + n, + p[0] + dx, + p[1] + dy, + p[0] - p0[0], + p[1] - p0[1], + sublisteners + ), + sublisteners.apply, + sublisteners, + [type, that, args] + ); + }; + } + + drag.filter = function (_) { + return arguments.length + ? ((filter = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_4__.default + )(Boolean(_))), + drag) + : filter; + }; + + drag.container = function (_) { + return arguments.length + ? ((container = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_4__.default + )(_)), + drag) + : container; + }; + + drag.subject = function (_) { + return arguments.length + ? ((subject = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_4__.default + )(_)), + drag) + : subject; + }; + + drag.touchable = function (_) { + return arguments.length + ? ((touchable = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_4__.default + )(Boolean(_))), + drag) + : touchable; + }; + + drag.on = function () { + var value = listeners.on.apply(listeners, arguments); + return value === listeners ? drag : value; + }; + + drag.clickDistance = function (_) { + return arguments.length + ? ((clickDistance2 = (_ = Number(_)) * _), drag) + : Math.sqrt(clickDistance2); + }; + + return drag; + }; + + /***/ + }, + + /***/ "./node_modules/d3-drag/src/event.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-drag/src/event.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return DragEvent; + } + ); + function DragEvent( + target, + type, + subject, + id, + active, + x, + y, + dx, + dy, + dispatch + ) { + this.target = target; + this.type = type; + this.subject = subject; + this.identifier = id; + this.active = active; + this.x = x; + this.y = y; + this.dx = dx; + this.dy = dy; + this._ = dispatch; + } + + DragEvent.prototype.on = function () { + var value = this._.on.apply(this._, arguments); + + return value === this._ ? this : value; + }; + + /***/ + }, + + /***/ "./node_modules/d3-drag/src/index.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-drag/src/index.js ***! + \*******************************************/ + /* ! exports provided: drag, dragDisable, dragEnable */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _drag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./drag.js */ "./node_modules/d3-drag/src/drag.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "drag", + function () { + return _drag_js__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _nodrag_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./nodrag.js */ "./node_modules/d3-drag/src/nodrag.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dragDisable", + function () { + return _nodrag_js__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dragEnable", + function () { + return _nodrag_js__WEBPACK_IMPORTED_MODULE_1__.yesdrag; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-drag/src/nodrag.js": + /* !********************************************!*\ + !*** ./node_modules/d3-drag/src/nodrag.js ***! + \********************************************/ + /* ! exports provided: default, yesdrag */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "yesdrag", + function () { + return yesdrag; + } + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _noevent_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./noevent.js */ "./node_modules/d3-drag/src/noevent.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (view) { + var root = view.document.documentElement, + selection = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_0__.select + )(view).on( + "dragstart.drag", + _noevent_js__WEBPACK_IMPORTED_MODULE_1__.default, + true + ); + + if ("onselectstart" in root) { + selection.on( + "selectstart.drag", + _noevent_js__WEBPACK_IMPORTED_MODULE_1__.default, + true + ); + } else { + root.__noselect = root.style.MozUserSelect; + root.style.MozUserSelect = "none"; + } + }; + function yesdrag(view, noclick) { + var root = view.document.documentElement, + selection = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_0__.select + )(view).on("dragstart.drag", null); + + if (noclick) { + selection.on( + "click.drag", + _noevent_js__WEBPACK_IMPORTED_MODULE_1__.default, + true + ); + setTimeout(function () { + selection.on("click.drag", null); + }, 0); + } + + if ("onselectstart" in root) { + selection.on("selectstart.drag", null); + } else { + root.style.MozUserSelect = root.__noselect; + delete root.__noselect; + } + } + + /***/ + }, + + /***/ "./node_modules/d3-drag/src/noevent.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-drag/src/noevent.js ***! + \*********************************************/ + /* ! exports provided: nopropagation, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "nopropagation", + function () { + return nopropagation; + } + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + + function nopropagation() { + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.stopImmediatePropagation(); + } + /* Harmony default export */ __webpack_exports__.default = function () { + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.preventDefault(); + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.stopImmediatePropagation(); + }; + + /***/ + }, + + /***/ "./node_modules/d3-dsv/src/autoType.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-dsv/src/autoType.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return autoType; + } + ); + function autoType(object) { + for (var key in object) { + var value = object[key].trim(), + number; + if (!value) value = null; + else if (value === "true") value = true; + else if (value === "false") value = false; + else if (value === "NaN") value = NaN; + else if (!isNaN((number = Number(value)))) value = number; + else if ( + /^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/.test( + value + ) + ) + value = new Date(value); + else continue; + object[key] = value; + } + + return object; + } + + /***/ + }, + + /***/ "./node_modules/d3-dsv/src/csv.js": + /* !****************************************!*\ + !*** ./node_modules/d3-dsv/src/csv.js ***! + \****************************************/ + /* ! exports provided: csvParse, csvParseRows, csvFormat, csvFormatBody, csvFormatRows */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "csvParse", + function () { + return csvParse; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "csvParseRows", + function () { + return csvParseRows; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "csvFormat", + function () { + return csvFormat; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "csvFormatBody", + function () { + return csvFormatBody; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "csvFormatRows", + function () { + return csvFormatRows; + } + ); + /* Harmony import */ var _dsv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./dsv */ "./node_modules/d3-dsv/src/dsv.js" + ); + + var csv = Object(_dsv__WEBPACK_IMPORTED_MODULE_0__.default)(","); + var csvParse = csv.parse; + var csvParseRows = csv.parseRows; + var csvFormat = csv.format; + var csvFormatBody = csv.formatBody; + var csvFormatRows = csv.formatRows; + + /***/ + }, + + /***/ "./node_modules/d3-dsv/src/dsv.js": + /* !****************************************!*\ + !*** ./node_modules/d3-dsv/src/dsv.js ***! + \****************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + var EOL = {}, + EOF = {}, + QUOTE = 34, + NEWLINE = 10, + RETURN = 13; + + function objectConverter(columns) { + return new Function( + "d", + "return {" + + columns + .map(function (name, i) { + return JSON.stringify(name) + ": d[" + i + "]"; + }) + .join(",") + + "}" + ); + } + + function customConverter(columns, f) { + var object = objectConverter(columns); + return function (row, i) { + return f(object(row), i, columns); + }; + } // Compute unique columns in order of discovery. + + function inferColumns(rows) { + var columnSet = Object.create(null), + columns = []; + rows.forEach(function (row) { + for (var column in row) { + if (!(column in columnSet)) { + columns.push((columnSet[column] = column)); + } + } + }); + return columns; + } + + function pad(value, width) { + var s = String(value), + length = s.length; + return length < width + ? new Array(width - length + 1).join(0) + s + : s; + } + + function formatYear(year) { + return year < 0 + ? "-" + pad(-year, 6) + : year > 9999 + ? "+" + pad(year, 6) + : pad(year, 4); + } + + function formatDate(date) { + var hours = date.getUTCHours(), + minutes = date.getUTCMinutes(), + seconds = date.getUTCSeconds(), + milliseconds = date.getUTCMilliseconds(); + return isNaN(date) + ? "Invalid Date" + : formatYear(date.getUTCFullYear(), 4) + + "-" + + pad(date.getUTCMonth() + 1, 2) + + "-" + + pad(date.getUTCDate(), 2) + + (milliseconds + ? "T" + + pad(hours, 2) + + ":" + + pad(minutes, 2) + + ":" + + pad(seconds, 2) + + "." + + pad(milliseconds, 3) + + "Z" + : seconds + ? "T" + + pad(hours, 2) + + ":" + + pad(minutes, 2) + + ":" + + pad(seconds, 2) + + "Z" + : minutes || hours + ? "T" + + pad(hours, 2) + + ":" + + pad(minutes, 2) + + "Z" + : ""); + } + + /* Harmony default export */ __webpack_exports__.default = function (delimiter) { + var reFormat = new RegExp('["' + delimiter + "\n\r]"), + DELIMITER = delimiter.charCodeAt(0); + + function parse(text, f) { + var convert, + columns, + rows = parseRows(text, function (row, i) { + if (convert) return convert(row, i - 1); + (columns = row), + (convert = f + ? customConverter(row, f) + : objectConverter(row)); + }); + rows.columns = columns || []; + return rows; + } + + function parseRows(text, f) { + var rows = [], + // Output rows + N = text.length, + I = 0, + // Current character index + n = 0, + // Current line number + t, + // Current token + eof = N <= 0, + // Current token followed by EOF? + eol = false; // Current token followed by EOL? + // Strip the trailing newline. + + if (text.charCodeAt(N - 1) === NEWLINE) --N; + if (text.charCodeAt(N - 1) === RETURN) --N; + + function token() { + if (eof) return EOF; + if (eol) return (eol = false), EOL; // Unescape quotes. + + var i, + j = I, + c; + + if (text.charCodeAt(j) === QUOTE) { + while ( + (I++ < N && text.charCodeAt(I) !== QUOTE) || + text.charCodeAt(++I) === QUOTE + ) {} + + if ((i = I) >= N) eof = true; + else if ((c = text.charCodeAt(I++)) === NEWLINE) + eol = true; + else if (c === RETURN) { + eol = true; + if (text.charCodeAt(I) === NEWLINE) ++I; + } + return text.slice(j + 1, i - 1).replace(/""/g, '"'); + } // Find next delimiter or newline. + + while (I < N) { + if ((c = text.charCodeAt((i = I++))) === NEWLINE) + eol = true; + else if (c === RETURN) { + eol = true; + if (text.charCodeAt(I) === NEWLINE) ++I; + } else if (c !== DELIMITER) continue; + return text.slice(j, i); + } // Return last token before EOF. + + return (eof = true), text.slice(j, N); + } + + while ((t = token()) !== EOF) { + var row = []; + + while (t !== EOL && t !== EOF) { + row.push(t), (t = token()); + } + + if (f && (row = f(row, n++)) == null) continue; + rows.push(row); + } + + return rows; + } + + function preformatBody(rows, columns) { + return rows.map(function (row) { + return columns + .map(function (column) { + return formatValue(row[column]); + }) + .join(delimiter); + }); + } + + function format(rows, columns) { + if (columns == null) columns = inferColumns(rows); + return [columns.map(formatValue).join(delimiter)] + .concat(preformatBody(rows, columns)) + .join("\n"); + } + + function formatBody(rows, columns) { + if (columns == null) columns = inferColumns(rows); + return preformatBody(rows, columns).join("\n"); + } + + function formatRows(rows) { + return rows.map(formatRow).join("\n"); + } + + function formatRow(row) { + return row.map(formatValue).join(delimiter); + } + + function formatValue(value) { + return value == null + ? "" + : value instanceof Date + ? formatDate(value) + : reFormat.test((value = String(value))) + ? '"' + value.replace(/"/g, '""') + '"' + : value; + } + + return { + parse: parse, + parseRows: parseRows, + format: format, + formatBody: formatBody, + formatRows: formatRows, + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-dsv/src/index.js": + /* !******************************************!*\ + !*** ./node_modules/d3-dsv/src/index.js ***! + \******************************************/ + /* ! exports provided: dsvFormat, csvParse, csvParseRows, csvFormat, csvFormatBody, csvFormatRows, tsvParse, tsvParseRows, tsvFormat, tsvFormatBody, tsvFormatRows, autoType */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _dsv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./dsv */ "./node_modules/d3-dsv/src/dsv.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dsvFormat", + function () { + return _dsv__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _csv__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./csv */ "./node_modules/d3-dsv/src/csv.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvParse", + function () { + return _csv__WEBPACK_IMPORTED_MODULE_1__.csvParse; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvParseRows", + function () { + return _csv__WEBPACK_IMPORTED_MODULE_1__.csvParseRows; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvFormat", + function () { + return _csv__WEBPACK_IMPORTED_MODULE_1__.csvFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvFormatBody", + function () { + return _csv__WEBPACK_IMPORTED_MODULE_1__.csvFormatBody; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvFormatRows", + function () { + return _csv__WEBPACK_IMPORTED_MODULE_1__.csvFormatRows; + } + ); + + /* Harmony import */ var _tsv__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./tsv */ "./node_modules/d3-dsv/src/tsv.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvParse", + function () { + return _tsv__WEBPACK_IMPORTED_MODULE_2__.tsvParse; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvParseRows", + function () { + return _tsv__WEBPACK_IMPORTED_MODULE_2__.tsvParseRows; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormat", + function () { + return _tsv__WEBPACK_IMPORTED_MODULE_2__.tsvFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormatBody", + function () { + return _tsv__WEBPACK_IMPORTED_MODULE_2__.tsvFormatBody; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormatRows", + function () { + return _tsv__WEBPACK_IMPORTED_MODULE_2__.tsvFormatRows; + } + ); + + /* Harmony import */ var _autoType__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./autoType */ "./node_modules/d3-dsv/src/autoType.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "autoType", + function () { + return _autoType__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-dsv/src/tsv.js": + /* !****************************************!*\ + !*** ./node_modules/d3-dsv/src/tsv.js ***! + \****************************************/ + /* ! exports provided: tsvParse, tsvParseRows, tsvFormat, tsvFormatBody, tsvFormatRows */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tsvParse", + function () { + return tsvParse; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tsvParseRows", + function () { + return tsvParseRows; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormat", + function () { + return tsvFormat; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormatBody", + function () { + return tsvFormatBody; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormatRows", + function () { + return tsvFormatRows; + } + ); + /* Harmony import */ var _dsv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./dsv */ "./node_modules/d3-dsv/src/dsv.js" + ); + + var tsv = Object(_dsv__WEBPACK_IMPORTED_MODULE_0__.default)( + "\t" + ); + var tsvParse = tsv.parse; + var tsvParseRows = tsv.parseRows; + var tsvFormat = tsv.format; + var tsvFormatBody = tsv.formatBody; + var tsvFormatRows = tsv.formatRows; + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/back.js": + /* !******************************************!*\ + !*** ./node_modules/d3-ease/src/back.js ***! + \******************************************/ + /* ! exports provided: backIn, backOut, backInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "backIn", + function () { + return backIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "backOut", + function () { + return backOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "backInOut", + function () { + return backInOut; + } + ); + var overshoot = 1.70158; + var backIn = (function custom(s) { + s = Number(s); + + function backIn(t) { + return t * t * ((s + 1) * t - s); + } + + backIn.overshoot = custom; + return backIn; + })(overshoot); + var backOut = (function custom(s) { + s = Number(s); + + function backOut(t) { + return --t * t * ((s + 1) * t + s) + 1; + } + + backOut.overshoot = custom; + return backOut; + })(overshoot); + var backInOut = (function custom(s) { + s = Number(s); + + function backInOut(t) { + return ( + ((t *= 2) < 1 + ? t * t * ((s + 1) * t - s) + : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2 + ); + } + + backInOut.overshoot = custom; + return backInOut; + })(overshoot); + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/bounce.js": + /* !********************************************!*\ + !*** ./node_modules/d3-ease/src/bounce.js ***! + \********************************************/ + /* ! exports provided: bounceIn, bounceOut, bounceInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "bounceIn", + function () { + return bounceIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "bounceOut", + function () { + return bounceOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "bounceInOut", + function () { + return bounceInOut; + } + ); + var b1 = 4 / 11, + b2 = 6 / 11, + b3 = 8 / 11, + b4 = 3 / 4, + b5 = 9 / 11, + b6 = 10 / 11, + b7 = 15 / 16, + b8 = 21 / 22, + b9 = 63 / 64, + b0 = 1 / b1 / b1; + function bounceIn(t) { + return 1 - bounceOut(1 - t); + } + function bounceOut(t) { + return (t = Number(t)) < b1 + ? b0 * t * t + : t < b3 + ? b0 * (t -= b2) * t + b4 + : t < b6 + ? b0 * (t -= b5) * t + b7 + : b0 * (t -= b8) * t + b9; + } + function bounceInOut(t) { + return ( + ((t *= 2) <= 1 + ? 1 - bounceOut(1 - t) + : bounceOut(t - 1) + 1) / 2 + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/circle.js": + /* !********************************************!*\ + !*** ./node_modules/d3-ease/src/circle.js ***! + \********************************************/ + /* ! exports provided: circleIn, circleOut, circleInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "circleIn", + function () { + return circleIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "circleOut", + function () { + return circleOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "circleInOut", + function () { + return circleInOut; + } + ); + function circleIn(t) { + return 1 - Math.sqrt(1 - t * t); + } + function circleOut(t) { + return Math.sqrt(1 - --t * t); + } + function circleInOut(t) { + return ( + ((t *= 2) <= 1 + ? 1 - Math.sqrt(1 - t * t) + : Math.sqrt(1 - (t -= 2) * t) + 1) / 2 + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/cubic.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-ease/src/cubic.js ***! + \*******************************************/ + /* ! exports provided: cubicIn, cubicOut, cubicInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cubicIn", + function () { + return cubicIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cubicOut", + function () { + return cubicOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cubicInOut", + function () { + return cubicInOut; + } + ); + function cubicIn(t) { + return t * t * t; + } + function cubicOut(t) { + return --t * t * t + 1; + } + function cubicInOut(t) { + return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; + } + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/elastic.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-ease/src/elastic.js ***! + \*********************************************/ + /* ! exports provided: elasticIn, elasticOut, elasticInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "elasticIn", + function () { + return elasticIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "elasticOut", + function () { + return elasticOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "elasticInOut", + function () { + return elasticInOut; + } + ); + var tau = 2 * Math.PI, + amplitude = 1, + period = 0.3; + var elasticIn = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticIn(t) { + return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p); + } + + elasticIn.amplitude = function (a) { + return custom(a, p * tau); + }; + + elasticIn.period = function (p) { + return custom(a, p); + }; + + return elasticIn; + })(amplitude, period); + var elasticOut = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticOut(t) { + return ( + 1 - + a * Math.pow(2, -10 * (t = Number(t))) * Math.sin((t + s) / p) + ); + } + + elasticOut.amplitude = function (a) { + return custom(a, p * tau); + }; + + elasticOut.period = function (p) { + return custom(a, p); + }; + + return elasticOut; + })(amplitude, period); + var elasticInOut = (function custom(a, p) { + var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); + + function elasticInOut(t) { + return ( + ((t = t * 2 - 1) < 0 + ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p) + : 2 - + a * + Math.pow(2, -10 * t) * + Math.sin((s + t) / p)) / 2 + ); + } + + elasticInOut.amplitude = function (a) { + return custom(a, p * tau); + }; + + elasticInOut.period = function (p) { + return custom(a, p); + }; + + return elasticInOut; + })(amplitude, period); + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/exp.js": + /* !*****************************************!*\ + !*** ./node_modules/d3-ease/src/exp.js ***! + \*****************************************/ + /* ! exports provided: expIn, expOut, expInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "expIn", + function () { + return expIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "expOut", + function () { + return expOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "expInOut", + function () { + return expInOut; + } + ); + function expIn(t) { + return Math.pow(2, 10 * t - 10); + } + function expOut(t) { + return 1 - Math.pow(2, -10 * t); + } + function expInOut(t) { + return ( + ((t *= 2) <= 1 + ? Math.pow(2, 10 * t - 10) + : 2 - Math.pow(2, 10 - 10 * t)) / 2 + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/index.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-ease/src/index.js ***! + \*******************************************/ + /* ! exports provided: easeLinear, easeQuad, easeQuadIn, easeQuadOut, easeQuadInOut, easeCubic, easeCubicIn, easeCubicOut, easeCubicInOut, easePoly, easePolyIn, easePolyOut, easePolyInOut, easeSin, easeSinIn, easeSinOut, easeSinInOut, easeExp, easeExpIn, easeExpOut, easeExpInOut, easeCircle, easeCircleIn, easeCircleOut, easeCircleInOut, easeBounce, easeBounceIn, easeBounceOut, easeBounceInOut, easeBack, easeBackIn, easeBackOut, easeBackInOut, easeElastic, easeElasticIn, easeElasticOut, easeElasticInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-ease/src/linear.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeLinear", + function () { + return _linear__WEBPACK_IMPORTED_MODULE_0__.linear; + } + ); + + /* Harmony import */ var _quad__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./quad */ "./node_modules/d3-ease/src/quad.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeQuad", + function () { + return _quad__WEBPACK_IMPORTED_MODULE_1__.quadInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeQuadIn", + function () { + return _quad__WEBPACK_IMPORTED_MODULE_1__.quadIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeQuadOut", + function () { + return _quad__WEBPACK_IMPORTED_MODULE_1__.quadOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeQuadInOut", + function () { + return _quad__WEBPACK_IMPORTED_MODULE_1__.quadInOut; + } + ); + + /* Harmony import */ var _cubic__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./cubic */ "./node_modules/d3-ease/src/cubic.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCubic", + function () { + return _cubic__WEBPACK_IMPORTED_MODULE_2__.cubicInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCubicIn", + function () { + return _cubic__WEBPACK_IMPORTED_MODULE_2__.cubicIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCubicOut", + function () { + return _cubic__WEBPACK_IMPORTED_MODULE_2__.cubicOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCubicInOut", + function () { + return _cubic__WEBPACK_IMPORTED_MODULE_2__.cubicInOut; + } + ); + + /* Harmony import */ var _poly__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./poly */ "./node_modules/d3-ease/src/poly.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easePoly", + function () { + return _poly__WEBPACK_IMPORTED_MODULE_3__.polyInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easePolyIn", + function () { + return _poly__WEBPACK_IMPORTED_MODULE_3__.polyIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easePolyOut", + function () { + return _poly__WEBPACK_IMPORTED_MODULE_3__.polyOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easePolyInOut", + function () { + return _poly__WEBPACK_IMPORTED_MODULE_3__.polyInOut; + } + ); + + /* Harmony import */ var _sin__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./sin */ "./node_modules/d3-ease/src/sin.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeSin", + function () { + return _sin__WEBPACK_IMPORTED_MODULE_4__.sinInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeSinIn", + function () { + return _sin__WEBPACK_IMPORTED_MODULE_4__.sinIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeSinOut", + function () { + return _sin__WEBPACK_IMPORTED_MODULE_4__.sinOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeSinInOut", + function () { + return _sin__WEBPACK_IMPORTED_MODULE_4__.sinInOut; + } + ); + + /* Harmony import */ var _exp__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./exp */ "./node_modules/d3-ease/src/exp.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeExp", + function () { + return _exp__WEBPACK_IMPORTED_MODULE_5__.expInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeExpIn", + function () { + return _exp__WEBPACK_IMPORTED_MODULE_5__.expIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeExpOut", + function () { + return _exp__WEBPACK_IMPORTED_MODULE_5__.expOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeExpInOut", + function () { + return _exp__WEBPACK_IMPORTED_MODULE_5__.expInOut; + } + ); + + /* Harmony import */ var _circle__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./circle */ "./node_modules/d3-ease/src/circle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCircle", + function () { + return _circle__WEBPACK_IMPORTED_MODULE_6__.circleInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCircleIn", + function () { + return _circle__WEBPACK_IMPORTED_MODULE_6__.circleIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCircleOut", + function () { + return _circle__WEBPACK_IMPORTED_MODULE_6__.circleOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCircleInOut", + function () { + return _circle__WEBPACK_IMPORTED_MODULE_6__.circleInOut; + } + ); + + /* Harmony import */ var _bounce__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./bounce */ "./node_modules/d3-ease/src/bounce.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBounce", + function () { + return _bounce__WEBPACK_IMPORTED_MODULE_7__.bounceOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBounceIn", + function () { + return _bounce__WEBPACK_IMPORTED_MODULE_7__.bounceIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBounceOut", + function () { + return _bounce__WEBPACK_IMPORTED_MODULE_7__.bounceOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBounceInOut", + function () { + return _bounce__WEBPACK_IMPORTED_MODULE_7__.bounceInOut; + } + ); + + /* Harmony import */ var _back__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./back */ "./node_modules/d3-ease/src/back.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBack", + function () { + return _back__WEBPACK_IMPORTED_MODULE_8__.backInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBackIn", + function () { + return _back__WEBPACK_IMPORTED_MODULE_8__.backIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBackOut", + function () { + return _back__WEBPACK_IMPORTED_MODULE_8__.backOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBackInOut", + function () { + return _back__WEBPACK_IMPORTED_MODULE_8__.backInOut; + } + ); + + /* Harmony import */ var _elastic__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./elastic */ "./node_modules/d3-ease/src/elastic.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeElastic", + function () { + return _elastic__WEBPACK_IMPORTED_MODULE_9__.elasticOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeElasticIn", + function () { + return _elastic__WEBPACK_IMPORTED_MODULE_9__.elasticIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeElasticOut", + function () { + return _elastic__WEBPACK_IMPORTED_MODULE_9__.elasticOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeElasticInOut", + function () { + return _elastic__WEBPACK_IMPORTED_MODULE_9__.elasticInOut; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/linear.js": + /* !********************************************!*\ + !*** ./node_modules/d3-ease/src/linear.js ***! + \********************************************/ + /* ! exports provided: linear */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "linear", + function () { + return linear; + } + ); + function linear(t) { + return Number(t); + } + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/poly.js": + /* !******************************************!*\ + !*** ./node_modules/d3-ease/src/poly.js ***! + \******************************************/ + /* ! exports provided: polyIn, polyOut, polyInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "polyIn", + function () { + return polyIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "polyOut", + function () { + return polyOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "polyInOut", + function () { + return polyInOut; + } + ); + var exponent = 3; + var polyIn = (function custom(e) { + e = Number(e); + + function polyIn(t) { + return Math.pow(t, e); + } + + polyIn.exponent = custom; + return polyIn; + })(exponent); + var polyOut = (function custom(e) { + e = Number(e); + + function polyOut(t) { + return 1 - Math.pow(1 - t, e); + } + + polyOut.exponent = custom; + return polyOut; + })(exponent); + var polyInOut = (function custom(e) { + e = Number(e); + + function polyInOut(t) { + return ( + ((t *= 2) <= 1 + ? Math.pow(t, e) + : 2 - Math.pow(2 - t, e)) / 2 + ); + } + + polyInOut.exponent = custom; + return polyInOut; + })(exponent); + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/quad.js": + /* !******************************************!*\ + !*** ./node_modules/d3-ease/src/quad.js ***! + \******************************************/ + /* ! exports provided: quadIn, quadOut, quadInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "quadIn", + function () { + return quadIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "quadOut", + function () { + return quadOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "quadInOut", + function () { + return quadInOut; + } + ); + function quadIn(t) { + return t * t; + } + function quadOut(t) { + return t * (2 - t); + } + function quadInOut(t) { + return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2; + } + + /***/ + }, + + /***/ "./node_modules/d3-ease/src/sin.js": + /* !*****************************************!*\ + !*** ./node_modules/d3-ease/src/sin.js ***! + \*****************************************/ + /* ! exports provided: sinIn, sinOut, sinInOut */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sinIn", + function () { + return sinIn; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sinOut", + function () { + return sinOut; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sinInOut", + function () { + return sinInOut; + } + ); + var pi = Math.PI, + halfPi = pi / 2; + function sinIn(t) { + return 1 - Math.cos(t * halfPi); + } + function sinOut(t) { + return Math.sin(t * halfPi); + } + function sinInOut(t) { + return (1 - Math.cos(pi * t)) / 2; + } + + /***/ + }, + + /***/ "./node_modules/d3-fetch/src/blob.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-fetch/src/blob.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function responseBlob(response) { + if (!response.ok) + throw new Error( + response.status + " " + response.statusText + ); + return response.blob(); + } + + /* Harmony default export */ __webpack_exports__.default = function (input, init) { + return fetch(input, init).then(responseBlob); + }; + + /***/ + }, + + /***/ "./node_modules/d3-fetch/src/buffer.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-fetch/src/buffer.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function responseArrayBuffer(response) { + if (!response.ok) + throw new Error( + response.status + " " + response.statusText + ); + return response.arrayBuffer(); + } + + /* Harmony default export */ __webpack_exports__.default = function (input, init) { + return fetch(input, init).then(responseArrayBuffer); + }; + + /***/ + }, + + /***/ "./node_modules/d3-fetch/src/dsv.js": + /* !******************************************!*\ + !*** ./node_modules/d3-fetch/src/dsv.js ***! + \******************************************/ + /* ! exports provided: default, csv, tsv */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return dsv; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "csv", + function () { + return csv; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tsv", + function () { + return tsv; + } + ); + /* Harmony import */ var d3_dsv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-dsv */ "./node_modules/d3-dsv/src/index.js" + ); + /* Harmony import */ var _text__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./text */ "./node_modules/d3-fetch/src/text.js" + ); + + function dsvParse(parse) { + return function (input, init, row) { + if (arguments.length === 2 && typeof init === "function") + (row = init), (init = undefined); + return Object( + _text__WEBPACK_IMPORTED_MODULE_1__.default + )(input, init).then(function (response) { + return parse(response, row); + }); + }; + } + + function dsv(delimiter, input, init, row) { + if (arguments.length === 3 && typeof init === "function") + (row = init), (init = undefined); + var format = Object( + d3_dsv__WEBPACK_IMPORTED_MODULE_0__.dsvFormat + )(delimiter); + return Object(_text__WEBPACK_IMPORTED_MODULE_1__.default)( + input, + init + ).then(function (response) { + return format.parse(response, row); + }); + } + var csv = dsvParse(d3_dsv__WEBPACK_IMPORTED_MODULE_0__.csvParse); + var tsv = dsvParse(d3_dsv__WEBPACK_IMPORTED_MODULE_0__.tsvParse); + + /***/ + }, + + /***/ "./node_modules/d3-fetch/src/image.js": + /* !********************************************!*\ + !*** ./node_modules/d3-fetch/src/image.js ***! + \********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (input, init) { + return new Promise(function (resolve, reject) { + var image = new Image(); + + for (var key in init) { + image[key] = init[key]; + } + + image.onerror = reject; + + image.onload = function () { + resolve(image); + }; + + image.src = input; + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-fetch/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-fetch/src/index.js ***! + \********************************************/ + /* ! exports provided: blob, buffer, dsv, csv, tsv, image, json, text, xml, html, svg */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _blob__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./blob */ "./node_modules/d3-fetch/src/blob.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "blob", + function () { + return _blob__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _buffer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./buffer */ "./node_modules/d3-fetch/src/buffer.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "buffer", + function () { + return _buffer__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _dsv__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./dsv */ "./node_modules/d3-fetch/src/dsv.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dsv", + function () { + return _dsv__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csv", + function () { + return _dsv__WEBPACK_IMPORTED_MODULE_2__.csv; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsv", + function () { + return _dsv__WEBPACK_IMPORTED_MODULE_2__.tsv; + } + ); + + /* Harmony import */ var _image__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./image */ "./node_modules/d3-fetch/src/image.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "image", + function () { + return _image__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _json__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./json */ "./node_modules/d3-fetch/src/json.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "json", + function () { + return _json__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _text__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./text */ "./node_modules/d3-fetch/src/text.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "text", + function () { + return _text__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _xml__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./xml */ "./node_modules/d3-fetch/src/xml.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "xml", + function () { + return _xml__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "html", + function () { + return _xml__WEBPACK_IMPORTED_MODULE_6__.html; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "svg", + function () { + return _xml__WEBPACK_IMPORTED_MODULE_6__.svg; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-fetch/src/json.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-fetch/src/json.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function responseJson(response) { + if (!response.ok) + throw new Error( + response.status + " " + response.statusText + ); + return response.json(); + } + + /* Harmony default export */ __webpack_exports__.default = function (input, init) { + return fetch(input, init).then(responseJson); + }; + + /***/ + }, + + /***/ "./node_modules/d3-fetch/src/text.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-fetch/src/text.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function responseText(response) { + if (!response.ok) + throw new Error( + response.status + " " + response.statusText + ); + return response.text(); + } + + /* Harmony default export */ __webpack_exports__.default = function (input, init) { + return fetch(input, init).then(responseText); + }; + + /***/ + }, + + /***/ "./node_modules/d3-fetch/src/xml.js": + /* !******************************************!*\ + !*** ./node_modules/d3-fetch/src/xml.js ***! + \******************************************/ + /* ! exports provided: default, html, svg */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "html", + function () { + return html; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "svg", + function () { + return svg; + } + ); + /* Harmony import */ var _text__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./text */ "./node_modules/d3-fetch/src/text.js" + ); + + function parser(type) { + return function (input, init) { + return Object( + _text__WEBPACK_IMPORTED_MODULE_0__.default + )(input, init).then(function (text) { + return new DOMParser().parseFromString(text, type); + }); + }; + } + + /* Harmony default export */ __webpack_exports__.default = parser("application/xml"); + var html = parser("text/html"); + var svg = parser("image/svg+xml"); + + /***/ + }, + + /***/ "./node_modules/d3-force/src/center.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-force/src/center.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x, y) { + var nodes; + if (x == null) x = 0; + if (y == null) y = 0; + + function force() { + var i, + n = nodes.length, + node, + sx = 0, + sy = 0; + + for (i = 0; i < n; ++i) { + (node = nodes[i]), (sx += node.x), (sy += node.y); + } + + for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) { + (node = nodes[i]), (node.x -= sx), (node.y -= sy); + } + } + + force.initialize = function (_) { + nodes = _; + }; + + force.x = function (_) { + return arguments.length ? ((x = Number(_)), force) : x; + }; + + force.y = function (_) { + return arguments.length ? ((y = Number(_)), force) : y; + }; + + return force; + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/collide.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-force/src/collide.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-force/src/constant.js" + ); + /* Harmony import */ var _jiggle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./jiggle */ "./node_modules/d3-force/src/jiggle.js" + ); + /* Harmony import */ var d3_quadtree__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-quadtree */ "./node_modules/d3-quadtree/src/index.js" + ); + + function x(d) { + return d.x + d.vx; + } + + function y(d) { + return d.y + d.vy; + } + + /* Harmony default export */ __webpack_exports__.default = function (radius) { + var nodes, + radii, + strength = 1, + iterations = 1; + if (typeof radius !== "function") + radius = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(radius == null ? 1 : Number(radius)); + + function force() { + var i, + n = nodes.length, + tree, + node, + xi, + yi, + ri, + ri2; + + for (var k = 0; k < iterations; ++k) { + tree = Object( + d3_quadtree__WEBPACK_IMPORTED_MODULE_2__.quadtree + )(nodes, x, y).visitAfter(prepare); + + for (i = 0; i < n; ++i) { + node = nodes[i]; + (ri = radii[node.index]), (ri2 = ri * ri); + xi = node.x + node.vx; + yi = node.y + node.vy; + tree.visit(apply); + } + } + + function apply(quad, x0, y0, x1, y1) { + var data = quad.data, + rj = quad.r, + r = ri + rj; + + if (data) { + if (data.index > node.index) { + var x = xi - data.x - data.vx, + y = yi - data.y - data.vy, + l = x * x + y * y; + + if (l < r * r) { + if (x === 0) + (x = Object( + _jiggle__WEBPACK_IMPORTED_MODULE_1__.default + )()), + (l += x * x); + if (y === 0) + (y = Object( + _jiggle__WEBPACK_IMPORTED_MODULE_1__.default + )()), + (l += y * y); + l = + ((r - (l = Math.sqrt(l))) / l) * + strength; + node.vx += + (x *= l) * + (r = (rj *= rj) / (ri2 + rj)); + node.vy += (y *= l) * r; + data.vx -= x * (r = 1 - r); + data.vy -= y * r; + } + } + + return; + } + + return ( + x0 > xi + r || + x1 < xi - r || + y0 > yi + r || + y1 < yi - r + ); + } + } + + function prepare(quad) { + if (quad.data) return (quad.r = radii[quad.data.index]); + + for (var i = (quad.r = 0); i < 4; ++i) { + if (quad[i] && quad[i].r > quad.r) { + quad.r = quad[i].r; + } + } + } + + function initialize() { + if (!nodes) return; + var i, + n = nodes.length, + node; + radii = new Array(n); + + for (i = 0; i < n; ++i) { + (node = nodes[i]), + (radii[node.index] = Number(radius(node, i, nodes))); + } + } + + force.initialize = function (_) { + nodes = _; + initialize(); + }; + + force.iterations = function (_) { + return arguments.length + ? ((iterations = Number(_)), force) + : iterations; + }; + + force.strength = function (_) { + return arguments.length + ? ((strength = Number(_)), force) + : strength; + }; + + force.radius = function (_) { + return arguments.length + ? ((radius = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initialize(), + force) + : radius; + }; + + return force; + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/constant.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-force/src/constant.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-force/src/index.js ***! + \********************************************/ + /* ! exports provided: forceCenter, forceCollide, forceLink, forceManyBody, forceRadial, forceSimulation, forceX, forceY */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _center__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./center */ "./node_modules/d3-force/src/center.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceCenter", + function () { + return _center__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _collide__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./collide */ "./node_modules/d3-force/src/collide.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceCollide", + function () { + return _collide__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _link__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./link */ "./node_modules/d3-force/src/link.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceLink", + function () { + return _link__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _manyBody__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./manyBody */ "./node_modules/d3-force/src/manyBody.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceManyBody", + function () { + return _manyBody__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _radial__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./radial */ "./node_modules/d3-force/src/radial.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceRadial", + function () { + return _radial__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _simulation__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./simulation */ "./node_modules/d3-force/src/simulation.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceSimulation", + function () { + return _simulation__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _x__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./x */ "./node_modules/d3-force/src/x.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceX", + function () { + return _x__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony import */ var _y__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./y */ "./node_modules/d3-force/src/y.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceY", + function () { + return _y__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-force/src/jiggle.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-force/src/jiggle.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + return (Math.random() - 0.5) * 1e-6; + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/link.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-force/src/link.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-force/src/constant.js" + ); + /* Harmony import */ var _jiggle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./jiggle */ "./node_modules/d3-force/src/jiggle.js" + ); + /* Harmony import */ var d3_collection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-collection */ "./node_modules/d3-collection/src/index.js" + ); + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + function index(d) { + return d.index; + } + + function find(nodeById, nodeId) { + var node = nodeById.get(nodeId); + if (!node) throw new Error("missing: " + nodeId); + return node; + } + + /* Harmony default export */ __webpack_exports__.default = function (links) { + var id = index, + strength = defaultStrength, + strengths, + distance = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(30), + distances, + nodes, + count, + bias, + iterations = 1; + if (links == null) links = []; + + function defaultStrength(link) { + return ( + 1 / + Math.min( + count[link.source.index], + count[link.target.index] + ) + ); + } + + function force(alpha) { + for (var k = 0, n = links.length; k < iterations; ++k) { + for ( + var i = 0, link, source, target, x, y, l, b; + i < n; + ++i + ) { + (link = links[i]), + (source = link.source), + (target = link.target); + x = + target.x + target.vx - source.x - source.vx || + Object( + _jiggle__WEBPACK_IMPORTED_MODULE_1__.default + )(); + y = + target.y + target.vy - source.y - source.vy || + Object( + _jiggle__WEBPACK_IMPORTED_MODULE_1__.default + )(); + l = Math.sqrt(x * x + y * y); + l = ((l - distances[i]) / l) * alpha * strengths[i]; + (x *= l), (y *= l); + target.vx -= x * (b = bias[i]); + target.vy -= y * b; + source.vx += x * (b = 1 - b); + source.vy += y * b; + } + } + } + + function initialize() { + if (!nodes) return; + var i, + n = nodes.length, + m = links.length, + nodeById = Object( + d3_collection__WEBPACK_IMPORTED_MODULE_2__.map + )(nodes, id), + link; + + for (i = 0, count = new Array(n); i < m; ++i) { + (link = links[i]), (link.index = i); + if (_typeof(link.source) !== "object") + link.source = find(nodeById, link.source); + if (_typeof(link.target) !== "object") + link.target = find(nodeById, link.target); + count[link.source.index] = + (count[link.source.index] || 0) + 1; + count[link.target.index] = + (count[link.target.index] || 0) + 1; + } + + for (i = 0, bias = new Array(m); i < m; ++i) { + (link = links[i]), + (bias[i] = + count[link.source.index] / + (count[link.source.index] + + count[link.target.index])); + } + + (strengths = new Array(m)), initializeStrength(); + (distances = new Array(m)), initializeDistance(); + } + + function initializeStrength() { + if (!nodes) return; + + for (var i = 0, n = links.length; i < n; ++i) { + strengths[i] = Number(strength(links[i], i, links)); + } + } + + function initializeDistance() { + if (!nodes) return; + + for (var i = 0, n = links.length; i < n; ++i) { + distances[i] = Number(distance(links[i], i, links)); + } + } + + force.initialize = function (_) { + nodes = _; + initialize(); + }; + + force.links = function (_) { + return arguments.length + ? ((links = _), initialize(), force) + : links; + }; + + force.id = function (_) { + return arguments.length ? ((id = _), force) : id; + }; + + force.iterations = function (_) { + return arguments.length + ? ((iterations = Number(_)), force) + : iterations; + }; + + force.strength = function (_) { + return arguments.length + ? ((strength = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initializeStrength(), + force) + : strength; + }; + + force.distance = function (_) { + return arguments.length + ? ((distance = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initializeDistance(), + force) + : distance; + }; + + return force; + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/manyBody.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-force/src/manyBody.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-force/src/constant.js" + ); + /* Harmony import */ var _jiggle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./jiggle */ "./node_modules/d3-force/src/jiggle.js" + ); + /* Harmony import */ var d3_quadtree__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-quadtree */ "./node_modules/d3-quadtree/src/index.js" + ); + /* Harmony import */ var _simulation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./simulation */ "./node_modules/d3-force/src/simulation.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var nodes, + node, + alpha, + strength = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(-30), + strengths, + distanceMin2 = 1, + distanceMax2 = Infinity, + theta2 = 0.81; + + function force(_) { + var i, + n = nodes.length, + tree = Object( + d3_quadtree__WEBPACK_IMPORTED_MODULE_2__.quadtree + )( + nodes, + _simulation__WEBPACK_IMPORTED_MODULE_3__.x, + _simulation__WEBPACK_IMPORTED_MODULE_3__.y + ).visitAfter(accumulate); + + for (alpha = _, i = 0; i < n; ++i) { + (node = nodes[i]), tree.visit(apply); + } + } + + function initialize() { + if (!nodes) return; + var i, + n = nodes.length, + node; + strengths = new Array(n); + + for (i = 0; i < n; ++i) { + (node = nodes[i]), + (strengths[node.index] = Number(strength(node, i, nodes))); + } + } + + function accumulate(quad) { + var strength = 0, + q, + c, + weight = 0, + x, + y, + i; // For internal nodes, accumulate forces from child quadrants. + + if (quad.length) { + for (x = y = i = 0; i < 4; ++i) { + if ((q = quad[i]) && (c = Math.abs(q.value))) { + (strength += q.value), + (weight += c), + (x += c * q.x), + (y += c * q.y); + } + } + + quad.x = x / weight; + quad.y = y / weight; + } // For leaf nodes, accumulate forces from coincident quadrants. + else { + q = quad; + q.x = q.data.x; + q.y = q.data.y; + + do { + strength += strengths[q.data.index]; + } while ((q = q.next)); + } + + quad.value = strength; + } + + function apply(quad, x1, _, x2) { + if (!quad.value) return true; + var x = quad.x - node.x, + y = quad.y - node.y, + w = x2 - x1, + l = x * x + y * y; // Apply the Barnes-Hut approximation if possible. + // Limit forces for very close nodes; randomize direction if coincident. + + if ((w * w) / theta2 < l) { + if (l < distanceMax2) { + if (x === 0) + (x = Object( + _jiggle__WEBPACK_IMPORTED_MODULE_1__.default + )()), + (l += x * x); + if (y === 0) + (y = Object( + _jiggle__WEBPACK_IMPORTED_MODULE_1__.default + )()), + (l += y * y); + if (l < distanceMin2) + l = Math.sqrt(distanceMin2 * l); + node.vx += (x * quad.value * alpha) / l; + node.vy += (y * quad.value * alpha) / l; + } + + return true; + } // Otherwise, process points directly. + else if (quad.length || l >= distanceMax2) return; // Limit forces for very close nodes; randomize direction if coincident. + + if (quad.data !== node || quad.next) { + if (x === 0) + (x = Object( + _jiggle__WEBPACK_IMPORTED_MODULE_1__.default + )()), + (l += x * x); + if (y === 0) + (y = Object( + _jiggle__WEBPACK_IMPORTED_MODULE_1__.default + )()), + (l += y * y); + if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); + } + + do { + if (quad.data !== node) { + w = (strengths[quad.data.index] * alpha) / l; + node.vx += x * w; + node.vy += y * w; + } + } while ((quad = quad.next)); + } + + force.initialize = function (_) { + nodes = _; + initialize(); + }; + + force.strength = function (_) { + return arguments.length + ? ((strength = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initialize(), + force) + : strength; + }; + + force.distanceMin = function (_) { + return arguments.length + ? ((distanceMin2 = _ * _), force) + : Math.sqrt(distanceMin2); + }; + + force.distanceMax = function (_) { + return arguments.length + ? ((distanceMax2 = _ * _), force) + : Math.sqrt(distanceMax2); + }; + + force.theta = function (_) { + return arguments.length + ? ((theta2 = _ * _), force) + : Math.sqrt(theta2); + }; + + return force; + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/radial.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-force/src/radial.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-force/src/constant.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (radius, x, y) { + var nodes, + strength = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(0.1), + strengths, + radiuses; + if (typeof radius !== "function") + radius = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(radius)); + if (x == null) x = 0; + if (y == null) y = 0; + + function force(alpha) { + for (var i = 0, n = nodes.length; i < n; ++i) { + var node = nodes[i], + dx = node.x - x || 1e-6, + dy = node.y - y || 1e-6, + r = Math.sqrt(dx * dx + dy * dy), + k = ((radiuses[i] - r) * strengths[i] * alpha) / r; + node.vx += dx * k; + node.vy += dy * k; + } + } + + function initialize() { + if (!nodes) return; + var i, + n = nodes.length; + strengths = new Array(n); + radiuses = new Array(n); + + for (i = 0; i < n; ++i) { + radiuses[i] = Number(radius(nodes[i], i, nodes)); + strengths[i] = isNaN(radiuses[i]) + ? 0 + : Number(strength(nodes[i], i, nodes)); + } + } + + force.initialize = function (_) { + (nodes = _), initialize(); + }; + + force.strength = function (_) { + return arguments.length + ? ((strength = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initialize(), + force) + : strength; + }; + + force.radius = function (_) { + return arguments.length + ? ((radius = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initialize(), + force) + : radius; + }; + + force.x = function (_) { + return arguments.length ? ((x = Number(_)), force) : x; + }; + + force.y = function (_) { + return arguments.length ? ((y = Number(_)), force) : y; + }; + + return force; + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/simulation.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-force/src/simulation.js ***! + \*************************************************/ + /* ! exports provided: x, y, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "x", + function () { + return x; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "y", + function () { + return y; + } + ); + /* Harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js" + ); + /* Harmony import */ var d3_collection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-collection */ "./node_modules/d3-collection/src/index.js" + ); + /* Harmony import */ var d3_timer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-timer */ "./node_modules/d3-timer/src/index.js" + ); + + function x(d) { + return d.x; + } + function y(d) { + return d.y; + } + var initialRadius = 10, + initialAngle = Math.PI * (3 - Math.sqrt(5)); + /* Harmony default export */ __webpack_exports__.default = function (_nodes) { + var simulation, + _alpha = 1, + _alphaMin = 0.001, + _alphaDecay = 1 - Math.pow(_alphaMin, 1 / 300), + _alphaTarget = 0, + _velocityDecay = 0.6, + forces = Object( + d3_collection__WEBPACK_IMPORTED_MODULE_1__.map + )(), + stepper = Object( + d3_timer__WEBPACK_IMPORTED_MODULE_2__.timer + )(step), + event = Object( + d3_dispatch__WEBPACK_IMPORTED_MODULE_0__.dispatch + )("tick", "end"); + + if (_nodes == null) _nodes = []; + + function step() { + tick(); + event.call("tick", simulation); + + if (_alpha < _alphaMin) { + stepper.stop(); + event.call("end", simulation); + } + } + + function tick(iterations) { + var i, + n = _nodes.length, + node; + if (iterations === undefined) iterations = 1; + + for (var k = 0; k < iterations; ++k) { + _alpha += (_alphaTarget - _alpha) * _alphaDecay; + forces.each(function (force) { + force(_alpha); + }); + + for (i = 0; i < n; ++i) { + node = _nodes[i]; + if (node.fx == null) + node.x += node.vx *= _velocityDecay; + else (node.x = node.fx), (node.vx = 0); + if (node.fy == null) + node.y += node.vy *= _velocityDecay; + else (node.y = node.fy), (node.vy = 0); + } + } + + return simulation; + } + + function initializeNodes() { + for (var i = 0, n = _nodes.length, node; i < n; ++i) { + (node = _nodes[i]), (node.index = i); + if (node.fx != null) node.x = node.fx; + if (node.fy != null) node.y = node.fy; + + if (isNaN(node.x) || isNaN(node.y)) { + var radius = initialRadius * Math.sqrt(i), + angle = i * initialAngle; + node.x = radius * Math.cos(angle); + node.y = radius * Math.sin(angle); + } + + if (isNaN(node.vx) || isNaN(node.vy)) { + node.vx = node.vy = 0; + } + } + } + + function initializeForce(force) { + if (force.initialize) force.initialize(_nodes); + return force; + } + + initializeNodes(); + return (simulation = { + tick: tick, + restart: function restart() { + return stepper.restart(step), simulation; + }, + stop: function stop() { + return stepper.stop(), simulation; + }, + nodes: function nodes(_) { + return arguments.length + ? ((_nodes = _), + initializeNodes(), + forces.each(initializeForce), + simulation) + : _nodes; + }, + alpha: function alpha(_) { + return arguments.length + ? ((_alpha = Number(_)), simulation) + : _alpha; + }, + alphaMin: function alphaMin(_) { + return arguments.length + ? ((_alphaMin = Number(_)), simulation) + : _alphaMin; + }, + alphaDecay: function alphaDecay(_) { + return arguments.length + ? ((_alphaDecay = Number(_)), simulation) + : Number(_alphaDecay); + }, + alphaTarget: function alphaTarget(_) { + return arguments.length + ? ((_alphaTarget = Number(_)), simulation) + : _alphaTarget; + }, + velocityDecay: function velocityDecay(_) { + return arguments.length + ? ((_velocityDecay = 1 - _), simulation) + : 1 - _velocityDecay; + }, + force: function force(name, _) { + return arguments.length > 1 + ? (_ == null + ? forces.remove(name) + : forces.set(name, initializeForce(_)), + simulation) + : forces.get(name); + }, + find: function find(x, y, radius) { + var i = 0, + n = _nodes.length, + dx, + dy, + d2, + node, + closest; + if (radius == null) radius = Infinity; + else radius *= radius; + + for (i = 0; i < n; ++i) { + node = _nodes[i]; + dx = x - node.x; + dy = y - node.y; + d2 = dx * dx + dy * dy; + if (d2 < radius) (closest = node), (radius = d2); + } + + return closest; + }, + on: function on(name, _) { + return arguments.length > 1 + ? (event.on(name, _), simulation) + : event.on(name); + }, + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/x.js": + /* !****************************************!*\ + !*** ./node_modules/d3-force/src/x.js ***! + \****************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-force/src/constant.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (x) { + var strength = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(0.1), + nodes, + strengths, + xz; + if (typeof x !== "function") + x = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(x == null ? 0 : Number(x)); + + function force(alpha) { + for (var i = 0, n = nodes.length, node; i < n; ++i) { + (node = nodes[i]), + (node.vx += + (xz[i] - node.x) * strengths[i] * alpha); + } + } + + function initialize() { + if (!nodes) return; + var i, + n = nodes.length; + strengths = new Array(n); + xz = new Array(n); + + for (i = 0; i < n; ++i) { + strengths[i] = isNaN((xz[i] = Number(x(nodes[i], i, nodes)))) + ? 0 + : Number(strength(nodes[i], i, nodes)); + } + } + + force.initialize = function (_) { + nodes = _; + initialize(); + }; + + force.strength = function (_) { + return arguments.length + ? ((strength = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initialize(), + force) + : strength; + }; + + force.x = function (_) { + return arguments.length + ? ((x = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initialize(), + force) + : x; + }; + + return force; + }; + + /***/ + }, + + /***/ "./node_modules/d3-force/src/y.js": + /* !****************************************!*\ + !*** ./node_modules/d3-force/src/y.js ***! + \****************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-force/src/constant.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (y) { + var strength = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(0.1), + nodes, + strengths, + yz; + if (typeof y !== "function") + y = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(y == null ? 0 : Number(y)); + + function force(alpha) { + for (var i = 0, n = nodes.length, node; i < n; ++i) { + (node = nodes[i]), + (node.vy += + (yz[i] - node.y) * strengths[i] * alpha); + } + } + + function initialize() { + if (!nodes) return; + var i, + n = nodes.length; + strengths = new Array(n); + yz = new Array(n); + + for (i = 0; i < n; ++i) { + strengths[i] = isNaN((yz[i] = Number(y(nodes[i], i, nodes)))) + ? 0 + : Number(strength(nodes[i], i, nodes)); + } + } + + force.initialize = function (_) { + nodes = _; + initialize(); + }; + + force.strength = function (_) { + return arguments.length + ? ((strength = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initialize(), + force) + : strength; + }; + + force.y = function (_) { + return arguments.length + ? ((y = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + initialize(), + force) + : y; + }; + + return force; + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/defaultLocale.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-format/src/defaultLocale.js ***! + \*****************************************************/ + /* ! exports provided: format, formatPrefix, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "format", + function () { + return format; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "formatPrefix", + function () { + return formatPrefix; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return defaultLocale; + } + ); + /* Harmony import */ var _locale_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./locale.js */ "./node_modules/d3-format/src/locale.js" + ); + + var locale; + var format; + var formatPrefix; + defaultLocale({ + decimal: ".", + thousands: ",", + grouping: [3], + currency: ["$", ""], + minus: "-", + }); + function defaultLocale(definition) { + locale = Object( + _locale_js__WEBPACK_IMPORTED_MODULE_0__.default + )(definition); + format = locale.format; + formatPrefix = locale.formatPrefix; + return locale; + } + + /***/ + }, + + /***/ "./node_modules/d3-format/src/exponent.js": + /* !************************************************!*\ + !*** ./node_modules/d3-format/src/exponent.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./formatDecimal.js */ "./node_modules/d3-format/src/formatDecimal.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (x) { + return ( + (x = Object( + _formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__.default + )(Math.abs(x))), + x ? x[1] : NaN + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/formatDecimal.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-format/src/formatDecimal.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + // Computes the decimal coefficient and exponent of the specified number x with + // significant digits p, where x is positive and p is in [1, 21] or undefined. + // For example, formatDecimal(1.23) returns ["123", 0]. + /* harmony default export */ __webpack_exports__.default = function (x, p) { + if ( + (i = (x = p + ? x.toExponential(p - 1) + : x.toExponential()).indexOf("e")) < 0 + ) + return null; // NaN, ±Infinity + + var i, + coefficient = x.slice(0, i); // The string returned by toExponential either has the form \d\.\d+e[-+]\d+ + // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3). + + return [ + coefficient.length > 1 + ? coefficient[0] + coefficient.slice(2) + : coefficient, + Number(x.slice(i + 1)), + ]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/formatGroup.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-format/src/formatGroup.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (grouping, thousands) { + return function (value, width) { + var i = value.length, + t = [], + j = 0, + g = grouping[0], + length = 0; + + while (i > 0 && g > 0) { + if (length + g + 1 > width) + g = Math.max(1, width - length); + t.push(value.substring((i -= g), i + g)); + if ((length += g + 1) > width) break; + g = grouping[(j = (j + 1) % grouping.length)]; + } + + return t.reverse().join(thousands); + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/formatNumerals.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-format/src/formatNumerals.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (numerals) { + return function (value) { + return value.replace(/[0-9]/g, function (i) { + return numerals[Number(i)]; + }); + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/formatPrefixAuto.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-format/src/formatPrefixAuto.js ***! + \********************************************************/ + /* ! exports provided: prefixExponent, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "prefixExponent", + function () { + return prefixExponent; + } + ); + /* Harmony import */ var _formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./formatDecimal.js */ "./node_modules/d3-format/src/formatDecimal.js" + ); + + var prefixExponent; + /* Harmony default export */ __webpack_exports__.default = function (x, p) { + var d = Object( + _formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__.default + )(x, p); + if (!d) return String(x); + var coefficient = d[0], + exponent = d[1], + i = + exponent - + (prefixExponent = + Math.max( + -8, + Math.min(8, Math.floor(exponent / 3)) + ) * 3) + + 1, + n = coefficient.length; + return i === n + ? coefficient + : i > n + ? coefficient + new Array(i - n + 1).join("0") + : i > 0 + ? coefficient.slice(0, i) + "." + coefficient.slice(i) + : "0." + + new Array(1 - i).join("0") + + Object( + _formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__.default + )(x, Math.max(0, p + i - 1))[0]; // Less than 1y! + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/formatRounded.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-format/src/formatRounded.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./formatDecimal.js */ "./node_modules/d3-format/src/formatDecimal.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (x, p) { + var d = Object( + _formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__.default + )(x, p); + if (!d) return String(x); + var coefficient = d[0], + exponent = d[1]; + return exponent < 0 + ? "0." + new Array(-exponent).join("0") + coefficient + : coefficient.length > exponent + 1 + ? coefficient.slice(0, exponent + 1) + + "." + + coefficient.slice(exponent + 1) + : coefficient + + new Array(exponent - coefficient.length + 2).join("0"); + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/formatSpecifier.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-format/src/formatSpecifier.js ***! + \*******************************************************/ + /* ! exports provided: default, FormatSpecifier */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return formatSpecifier; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "FormatSpecifier", + function () { + return FormatSpecifier; + } + ); + // [[fill]align][sign][symbol][0][width][,][.precision][~][type] + var re = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i; + function formatSpecifier(specifier) { + if (!(match = re.exec(specifier))) + throw new Error("invalid format: " + specifier); + var match; + return new FormatSpecifier({ + fill: match[1], + align: match[2], + sign: match[3], + symbol: match[4], + zero: match[5], + width: match[6], + comma: match[7], + precision: match[8] && match[8].slice(1), + trim: match[9], + type: match[10], + }); + } + formatSpecifier.prototype = FormatSpecifier.prototype; // Instanceof + + function FormatSpecifier(specifier) { + this.fill = + specifier.fill === undefined ? " " : String(specifier.fill); + this.align = + specifier.align === undefined ? ">" : String(specifier.align); + this.sign = + specifier.sign === undefined ? "-" : String(specifier.sign); + this.symbol = + specifier.symbol === undefined ? "" : String(specifier.symbol); + this.zero = Boolean(specifier.zero); + this.width = + specifier.width === undefined + ? undefined + : Number(specifier.width); + this.comma = Boolean(specifier.comma); + this.precision = + specifier.precision === undefined + ? undefined + : Number(specifier.precision); + this.trim = Boolean(specifier.trim); + this.type = + specifier.type === undefined ? "" : String(specifier.type); + } + + FormatSpecifier.prototype.toString = function () { + return ( + this.fill + + this.align + + this.sign + + this.symbol + + (this.zero ? "0" : "") + + (this.width === undefined + ? "" + : Math.max(1, this.width | 0)) + + (this.comma ? "," : "") + + (this.precision === undefined + ? "" + : "." + Math.max(0, this.precision | 0)) + + (this.trim ? "~" : "") + + this.type + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/formatTrim.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-format/src/formatTrim.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + // Trims insignificant zeros, e.g., replaces 1.2000k with 1.2k. + /* harmony default export */ __webpack_exports__.default = function (s) { + out: for (var n = s.length, i = 1, i0 = -1, i1; i < n; ++i) { + switch (s[i]) { + case ".": + i0 = i1 = i; + break; + + case "0": + if (i0 === 0) i0 = i; + i1 = i; + break; + + default: + if (i0 > 0) { + if (!Number(s[i])) break out; + i0 = 0; + } + + break; + } + } + + return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s; + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/formatTypes.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-format/src/formatTypes.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _formatPrefixAuto_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./formatPrefixAuto.js */ "./node_modules/d3-format/src/formatPrefixAuto.js" + ); + /* Harmony import */ var _formatRounded_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./formatRounded.js */ "./node_modules/d3-format/src/formatRounded.js" + ); + + /* Harmony default export */ __webpack_exports__.default = { + "%": function _(x, p) { + return (x * 100).toFixed(p); + }, + b: function b(x) { + return Math.round(x).toString(2); + }, + c: function c(x) { + return String(x); + }, + d: function d(x) { + return Math.round(x).toString(10); + }, + e: function e(x, p) { + return x.toExponential(p); + }, + f: function f(x, p) { + return x.toFixed(p); + }, + g: function g(x, p) { + return x.toPrecision(p); + }, + o: function o(x) { + return Math.round(x).toString(8); + }, + p: function p(x, _p) { + return Object( + _formatRounded_js__WEBPACK_IMPORTED_MODULE_1__.default + )(x * 100, _p); + }, + r: _formatRounded_js__WEBPACK_IMPORTED_MODULE_1__.default, + s: _formatPrefixAuto_js__WEBPACK_IMPORTED_MODULE_0__.default, + X: function X(x) { + return Math.round(x).toString(16).toUpperCase(); + }, + x: function x(_x) { + return Math.round(_x).toString(16); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/identity.js": + /* !************************************************!*\ + !*** ./node_modules/d3-format/src/identity.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return x; + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/index.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-format/src/index.js ***! + \*********************************************/ + /* ! exports provided: formatDefaultLocale, format, formatPrefix, formatLocale, formatSpecifier, FormatSpecifier, precisionFixed, precisionPrefix, precisionRound */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _defaultLocale_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultLocale.js */ "./node_modules/d3-format/src/defaultLocale.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "formatDefaultLocale", + function () { + return _defaultLocale_js__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "format", + function () { + return _defaultLocale_js__WEBPACK_IMPORTED_MODULE_0__.format; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "formatPrefix", + function () { + return _defaultLocale_js__WEBPACK_IMPORTED_MODULE_0__.formatPrefix; + } + ); + + /* Harmony import */ var _locale_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./locale.js */ "./node_modules/d3-format/src/locale.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "formatLocale", + function () { + return _locale_js__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _formatSpecifier_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./formatSpecifier.js */ "./node_modules/d3-format/src/formatSpecifier.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "formatSpecifier", + function () { + return _formatSpecifier_js__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "FormatSpecifier", + function () { + return _formatSpecifier_js__WEBPACK_IMPORTED_MODULE_2__.FormatSpecifier; + } + ); + + /* Harmony import */ var _precisionFixed_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./precisionFixed.js */ "./node_modules/d3-format/src/precisionFixed.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "precisionFixed", + function () { + return _precisionFixed_js__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _precisionPrefix_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./precisionPrefix.js */ "./node_modules/d3-format/src/precisionPrefix.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "precisionPrefix", + function () { + return _precisionPrefix_js__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _precisionRound_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./precisionRound.js */ "./node_modules/d3-format/src/precisionRound.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "precisionRound", + function () { + return _precisionRound_js__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-format/src/locale.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-format/src/locale.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _exponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./exponent.js */ "./node_modules/d3-format/src/exponent.js" + ); + /* Harmony import */ var _formatGroup_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./formatGroup.js */ "./node_modules/d3-format/src/formatGroup.js" + ); + /* Harmony import */ var _formatNumerals_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./formatNumerals.js */ "./node_modules/d3-format/src/formatNumerals.js" + ); + /* Harmony import */ var _formatSpecifier_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./formatSpecifier.js */ "./node_modules/d3-format/src/formatSpecifier.js" + ); + /* Harmony import */ var _formatTrim_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./formatTrim.js */ "./node_modules/d3-format/src/formatTrim.js" + ); + /* Harmony import */ var _formatTypes_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./formatTypes.js */ "./node_modules/d3-format/src/formatTypes.js" + ); + /* Harmony import */ var _formatPrefixAuto_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./formatPrefixAuto.js */ "./node_modules/d3-format/src/formatPrefixAuto.js" + ); + /* Harmony import */ var _identity_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./identity.js */ "./node_modules/d3-format/src/identity.js" + ); + + var map = Array.prototype.map, + prefixes = [ + "y", + "z", + "a", + "f", + "p", + "n", + "µ", + "m", + "", + "k", + "M", + "G", + "T", + "P", + "E", + "Z", + "Y", + ]; + /* Harmony default export */ __webpack_exports__.default = function (locale) { + var group = + locale.grouping === undefined || + locale.thousands === undefined + ? _identity_js__WEBPACK_IMPORTED_MODULE_7__.default + : Object( + _formatGroup_js__WEBPACK_IMPORTED_MODULE_1__.default + )( + map.call(locale.grouping, Number), + String(locale.thousands) + ), + currencyPrefix = + locale.currency === undefined + ? "" + : String(locale.currency[0]), + currencySuffix = + locale.currency === undefined + ? "" + : String(locale.currency[1]), + decimal = + locale.decimal === undefined + ? "." + : String(locale.decimal), + numerals = + locale.numerals === undefined + ? _identity_js__WEBPACK_IMPORTED_MODULE_7__.default + : Object( + _formatNumerals_js__WEBPACK_IMPORTED_MODULE_2__.default + )(map.call(locale.numerals, String)), + percent = + locale.percent === undefined + ? "%" + : String(locale.percent), + minus = + locale.minus === undefined ? "-" : String(locale.minus), + nan = locale.nan === undefined ? "NaN" : String(locale.nan); + + function newFormat(specifier) { + specifier = Object( + _formatSpecifier_js__WEBPACK_IMPORTED_MODULE_3__.default + )(specifier); + var fill = specifier.fill, + align = specifier.align, + sign = specifier.sign, + symbol = specifier.symbol, + zero = specifier.zero, + width = specifier.width, + comma = specifier.comma, + precision = specifier.precision, + trim = specifier.trim, + type = specifier.type; // The "n" type is an alias for ",g". + + if (type === "n") (comma = true), (type = "g"); + // The "" type, and any invalid type, is an alias for ".12~g". + else if ( + !_formatTypes_js__WEBPACK_IMPORTED_MODULE_5__.default[type] + ) + precision === undefined && (precision = 12), + (trim = true), + (type = "g"); // If zero fill is specified, padding goes after sign and before digits. + + if (zero || (fill === "0" && align === "=")) + (zero = true), (fill = "0"), (align = "="); // Compute the prefix and suffix. + // For SI-prefix, the suffix is lazily computed. + + var prefix = + symbol === "$" + ? currencyPrefix + : symbol === "#" && /[boxX]/.test(type) + ? "0" + type.toLowerCase() + : "", + suffix = + symbol === "$" + ? currencySuffix + : /[%p]/.test(type) + ? percent + : ""; // What format function should we use? + // Is this an integer type? + // Can this type generate exponential notation? + + var formatType = + _formatTypes_js__WEBPACK_IMPORTED_MODULE_5__.default[type], + maybeSuffix = /[defgprs%]/.test(type); // Set the default precision if not specified, + // or clamp the specified precision to the supported range. + // For significant precision, it must be in [1, 21]. + // For fixed precision, it must be in [0, 20]. + + precision = + precision === undefined + ? 6 + : /[gprs]/.test(type) + ? Math.max(1, Math.min(21, precision)) + : Math.max(0, Math.min(20, precision)); + + function format(value) { + var valuePrefix = prefix, + valueSuffix = suffix, + i, + n, + c; + + if (type === "c") { + valueSuffix = formatType(value) + valueSuffix; + value = ""; + } else { + value = Number(value); // Perform the initial formatting. + + var valueNegative = value < 0; + value = isNaN(value) + ? nan + : formatType(Math.abs(value), precision); // Trim insignificant zeros. + + if (trim) + value = Object( + _formatTrim_js__WEBPACK_IMPORTED_MODULE_4__.default + )(value); // If a negative value rounds to zero during formatting, treat as positive. + + if (valueNegative && Number(value) === 0) + valueNegative = false; // Compute the prefix and suffix. + + valuePrefix = + (valueNegative + ? sign === "(" + ? sign + : minus + : sign === "-" || sign === "(" + ? "" + : sign) + valuePrefix; + valueSuffix = + (type === "s" + ? prefixes[ + 8 + + _formatPrefixAuto_js__WEBPACK_IMPORTED_MODULE_6__.prefixExponent / + 3 + ] + : "") + + valueSuffix + + (valueNegative && sign === "(" ? ")" : ""); // Break the formatted value into the integer “value” part that can be + // grouped, and fractional or exponential “suffix” part that is not. + + if (maybeSuffix) { + (i = -1), (n = value.length); + + while (++i < n) { + if ( + ((c = value.charCodeAt(i)), + c < 48 || c > 57) + ) { + valueSuffix = + (c === 46 + ? decimal + value.slice(i + 1) + : value.slice(i)) + valueSuffix; + value = value.slice(0, i); + break; + } + } + } + } // If the fill character is not "0", grouping is applied before padding. + + if (comma && !zero) value = group(value, Infinity); // Compute the padding. + + var length = + valuePrefix.length + + value.length + + valueSuffix.length, + padding = + length < width + ? new Array(width - length + 1).join(fill) + : ""; // If the fill character is "0", grouping is applied after padding. + + if (comma && zero) + (value = group( + padding + value, + padding.length + ? width - valueSuffix.length + : Infinity + )), + (padding = ""); // Reconstruct the final output based on the desired alignment. + + switch (align) { + case "<": + value = + valuePrefix + value + valueSuffix + padding; + break; + + case "=": + value = + valuePrefix + padding + value + valueSuffix; + break; + + case "^": + value = + padding.slice( + 0, + (length = padding.length >> 1) + ) + + valuePrefix + + value + + valueSuffix + + padding.slice(length); + break; + + default: + value = + padding + valuePrefix + value + valueSuffix; + break; + } + + return numerals(value); + } + + format.toString = function () { + return String(specifier); + }; + + return format; + } + + function formatPrefix(specifier, value) { + var f = newFormat( + ((specifier = Object( + _formatSpecifier_js__WEBPACK_IMPORTED_MODULE_3__.default + )(specifier)), + (specifier.type = "f"), + specifier) + ), + e = + Math.max( + -8, + Math.min( + 8, + Math.floor( + Object( + _exponent_js__WEBPACK_IMPORTED_MODULE_0__.default + )(value) / 3 + ) + ) + ) * 3, + k = Math.pow(10, -e), + prefix = prefixes[8 + e / 3]; + return function (value) { + return f(k * value) + prefix; + }; + } + + return { + format: newFormat, + formatPrefix: formatPrefix, + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/precisionFixed.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-format/src/precisionFixed.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _exponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./exponent.js */ "./node_modules/d3-format/src/exponent.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (step) { + return Math.max( + 0, + -Object( + _exponent_js__WEBPACK_IMPORTED_MODULE_0__.default + )(Math.abs(step)) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/precisionPrefix.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-format/src/precisionPrefix.js ***! + \*******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _exponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./exponent.js */ "./node_modules/d3-format/src/exponent.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (step, value) { + return Math.max( + 0, + Math.max( + -8, + Math.min( + 8, + Math.floor( + Object( + _exponent_js__WEBPACK_IMPORTED_MODULE_0__.default + )(value) / 3 + ) + ) + ) * + 3 - + Object( + _exponent_js__WEBPACK_IMPORTED_MODULE_0__.default + )(Math.abs(step)) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-format/src/precisionRound.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-format/src/precisionRound.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _exponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./exponent.js */ "./node_modules/d3-format/src/exponent.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (step, max) { + (step = Math.abs(step)), (max = Math.abs(max) - step); + return ( + Math.max( + 0, + Object( + _exponent_js__WEBPACK_IMPORTED_MODULE_0__.default + )(max) - + Object( + _exponent_js__WEBPACK_IMPORTED_MODULE_0__.default + )(step) + ) + 1 + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/adder.js": + /* !******************************************!*\ + !*** ./node_modules/d3-geo/src/adder.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + // Adds floating point numbers with twice the normal precision. + // Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and + // Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3) + // 305–363 (1997). + // Code adapted from GeographicLib by Charles F. F. Karney, + // http://geographiclib.sourceforge.net/ + /* harmony default export */ __webpack_exports__.default = function () { + return new Adder(); + }; + + function Adder() { + this.reset(); + } + + Adder.prototype = { + constructor: Adder, + reset: function reset() { + this.s = this.t = 0; // Rounded value // exact error + }, + add: function add(y) { + _add(temp, y, this.t); + + _add(this, temp.s, this.s); + + if (this.s) this.t += temp.t; + else this.s = temp.t; + }, + valueOf: function valueOf() { + return this.s; + }, + }; + var temp = new Adder(); + + function _add(adder, a, b) { + var x = (adder.s = a + b), + bv = x - a, + av = x - bv; + adder.t = a - av + (b - bv); + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/area.js": + /* !*****************************************!*\ + !*** ./node_modules/d3-geo/src/area.js ***! + \*****************************************/ + /* ! exports provided: areaRingSum, areaStream, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "areaRingSum", + function () { + return areaRingSum; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "areaStream", + function () { + return areaStream; + } + ); + /* Harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./adder */ "./node_modules/d3-geo/src/adder.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./noop */ "./node_modules/d3-geo/src/noop.js" + ); + /* Harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./stream */ "./node_modules/d3-geo/src/stream.js" + ); + + var areaRingSum = Object( + _adder__WEBPACK_IMPORTED_MODULE_0__.default + )(); + var areaSum = Object( + _adder__WEBPACK_IMPORTED_MODULE_0__.default + )(), + lambda00, + phi00, + lambda0, + cosPhi0, + sinPhi0; + var areaStream = { + point: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + lineStart: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + lineEnd: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + polygonStart: function polygonStart() { + areaRingSum.reset(); + areaStream.lineStart = areaRingStart; + areaStream.lineEnd = areaRingEnd; + }, + polygonEnd: function polygonEnd() { + var areaRing = Number(areaRingSum); + areaSum.add( + areaRing < 0 + ? _math__WEBPACK_IMPORTED_MODULE_1__.tau + + areaRing + : areaRing + ); + this.lineStart = this.lineEnd = this.point = + _noop__WEBPACK_IMPORTED_MODULE_2__.default; + }, + sphere: function sphere() { + areaSum.add(_math__WEBPACK_IMPORTED_MODULE_1__.tau); + }, + }; + + function areaRingStart() { + areaStream.point = areaPointFirst; + } + + function areaRingEnd() { + areaPoint(lambda00, phi00); + } + + function areaPointFirst(lambda, phi) { + areaStream.point = areaPoint; + (lambda00 = lambda), (phi00 = phi); + (lambda *= _math__WEBPACK_IMPORTED_MODULE_1__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_1__.radians); + (lambda0 = lambda), + (cosPhi0 = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )( + (phi = + phi / 2 + + _math__WEBPACK_IMPORTED_MODULE_1__.quarterPi) + )), + (sinPhi0 = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.sin + )(phi)); + } + + function areaPoint(lambda, phi) { + (lambda *= _math__WEBPACK_IMPORTED_MODULE_1__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_1__.radians); + phi = phi / 2 + _math__WEBPACK_IMPORTED_MODULE_1__.quarterPi; // Half the angular distance from south pole + // Spherical excess E for a spherical triangle with vertices: south pole, + // previous point, current point. Uses a formula derived from Cagnoli’s + // theorem. See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2). + + var dLambda = lambda - lambda0, + sdLambda = dLambda >= 0 ? 1 : -1, + adLambda = sdLambda * dLambda, + cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__.cos)( + phi + ), + sinPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + phi + ), + k = sinPhi0 * sinPhi, + u = + cosPhi0 * cosPhi + + k * + Object(_math__WEBPACK_IMPORTED_MODULE_1__.cos)( + adLambda + ), + v = + k * + sdLambda * + Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + adLambda + ); + areaRingSum.add( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.atan2)(v, u) + ); // Advance the previous points. + + (lambda0 = lambda), (cosPhi0 = cosPhi), (sinPhi0 = sinPhi); + } + + /* Harmony default export */ __webpack_exports__.default = function (object) { + areaSum.reset(); + Object(_stream__WEBPACK_IMPORTED_MODULE_3__.default)( + object, + areaStream + ); + return areaSum * 2; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/bounds.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-geo/src/bounds.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./adder */ "./node_modules/d3-geo/src/adder.js" + ); + /* Harmony import */ var _area__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./area */ "./node_modules/d3-geo/src/area.js" + ); + /* Harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./cartesian */ "./node_modules/d3-geo/src/cartesian.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./stream */ "./node_modules/d3-geo/src/stream.js" + ); + + var lambda0, + phi0, + lambda1, + phi1, + // Bounds + lambda2, + // Previous lambda-coordinate + lambda00, + phi00, + // First point + p0, + // Previous 3D point + deltaSum = Object( + _adder__WEBPACK_IMPORTED_MODULE_0__.default + )(), + ranges, + range; + var boundsStream = { + point: boundsPoint, + lineStart: boundsLineStart, + lineEnd: boundsLineEnd, + polygonStart: function polygonStart() { + boundsStream.point = boundsRingPoint; + boundsStream.lineStart = boundsRingStart; + boundsStream.lineEnd = boundsRingEnd; + deltaSum.reset(); + _area__WEBPACK_IMPORTED_MODULE_1__.areaStream.polygonStart(); + }, + polygonEnd: function polygonEnd() { + _area__WEBPACK_IMPORTED_MODULE_1__.areaStream.polygonEnd(); + boundsStream.point = boundsPoint; + boundsStream.lineStart = boundsLineStart; + boundsStream.lineEnd = boundsLineEnd; + if (_area__WEBPACK_IMPORTED_MODULE_1__.areaRingSum < 0) + (lambda0 = -(lambda1 = 180)), (phi0 = -(phi1 = 90)); + else if ( + deltaSum > _math__WEBPACK_IMPORTED_MODULE_3__.epsilon + ) + phi1 = 90; + else if ( + deltaSum < + -_math__WEBPACK_IMPORTED_MODULE_3__.epsilon + ) + phi0 = -90; + (range[0] = lambda0), (range[1] = lambda1); + }, + sphere: function sphere() { + (lambda0 = -(lambda1 = 180)), (phi0 = -(phi1 = 90)); + }, + }; + + function boundsPoint(lambda, phi) { + ranges.push((range = [(lambda0 = lambda), (lambda1 = lambda)])); + if (phi < phi0) phi0 = phi; + if (phi > phi1) phi1 = phi; + } + + function linePoint(lambda, phi) { + var p = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_2__.cartesian + )([ + lambda * _math__WEBPACK_IMPORTED_MODULE_3__.radians, + phi * _math__WEBPACK_IMPORTED_MODULE_3__.radians, + ]); + + if (p0) { + var normal = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_2__.cartesianCross + )(p0, p), + equatorial = [normal[1], -normal[0], 0], + inflection = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_2__.cartesianCross + )(equatorial, normal); + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_2__.cartesianNormalizeInPlace + )(inflection); + inflection = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_2__.spherical + )(inflection); + var delta = lambda - lambda2, + sign = delta > 0 ? 1 : -1, + lambdai = + inflection[0] * + _math__WEBPACK_IMPORTED_MODULE_3__.degrees * + sign, + phii, + antimeridian = + Object(_math__WEBPACK_IMPORTED_MODULE_3__.abs)( + delta + ) > 180; + + if ( + antimeridian ^ + (sign * lambda2 < lambdai && lambdai < sign * lambda) + ) { + phii = + inflection[1] * + _math__WEBPACK_IMPORTED_MODULE_3__.degrees; + if (phii > phi1) phi1 = phii; + } else if ( + ((lambdai = ((lambdai + 360) % 360) - 180), + antimeridian ^ + (sign * lambda2 < lambdai && + lambdai < sign * lambda)) + ) { + phii = + -inflection[1] * + _math__WEBPACK_IMPORTED_MODULE_3__.degrees; + if (phii < phi0) phi0 = phii; + } else { + if (phi < phi0) phi0 = phi; + if (phi > phi1) phi1 = phi; + } + + if (antimeridian) { + if (lambda < lambda2) { + if ( + angle(lambda0, lambda) > angle(lambda0, lambda1) + ) + lambda1 = lambda; + } else if ( + angle(lambda, lambda1) > angle(lambda0, lambda1) + ) + lambda0 = lambda; + } else if (lambda1 >= lambda0) { + if (lambda < lambda0) lambda0 = lambda; + if (lambda > lambda1) lambda1 = lambda; + } else if (lambda > lambda2) { + if ( + angle(lambda0, lambda) > + angle(lambda0, lambda1) + ) + lambda1 = lambda; + } else if ( + angle(lambda, lambda1) > + angle(lambda0, lambda1) + ) + lambda0 = lambda; + } else { + ranges.push( + (range = [(lambda0 = lambda), (lambda1 = lambda)]) + ); + } + + if (phi < phi0) phi0 = phi; + if (phi > phi1) phi1 = phi; + (p0 = p), (lambda2 = lambda); + } + + function boundsLineStart() { + boundsStream.point = linePoint; + } + + function boundsLineEnd() { + (range[0] = lambda0), (range[1] = lambda1); + boundsStream.point = boundsPoint; + p0 = null; + } + + function boundsRingPoint(lambda, phi) { + if (p0) { + var delta = lambda - lambda2; + deltaSum.add( + Object(_math__WEBPACK_IMPORTED_MODULE_3__.abs)( + delta + ) > 180 + ? delta + (delta > 0 ? 360 : -360) + : delta + ); + } else { + (lambda00 = lambda), (phi00 = phi); + } + + _area__WEBPACK_IMPORTED_MODULE_1__.areaStream.point( + lambda, + phi + ); + linePoint(lambda, phi); + } + + function boundsRingStart() { + _area__WEBPACK_IMPORTED_MODULE_1__.areaStream.lineStart(); + } + + function boundsRingEnd() { + boundsRingPoint(lambda00, phi00); + _area__WEBPACK_IMPORTED_MODULE_1__.areaStream.lineEnd(); + if ( + Object(_math__WEBPACK_IMPORTED_MODULE_3__.abs)( + deltaSum + ) > _math__WEBPACK_IMPORTED_MODULE_3__.epsilon + ) + lambda0 = -(lambda1 = 180); + (range[0] = lambda0), (range[1] = lambda1); + p0 = null; + } // Finds the left-right distance between two longitudes. + // This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want + // the distance between ±180° to be 360°. + + function angle(lambda0, lambda1) { + return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1; + } + + function rangeCompare(a, b) { + return a[0] - b[0]; + } + + function rangeContains(range, x) { + return range[0] <= range[1] + ? range[0] <= x && x <= range[1] + : x < range[0] || range[1] < x; + } + + /* Harmony default export */ __webpack_exports__.default = function (feature) { + var i, n, a, b, merged, deltaMax, delta; + phi1 = lambda1 = -(lambda0 = phi0 = Infinity); + ranges = []; + Object(_stream__WEBPACK_IMPORTED_MODULE_4__.default)( + feature, + boundsStream + ); // First, sort ranges by their minimum longitudes. + + if ((n = ranges.length)) { + ranges.sort(rangeCompare); // Then, merge any ranges that overlap. + + for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) { + b = ranges[i]; + + if (rangeContains(a, b[0]) || rangeContains(a, b[1])) { + if (angle(a[0], b[1]) > angle(a[0], a[1])) + a[1] = b[1]; + if (angle(b[0], a[1]) > angle(a[0], a[1])) + a[0] = b[0]; + } else { + merged.push((a = b)); + } + } // Finally, find the largest gap between the merged ranges. + // The final bounding box will be the inverse of this gap. + + for ( + deltaMax = -Infinity, + n = merged.length - 1, + i = 0, + a = merged[n]; + i <= n; + a = b, ++i + ) { + b = merged[i]; + if ((delta = angle(a[1], b[0])) > deltaMax) + (deltaMax = delta), + (lambda0 = b[0]), + (lambda1 = a[1]); + } + } + + ranges = range = null; + return lambda0 === Infinity || phi0 === Infinity + ? [ + [NaN, NaN], + [NaN, NaN], + ] + : [ + [lambda0, phi0], + [lambda1, phi1], + ]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/cartesian.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-geo/src/cartesian.js ***! + \**********************************************/ + /* ! exports provided: spherical, cartesian, cartesianDot, cartesianCross, cartesianAddInPlace, cartesianScale, cartesianNormalizeInPlace */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "spherical", + function () { + return spherical; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cartesian", + function () { + return cartesian; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cartesianDot", + function () { + return cartesianDot; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cartesianCross", + function () { + return cartesianCross; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cartesianAddInPlace", + function () { + return cartesianAddInPlace; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cartesianScale", + function () { + return cartesianScale; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cartesianNormalizeInPlace", + function () { + return cartesianNormalizeInPlace; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + + function spherical(cartesian) { + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan2)( + cartesian[1], + cartesian[0] + ), + Object(_math__WEBPACK_IMPORTED_MODULE_0__.asin)( + cartesian[2] + ), + ]; + } + function cartesian(spherical) { + var lambda = spherical[0], + phi = spherical[1], + cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + phi + ); + return [ + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + lambda + ), + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + lambda + ), + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(phi), + ]; + } + function cartesianDot(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; + } + function cartesianCross(a, b) { + return [ + a[1] * b[2] - a[2] * b[1], + a[2] * b[0] - a[0] * b[2], + a[0] * b[1] - a[1] * b[0], + ]; + } // TODO return a + + function cartesianAddInPlace(a, b) { + (a[0] += b[0]), (a[1] += b[1]), (a[2] += b[2]); + } + function cartesianScale(vector, k) { + return [vector[0] * k, vector[1] * k, vector[2] * k]; + } // TODO return d + + function cartesianNormalizeInPlace(d) { + var l = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + d[0] * d[0] + d[1] * d[1] + d[2] * d[2] + ); + (d[0] /= l), (d[1] /= l), (d[2] /= l); + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/centroid.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-geo/src/centroid.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./noop */ "./node_modules/d3-geo/src/noop.js" + ); + /* Harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./stream */ "./node_modules/d3-geo/src/stream.js" + ); + + var W0, + W1, + X0, + Y0, + Z0, + X1, + Y1, + Z1, + X2, + Y2, + Z2, + lambda00, + phi00, // First point + x0, + y0, + z0; // Previous point + + var centroidStream = { + sphere: _noop__WEBPACK_IMPORTED_MODULE_1__.default, + point: centroidPoint, + lineStart: centroidLineStart, + lineEnd: centroidLineEnd, + polygonStart: function polygonStart() { + centroidStream.lineStart = centroidRingStart; + centroidStream.lineEnd = centroidRingEnd; + }, + polygonEnd: function polygonEnd() { + centroidStream.lineStart = centroidLineStart; + centroidStream.lineEnd = centroidLineEnd; + }, + }; // Arithmetic mean of Cartesian vectors. + + function centroidPoint(lambda, phi) { + (lambda *= _math__WEBPACK_IMPORTED_MODULE_0__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_0__.radians); + var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + phi + ); + centroidPointCartesian( + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + lambda + ), + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + lambda + ), + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(phi) + ); + } + + function centroidPointCartesian(x, y, z) { + ++W0; + X0 += (x - X0) / W0; + Y0 += (y - Y0) / W0; + Z0 += (z - Z0) / W0; + } + + function centroidLineStart() { + centroidStream.point = centroidLinePointFirst; + } + + function centroidLinePointFirst(lambda, phi) { + (lambda *= _math__WEBPACK_IMPORTED_MODULE_0__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_0__.radians); + var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + phi + ); + x0 = + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(lambda); + y0 = + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(lambda); + z0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(phi); + centroidStream.point = centroidLinePoint; + centroidPointCartesian(x0, y0, z0); + } + + function centroidLinePoint(lambda, phi) { + (lambda *= _math__WEBPACK_IMPORTED_MODULE_0__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_0__.radians); + var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + phi + ), + x = + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + lambda + ), + y = + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + lambda + ), + z = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(phi), + w = Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan2)( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + (w = y0 * z - z0 * y) * w + + (w = z0 * x - x0 * z) * w + + (w = x0 * y - y0 * x) * w + ), + x0 * x + y0 * y + z0 * z + ); + W1 += w; + X1 += w * (x0 + (x0 = x)); + Y1 += w * (y0 + (y0 = y)); + Z1 += w * (z0 + (z0 = z)); + centroidPointCartesian(x0, y0, z0); + } + + function centroidLineEnd() { + centroidStream.point = centroidPoint; + } // See J. E. Brock, The Inertia Tensor for a Spherical Triangle, + // J. Applied Mechanics 42, 239 (1975). + + function centroidRingStart() { + centroidStream.point = centroidRingPointFirst; + } + + function centroidRingEnd() { + centroidRingPoint(lambda00, phi00); + centroidStream.point = centroidPoint; + } + + function centroidRingPointFirst(lambda, phi) { + (lambda00 = lambda), (phi00 = phi); + (lambda *= _math__WEBPACK_IMPORTED_MODULE_0__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_0__.radians); + centroidStream.point = centroidRingPoint; + var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + phi + ); + x0 = + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(lambda); + y0 = + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(lambda); + z0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(phi); + centroidPointCartesian(x0, y0, z0); + } + + function centroidRingPoint(lambda, phi) { + (lambda *= _math__WEBPACK_IMPORTED_MODULE_0__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_0__.radians); + var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + phi + ), + x = + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + lambda + ), + y = + cosPhi * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + lambda + ), + z = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(phi), + cx = y0 * z - z0 * y, + cy = z0 * x - x0 * z, + cz = x0 * y - y0 * x, + m = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + cx * cx + cy * cy + cz * cz + ), + w = Object(_math__WEBPACK_IMPORTED_MODULE_0__.asin)(m), + // Line weight = angle + v = m && -w / m; // Area weight multiplier + + X2 += v * cx; + Y2 += v * cy; + Z2 += v * cz; + W1 += w; + X1 += w * (x0 + (x0 = x)); + Y1 += w * (y0 + (y0 = y)); + Z1 += w * (z0 + (z0 = z)); + centroidPointCartesian(x0, y0, z0); + } + + /* Harmony default export */ __webpack_exports__.default = function (object) { + W0 = W1 = X0 = Y0 = Z0 = X1 = Y1 = Z1 = X2 = Y2 = Z2 = 0; + Object(_stream__WEBPACK_IMPORTED_MODULE_2__.default)( + object, + centroidStream + ); + var x = X2, + y = Y2, + z = Z2, + m = x * x + y * y + z * z; // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid. + + if (m < _math__WEBPACK_IMPORTED_MODULE_0__.epsilon2) { + (x = X1), (y = Y1), (z = Z1); // If the feature has zero length, fall back to arithmetic mean of point vectors. + + if (W1 < _math__WEBPACK_IMPORTED_MODULE_0__.epsilon) + (x = X0), (y = Y0), (z = Z0); + m = x * x + y * y + z * z; // If the feature still has an undefined ccentroid, then return. + + if (m < _math__WEBPACK_IMPORTED_MODULE_0__.epsilon2) + return [NaN, NaN]; + } + + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan2)(y, x) * + _math__WEBPACK_IMPORTED_MODULE_0__.degrees, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.asin)( + z / + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + m + ) + ) * _math__WEBPACK_IMPORTED_MODULE_0__.degrees, + ]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/circle.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-geo/src/circle.js ***! + \*******************************************/ + /* ! exports provided: circleStream, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "circleStream", + function () { + return circleStream; + } + ); + /* Harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./cartesian */ "./node_modules/d3-geo/src/cartesian.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-geo/src/constant.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _rotation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./rotation */ "./node_modules/d3-geo/src/rotation.js" + ); + + // Generates a circle centered at [0°, 0°], with a given radius and precision. + + function circleStream(stream, radius, delta, direction, t0, t1) { + if (!delta) return; + var cosRadius = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(radius), + sinRadius = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(radius), + step = direction * delta; + + if (t0 == null) { + t0 = + radius + + direction * _math__WEBPACK_IMPORTED_MODULE_2__.tau; + t1 = radius - step / 2; + } else { + t0 = circleRadius(cosRadius, t0); + t1 = circleRadius(cosRadius, t1); + if (direction > 0 ? t0 < t1 : t0 > t1) + t0 += + direction * + _math__WEBPACK_IMPORTED_MODULE_2__.tau; + } + + for ( + var point, t = t0; + direction > 0 ? t > t1 : t < t1; + t -= step + ) { + point = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.spherical + )([ + cosRadius, + -sinRadius * + Object(_math__WEBPACK_IMPORTED_MODULE_2__.cos)( + t + ), + -sinRadius * + Object(_math__WEBPACK_IMPORTED_MODULE_2__.sin)( + t + ), + ]); + stream.point(point[0], point[1]); + } + } // Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0]. + + function circleRadius(cosRadius, point) { + (point = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesian + )(point)), + (point[0] -= cosRadius); + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianNormalizeInPlace + )(point); + var radius = Object(_math__WEBPACK_IMPORTED_MODULE_2__.acos)( + -point[1] + ); + return ( + ((-point[2] < 0 ? -radius : radius) + + _math__WEBPACK_IMPORTED_MODULE_2__.tau - + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon) % + _math__WEBPACK_IMPORTED_MODULE_2__.tau + ); + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var center = Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )([0, 0]), + radius = Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(90), + precision = Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(6), + ring, + rotate, + stream = { + point: point, + }; + + function point(x, y) { + ring.push((x = rotate(x, y))); + (x[0] *= _math__WEBPACK_IMPORTED_MODULE_2__.degrees), + (x[1] *= _math__WEBPACK_IMPORTED_MODULE_2__.degrees); + } + + function circle() { + var c = center.apply(this, arguments), + r = + radius.apply(this, arguments) * + _math__WEBPACK_IMPORTED_MODULE_2__.radians, + p = + precision.apply(this, arguments) * + _math__WEBPACK_IMPORTED_MODULE_2__.radians; + ring = []; + rotate = Object( + _rotation__WEBPACK_IMPORTED_MODULE_3__.rotateRadians + )( + -c[0] * _math__WEBPACK_IMPORTED_MODULE_2__.radians, + -c[1] * _math__WEBPACK_IMPORTED_MODULE_2__.radians, + 0 + ).invert; + circleStream(stream, r, p, 1); + c = { + type: "Polygon", + coordinates: [ring], + }; + ring = rotate = null; + return c; + } + + circle.center = function (_) { + return arguments.length + ? ((center = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )([Number(_[0]), Number(_[1])])), + circle) + : center; + }; + + circle.radius = function (_) { + return arguments.length + ? ((radius = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + circle) + : radius; + }; + + circle.precision = function (_) { + return arguments.length + ? ((precision = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + circle) + : precision; + }; + + return circle; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/clip/antimeridian.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-geo/src/clip/antimeridian.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/clip/index.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_index__WEBPACK_IMPORTED_MODULE_0__.default)( + function () { + return true; + }, + clipAntimeridianLine, + clipAntimeridianInterpolate, + [ + -_math__WEBPACK_IMPORTED_MODULE_1__.pi, + -_math__WEBPACK_IMPORTED_MODULE_1__.halfPi, + ] + ); // Takes a line and cuts into visible segments. Return values: 0 - there were + // intersections or the line was empty; 1 - no intersections; 2 - there were + // intersections, and the first and last segments should be rejoined. + + function clipAntimeridianLine(stream) { + var lambda0 = NaN, + phi0 = NaN, + sign0 = NaN, + _clean; // No intersections + + return { + lineStart: function lineStart() { + stream.lineStart(); + _clean = 1; + }, + point: function point(lambda1, phi1) { + var sign1 = + lambda1 > 0 + ? _math__WEBPACK_IMPORTED_MODULE_1__.pi + : -_math__WEBPACK_IMPORTED_MODULE_1__.pi, + delta = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.abs + )(lambda1 - lambda0); + + if ( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.abs)( + delta - _math__WEBPACK_IMPORTED_MODULE_1__.pi + ) < _math__WEBPACK_IMPORTED_MODULE_1__.epsilon + ) { + // Line crosses a pole + stream.point( + lambda0, + (phi0 = + (phi0 + phi1) / 2 > 0 + ? _math__WEBPACK_IMPORTED_MODULE_1__.halfPi + : -_math__WEBPACK_IMPORTED_MODULE_1__.halfPi) + ); + stream.point(sign0, phi0); + stream.lineEnd(); + stream.lineStart(); + stream.point(sign1, phi0); + stream.point(lambda1, phi0); + _clean = 0; + } else if ( + sign0 !== sign1 && + delta >= _math__WEBPACK_IMPORTED_MODULE_1__.pi + ) { + // Line crosses antimeridian + if ( + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.abs + )(lambda0 - sign0) < + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon + ) + lambda0 -= + sign0 * + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon; // Handle degeneracies + + if ( + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.abs + )(lambda1 - sign1) < + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon + ) + lambda1 -= + sign1 * + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon; + phi0 = clipAntimeridianIntersect( + lambda0, + phi0, + lambda1, + phi1 + ); + stream.point(sign0, phi0); + stream.lineEnd(); + stream.lineStart(); + stream.point(sign1, phi0); + _clean = 0; + } + + stream.point((lambda0 = lambda1), (phi0 = phi1)); + sign0 = sign1; + }, + lineEnd: function lineEnd() { + stream.lineEnd(); + lambda0 = phi0 = NaN; + }, + clean: function clean() { + return 2 - _clean; // If intersections, rejoin first and last segments + }, + }; + } + + function clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) { + var cosPhi0, + cosPhi1, + sinLambda0Lambda1 = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.sin + )(lambda0 - lambda1); + return Object(_math__WEBPACK_IMPORTED_MODULE_1__.abs)( + sinLambda0Lambda1 + ) > _math__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? Object(_math__WEBPACK_IMPORTED_MODULE_1__.atan)( + (Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + phi0 + ) * + (cosPhi1 = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(phi1)) * + Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + lambda1 + ) - + Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + phi1 + ) * + (cosPhi0 = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(phi0)) * + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.sin + )(lambda0)) / + (cosPhi0 * cosPhi1 * sinLambda0Lambda1) + ) + : (phi0 + phi1) / 2; + } + + function clipAntimeridianInterpolate(from, to, direction, stream) { + var phi; + + if (from == null) { + phi = + direction * + _math__WEBPACK_IMPORTED_MODULE_1__.halfPi; + stream.point( + -_math__WEBPACK_IMPORTED_MODULE_1__.pi, + phi + ); + stream.point(0, phi); + stream.point(_math__WEBPACK_IMPORTED_MODULE_1__.pi, phi); + stream.point(_math__WEBPACK_IMPORTED_MODULE_1__.pi, 0); + stream.point( + _math__WEBPACK_IMPORTED_MODULE_1__.pi, + -phi + ); + stream.point(0, -phi); + stream.point( + -_math__WEBPACK_IMPORTED_MODULE_1__.pi, + -phi + ); + stream.point(-_math__WEBPACK_IMPORTED_MODULE_1__.pi, 0); + stream.point( + -_math__WEBPACK_IMPORTED_MODULE_1__.pi, + phi + ); + } else if ( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.abs)( + from[0] - to[0] + ) > _math__WEBPACK_IMPORTED_MODULE_1__.epsilon + ) { + var lambda = + from[0] < to[0] + ? _math__WEBPACK_IMPORTED_MODULE_1__.pi + : -_math__WEBPACK_IMPORTED_MODULE_1__.pi; + phi = (direction * lambda) / 2; + stream.point(-lambda, phi); + stream.point(0, phi); + stream.point(lambda, phi); + } else { + stream.point(to[0], to[1]); + } + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/clip/buffer.js": + /* !************************************************!*\ + !*** ./node_modules/d3-geo/src/clip/buffer.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-geo/src/noop.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var lines = [], + line; + return { + point: function point(x, y) { + line.push([x, y]); + }, + lineStart: function lineStart() { + lines.push((line = [])); + }, + lineEnd: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + rejoin: function rejoin() { + if (lines.length > 1) + lines.push(lines.pop().concat(lines.shift())); + }, + result: function result() { + var result = lines; + lines = []; + line = null; + return result; + }, + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/clip/circle.js": + /* !************************************************!*\ + !*** ./node_modules/d3-geo/src/clip/circle.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../cartesian */ "./node_modules/d3-geo/src/cartesian.js" + ); + /* Harmony import */ var _circle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../circle */ "./node_modules/d3-geo/src/circle.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _pointEqual__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ../pointEqual */ "./node_modules/d3-geo/src/pointEqual.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/clip/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (radius) { + var cr = Object(_math__WEBPACK_IMPORTED_MODULE_2__.cos)( + radius + ), + delta = 6 * _math__WEBPACK_IMPORTED_MODULE_2__.radians, + smallRadius = cr > 0, + notHemisphere = + Object(_math__WEBPACK_IMPORTED_MODULE_2__.abs)(cr) > + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon; // TODO optimise for this common case + + function interpolate(from, to, direction, stream) { + Object( + _circle__WEBPACK_IMPORTED_MODULE_1__.circleStream + )(stream, radius, delta, direction, from, to); + } + + function visible(lambda, phi) { + return ( + Object(_math__WEBPACK_IMPORTED_MODULE_2__.cos)( + lambda + ) * + Object(_math__WEBPACK_IMPORTED_MODULE_2__.cos)( + phi + ) > + cr + ); + } // Takes a line and cuts into visible segments. Return values used for polygon + // clipping: 0 - there were intersections or the line was empty; 1 - no + // intersections 2 - there were intersections, and the first and last segments + // should be rejoined. + + function clipLine(stream) { + var point0, // Previous point + c0, // Code for previous point + v0, // Visibility of previous point + v00, // Visibility of first point + _clean; // No intersections + + return { + lineStart: function lineStart() { + v00 = v0 = false; + _clean = 1; + }, + point: function point(lambda, phi) { + var point1 = [lambda, phi], + point2, + v = visible(lambda, phi), + c = smallRadius + ? v + ? 0 + : code(lambda, phi) + : v + ? code( + lambda + + (lambda < 0 + ? _math__WEBPACK_IMPORTED_MODULE_2__.pi + : -_math__WEBPACK_IMPORTED_MODULE_2__.pi), + phi + ) + : 0; + if (!point0 && (v00 = v0 = v)) stream.lineStart(); // Handle degeneracies. + // TODO ignore if not clipping polygons. + + if (v !== v0) { + point2 = intersect(point0, point1); + + if ( + !point2 || + Object( + _pointEqual__WEBPACK_IMPORTED_MODULE_3__.default + )(point0, point2) || + Object( + _pointEqual__WEBPACK_IMPORTED_MODULE_3__.default + )(point1, point2) + ) { + point1[0] += + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon; + point1[1] += + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon; + v = visible(point1[0], point1[1]); + } + } + + if (v !== v0) { + _clean = 0; + + if (v) { + // Outside going in + stream.lineStart(); + point2 = intersect(point1, point0); + stream.point(point2[0], point2[1]); + } else { + // Inside going out + point2 = intersect(point0, point1); + stream.point(point2[0], point2[1]); + stream.lineEnd(); + } + + point0 = point2; + } else if ( + notHemisphere && + point0 && + smallRadius ^ v + ) { + var t; // If the codes for two points are different, or are both zero, + // and there this segment intersects with the small circle. + + if ( + !(c & c0) && + (t = intersect(point1, point0, true)) + ) { + _clean = 0; + + if (smallRadius) { + stream.lineStart(); + stream.point(t[0][0], t[0][1]); + stream.point(t[1][0], t[1][1]); + stream.lineEnd(); + } else { + stream.point(t[1][0], t[1][1]); + stream.lineEnd(); + stream.lineStart(); + stream.point(t[0][0], t[0][1]); + } + } + } + + if ( + v && + (!point0 || + !Object( + _pointEqual__WEBPACK_IMPORTED_MODULE_3__.default + )(point0, point1)) + ) { + stream.point(point1[0], point1[1]); + } + + (point0 = point1), (v0 = v), (c0 = c); + }, + lineEnd: function lineEnd() { + if (v0) stream.lineEnd(); + point0 = null; + }, + // Rejoin first and last segments if there were intersections and the first + // and last points were visible. + clean: function clean() { + return _clean | ((v00 && v0) << 1); + }, + }; + } // Intersects the great circle between a and b with the clip circle. + + function intersect(a, b, two) { + var pa = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesian + )(a), + pb = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesian + )(b); // We have two planes, n1.p = d1 and n2.p = d2. + // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2). + + var n1 = [1, 0, 0], + // Normal + n2 = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianCross + )(pa, pb), + n2n2 = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianDot + )(n2, n2), + n1n2 = n2[0], + // CartesianDot(n1, n2), + determinant = n2n2 - n1n2 * n1n2; // Two polar points. + + if (!determinant) return !two && a; + var c1 = (cr * n2n2) / determinant, + c2 = (-cr * n1n2) / determinant, + n1xn2 = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianCross + )(n1, n2), + A = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianScale + )(n1, c1), + B = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianScale + )(n2, c2); + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianAddInPlace + )(A, B); // Solve |p(t)|^2 = 1. + + var u = n1xn2, + w = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianDot + )(A, u), + uu = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianDot + )(u, u), + t2 = + w * w - + uu * + (Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianDot + )(A, A) - + 1); + if (t2 < 0) return; + var t = Object(_math__WEBPACK_IMPORTED_MODULE_2__.sqrt)( + t2 + ), + q = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianScale + )(u, (-w - t) / uu); + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianAddInPlace + )(q, A); + q = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.spherical + )(q); + if (!two) return q; // Two intersection points. + + var lambda0 = a[0], + lambda1 = b[0], + phi0 = a[1], + phi1 = b[1], + z; + if (lambda1 < lambda0) + (z = lambda0), (lambda0 = lambda1), (lambda1 = z); + var delta = lambda1 - lambda0, + polar = + Object(_math__WEBPACK_IMPORTED_MODULE_2__.abs)( + delta - _math__WEBPACK_IMPORTED_MODULE_2__.pi + ) < _math__WEBPACK_IMPORTED_MODULE_2__.epsilon, + meridian = + polar || + delta < + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon; + if (!polar && phi1 < phi0) + (z = phi0), (phi0 = phi1), (phi1 = z); // Check that the first point is between a and b. + + if ( + meridian + ? polar + ? (phi0 + phi1 > 0) ^ + (q[1] < + (Object( + _math__WEBPACK_IMPORTED_MODULE_2__.abs + )(q[0] - lambda0) < + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ? phi0 + : phi1)) + : phi0 <= q[1] && q[1] <= phi1 + : (delta > + _math__WEBPACK_IMPORTED_MODULE_2__.pi) ^ + (lambda0 <= q[0] && q[0] <= lambda1) + ) { + var q1 = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianScale + )(u, (-w + t) / uu); + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesianAddInPlace + )(q1, A); + return [ + q, + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.spherical + )(q1), + ]; + } + } // Generates a 4-bit vector representing the location of a point relative to + // the small circle's bounding box. + + function code(lambda, phi) { + var r = smallRadius + ? radius + : _math__WEBPACK_IMPORTED_MODULE_2__.pi - radius, + code = 0; + if (lambda < -r) code |= 1; + // Left + else if (lambda > r) code |= 2; // Right + + if (phi < -r) code |= 4; + // Below + else if (phi > r) code |= 8; // Above + + return code; + } + + return Object(_index__WEBPACK_IMPORTED_MODULE_4__.default)( + visible, + clipLine, + interpolate, + smallRadius + ? [0, -radius] + : [ + -_math__WEBPACK_IMPORTED_MODULE_2__.pi, + radius - _math__WEBPACK_IMPORTED_MODULE_2__.pi, + ] + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/clip/extent.js": + /* !************************************************!*\ + !*** ./node_modules/d3-geo/src/clip/extent.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _rectangle__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./rectangle */ "./node_modules/d3-geo/src/clip/rectangle.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var x0 = 0, + y0 = 0, + x1 = 960, + y1 = 500, + cache, + cacheStream, + clip; + return (clip = { + stream: function stream(_stream) { + return cache && cacheStream === _stream + ? cache + : (cache = Object( + _rectangle__WEBPACK_IMPORTED_MODULE_0__.default + )( + x0, + y0, + x1, + y1 + )((cacheStream = _stream))); + }, + extent: function extent(_) { + return arguments.length + ? ((x0 = Number(_[0][0])), + (y0 = Number(_[0][1])), + (x1 = Number(_[1][0])), + (y1 = Number(_[1][1])), + (cache = cacheStream = null), + clip) + : [ + [x0, y0], + [x1, y1], + ]; + }, + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/clip/index.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-geo/src/clip/index.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _buffer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./buffer */ "./node_modules/d3-geo/src/clip/buffer.js" + ); + /* Harmony import */ var _rejoin__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./rejoin */ "./node_modules/d3-geo/src/clip/rejoin.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _polygonContains__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ../polygonContains */ "./node_modules/d3-geo/src/polygonContains.js" + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (pointVisible, clipLine, interpolate, start) { + return function (sink) { + var line = clipLine(sink), + ringBuffer = Object( + _buffer__WEBPACK_IMPORTED_MODULE_0__.default + )(), + ringSink = clipLine(ringBuffer), + polygonStarted = false, + polygon, + segments, + ring; + var clip = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: function polygonStart() { + clip.point = pointRing; + clip.lineStart = ringStart; + clip.lineEnd = ringEnd; + segments = []; + polygon = []; + }, + polygonEnd: function polygonEnd() { + clip.point = point; + clip.lineStart = lineStart; + clip.lineEnd = lineEnd; + segments = Object( + d3_array__WEBPACK_IMPORTED_MODULE_4__.merge + )(segments); + var startInside = Object( + _polygonContains__WEBPACK_IMPORTED_MODULE_3__.default + )(polygon, start); + + if (segments.length) { + if (!polygonStarted) + sink.polygonStart(), + (polygonStarted = true); + Object( + _rejoin__WEBPACK_IMPORTED_MODULE_1__.default + )( + segments, + compareIntersection, + startInside, + interpolate, + sink + ); + } else if (startInside) { + if (!polygonStarted) + sink.polygonStart(), + (polygonStarted = true); + sink.lineStart(); + interpolate(null, null, 1, sink); + sink.lineEnd(); + } + + if (polygonStarted) + sink.polygonEnd(), (polygonStarted = false); + segments = polygon = null; + }, + sphere: function sphere() { + sink.polygonStart(); + sink.lineStart(); + interpolate(null, null, 1, sink); + sink.lineEnd(); + sink.polygonEnd(); + }, + }; + + function point(lambda, phi) { + if (pointVisible(lambda, phi)) sink.point(lambda, phi); + } + + function pointLine(lambda, phi) { + line.point(lambda, phi); + } + + function lineStart() { + clip.point = pointLine; + line.lineStart(); + } + + function lineEnd() { + clip.point = point; + line.lineEnd(); + } + + function pointRing(lambda, phi) { + ring.push([lambda, phi]); + ringSink.point(lambda, phi); + } + + function ringStart() { + ringSink.lineStart(); + ring = []; + } + + function ringEnd() { + pointRing(ring[0][0], ring[0][1]); + ringSink.lineEnd(); + var clean = ringSink.clean(), + ringSegments = ringBuffer.result(), + i, + n = ringSegments.length, + m, + segment, + point; + ring.pop(); + polygon.push(ring); + ring = null; + if (!n) return; // No intersections. + + if (clean & 1) { + segment = ringSegments[0]; + + if ((m = segment.length - 1) > 0) { + if (!polygonStarted) + sink.polygonStart(), + (polygonStarted = true); + sink.lineStart(); + + for (i = 0; i < m; ++i) { + sink.point( + (point = segment[i])[0], + point[1] + ); + } + + sink.lineEnd(); + } + + return; + } // Rejoin connected segments. + // TODO reuse ringBuffer.rejoin()? + + if (n > 1 && clean & 2) + ringSegments.push( + ringSegments.pop().concat(ringSegments.shift()) + ); + segments.push(ringSegments.filter(validSegment)); + } + + return clip; + }; + }; + + function validSegment(segment) { + return segment.length > 1; + } // Intersections are sorted along the clip edge. For both antimeridian cutting + // and circle clipping, the same comparison is used. + + function compareIntersection(a, b) { + return ( + ((a = a.x)[0] < 0 + ? a[1] - + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi - + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + : _math__WEBPACK_IMPORTED_MODULE_2__.halfPi - a[1]) - + ((b = b.x)[0] < 0 + ? b[1] - + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi - + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + : _math__WEBPACK_IMPORTED_MODULE_2__.halfPi - b[1]) + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/clip/line.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-geo/src/clip/line.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b, x0, y0, x1, y1) { + var ax = a[0], + ay = a[1], + bx = b[0], + by = b[1], + t0 = 0, + t1 = 1, + dx = bx - ax, + dy = by - ay, + r; + r = x0 - ax; + if (!dx && r > 0) return; + r /= dx; + + if (dx < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dx > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + + r = x1 - ax; + if (!dx && r < 0) return; + r /= dx; + + if (dx < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dx > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + + r = y0 - ay; + if (!dy && r > 0) return; + r /= dy; + + if (dy < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dy > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + + r = y1 - ay; + if (!dy && r < 0) return; + r /= dy; + + if (dy < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dy > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + + if (t0 > 0) (a[0] = ax + t0 * dx), (a[1] = ay + t0 * dy); + if (t1 < 1) (b[0] = ax + t1 * dx), (b[1] = ay + t1 * dy); + return true; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/clip/rectangle.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-geo/src/clip/rectangle.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return clipRectangle; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _buffer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./buffer */ "./node_modules/d3-geo/src/clip/buffer.js" + ); + /* Harmony import */ var _line__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./line */ "./node_modules/d3-geo/src/clip/line.js" + ); + /* Harmony import */ var _rejoin__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./rejoin */ "./node_modules/d3-geo/src/clip/rejoin.js" + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + + var clipMax = 1e9, + clipMin = -clipMax; // TODO Use d3-polygon’s polygonContains here for the ring check? + // TODO Eliminate duplicate buffering in clipBuffer and polygon.push? + + function clipRectangle(x0, y0, x1, y1) { + function visible(x, y) { + return x0 <= x && x <= x1 && y0 <= y && y <= y1; + } + + function interpolate(from, to, direction, stream) { + var a = 0, + a1 = 0; + + if ( + from == null || + (a = corner(from, direction)) !== + (a1 = corner(to, direction)) || + (comparePoint(from, to) < 0) ^ (direction > 0) + ) { + do { + stream.point( + a === 0 || a === 3 ? x0 : x1, + a > 1 ? y1 : y0 + ); + } while ((a = (a + direction + 4) % 4) !== a1); + } else { + stream.point(to[0], to[1]); + } + } + + function corner(p, direction) { + return Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)( + p[0] - x0 + ) < _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ? direction > 0 + ? 0 + : 3 + : Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)( + p[0] - x1 + ) < _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ? direction > 0 + ? 2 + : 1 + : Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)( + p[1] - y0 + ) < _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ? direction > 0 + ? 1 + : 0 + : direction > 0 + ? 3 + : 2; // Abs(p[1] - y1) < epsilon + } + + function compareIntersection(a, b) { + return comparePoint(a.x, b.x); + } + + function comparePoint(a, b) { + var ca = corner(a, 1), + cb = corner(b, 1); + return ca !== cb + ? ca - cb + : ca === 0 + ? b[1] - a[1] + : ca === 1 + ? a[0] - b[0] + : ca === 2 + ? a[1] - b[1] + : b[0] - a[0]; + } + + return function (stream) { + var activeStream = stream, + bufferStream = Object( + _buffer__WEBPACK_IMPORTED_MODULE_1__.default + )(), + segments, + polygon, + ring, + x__, + y__, + v__, + // First point + x_, + y_, + v_, + // Previous point + first, + clean; + var clipStream = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: polygonStart, + polygonEnd: polygonEnd, + }; + + function point(x, y) { + if (visible(x, y)) activeStream.point(x, y); + } + + function polygonInside() { + var winding = 0; + + for (var i = 0, n = polygon.length; i < n; ++i) { + for ( + var ring = polygon[i], + j = 1, + m = ring.length, + point = ring[0], + a0, + a1, + b0 = point[0], + b1 = point[1]; + j < m; + ++j + ) { + (a0 = b0), + (a1 = b1), + (point = ring[j]), + (b0 = point[0]), + (b1 = point[1]); + + if (a1 <= y1) { + if ( + b1 > y1 && + (b0 - a0) * (y1 - a1) > + (b1 - a1) * (x0 - a0) + ) + ++winding; + } else if ( + b1 <= y1 && + (b0 - a0) * (y1 - a1) < + (b1 - a1) * (x0 - a0) + ) + --winding; + } + } + + return winding; + } // Buffer geometry within a polygon and then clip it en masse. + + function polygonStart() { + (activeStream = bufferStream), + (segments = []), + (polygon = []), + (clean = true); + } + + function polygonEnd() { + var startInside = polygonInside(), + cleanInside = clean && startInside, + visible = (segments = Object( + d3_array__WEBPACK_IMPORTED_MODULE_4__.merge + )(segments)).length; + + if (cleanInside || visible) { + stream.polygonStart(); + + if (cleanInside) { + stream.lineStart(); + interpolate(null, null, 1, stream); + stream.lineEnd(); + } + + if (visible) { + Object( + _rejoin__WEBPACK_IMPORTED_MODULE_3__.default + )( + segments, + compareIntersection, + startInside, + interpolate, + stream + ); + } + + stream.polygonEnd(); + } + + (activeStream = stream), + (segments = polygon = ring = null); + } + + function lineStart() { + clipStream.point = linePoint; + if (polygon) polygon.push((ring = [])); + first = true; + v_ = false; + x_ = y_ = NaN; + } // TODO rather than special-case polygons, simply handle them separately. + // Ideally, coincident intersection points should be jittered to avoid + // clipping issues. + + function lineEnd() { + if (segments) { + linePoint(x__, y__); + if (v__ && v_) bufferStream.rejoin(); + segments.push(bufferStream.result()); + } + + clipStream.point = point; + if (v_) activeStream.lineEnd(); + } + + function linePoint(x, y) { + var v = visible(x, y); + if (polygon) ring.push([x, y]); + + if (first) { + (x__ = x), (y__ = y), (v__ = v); + first = false; + + if (v) { + activeStream.lineStart(); + activeStream.point(x, y); + } + } else if (v && v_) activeStream.point(x, y); + else { + var a = [ + (x_ = Math.max( + clipMin, + Math.min(clipMax, x_) + )), + (y_ = Math.max( + clipMin, + Math.min(clipMax, y_) + )), + ], + b = [ + (x = Math.max( + clipMin, + Math.min(clipMax, x) + )), + (y = Math.max( + clipMin, + Math.min(clipMax, y) + )), + ]; + + if ( + Object( + _line__WEBPACK_IMPORTED_MODULE_2__.default + )(a, b, x0, y0, x1, y1) + ) { + if (!v_) { + activeStream.lineStart(); + activeStream.point(a[0], a[1]); + } + + activeStream.point(b[0], b[1]); + if (!v) activeStream.lineEnd(); + clean = false; + } else if (v) { + activeStream.lineStart(); + activeStream.point(x, y); + clean = false; + } + } + + (x_ = x), (y_ = y), (v_ = v); + } + + return clipStream; + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/clip/rejoin.js": + /* !************************************************!*\ + !*** ./node_modules/d3-geo/src/clip/rejoin.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _pointEqual__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../pointEqual */ "./node_modules/d3-geo/src/pointEqual.js" + ); + + function Intersection(point, points, other, entry) { + this.x = point; + this.z = points; + this.o = other; // Another intersection + + this.e = entry; // Is an entry? + + this.v = false; // Visited + + this.n = this.p = null; // Next & previous + } // A generalized polygon clipping algorithm: given a polygon that has been cut + // into its visible line segments, and rejoins the segments by interpolating + // along the clip edge. + + /* harmony default export */ __webpack_exports__.default = function ( + segments, + compareIntersection, + startInside, + interpolate, + stream + ) { + var subject = [], + clip = [], + i, + n; + segments.forEach(function (segment) { + if ((n = segment.length - 1) <= 0) return; + var n, + p0 = segment[0], + p1 = segment[n], + x; // If the first and last points of a segment are coincident, then treat as a + // closed ring. TODO if all rings are closed, then the winding order of the + // exterior ring should be checked. + + if ( + Object( + _pointEqual__WEBPACK_IMPORTED_MODULE_0__.default + )(p0, p1) + ) { + stream.lineStart(); + + for (i = 0; i < n; ++i) { + stream.point((p0 = segment[i])[0], p0[1]); + } + + stream.lineEnd(); + return; + } + + subject.push( + (x = new Intersection(p0, segment, null, true)) + ); + clip.push((x.o = new Intersection(p0, null, x, false))); + subject.push( + (x = new Intersection(p1, segment, null, false)) + ); + clip.push((x.o = new Intersection(p1, null, x, true))); + }); + if (!subject.length) return; + clip.sort(compareIntersection); + link(subject); + link(clip); + + for (i = 0, n = clip.length; i < n; ++i) { + clip[i].e = startInside = !startInside; + } + + var start = subject[0], + points, + point; + + while (1) { + // Find first unvisited intersection. + var current = start, + isSubject = true; + + while (current.v) { + if ((current = current.n) === start) return; + } + + points = current.z; + stream.lineStart(); + + do { + current.v = current.o.v = true; + + if (current.e) { + if (isSubject) { + for (i = 0, n = points.length; i < n; ++i) { + stream.point( + (point = points[i])[0], + point[1] + ); + } + } else { + interpolate(current.x, current.n.x, 1, stream); + } + + current = current.n; + } else { + if (isSubject) { + points = current.p.z; + + for (i = points.length - 1; i >= 0; --i) { + stream.point( + (point = points[i])[0], + point[1] + ); + } + } else { + interpolate(current.x, current.p.x, -1, stream); + } + + current = current.p; + } + + current = current.o; + points = current.z; + isSubject = !isSubject; + } while (!current.v); + + stream.lineEnd(); + } + }; + + function link(array) { + if (!(n = array.length)) return; + var n, + i = 0, + a = array[0], + b; + + while (++i < n) { + a.n = b = array[i]; + b.p = a; + a = b; + } + + a.n = b = array[0]; + b.p = a; + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/compose.js": + /* !********************************************!*\ + !*** ./node_modules/d3-geo/src/compose.js ***! + \********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + function compose(x, y) { + return (x = a(x, y)), b(x[0], x[1]); + } + + if (a.invert && b.invert) + compose.invert = function (x, y) { + return (x = b.invert(x, y)), x && a.invert(x[0], x[1]); + }; + return compose; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/constant.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-geo/src/constant.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/contains.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-geo/src/contains.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _polygonContains__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./polygonContains */ "./node_modules/d3-geo/src/polygonContains.js" + ); + /* Harmony import */ var _distance__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./distance */ "./node_modules/d3-geo/src/distance.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + + var containsObjectType = { + Feature: function Feature(object, point) { + return containsGeometry(object.geometry, point); + }, + FeatureCollection: function FeatureCollection(object, point) { + var features = object.features, + i = -1, + n = features.length; + + while (++i < n) { + if (containsGeometry(features[i].geometry, point)) + return true; + } + + return false; + }, + }; + var containsGeometryType = { + Sphere: function Sphere() { + return true; + }, + Point: function Point(object, point) { + return containsPoint(object.coordinates, point); + }, + MultiPoint: function MultiPoint(object, point) { + var coordinates = object.coordinates, + i = -1, + n = coordinates.length; + + while (++i < n) { + if (containsPoint(coordinates[i], point)) return true; + } + + return false; + }, + LineString: function LineString(object, point) { + return containsLine(object.coordinates, point); + }, + MultiLineString: function MultiLineString(object, point) { + var coordinates = object.coordinates, + i = -1, + n = coordinates.length; + + while (++i < n) { + if (containsLine(coordinates[i], point)) return true; + } + + return false; + }, + Polygon: function Polygon(object, point) { + return containsPolygon(object.coordinates, point); + }, + MultiPolygon: function MultiPolygon(object, point) { + var coordinates = object.coordinates, + i = -1, + n = coordinates.length; + + while (++i < n) { + if (containsPolygon(coordinates[i], point)) return true; + } + + return false; + }, + GeometryCollection: function GeometryCollection(object, point) { + var geometries = object.geometries, + i = -1, + n = geometries.length; + + while (++i < n) { + if (containsGeometry(geometries[i], point)) return true; + } + + return false; + }, + }; + + function containsGeometry(geometry, point) { + return geometry && + containsGeometryType.hasOwnProperty(geometry.type) + ? containsGeometryType[geometry.type](geometry, point) + : false; + } + + function containsPoint(coordinates, point) { + return ( + Object(_distance__WEBPACK_IMPORTED_MODULE_1__.default)( + coordinates, + point + ) === 0 + ); + } + + function containsLine(coordinates, point) { + var ao, bo, ab; + + for (var i = 0, n = coordinates.length; i < n; i++) { + bo = Object( + _distance__WEBPACK_IMPORTED_MODULE_1__.default + )(coordinates[i], point); + if (bo === 0) return true; + + if (i > 0) { + ab = Object( + _distance__WEBPACK_IMPORTED_MODULE_1__.default + )(coordinates[i], coordinates[i - 1]); + if ( + ab > 0 && + ao <= ab && + bo <= ab && + (ao + bo - ab) * (1 - Math.pow((ao - bo) / ab, 2)) < + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon2 * + ab + ) + return true; + } + + ao = bo; + } + + return false; + } + + function containsPolygon(coordinates, point) { + return Boolean(Object( + _polygonContains__WEBPACK_IMPORTED_MODULE_0__.default + )(coordinates.map(ringRadians), pointRadians(point))); + } + + function ringRadians(ring) { + return (ring = ring.map(pointRadians)), ring.pop(), ring; + } + + function pointRadians(point) { + return [ + point[0] * _math__WEBPACK_IMPORTED_MODULE_2__.radians, + point[1] * _math__WEBPACK_IMPORTED_MODULE_2__.radians, + ]; + } + + /* Harmony default export */ __webpack_exports__.default = function (object, point) { + return (object && containsObjectType.hasOwnProperty(object.type) + ? containsObjectType[object.type] + : containsGeometry)(object, point); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/distance.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-geo/src/distance.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _length__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./length */ "./node_modules/d3-geo/src/length.js" + ); + + var coordinates = [null, null], + object = { + type: "LineString", + coordinates: coordinates, + }; + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + coordinates[0] = a; + coordinates[1] = b; + return Object(_length__WEBPACK_IMPORTED_MODULE_0__.default)( + object + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/graticule.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-geo/src/graticule.js ***! + \**********************************************/ + /* ! exports provided: default, graticule10 */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return graticule; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "graticule10", + function () { + return graticule10; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + + function graticuleX(y0, y1, dy) { + var y = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__.range)( + y0, + y1 - _math__WEBPACK_IMPORTED_MODULE_1__.epsilon, + dy + ).concat(y1); + return function (x) { + return y.map(function (y) { + return [x, y]; + }); + }; + } + + function graticuleY(x0, x1, dx) { + var x = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__.range)( + x0, + x1 - _math__WEBPACK_IMPORTED_MODULE_1__.epsilon, + dx + ).concat(x1); + return function (y) { + return x.map(function (x) { + return [x, y]; + }); + }; + } + + function graticule() { + var x1, + x0, + X1, + X0, + y1, + y0, + Y1, + Y0, + dx = 10, + dy = dx, + DX = 90, + DY = 360, + x, + y, + X, + Y, + precision = 2.5; + + function graticule() { + return { + type: "MultiLineString", + coordinates: lines(), + }; + } + + function lines() { + return Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.ceil)( + X0 / DX + ) * DX, + X1, + DX + ) + .map(X) + .concat( + Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )( + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.ceil + )(Y0 / DY) * DY, + Y1, + DY + ).map(Y) + ) + .concat( + Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )( + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.ceil + )(x0 / dx) * dx, + x1, + dx + ) + .filter(function (x) { + return ( + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.abs + )(x % DX) > + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon + ); + }) + .map(x) + ) + .concat( + Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )( + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.ceil + )(y0 / dy) * dy, + y1, + dy + ) + .filter(function (y) { + return ( + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.abs + )(y % DY) > + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon + ); + }) + .map(y) + ); + } + + graticule.lines = function () { + return lines().map(function (coordinates) { + return { + type: "LineString", + coordinates: coordinates, + }; + }); + }; + + graticule.outline = function () { + return { + type: "Polygon", + coordinates: [ + X(X0).concat( + Y(Y1).slice(1), + X(X1).reverse().slice(1), + Y(Y0).reverse().slice(1) + ), + ], + }; + }; + + graticule.extent = function (_) { + if (!arguments.length) return graticule.extentMinor(); + return graticule.extentMajor(_).extentMinor(_); + }; + + graticule.extentMajor = function (_) { + if (!arguments.length) + return [ + [X0, Y0], + [X1, Y1], + ]; + (X0 = Number(_[0][0])), (X1 = Number(_[1][0])); + (Y0 = Number(_[0][1])), (Y1 = Number(_[1][1])); + if (X0 > X1) (_ = X0), (X0 = X1), (X1 = _); + if (Y0 > Y1) (_ = Y0), (Y0 = Y1), (Y1 = _); + return graticule.precision(precision); + }; + + graticule.extentMinor = function (_) { + if (!arguments.length) + return [ + [x0, y0], + [x1, y1], + ]; + (x0 = Number(_[0][0])), (x1 = Number(_[1][0])); + (y0 = Number(_[0][1])), (y1 = Number(_[1][1])); + if (x0 > x1) (_ = x0), (x0 = x1), (x1 = _); + if (y0 > y1) (_ = y0), (y0 = y1), (y1 = _); + return graticule.precision(precision); + }; + + graticule.step = function (_) { + if (!arguments.length) return graticule.stepMinor(); + return graticule.stepMajor(_).stepMinor(_); + }; + + graticule.stepMajor = function (_) { + if (!arguments.length) return [DX, DY]; + (DX = Number(_[0])), (DY = Number(_[1])); + return graticule; + }; + + graticule.stepMinor = function (_) { + if (!arguments.length) return [dx, dy]; + (dx = Number(_[0])), (dy = Number(_[1])); + return graticule; + }; + + graticule.precision = function (_) { + if (!arguments.length) return precision; + precision = Number(_); + x = graticuleX(y0, y1, 90); + y = graticuleY(x0, x1, precision); + X = graticuleX(Y0, Y1, 90); + Y = graticuleY(X0, X1, precision); + return graticule; + }; + + return graticule + .extentMajor([ + [ + -180, + -90 + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon, + ], + [ + 180, + 90 - _math__WEBPACK_IMPORTED_MODULE_1__.epsilon, + ], + ]) + .extentMinor([ + [ + -180, + -80 - _math__WEBPACK_IMPORTED_MODULE_1__.epsilon, + ], + [ + 180, + 80 + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon, + ], + ]); + } + function graticule10() { + return graticule()(); + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/identity.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-geo/src/identity.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return x; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/index.js": + /* !******************************************!*\ + !*** ./node_modules/d3-geo/src/index.js ***! + \******************************************/ + /* ! exports provided: geoArea, geoBounds, geoCentroid, geoCircle, geoClipAntimeridian, geoClipCircle, geoClipExtent, geoClipRectangle, geoContains, geoDistance, geoGraticule, geoGraticule10, geoInterpolate, geoLength, geoPath, geoAlbers, geoAlbersUsa, geoAzimuthalEqualArea, geoAzimuthalEqualAreaRaw, geoAzimuthalEquidistant, geoAzimuthalEquidistantRaw, geoConicConformal, geoConicConformalRaw, geoConicEqualArea, geoConicEqualAreaRaw, geoConicEquidistant, geoConicEquidistantRaw, geoEqualEarth, geoEqualEarthRaw, geoEquirectangular, geoEquirectangularRaw, geoGnomonic, geoGnomonicRaw, geoIdentity, geoProjection, geoProjectionMutator, geoMercator, geoMercatorRaw, geoNaturalEarth1, geoNaturalEarth1Raw, geoOrthographic, geoOrthographicRaw, geoStereographic, geoStereographicRaw, geoTransverseMercator, geoTransverseMercatorRaw, geoRotation, geoStream, geoTransform */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _area__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./area */ "./node_modules/d3-geo/src/area.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoArea", + function () { + return _area__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _bounds__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./bounds */ "./node_modules/d3-geo/src/bounds.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoBounds", + function () { + return _bounds__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _centroid__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./centroid */ "./node_modules/d3-geo/src/centroid.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoCentroid", + function () { + return _centroid__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _circle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./circle */ "./node_modules/d3-geo/src/circle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoCircle", + function () { + return _circle__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _clip_antimeridian__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./clip/antimeridian */ "./node_modules/d3-geo/src/clip/antimeridian.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoClipAntimeridian", + function () { + return _clip_antimeridian__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _clip_circle__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./clip/circle */ "./node_modules/d3-geo/src/clip/circle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoClipCircle", + function () { + return _clip_circle__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _clip_extent__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./clip/extent */ "./node_modules/d3-geo/src/clip/extent.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoClipExtent", + function () { + return _clip_extent__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony import */ var _clip_rectangle__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./clip/rectangle */ "./node_modules/d3-geo/src/clip/rectangle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoClipRectangle", + function () { + return _clip_rectangle__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /* Harmony import */ var _contains__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./contains */ "./node_modules/d3-geo/src/contains.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoContains", + function () { + return _contains__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony import */ var _distance__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./distance */ "./node_modules/d3-geo/src/distance.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoDistance", + function () { + return _distance__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony import */ var _graticule__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./graticule */ "./node_modules/d3-geo/src/graticule.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoGraticule", + function () { + return _graticule__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoGraticule10", + function () { + return _graticule__WEBPACK_IMPORTED_MODULE_10__.graticule10; + } + ); + + /* Harmony import */ var _interpolate__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./interpolate */ "./node_modules/d3-geo/src/interpolate.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoInterpolate", + function () { + return _interpolate__WEBPACK_IMPORTED_MODULE_11__.default; + } + ); + + /* Harmony import */ var _length__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./length */ "./node_modules/d3-geo/src/length.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoLength", + function () { + return _length__WEBPACK_IMPORTED_MODULE_12__.default; + } + ); + + /* Harmony import */ var _path_index__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./path/index */ "./node_modules/d3-geo/src/path/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoPath", + function () { + return _path_index__WEBPACK_IMPORTED_MODULE_13__.default; + } + ); + + /* Harmony import */ var _projection_albers__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./projection/albers */ "./node_modules/d3-geo/src/projection/albers.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAlbers", + function () { + return _projection_albers__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /* Harmony import */ var _projection_albersUsa__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./projection/albersUsa */ "./node_modules/d3-geo/src/projection/albersUsa.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAlbersUsa", + function () { + return _projection_albersUsa__WEBPACK_IMPORTED_MODULE_15__.default; + } + ); + + /* Harmony import */ var _projection_azimuthalEqualArea__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! ./projection/azimuthalEqualArea */ "./node_modules/d3-geo/src/projection/azimuthalEqualArea.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAzimuthalEqualArea", + function () { + return _projection_azimuthalEqualArea__WEBPACK_IMPORTED_MODULE_16__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAzimuthalEqualAreaRaw", + function () { + return _projection_azimuthalEqualArea__WEBPACK_IMPORTED_MODULE_16__.azimuthalEqualAreaRaw; + } + ); + + /* Harmony import */ var _projection_azimuthalEquidistant__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! ./projection/azimuthalEquidistant */ "./node_modules/d3-geo/src/projection/azimuthalEquidistant.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAzimuthalEquidistant", + function () { + return _projection_azimuthalEquidistant__WEBPACK_IMPORTED_MODULE_17__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAzimuthalEquidistantRaw", + function () { + return _projection_azimuthalEquidistant__WEBPACK_IMPORTED_MODULE_17__.azimuthalEquidistantRaw; + } + ); + + /* Harmony import */ var _projection_conicConformal__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__( + /* ! ./projection/conicConformal */ "./node_modules/d3-geo/src/projection/conicConformal.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicConformal", + function () { + return _projection_conicConformal__WEBPACK_IMPORTED_MODULE_18__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicConformalRaw", + function () { + return _projection_conicConformal__WEBPACK_IMPORTED_MODULE_18__.conicConformalRaw; + } + ); + + /* Harmony import */ var _projection_conicEqualArea__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__( + /* ! ./projection/conicEqualArea */ "./node_modules/d3-geo/src/projection/conicEqualArea.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicEqualArea", + function () { + return _projection_conicEqualArea__WEBPACK_IMPORTED_MODULE_19__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicEqualAreaRaw", + function () { + return _projection_conicEqualArea__WEBPACK_IMPORTED_MODULE_19__.conicEqualAreaRaw; + } + ); + + /* Harmony import */ var _projection_conicEquidistant__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__( + /* ! ./projection/conicEquidistant */ "./node_modules/d3-geo/src/projection/conicEquidistant.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicEquidistant", + function () { + return _projection_conicEquidistant__WEBPACK_IMPORTED_MODULE_20__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicEquidistantRaw", + function () { + return _projection_conicEquidistant__WEBPACK_IMPORTED_MODULE_20__.conicEquidistantRaw; + } + ); + + /* Harmony import */ var _projection_equalEarth__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__( + /* ! ./projection/equalEarth */ "./node_modules/d3-geo/src/projection/equalEarth.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoEqualEarth", + function () { + return _projection_equalEarth__WEBPACK_IMPORTED_MODULE_21__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoEqualEarthRaw", + function () { + return _projection_equalEarth__WEBPACK_IMPORTED_MODULE_21__.equalEarthRaw; + } + ); + + /* Harmony import */ var _projection_equirectangular__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__( + /* ! ./projection/equirectangular */ "./node_modules/d3-geo/src/projection/equirectangular.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoEquirectangular", + function () { + return _projection_equirectangular__WEBPACK_IMPORTED_MODULE_22__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoEquirectangularRaw", + function () { + return _projection_equirectangular__WEBPACK_IMPORTED_MODULE_22__.equirectangularRaw; + } + ); + + /* Harmony import */ var _projection_gnomonic__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__( + /* ! ./projection/gnomonic */ "./node_modules/d3-geo/src/projection/gnomonic.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoGnomonic", + function () { + return _projection_gnomonic__WEBPACK_IMPORTED_MODULE_23__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoGnomonicRaw", + function () { + return _projection_gnomonic__WEBPACK_IMPORTED_MODULE_23__.gnomonicRaw; + } + ); + + /* Harmony import */ var _projection_identity__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__( + /* ! ./projection/identity */ "./node_modules/d3-geo/src/projection/identity.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoIdentity", + function () { + return _projection_identity__WEBPACK_IMPORTED_MODULE_24__.default; + } + ); + + /* Harmony import */ var _projection_index__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__( + /* ! ./projection/index */ "./node_modules/d3-geo/src/projection/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoProjection", + function () { + return _projection_index__WEBPACK_IMPORTED_MODULE_25__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoProjectionMutator", + function () { + return _projection_index__WEBPACK_IMPORTED_MODULE_25__.projectionMutator; + } + ); + + /* Harmony import */ var _projection_mercator__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__( + /* ! ./projection/mercator */ "./node_modules/d3-geo/src/projection/mercator.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoMercator", + function () { + return _projection_mercator__WEBPACK_IMPORTED_MODULE_26__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoMercatorRaw", + function () { + return _projection_mercator__WEBPACK_IMPORTED_MODULE_26__.mercatorRaw; + } + ); + + /* Harmony import */ var _projection_naturalEarth1__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__( + /* ! ./projection/naturalEarth1 */ "./node_modules/d3-geo/src/projection/naturalEarth1.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoNaturalEarth1", + function () { + return _projection_naturalEarth1__WEBPACK_IMPORTED_MODULE_27__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoNaturalEarth1Raw", + function () { + return _projection_naturalEarth1__WEBPACK_IMPORTED_MODULE_27__.naturalEarth1Raw; + } + ); + + /* Harmony import */ var _projection_orthographic__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__( + /* ! ./projection/orthographic */ "./node_modules/d3-geo/src/projection/orthographic.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoOrthographic", + function () { + return _projection_orthographic__WEBPACK_IMPORTED_MODULE_28__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoOrthographicRaw", + function () { + return _projection_orthographic__WEBPACK_IMPORTED_MODULE_28__.orthographicRaw; + } + ); + + /* Harmony import */ var _projection_stereographic__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__( + /* ! ./projection/stereographic */ "./node_modules/d3-geo/src/projection/stereographic.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoStereographic", + function () { + return _projection_stereographic__WEBPACK_IMPORTED_MODULE_29__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoStereographicRaw", + function () { + return _projection_stereographic__WEBPACK_IMPORTED_MODULE_29__.stereographicRaw; + } + ); + + /* Harmony import */ var _projection_transverseMercator__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__( + /* ! ./projection/transverseMercator */ "./node_modules/d3-geo/src/projection/transverseMercator.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoTransverseMercator", + function () { + return _projection_transverseMercator__WEBPACK_IMPORTED_MODULE_30__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoTransverseMercatorRaw", + function () { + return _projection_transverseMercator__WEBPACK_IMPORTED_MODULE_30__.transverseMercatorRaw; + } + ); + + /* Harmony import */ var _rotation__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__( + /* ! ./rotation */ "./node_modules/d3-geo/src/rotation.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoRotation", + function () { + return _rotation__WEBPACK_IMPORTED_MODULE_31__.default; + } + ); + + /* Harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__( + /* ! ./stream */ "./node_modules/d3-geo/src/stream.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoStream", + function () { + return _stream__WEBPACK_IMPORTED_MODULE_32__.default; + } + ); + + /* Harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__( + /* ! ./transform */ "./node_modules/d3-geo/src/transform.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoTransform", + function () { + return _transform__WEBPACK_IMPORTED_MODULE_33__.default; + } + ); + + // DEPRECATED! Use d3.geoIdentity().clipExtent(…). + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/interpolate.js": + /* !************************************************!*\ + !*** ./node_modules/d3-geo/src/interpolate.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + var x0 = a[0] * _math__WEBPACK_IMPORTED_MODULE_0__.radians, + y0 = a[1] * _math__WEBPACK_IMPORTED_MODULE_0__.radians, + x1 = b[0] * _math__WEBPACK_IMPORTED_MODULE_0__.radians, + y1 = b[1] * _math__WEBPACK_IMPORTED_MODULE_0__.radians, + cy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(y0), + sy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(y0), + cy1 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(y1), + sy1 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(y1), + kx0 = + cy0 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(x0), + ky0 = + cy0 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(x0), + kx1 = + cy1 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(x1), + ky1 = + cy1 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(x1), + d = + 2 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.asin)( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.haversin + )(y1 - y0) + + cy0 * + cy1 * + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.haversin + )(x1 - x0) + ) + ), + k = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(d); + var interpolate = d + ? function (t) { + var B = + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.sin + )((t *= d)) / k, + A = + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.sin + )(d - t) / k, + x = A * kx0 + B * kx1, + y = A * ky0 + B * ky1, + z = A * sy0 + B * sy1; + return [ + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.atan2 + )(y, x) * + _math__WEBPACK_IMPORTED_MODULE_0__.degrees, + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.atan2 + )( + z, + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.sqrt + )(x * x + y * y) + ) * _math__WEBPACK_IMPORTED_MODULE_0__.degrees, + ]; + } + : function () { + return [ + x0 * + _math__WEBPACK_IMPORTED_MODULE_0__.degrees, + y0 * + _math__WEBPACK_IMPORTED_MODULE_0__.degrees, + ]; + }; + interpolate.distance = d; + return interpolate; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/length.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-geo/src/length.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./adder */ "./node_modules/d3-geo/src/adder.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./noop */ "./node_modules/d3-geo/src/noop.js" + ); + /* Harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./stream */ "./node_modules/d3-geo/src/stream.js" + ); + + var lengthSum = Object( + _adder__WEBPACK_IMPORTED_MODULE_0__.default + )(), + lambda0, + sinPhi0, + cosPhi0; + var lengthStream = { + sphere: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + point: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + lineStart: lengthLineStart, + lineEnd: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + polygonStart: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + polygonEnd: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + }; + + function lengthLineStart() { + lengthStream.point = lengthPointFirst; + lengthStream.lineEnd = lengthLineEnd; + } + + function lengthLineEnd() { + lengthStream.point = lengthStream.lineEnd = + _noop__WEBPACK_IMPORTED_MODULE_2__.default; + } + + function lengthPointFirst(lambda, phi) { + (lambda *= _math__WEBPACK_IMPORTED_MODULE_1__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_1__.radians); + (lambda0 = lambda), + (sinPhi0 = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.sin + )(phi)), + (cosPhi0 = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(phi)); + lengthStream.point = lengthPoint; + } + + function lengthPoint(lambda, phi) { + (lambda *= _math__WEBPACK_IMPORTED_MODULE_1__.radians), + (phi *= _math__WEBPACK_IMPORTED_MODULE_1__.radians); + var sinPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + phi + ), + cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__.cos)( + phi + ), + delta = Object(_math__WEBPACK_IMPORTED_MODULE_1__.abs)( + lambda - lambda0 + ), + cosDelta = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(delta), + sinDelta = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.sin + )(delta), + x = cosPhi * sinDelta, + y = cosPhi0 * sinPhi - sinPhi0 * cosPhi * cosDelta, + z = sinPhi0 * sinPhi + cosPhi0 * cosPhi * cosDelta; + lengthSum.add( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.atan2)( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.sqrt)( + x * x + y * y + ), + z + ) + ); + (lambda0 = lambda), (sinPhi0 = sinPhi), (cosPhi0 = cosPhi); + } + + /* Harmony default export */ __webpack_exports__.default = function (object) { + lengthSum.reset(); + Object(_stream__WEBPACK_IMPORTED_MODULE_3__.default)( + object, + lengthStream + ); + return Number(lengthSum); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/math.js": + /* !*****************************************!*\ + !*** ./node_modules/d3-geo/src/math.js ***! + \*****************************************/ + /* ! exports provided: epsilon, epsilon2, pi, halfPi, quarterPi, tau, degrees, radians, abs, atan, atan2, cos, ceil, exp, floor, log, pow, sin, sign, sqrt, tan, acos, asin, haversin */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "epsilon", + function () { + return epsilon; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "epsilon2", + function () { + return epsilon2; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "pi", + function () { + return pi; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "halfPi", + function () { + return halfPi; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "quarterPi", + function () { + return quarterPi; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tau", + function () { + return tau; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "degrees", + function () { + return degrees; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "radians", + function () { + return radians; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "abs", + function () { + return abs; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "atan", + function () { + return atan; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "atan2", + function () { + return atan2; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cos", + function () { + return cos; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "ceil", + function () { + return ceil; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "exp", + function () { + return exp; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "floor", + function () { + return floor; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "log", + function () { + return log; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "pow", + function () { + return pow; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sin", + function () { + return sin; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sign", + function () { + return sign; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sqrt", + function () { + return sqrt; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tan", + function () { + return tan; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "acos", + function () { + return acos; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "asin", + function () { + return asin; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "haversin", + function () { + return haversin; + } + ); + var epsilon = 1e-6; + var epsilon2 = 1e-12; + var pi = Math.PI; + var halfPi = pi / 2; + var quarterPi = pi / 4; + var tau = pi * 2; + var degrees = 180 / pi; + var radians = pi / 180; + var abs = Math.abs; + var atan = Math.atan; + var atan2 = Math.atan2; + var cos = Math.cos; + var ceil = Math.ceil; + var exp = Math.exp; + var floor = Math.floor; + var log = Math.log; + var pow = Math.pow; + var sin = Math.sin; + var sign = + Math.sign || + function (x) { + return x > 0 ? 1 : x < 0 ? -1 : 0; + }; + var sqrt = Math.sqrt; + var tan = Math.tan; + function acos(x) { + return x > 1 ? 0 : x < -1 ? pi : Math.acos(x); + } + function asin(x) { + return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x); + } + function haversin(x) { + return (x = sin(x / 2)) * x; + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/noop.js": + /* !*****************************************!*\ + !*** ./node_modules/d3-geo/src/noop.js ***! + \*****************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return noop; + } + ); + function noop() {} + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/path/area.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-geo/src/path/area.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../adder */ "./node_modules/d3-geo/src/adder.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-geo/src/noop.js" + ); + + var areaSum = Object( + _adder__WEBPACK_IMPORTED_MODULE_0__.default + )(), + areaRingSum = Object( + _adder__WEBPACK_IMPORTED_MODULE_0__.default + )(), + x00, + y00, + x0, + y0; + var areaStream = { + point: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + lineStart: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + lineEnd: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + polygonStart: function polygonStart() { + areaStream.lineStart = areaRingStart; + areaStream.lineEnd = areaRingEnd; + }, + polygonEnd: function polygonEnd() { + areaStream.lineStart = areaStream.lineEnd = areaStream.point = + _noop__WEBPACK_IMPORTED_MODULE_2__.default; + areaSum.add( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.abs)( + areaRingSum + ) + ); + areaRingSum.reset(); + }, + result: function result() { + var area = areaSum / 2; + areaSum.reset(); + return area; + }, + }; + + function areaRingStart() { + areaStream.point = areaPointFirst; + } + + function areaPointFirst(x, y) { + areaStream.point = areaPoint; + (x00 = x0 = x), (y00 = y0 = y); + } + + function areaPoint(x, y) { + areaRingSum.add(y0 * x - x0 * y); + (x0 = x), (y0 = y); + } + + function areaRingEnd() { + areaPoint(x00, y00); + } + + /* Harmony default export */ __webpack_exports__.default = areaStream; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/path/bounds.js": + /* !************************************************!*\ + !*** ./node_modules/d3-geo/src/path/bounds.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-geo/src/noop.js" + ); + + var x0 = Infinity, + y0 = x0, + x1 = -x0, + y1 = x1; + var boundsStream = { + point: boundsPoint, + lineStart: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + lineEnd: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + polygonStart: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + polygonEnd: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + result: function result() { + var bounds = [ + [x0, y0], + [x1, y1], + ]; + x1 = y1 = -(y0 = x0 = Infinity); + return bounds; + }, + }; + + function boundsPoint(x, y) { + if (x < x0) x0 = x; + if (x > x1) x1 = x; + if (y < y0) y0 = y; + if (y > y1) y1 = y; + } + + /* Harmony default export */ __webpack_exports__.default = boundsStream; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/path/centroid.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-geo/src/path/centroid.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + // TODO Enforce positive area for exterior, negative area for interior? + + var X0 = 0, + Y0 = 0, + Z0 = 0, + X1 = 0, + Y1 = 0, + Z1 = 0, + X2 = 0, + Y2 = 0, + Z2 = 0, + x00, + y00, + x0, + y0; + var centroidStream = { + point: centroidPoint, + lineStart: centroidLineStart, + lineEnd: centroidLineEnd, + polygonStart: function polygonStart() { + centroidStream.lineStart = centroidRingStart; + centroidStream.lineEnd = centroidRingEnd; + }, + polygonEnd: function polygonEnd() { + centroidStream.point = centroidPoint; + centroidStream.lineStart = centroidLineStart; + centroidStream.lineEnd = centroidLineEnd; + }, + result: function result() { + var centroid = Z2 + ? [X2 / Z2, Y2 / Z2] + : Z1 + ? [X1 / Z1, Y1 / Z1] + : Z0 + ? [X0 / Z0, Y0 / Z0] + : [NaN, NaN]; + X0 = Y0 = Z0 = X1 = Y1 = Z1 = X2 = Y2 = Z2 = 0; + return centroid; + }, + }; + + function centroidPoint(x, y) { + X0 += x; + Y0 += y; + ++Z0; + } + + function centroidLineStart() { + centroidStream.point = centroidPointFirstLine; + } + + function centroidPointFirstLine(x, y) { + centroidStream.point = centroidPointLine; + centroidPoint((x0 = x), (y0 = y)); + } + + function centroidPointLine(x, y) { + var dx = x - x0, + dy = y - y0, + z = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + dx * dx + dy * dy + ); + X1 += (z * (x0 + x)) / 2; + Y1 += (z * (y0 + y)) / 2; + Z1 += z; + centroidPoint((x0 = x), (y0 = y)); + } + + function centroidLineEnd() { + centroidStream.point = centroidPoint; + } + + function centroidRingStart() { + centroidStream.point = centroidPointFirstRing; + } + + function centroidRingEnd() { + centroidPointRing(x00, y00); + } + + function centroidPointFirstRing(x, y) { + centroidStream.point = centroidPointRing; + centroidPoint((x00 = x0 = x), (y00 = y0 = y)); + } + + function centroidPointRing(x, y) { + var dx = x - x0, + dy = y - y0, + z = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + dx * dx + dy * dy + ); + X1 += (z * (x0 + x)) / 2; + Y1 += (z * (y0 + y)) / 2; + Z1 += z; + z = y0 * x - x0 * y; + X2 += z * (x0 + x); + Y2 += z * (y0 + y); + Z2 += z * 3; + centroidPoint((x0 = x), (y0 = y)); + } + + /* Harmony default export */ __webpack_exports__.default = centroidStream; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/path/context.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-geo/src/path/context.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return PathContext; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-geo/src/noop.js" + ); + + function PathContext(context) { + this._context = context; + } + PathContext.prototype = { + _radius: 4.5, + pointRadius: function pointRadius(_) { + return (this._radius = _), this; + }, + polygonStart: function polygonStart() { + this._line = 0; + }, + polygonEnd: function polygonEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._point = 0; + }, + lineEnd: function lineEnd() { + if (this._line === 0) this._context.closePath(); + this._point = NaN; + }, + point: function point(x, y) { + switch (this._point) { + case 0: { + this._context.moveTo(x, y); + + this._point = 1; + break; + } + + case 1: { + this._context.lineTo(x, y); + + break; + } + + default: { + this._context.moveTo(x + this._radius, y); + + this._context.arc( + x, + y, + this._radius, + 0, + _math__WEBPACK_IMPORTED_MODULE_0__.tau + ); + + break; + } + } + }, + result: _noop__WEBPACK_IMPORTED_MODULE_1__.default, + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/path/index.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-geo/src/path/index.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../identity */ "./node_modules/d3-geo/src/identity.js" + ); + /* Harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../stream */ "./node_modules/d3-geo/src/stream.js" + ); + /* Harmony import */ var _area__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./area */ "./node_modules/d3-geo/src/path/area.js" + ); + /* Harmony import */ var _bounds__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./bounds */ "./node_modules/d3-geo/src/path/bounds.js" + ); + /* Harmony import */ var _centroid__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./centroid */ "./node_modules/d3-geo/src/path/centroid.js" + ); + /* Harmony import */ var _context__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./context */ "./node_modules/d3-geo/src/path/context.js" + ); + /* Harmony import */ var _measure__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./measure */ "./node_modules/d3-geo/src/path/measure.js" + ); + /* Harmony import */ var _string__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./string */ "./node_modules/d3-geo/src/path/string.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (projection, context) { + var pointRadius = 4.5, + projectionStream, + contextStream; + + function path(object) { + if (object) { + if (typeof pointRadius === "function") + contextStream.pointRadius( + Number(pointRadius.apply(this, arguments)) + ); + Object(_stream__WEBPACK_IMPORTED_MODULE_1__.default)( + object, + projectionStream(contextStream) + ); + } + + return contextStream.result(); + } + + path.area = function (object) { + Object(_stream__WEBPACK_IMPORTED_MODULE_1__.default)( + object, + projectionStream( + _area__WEBPACK_IMPORTED_MODULE_2__.default + ) + ); + return _area__WEBPACK_IMPORTED_MODULE_2__.default.result(); + }; + + path.measure = function (object) { + Object(_stream__WEBPACK_IMPORTED_MODULE_1__.default)( + object, + projectionStream( + _measure__WEBPACK_IMPORTED_MODULE_6__.default + ) + ); + return _measure__WEBPACK_IMPORTED_MODULE_6__.default.result(); + }; + + path.bounds = function (object) { + Object(_stream__WEBPACK_IMPORTED_MODULE_1__.default)( + object, + projectionStream( + _bounds__WEBPACK_IMPORTED_MODULE_3__.default + ) + ); + return _bounds__WEBPACK_IMPORTED_MODULE_3__.default.result(); + }; + + path.centroid = function (object) { + Object(_stream__WEBPACK_IMPORTED_MODULE_1__.default)( + object, + projectionStream( + _centroid__WEBPACK_IMPORTED_MODULE_4__.default + ) + ); + return _centroid__WEBPACK_IMPORTED_MODULE_4__.default.result(); + }; + + path.projection = function (_) { + return arguments.length + ? ((projectionStream = + _ == null + ? ((projection = null), + _identity__WEBPACK_IMPORTED_MODULE_0__.default) + : (projection = _).stream), + path) + : projection; + }; + + path.context = function (_) { + if (!arguments.length) return context; + contextStream = + _ == null + ? ((context = null), + new _string__WEBPACK_IMPORTED_MODULE_7__.default()) + : new _context__WEBPACK_IMPORTED_MODULE_5__.default((context = _)); + if (typeof pointRadius !== "function") + contextStream.pointRadius(pointRadius); + return path; + }; + + path.pointRadius = function (_) { + if (!arguments.length) return pointRadius; + pointRadius = + typeof _ === "function" + ? _ + : (contextStream.pointRadius(Number(_)), Number(_)); + return path; + }; + + return path.projection(projection).context(context); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/path/measure.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-geo/src/path/measure.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../adder */ "./node_modules/d3-geo/src/adder.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-geo/src/noop.js" + ); + + var lengthSum = Object( + _adder__WEBPACK_IMPORTED_MODULE_0__.default + )(), + lengthRing, + x00, + y00, + x0, + y0; + var lengthStream = { + point: _noop__WEBPACK_IMPORTED_MODULE_2__.default, + lineStart: function lineStart() { + lengthStream.point = lengthPointFirst; + }, + lineEnd: function lineEnd() { + if (lengthRing) lengthPoint(x00, y00); + lengthStream.point = + _noop__WEBPACK_IMPORTED_MODULE_2__.default; + }, + polygonStart: function polygonStart() { + lengthRing = true; + }, + polygonEnd: function polygonEnd() { + lengthRing = null; + }, + result: function result() { + var length = Number(lengthSum); + lengthSum.reset(); + return length; + }, + }; + + function lengthPointFirst(x, y) { + lengthStream.point = lengthPoint; + (x00 = x0 = x), (y00 = y0 = y); + } + + function lengthPoint(x, y) { + (x0 -= x), (y0 -= y); + lengthSum.add( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.sqrt)( + x0 * x0 + y0 * y0 + ) + ); + (x0 = x), (y0 = y); + } + + /* Harmony default export */ __webpack_exports__.default = lengthStream; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/path/string.js": + /* !************************************************!*\ + !*** ./node_modules/d3-geo/src/path/string.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return PathString; + } + ); + function PathString() { + this._string = []; + } + PathString.prototype = { + _radius: 4.5, + _circle: circle(4.5), + pointRadius: function pointRadius(_) { + if ((_ = Number(_)) !== this._radius) + (this._radius = _), (this._circle = null); + return this; + }, + polygonStart: function polygonStart() { + this._line = 0; + }, + polygonEnd: function polygonEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._point = 0; + }, + lineEnd: function lineEnd() { + if (this._line === 0) this._string.push("Z"); + this._point = NaN; + }, + point: function point(x, y) { + switch (this._point) { + case 0: { + this._string.push("M", x, ",", y); + + this._point = 1; + break; + } + + case 1: { + this._string.push("L", x, ",", y); + + break; + } + + default: { + if (this._circle == null) + this._circle = circle(this._radius); + + this._string.push("M", x, ",", y, this._circle); + + break; + } + } + }, + result: function result() { + if (this._string.length) { + var result = this._string.join(""); + + this._string = []; + return result; + } + return null; + + }, + }; + + function circle(radius) { + return ( + "m0," + + radius + + "a" + + radius + + "," + + radius + + " 0 1,1 0," + + -2 * radius + + "a" + + radius + + "," + + radius + + " 0 1,1 0," + + 2 * radius + + "z" + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/pointEqual.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-geo/src/pointEqual.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + return ( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)( + a[0] - b[0] + ) < _math__WEBPACK_IMPORTED_MODULE_0__.epsilon && + Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)( + a[1] - b[1] + ) < _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/polygonContains.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-geo/src/polygonContains.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./adder */ "./node_modules/d3-geo/src/adder.js" + ); + /* Harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./cartesian */ "./node_modules/d3-geo/src/cartesian.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + + var sum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__.default)(); + + function longitude(point) { + if ( + Object(_math__WEBPACK_IMPORTED_MODULE_2__.abs)( + point[0] + ) <= _math__WEBPACK_IMPORTED_MODULE_2__.pi + ) + return point[0]; + return ( + Object(_math__WEBPACK_IMPORTED_MODULE_2__.sign)( + point[0] + ) * + (((Object(_math__WEBPACK_IMPORTED_MODULE_2__.abs)( + point[0] + ) + + _math__WEBPACK_IMPORTED_MODULE_2__.pi) % + _math__WEBPACK_IMPORTED_MODULE_2__.tau) - + _math__WEBPACK_IMPORTED_MODULE_2__.pi) + ); + } + + /* Harmony default export */ __webpack_exports__.default = function (polygon, point) { + var lambda = longitude(point), + phi = point[1], + sinPhi = Object(_math__WEBPACK_IMPORTED_MODULE_2__.sin)( + phi + ), + normal = [ + Object(_math__WEBPACK_IMPORTED_MODULE_2__.sin)( + lambda + ), + -Object(_math__WEBPACK_IMPORTED_MODULE_2__.cos)( + lambda + ), + 0, + ], + angle = 0, + winding = 0; + sum.reset(); + if (sinPhi === 1) + phi = + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi + + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon; + else if (sinPhi === -1) + phi = + -_math__WEBPACK_IMPORTED_MODULE_2__.halfPi - + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon; + + for (var i = 0, n = polygon.length; i < n; ++i) { + if (!(m = (ring = polygon[i]).length)) continue; + var ring, + m, + point0 = ring[m - 1], + lambda0 = longitude(point0), + phi0 = + point0[1] / 2 + + _math__WEBPACK_IMPORTED_MODULE_2__.quarterPi, + sinPhi0 = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(phi0), + cosPhi0 = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(phi0); + + for ( + var j = 0; + j < m; + ++j, + lambda0 = lambda1, + sinPhi0 = sinPhi1, + cosPhi0 = cosPhi1, + point0 = point1 + ) { + var point1 = ring[j], + lambda1 = longitude(point1), + phi1 = + point1[1] / 2 + + _math__WEBPACK_IMPORTED_MODULE_2__.quarterPi, + sinPhi1 = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(phi1), + cosPhi1 = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(phi1), + delta = lambda1 - lambda0, + sign = delta >= 0 ? 1 : -1, + absDelta = sign * delta, + antimeridian = + absDelta > + _math__WEBPACK_IMPORTED_MODULE_2__.pi, + k = sinPhi0 * sinPhi1; + sum.add( + Object(_math__WEBPACK_IMPORTED_MODULE_2__.atan2)( + k * + sign * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(absDelta), + cosPhi0 * cosPhi1 + + k * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(absDelta) + ) + ); + angle += antimeridian + ? delta + + sign * _math__WEBPACK_IMPORTED_MODULE_2__.tau + : delta; // Are the longitudes either side of the point’s meridian (lambda), + // and are the latitudes smaller than the parallel (phi)? + + if ( + antimeridian ^ + (lambda0 >= lambda) ^ + (lambda1 >= lambda) + ) { + var arc = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_1__.cartesianCross + )( + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_1__.cartesian + )(point0), + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_1__.cartesian + )(point1) + ); + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_1__.cartesianNormalizeInPlace + )(arc); + var intersection = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_1__.cartesianCross + )(normal, arc); + Object( + _cartesian__WEBPACK_IMPORTED_MODULE_1__.cartesianNormalizeInPlace + )(intersection); + var phiArc = + (antimeridian ^ (delta >= 0) ? -1 : 1) * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.asin + )(intersection[2]); + + if ( + phi > phiArc || + (phi === phiArc && (arc[0] || arc[1])) + ) { + winding += antimeridian ^ (delta >= 0) ? 1 : -1; + } + } + } + } // First, determine whether the South pole is inside or outside: + // + // It is inside if: + // * the polygon winds around it in a clockwise direction. + // * the polygon does not (cumulatively) wind around it, but has a negative + // (counter-clockwise) area. + // + // Second, count the (signed) number of times a segment crosses a lambda + // from the point to the South pole. If it is zero, then the point is the + // same side as the South pole. + + return ( + (angle < -_math__WEBPACK_IMPORTED_MODULE_2__.epsilon || + (angle < + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon && + sum < + -_math__WEBPACK_IMPORTED_MODULE_2__.epsilon)) ^ + (winding & 1) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/albers.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/albers.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _conicEqualArea__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./conicEqualArea */ "./node_modules/d3-geo/src/projection/conicEqualArea.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + return Object( + _conicEqualArea__WEBPACK_IMPORTED_MODULE_0__.default + )() + .parallels([29.5, 45.5]) + .scale(1070) + .translate([480, 250]) + .rotate([96, 0]) + .center([-0.6, 38.7]); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/albersUsa.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/albersUsa.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _albers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./albers */ "./node_modules/d3-geo/src/projection/albers.js" + ); + /* Harmony import */ var _conicEqualArea__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./conicEqualArea */ "./node_modules/d3-geo/src/projection/conicEqualArea.js" + ); + /* Harmony import */ var _fit__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./fit */ "./node_modules/d3-geo/src/projection/fit.js" + ); + + // The projections must have mutually exclusive clip regions on the sphere, + // as this will avoid emitting interleaving lines and polygons. + + function multiplex(streams) { + var n = streams.length; + return { + point: function point(x, y) { + var i = -1; + + while (++i < n) { + streams[i].point(x, y); + } + }, + sphere: function sphere() { + var i = -1; + + while (++i < n) { + streams[i].sphere(); + } + }, + lineStart: function lineStart() { + var i = -1; + + while (++i < n) { + streams[i].lineStart(); + } + }, + lineEnd: function lineEnd() { + var i = -1; + + while (++i < n) { + streams[i].lineEnd(); + } + }, + polygonStart: function polygonStart() { + var i = -1; + + while (++i < n) { + streams[i].polygonStart(); + } + }, + polygonEnd: function polygonEnd() { + var i = -1; + + while (++i < n) { + streams[i].polygonEnd(); + } + }, + }; + } // A composite projection for the United States, configured by default for + // 960×500. The projection also works quite well at 960×600 if you change the + // scale to 1285 and adjust the translate accordingly. The set of standard + // parallels for each region comes from USGS, which is published here: + // http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers + + /* harmony default export */ __webpack_exports__.default = function () { + var cache, + cacheStream, + lower48 = Object( + _albers__WEBPACK_IMPORTED_MODULE_1__.default + )(), + lower48Point, + alaska = Object( + _conicEqualArea__WEBPACK_IMPORTED_MODULE_2__.default + )() + .rotate([154, 0]) + .center([-2, 58.5]) + .parallels([55, 65]), + alaskaPoint, + // EPSG:3338 + hawaii = Object( + _conicEqualArea__WEBPACK_IMPORTED_MODULE_2__.default + )() + .rotate([157, 0]) + .center([-3, 19.9]) + .parallels([8, 18]), + hawaiiPoint, + // ESRI:102007 + _point, + pointStream = { + point: function point(x, y) { + _point = [x, y]; + }, + }; + + function albersUsa(coordinates) { + var x = coordinates[0], + y = coordinates[1]; + return ( + (_point = null), + (lower48Point.point(x, y), _point) || + (alaskaPoint.point(x, y), _point) || + (hawaiiPoint.point(x, y), _point) + ); + } + + albersUsa.invert = function (coordinates) { + var k = lower48.scale(), + t = lower48.translate(), + x = (coordinates[0] - t[0]) / k, + y = (coordinates[1] - t[1]) / k; + return (y >= 0.12 && y < 0.234 && x >= -0.425 && x < -0.214 + ? alaska + : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 + ? hawaii + : lower48 + ).invert(coordinates); + }; + + albersUsa.stream = function (stream) { + return cache && cacheStream === stream + ? cache + : (cache = multiplex([ + lower48.stream((cacheStream = stream)), + alaska.stream(stream), + hawaii.stream(stream), + ])); + }; + + albersUsa.precision = function (_) { + if (!arguments.length) return lower48.precision(); + lower48.precision(_), + alaska.precision(_), + hawaii.precision(_); + return reset(); + }; + + albersUsa.scale = function (_) { + if (!arguments.length) return lower48.scale(); + lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_); + return albersUsa.translate(lower48.translate()); + }; + + albersUsa.translate = function (_) { + if (!arguments.length) return lower48.translate(); + var k = lower48.scale(), + x = Number(_[0]), + y = Number(_[1]); + lower48Point = lower48 + .translate(_) + .clipExtent([ + [x - 0.455 * k, y - 0.238 * k], + [x + 0.455 * k, y + 0.238 * k], + ]) + .stream(pointStream); + alaskaPoint = alaska + .translate([x - 0.307 * k, y + 0.201 * k]) + .clipExtent([ + [ + x - + 0.425 * k + + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon, + y + + 0.12 * k + + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon, + ], + [ + x - + 0.214 * k - + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon, + y + + 0.234 * k - + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon, + ], + ]) + .stream(pointStream); + hawaiiPoint = hawaii + .translate([x - 0.205 * k, y + 0.212 * k]) + .clipExtent([ + [ + x - + 0.214 * k + + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon, + y + + 0.166 * k + + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon, + ], + [ + x - + 0.115 * k - + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon, + y + + 0.234 * k - + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon, + ], + ]) + .stream(pointStream); + return reset(); + }; + + albersUsa.fitExtent = function (extent, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_3__.fitExtent + )(albersUsa, extent, object); + }; + + albersUsa.fitSize = function (size, object) { + return Object(_fit__WEBPACK_IMPORTED_MODULE_3__.fitSize)( + albersUsa, + size, + object + ); + }; + + albersUsa.fitWidth = function (width, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_3__.fitWidth + )(albersUsa, width, object); + }; + + albersUsa.fitHeight = function (height, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_3__.fitHeight + )(albersUsa, height, object); + }; + + function reset() { + cache = cacheStream = null; + return albersUsa; + } + + return albersUsa.scale(1070); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/azimuthal.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/azimuthal.js ***! + \*********************************************************/ + /* ! exports provided: azimuthalRaw, azimuthalInvert */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "azimuthalRaw", + function () { + return azimuthalRaw; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "azimuthalInvert", + function () { + return azimuthalInvert; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + + function azimuthalRaw(scale) { + return function (x, y) { + var cx = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + x + ), + cy = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + y + ), + k = scale(cx * cy); + return [ + k * + cy * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + x + ), + k * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + y + ), + ]; + }; + } + function azimuthalInvert(angle) { + return function (x, y) { + var z = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + x * x + y * y + ), + c = angle(z), + sc = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + c + ), + cc = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + c + ); + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan2)( + x * sc, + z * cc + ), + Object(_math__WEBPACK_IMPORTED_MODULE_0__.asin)( + z && (y * sc) / z + ), + ]; + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/azimuthalEqualArea.js": + /* !******************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/azimuthalEqualArea.js ***! + \******************************************************************/ + /* ! exports provided: azimuthalEqualAreaRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "azimuthalEqualAreaRaw", + function () { + return azimuthalEqualAreaRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + + var azimuthalEqualAreaRaw = Object( + _azimuthal__WEBPACK_IMPORTED_MODULE_1__.azimuthalRaw + )(function (cxcy) { + return Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + 2 / (1 + cxcy) + ); + }); + azimuthalEqualAreaRaw.invert = Object( + _azimuthal__WEBPACK_IMPORTED_MODULE_1__.azimuthalInvert + )(function (z) { + return ( + 2 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.asin)(z / 2) + ); + }); + /* Harmony default export */ __webpack_exports__.default = function () { + return Object(_index__WEBPACK_IMPORTED_MODULE_2__.default)( + azimuthalEqualAreaRaw + ) + .scale(124.75) + .clipAngle(180 - 1e-3); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/azimuthalEquidistant.js": + /* !********************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/azimuthalEquidistant.js ***! + \********************************************************************/ + /* ! exports provided: azimuthalEquidistantRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "azimuthalEquidistantRaw", + function () { + return azimuthalEquidistantRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + + var azimuthalEquidistantRaw = Object( + _azimuthal__WEBPACK_IMPORTED_MODULE_1__.azimuthalRaw + )(function (c) { + return ( + (c = Object(_math__WEBPACK_IMPORTED_MODULE_0__.acos)( + c + )) && + c / Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(c) + ); + }); + azimuthalEquidistantRaw.invert = Object( + _azimuthal__WEBPACK_IMPORTED_MODULE_1__.azimuthalInvert + )(function (z) { + return z; + }); + /* Harmony default export */ __webpack_exports__.default = function () { + return Object(_index__WEBPACK_IMPORTED_MODULE_2__.default)( + azimuthalEquidistantRaw + ) + .scale(79.4188) + .clipAngle(180 - 1e-3); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/conic.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/conic.js ***! + \*****************************************************/ + /* ! exports provided: conicProjection */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "conicProjection", + function () { + return conicProjection; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + + function conicProjection(projectAt) { + var phi0 = 0, + phi1 = _math__WEBPACK_IMPORTED_MODULE_0__.pi / 3, + m = Object( + _index__WEBPACK_IMPORTED_MODULE_1__.projectionMutator + )(projectAt), + p = m(phi0, phi1); + + p.parallels = function (_) { + return arguments.length + ? m( + (phi0 = + _[0] * + _math__WEBPACK_IMPORTED_MODULE_0__.radians), + (phi1 = + _[1] * + _math__WEBPACK_IMPORTED_MODULE_0__.radians) + ) + : [ + phi0 * + _math__WEBPACK_IMPORTED_MODULE_0__.degrees, + phi1 * + _math__WEBPACK_IMPORTED_MODULE_0__.degrees, + ]; + }; + + return p; + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/conicConformal.js": + /* !**************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/conicConformal.js ***! + \**************************************************************/ + /* ! exports provided: conicConformalRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "conicConformalRaw", + function () { + return conicConformalRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _conic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./conic */ "./node_modules/d3-geo/src/projection/conic.js" + ); + /* Harmony import */ var _mercator__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./mercator */ "./node_modules/d3-geo/src/projection/mercator.js" + ); + + function tany(y) { + return Object(_math__WEBPACK_IMPORTED_MODULE_0__.tan)( + (_math__WEBPACK_IMPORTED_MODULE_0__.halfPi + y) / 2 + ); + } + + function conicConformalRaw(y0, y1) { + var cy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(y0), + n = + y0 === y1 + ? Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + y0 + ) + : Object(_math__WEBPACK_IMPORTED_MODULE_0__.log)( + cy0 / + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.cos + )(y1) + ) / + Object(_math__WEBPACK_IMPORTED_MODULE_0__.log)( + tany(y1) / tany(y0) + ), + f = + (cy0 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.pow)( + tany(y0), + n + )) / + n; + if (!n) + return _mercator__WEBPACK_IMPORTED_MODULE_2__.mercatorRaw; + + function project(x, y) { + if (f > 0) { + if ( + y < + -_math__WEBPACK_IMPORTED_MODULE_0__.halfPi + + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ) + y = + -_math__WEBPACK_IMPORTED_MODULE_0__.halfPi + + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon; + } else if ( + y > + _math__WEBPACK_IMPORTED_MODULE_0__.halfPi - + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ) + y = + _math__WEBPACK_IMPORTED_MODULE_0__.halfPi - + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon; + + var r = + f / + Object(_math__WEBPACK_IMPORTED_MODULE_0__.pow)( + tany(y), + n + ); + return [ + r * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + n * x + ), + f - + r * + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.cos + )(n * x), + ]; + } + + project.invert = function (x, y) { + var fy = f - y, + r = + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sign)( + n + ) * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + x * x + fy * fy + ); + return [ + (Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan2)( + x, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)( + fy + ) + ) / + n) * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sign)( + fy + ), + 2 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan)( + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.pow + )(f / r, 1 / n) + ) - + _math__WEBPACK_IMPORTED_MODULE_0__.halfPi, + ]; + }; + + return project; + } + /* Harmony default export */ __webpack_exports__.default = function () { + return Object( + _conic__WEBPACK_IMPORTED_MODULE_1__.conicProjection + )(conicConformalRaw) + .scale(109.5) + .parallels([30, 30]); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/conicEqualArea.js": + /* !**************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/conicEqualArea.js ***! + \**************************************************************/ + /* ! exports provided: conicEqualAreaRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "conicEqualAreaRaw", + function () { + return conicEqualAreaRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _conic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./conic */ "./node_modules/d3-geo/src/projection/conic.js" + ); + /* Harmony import */ var _cylindricalEqualArea__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./cylindricalEqualArea */ "./node_modules/d3-geo/src/projection/cylindricalEqualArea.js" + ); + + function conicEqualAreaRaw(y0, y1) { + var sy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(y0), + n = + (sy0 + + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + y1 + )) / + 2; // Are the parallels symmetrical around the Equator? + + if ( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)(n) < + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ) + return Object( + _cylindricalEqualArea__WEBPACK_IMPORTED_MODULE_2__.cylindricalEqualAreaRaw + )(y0); + var c = 1 + sy0 * (2 * n - sy0), + r0 = + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)(c) / + n; + + function project(x, y) { + var r = + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sqrt)( + c - + 2 * + n * + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.sin + )(y) + ) / n; + return [ + r * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + (x *= n) + ), + r0 - + r * + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.cos + )(x), + ]; + } + + project.invert = function (x, y) { + var r0y = r0 - y; + return [ + (Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan2)( + x, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)( + r0y + ) + ) / + n) * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sign)( + r0y + ), + Object(_math__WEBPACK_IMPORTED_MODULE_0__.asin)( + (c - (x * x + r0y * r0y) * n * n) / (2 * n) + ), + ]; + }; + + return project; + } + /* Harmony default export */ __webpack_exports__.default = function () { + return Object( + _conic__WEBPACK_IMPORTED_MODULE_1__.conicProjection + )(conicEqualAreaRaw) + .scale(155.424) + .center([0, 33.6442]); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/conicEquidistant.js": + /* !****************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/conicEquidistant.js ***! + \****************************************************************/ + /* ! exports provided: conicEquidistantRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "conicEquidistantRaw", + function () { + return conicEquidistantRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _conic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./conic */ "./node_modules/d3-geo/src/projection/conic.js" + ); + /* Harmony import */ var _equirectangular__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./equirectangular */ "./node_modules/d3-geo/src/projection/equirectangular.js" + ); + + function conicEquidistantRaw(y0, y1) { + var cy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(y0), + n = + y0 === y1 + ? Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + y0 + ) + : (cy0 - + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.cos + )(y1)) / + (y1 - y0), + g = cy0 / n + y0; + if ( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)(n) < + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ) + return _equirectangular__WEBPACK_IMPORTED_MODULE_2__.equirectangularRaw; + + function project(x, y) { + var gy = g - y, + nx = n * x; + return [ + gy * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)( + nx + ), + g - + gy * + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.cos + )(nx), + ]; + } + + project.invert = function (x, y) { + var gy = g - y; + return [ + (Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan2)( + x, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.abs)( + gy + ) + ) / + n) * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sign)( + gy + ), + g - + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sign)( + n + ) * + Object( + _math__WEBPACK_IMPORTED_MODULE_0__.sqrt + )(x * x + gy * gy), + ]; + }; + + return project; + } + /* Harmony default export */ __webpack_exports__.default = function () { + return Object( + _conic__WEBPACK_IMPORTED_MODULE_1__.conicProjection + )(conicEquidistantRaw) + .scale(131.154) + .center([0, 13.9389]); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/cylindricalEqualArea.js": + /* !********************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/cylindricalEqualArea.js ***! + \********************************************************************/ + /* ! exports provided: cylindricalEqualAreaRaw */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cylindricalEqualAreaRaw", + function () { + return cylindricalEqualAreaRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + + function cylindricalEqualAreaRaw(phi0) { + var cosPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)( + phi0 + ); + + function forward(lambda, phi) { + return [ + lambda * cosPhi0, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(phi) / + cosPhi0, + ]; + } + + forward.invert = function (x, y) { + return [ + x / cosPhi0, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.asin)( + y * cosPhi0 + ), + ]; + }; + + return forward; + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/equalEarth.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/equalEarth.js ***! + \**********************************************************/ + /* ! exports provided: equalEarthRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "equalEarthRaw", + function () { + return equalEarthRaw; + } + ); + /* Harmony import */ var _index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index.js */ "./node_modules/d3-geo/src/projection/index.js" + ); + /* Harmony import */ var _math_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../math.js */ "./node_modules/d3-geo/src/math.js" + ); + + var A1 = 1.340264, + A2 = -0.081106, + A3 = 0.000893, + A4 = 0.003796, + M = + Object(_math_js__WEBPACK_IMPORTED_MODULE_1__.sqrt)(3) / + 2, + iterations = 12; + function equalEarthRaw(lambda, phi) { + var l = Object(_math_js__WEBPACK_IMPORTED_MODULE_1__.asin)( + M * + Object( + _math_js__WEBPACK_IMPORTED_MODULE_1__.sin + )(phi) + ), + l2 = l * l, + l6 = l2 * l2 * l2; + return [ + (lambda * + Object(_math_js__WEBPACK_IMPORTED_MODULE_1__.cos)( + l + )) / + (M * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2))), + l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)), + ]; + } + + equalEarthRaw.invert = function (x, y) { + var l = y, + l2 = l * l, + l6 = l2 * l2 * l2; + + for (var i = 0, delta, fy, fpy; i < iterations; ++i) { + fy = l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)) - y; + fpy = A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2); + (l -= delta = fy / fpy), (l2 = l * l), (l6 = l2 * l2 * l2); + if ( + Object(_math_js__WEBPACK_IMPORTED_MODULE_1__.abs)( + delta + ) < _math_js__WEBPACK_IMPORTED_MODULE_1__.epsilon2 + ) + break; + } + + return [ + (M * x * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2))) / + Object(_math_js__WEBPACK_IMPORTED_MODULE_1__.cos)(l), + Object(_math_js__WEBPACK_IMPORTED_MODULE_1__.asin)( + Object(_math_js__WEBPACK_IMPORTED_MODULE_1__.sin)( + l + ) / M + ), + ]; + }; + + /* Harmony default export */ __webpack_exports__.default = function () { + return Object( + _index_js__WEBPACK_IMPORTED_MODULE_0__.default + )(equalEarthRaw).scale(177.158); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/equirectangular.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/equirectangular.js ***! + \***************************************************************/ + /* ! exports provided: equirectangularRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "equirectangularRaw", + function () { + return equirectangularRaw; + } + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + + function equirectangularRaw(lambda, phi) { + return [lambda, phi]; + } + equirectangularRaw.invert = equirectangularRaw; + /* Harmony default export */ __webpack_exports__.default = function () { + return Object(_index__WEBPACK_IMPORTED_MODULE_0__.default)( + equirectangularRaw + ).scale(152.63); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/fit.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/fit.js ***! + \***************************************************/ + /* ! exports provided: fitExtent, fitSize, fitWidth, fitHeight */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "fitExtent", + function () { + return fitExtent; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "fitSize", + function () { + return fitSize; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "fitWidth", + function () { + return fitWidth; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "fitHeight", + function () { + return fitHeight; + } + ); + /* Harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../stream */ "./node_modules/d3-geo/src/stream.js" + ); + /* Harmony import */ var _path_bounds__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../path/bounds */ "./node_modules/d3-geo/src/path/bounds.js" + ); + + function fit(projection, fitBounds, object) { + var clip = projection.clipExtent && projection.clipExtent(); + projection.scale(150).translate([0, 0]); + if (clip != null) projection.clipExtent(null); + Object(_stream__WEBPACK_IMPORTED_MODULE_0__.default)( + object, + projection.stream( + _path_bounds__WEBPACK_IMPORTED_MODULE_1__.default + ) + ); + fitBounds( + _path_bounds__WEBPACK_IMPORTED_MODULE_1__.default.result() + ); + if (clip != null) projection.clipExtent(clip); + return projection; + } + + function fitExtent(projection, extent, object) { + return fit( + projection, + function (b) { + var w = extent[1][0] - extent[0][0], + h = extent[1][1] - extent[0][1], + k = Math.min( + w / (b[1][0] - b[0][0]), + h / (b[1][1] - b[0][1]) + ), + x = + Number(extent[0][0]) + + (w - k * (b[1][0] + b[0][0])) / 2, + y = + Number(extent[0][1]) + + (h - k * (b[1][1] + b[0][1])) / 2; + projection.scale(150 * k).translate([x, y]); + }, + object + ); + } + function fitSize(projection, size, object) { + return fitExtent(projection, [[0, 0], size], object); + } + function fitWidth(projection, width, object) { + return fit( + projection, + function (b) { + var w = Number(width), + k = w / (b[1][0] - b[0][0]), + x = (w - k * (b[1][0] + b[0][0])) / 2, + y = -k * b[0][1]; + projection.scale(150 * k).translate([x, y]); + }, + object + ); + } + function fitHeight(projection, height, object) { + return fit( + projection, + function (b) { + var h = Number(height), + k = h / (b[1][1] - b[0][1]), + x = -k * b[0][0], + y = (h - k * (b[1][1] + b[0][1])) / 2; + projection.scale(150 * k).translate([x, y]); + }, + object + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/gnomonic.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/gnomonic.js ***! + \********************************************************/ + /* ! exports provided: gnomonicRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "gnomonicRaw", + function () { + return gnomonicRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + + function gnomonicRaw(x, y) { + var cy = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(y), + k = + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(x) * + cy; + return [ + (cy * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(x)) / + k, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(y) / k, + ]; + } + gnomonicRaw.invert = Object( + _azimuthal__WEBPACK_IMPORTED_MODULE_1__.azimuthalInvert + )(_math__WEBPACK_IMPORTED_MODULE_0__.atan); + /* Harmony default export */ __webpack_exports__.default = function () { + return Object(_index__WEBPACK_IMPORTED_MODULE_2__.default)( + gnomonicRaw + ) + .scale(144.049) + .clipAngle(60); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/identity.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/identity.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _clip_rectangle__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../clip/rectangle */ "./node_modules/d3-geo/src/clip/rectangle.js" + ); + /* Harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../identity */ "./node_modules/d3-geo/src/identity.js" + ); + /* Harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../transform */ "./node_modules/d3-geo/src/transform.js" + ); + /* Harmony import */ var _fit__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./fit */ "./node_modules/d3-geo/src/projection/fit.js" + ); + + function scaleTranslate(kx, ky, tx, ty) { + return kx === 1 && ky === 1 && tx === 0 && ty === 0 + ? _identity__WEBPACK_IMPORTED_MODULE_1__.default + : Object( + _transform__WEBPACK_IMPORTED_MODULE_2__.transformer + )({ + point: function point(x, y) { + this.stream.point(x * kx + tx, y * ky + ty); + }, + }); + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var k = 1, + tx = 0, + ty = 0, + sx = 1, + sy = 1, + transform = + _identity__WEBPACK_IMPORTED_MODULE_1__.default, + // Scale, translate and reflect + x0 = null, + y0, + x1, + y1, + // Clip extent + _postclip = + _identity__WEBPACK_IMPORTED_MODULE_1__.default, + cache, + cacheStream, + projection; + + function reset() { + cache = cacheStream = null; + return projection; + } + + return (projection = { + stream: function stream(_stream) { + return cache && cacheStream === _stream + ? cache + : (cache = transform( + _postclip((cacheStream = _stream)) + )); + }, + postclip: function postclip(_) { + return arguments.length + ? ((_postclip = _), + (x0 = y0 = x1 = y1 = null), + reset()) + : _postclip; + }, + clipExtent: function clipExtent(_) { + return arguments.length + ? ((_postclip = + _ == null + ? ((x0 = y0 = x1 = y1 = null), + _identity__WEBPACK_IMPORTED_MODULE_1__.default) + : Object( + _clip_rectangle__WEBPACK_IMPORTED_MODULE_0__.default + )( + (x0 = Number(_[0][0])), + (y0 = Number(_[0][1])), + (x1 = Number(_[1][0])), + (y1 = Number(_[1][1])) + )), + reset()) + : x0 == null + ? null + : [ + [x0, y0], + [x1, y1], + ]; + }, + scale: function scale(_) { + return arguments.length + ? ((transform = scaleTranslate( + (k = Number(_)) * sx, + k * sy, + tx, + ty + )), + reset()) + : k; + }, + translate: function translate(_) { + return arguments.length + ? ((transform = scaleTranslate( + k * sx, + k * sy, + (tx = Number(_[0])), + (ty = Number(_[1])) + )), + reset()) + : [tx, ty]; + }, + reflectX: function reflectX(_) { + return arguments.length + ? ((transform = scaleTranslate( + k * (sx = _ ? -1 : 1), + k * sy, + tx, + ty + )), + reset()) + : sx < 0; + }, + reflectY: function reflectY(_) { + return arguments.length + ? ((transform = scaleTranslate( + k * sx, + k * (sy = _ ? -1 : 1), + tx, + ty + )), + reset()) + : sy < 0; + }, + fitExtent: function fitExtent(extent, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_3__.fitExtent + )(projection, extent, object); + }, + fitSize: function fitSize(size, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_3__.fitSize + )(projection, size, object); + }, + fitWidth: function fitWidth(width, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_3__.fitWidth + )(projection, width, object); + }, + fitHeight: function fitHeight(height, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_3__.fitHeight + )(projection, height, object); + }, + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/index.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/index.js ***! + \*****************************************************/ + /* ! exports provided: default, projectionMutator */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return projection; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "projectionMutator", + function () { + return projectionMutator; + } + ); + /* Harmony import */ var _clip_antimeridian__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../clip/antimeridian */ "./node_modules/d3-geo/src/clip/antimeridian.js" + ); + /* Harmony import */ var _clip_circle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../clip/circle */ "./node_modules/d3-geo/src/clip/circle.js" + ); + /* Harmony import */ var _clip_rectangle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../clip/rectangle */ "./node_modules/d3-geo/src/clip/rectangle.js" + ); + /* Harmony import */ var _compose__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ../compose */ "./node_modules/d3-geo/src/compose.js" + ); + /* Harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ../identity */ "./node_modules/d3-geo/src/identity.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _rotation__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ../rotation */ "./node_modules/d3-geo/src/rotation.js" + ); + /* Harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ../transform */ "./node_modules/d3-geo/src/transform.js" + ); + /* Harmony import */ var _fit__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./fit */ "./node_modules/d3-geo/src/projection/fit.js" + ); + /* Harmony import */ var _resample__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./resample */ "./node_modules/d3-geo/src/projection/resample.js" + ); + + var transformRadians = Object( + _transform__WEBPACK_IMPORTED_MODULE_7__.transformer + )({ + point: function point(x, y) { + this.stream.point( + x * _math__WEBPACK_IMPORTED_MODULE_5__.radians, + y * _math__WEBPACK_IMPORTED_MODULE_5__.radians + ); + }, + }); + + function transformRotate(rotate) { + return Object( + _transform__WEBPACK_IMPORTED_MODULE_7__.transformer + )({ + point: function point(x, y) { + var r = rotate(x, y); + return this.stream.point(r[0], r[1]); + }, + }); + } + + function scaleTranslate(k, dx, dy) { + function transform(x, y) { + return [dx + k * x, dy - k * y]; + } + + transform.invert = function (x, y) { + return [(x - dx) / k, (dy - y) / k]; + }; + + return transform; + } + + function scaleTranslateRotate(k, dx, dy, alpha) { + var cosAlpha = Object( + _math__WEBPACK_IMPORTED_MODULE_5__.cos + )(alpha), + sinAlpha = Object( + _math__WEBPACK_IMPORTED_MODULE_5__.sin + )(alpha), + a = cosAlpha * k, + b = sinAlpha * k, + ai = cosAlpha / k, + bi = sinAlpha / k, + ci = (sinAlpha * dy - cosAlpha * dx) / k, + fi = (sinAlpha * dx + cosAlpha * dy) / k; + + function transform(x, y) { + return [a * x - b * y + dx, dy - b * x - a * y]; + } + + transform.invert = function (x, y) { + return [ai * x - bi * y + ci, fi - bi * x - ai * y]; + }; + + return transform; + } + + function projection(project) { + return projectionMutator(function () { + return project; + })(); + } + function projectionMutator(projectAt) { + var project, + k = 150, + // Scale + x = 480, + y = 250, + // Translate + lambda = 0, + phi = 0, + // Center + deltaLambda = 0, + deltaPhi = 0, + deltaGamma = 0, + rotate, + // Pre-rotate + alpha = 0, + // Post-rotate + theta = null, + preclip = + _clip_antimeridian__WEBPACK_IMPORTED_MODULE_0__.default, + // Pre-clip angle + x0 = null, + y0, + x1, + y1, + postclip = + _identity__WEBPACK_IMPORTED_MODULE_4__.default, + // Post-clip extent + delta2 = 0.5, + // Precision + projectResample, + projectTransform, + projectRotateTransform, + cache, + cacheStream; + + function projection(point) { + return projectRotateTransform( + point[0] * + _math__WEBPACK_IMPORTED_MODULE_5__.radians, + point[1] * _math__WEBPACK_IMPORTED_MODULE_5__.radians + ); + } + + function invert(point) { + point = projectRotateTransform.invert(point[0], point[1]); + return ( + point && [ + point[0] * + _math__WEBPACK_IMPORTED_MODULE_5__.degrees, + point[1] * + _math__WEBPACK_IMPORTED_MODULE_5__.degrees, + ] + ); + } + + projection.stream = function (stream) { + return cache && cacheStream === stream + ? cache + : (cache = transformRadians( + transformRotate(rotate)( + preclip( + projectResample( + postclip((cacheStream = stream)) + ) + ) + ) + )); + }; + + projection.preclip = function (_) { + return arguments.length + ? ((preclip = _), (theta = undefined), reset()) + : preclip; + }; + + projection.postclip = function (_) { + return arguments.length + ? ((postclip = _), (x0 = y0 = x1 = y1 = null), reset()) + : postclip; + }; + + projection.clipAngle = function (_) { + return arguments.length + ? ((preclip = Number(_) + ? Object( + _clip_circle__WEBPACK_IMPORTED_MODULE_1__.default + )( + (theta = + _ * + _math__WEBPACK_IMPORTED_MODULE_5__.radians) + ) + : ((theta = null), + _clip_antimeridian__WEBPACK_IMPORTED_MODULE_0__.default)), + reset()) + : theta * _math__WEBPACK_IMPORTED_MODULE_5__.degrees; + }; + + projection.clipExtent = function (_) { + return arguments.length + ? ((postclip = + _ == null + ? ((x0 = y0 = x1 = y1 = null), + _identity__WEBPACK_IMPORTED_MODULE_4__.default) + : Object( + _clip_rectangle__WEBPACK_IMPORTED_MODULE_2__.default + )( + (x0 = Number(_[0][0])), + (y0 = Number(_[0][1])), + (x1 = Number(_[1][0])), + (y1 = Number(_[1][1])) + )), + reset()) + : x0 == null + ? null + : [ + [x0, y0], + [x1, y1], + ]; + }; + + projection.scale = function (_) { + return arguments.length ? ((k = Number(_)), recenter()) : k; + }; + + projection.translate = function (_) { + return arguments.length + ? ((x = Number(_[0])), (y = Number(_[1])), recenter()) + : [x, y]; + }; + + projection.center = function (_) { + return arguments.length + ? ((lambda = + (_[0] % 360) * + _math__WEBPACK_IMPORTED_MODULE_5__.radians), + (phi = + (_[1] % 360) * + _math__WEBPACK_IMPORTED_MODULE_5__.radians), + recenter()) + : [ + lambda * + _math__WEBPACK_IMPORTED_MODULE_5__.degrees, + phi * + _math__WEBPACK_IMPORTED_MODULE_5__.degrees, + ]; + }; + + projection.rotate = function (_) { + return arguments.length + ? ((deltaLambda = + (_[0] % 360) * + _math__WEBPACK_IMPORTED_MODULE_5__.radians), + (deltaPhi = + (_[1] % 360) * + _math__WEBPACK_IMPORTED_MODULE_5__.radians), + (deltaGamma = + _.length > 2 + ? (_[2] % 360) * + _math__WEBPACK_IMPORTED_MODULE_5__.radians + : 0), + recenter()) + : [ + deltaLambda * + _math__WEBPACK_IMPORTED_MODULE_5__.degrees, + deltaPhi * + _math__WEBPACK_IMPORTED_MODULE_5__.degrees, + deltaGamma * + _math__WEBPACK_IMPORTED_MODULE_5__.degrees, + ]; + }; + + projection.angle = function (_) { + return arguments.length + ? ((alpha = + (_ % 360) * + _math__WEBPACK_IMPORTED_MODULE_5__.radians), + recenter()) + : alpha * _math__WEBPACK_IMPORTED_MODULE_5__.degrees; + }; + + projection.precision = function (_) { + return arguments.length + ? ((projectResample = Object( + _resample__WEBPACK_IMPORTED_MODULE_9__.default + )(projectTransform, (delta2 = _ * _))), + reset()) + : Object(_math__WEBPACK_IMPORTED_MODULE_5__.sqrt)( + delta2 + ); + }; + + projection.fitExtent = function (extent, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_8__.fitExtent + )(projection, extent, object); + }; + + projection.fitSize = function (size, object) { + return Object(_fit__WEBPACK_IMPORTED_MODULE_8__.fitSize)( + projection, + size, + object + ); + }; + + projection.fitWidth = function (width, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_8__.fitWidth + )(projection, width, object); + }; + + projection.fitHeight = function (height, object) { + return Object( + _fit__WEBPACK_IMPORTED_MODULE_8__.fitHeight + )(projection, height, object); + }; + + function recenter() { + var center = scaleTranslateRotate(k, 0, 0, alpha).apply( + null, + project(lambda, phi) + ), + transform = (alpha + ? scaleTranslateRotate + : scaleTranslate)( + k, + x - center[0], + y - center[1], + alpha + ); + rotate = Object( + _rotation__WEBPACK_IMPORTED_MODULE_6__.rotateRadians + )(deltaLambda, deltaPhi, deltaGamma); + projectTransform = Object( + _compose__WEBPACK_IMPORTED_MODULE_3__.default + )(project, transform); + projectRotateTransform = Object( + _compose__WEBPACK_IMPORTED_MODULE_3__.default + )(rotate, projectTransform); + projectResample = Object( + _resample__WEBPACK_IMPORTED_MODULE_9__.default + )(projectTransform, delta2); + return reset(); + } + + function reset() { + cache = cacheStream = null; + return projection; + } + + return function () { + project = projectAt.apply(this, arguments); + projection.invert = project.invert && invert; + return recenter(); + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/mercator.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/mercator.js ***! + \********************************************************/ + /* ! exports provided: mercatorRaw, default, mercatorProjection */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "mercatorRaw", + function () { + return mercatorRaw; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "mercatorProjection", + function () { + return mercatorProjection; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _rotation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../rotation */ "./node_modules/d3-geo/src/rotation.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + + function mercatorRaw(lambda, phi) { + return [ + lambda, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.log)( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.tan)( + (_math__WEBPACK_IMPORTED_MODULE_0__.halfPi + + phi) / + 2 + ) + ), + ]; + } + + mercatorRaw.invert = function (x, y) { + return [ + x, + 2 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan)( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.exp)(y) + ) - + _math__WEBPACK_IMPORTED_MODULE_0__.halfPi, + ]; + }; + + /* Harmony default export */ __webpack_exports__.default = function () { + return mercatorProjection(mercatorRaw).scale( + 961 / _math__WEBPACK_IMPORTED_MODULE_0__.tau + ); + }; + function mercatorProjection(project) { + var m = Object(_index__WEBPACK_IMPORTED_MODULE_2__.default)( + project + ), + center = m.center, + scale = m.scale, + translate = m.translate, + clipExtent = m.clipExtent, + x0 = null, + y0, + x1, + y1; // Clip extent + + m.scale = function (_) { + return arguments.length ? (scale(_), reclip()) : scale(); + }; + + m.translate = function (_) { + return arguments.length + ? (translate(_), reclip()) + : translate(); + }; + + m.center = function (_) { + return arguments.length ? (center(_), reclip()) : center(); + }; + + m.clipExtent = function (_) { + return arguments.length + ? (_ == null + ? (x0 = y0 = x1 = y1 = null) + : ((x0 = Number(_[0][0])), + (y0 = Number(_[0][1])), + (x1 = Number(_[1][0])), + (y1 = Number(_[1][1]))), + reclip()) + : x0 == null + ? null + : [ + [x0, y0], + [x1, y1], + ]; + }; + + function reclip() { + var k = _math__WEBPACK_IMPORTED_MODULE_0__.pi * scale(), + t = m( + Object( + _rotation__WEBPACK_IMPORTED_MODULE_1__.default + )(m.rotate()).invert([0, 0]) + ); + return clipExtent( + x0 == null + ? [ + [t[0] - k, t[1] - k], + [t[0] + k, t[1] + k], + ] + : project === mercatorRaw + ? [ + [Math.max(t[0] - k, x0), y0], + [Math.min(t[0] + k, x1), y1], + ] + : [ + [x0, Math.max(t[1] - k, y0)], + [x1, Math.min(t[1] + k, y1)], + ] + ); + } + + return reclip(); + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/naturalEarth1.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/naturalEarth1.js ***! + \*************************************************************/ + /* ! exports provided: naturalEarth1Raw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "naturalEarth1Raw", + function () { + return naturalEarth1Raw; + } + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + + function naturalEarth1Raw(lambda, phi) { + var phi2 = phi * phi, + phi4 = phi2 * phi2; + return [ + lambda * + (0.8707 - + 0.131979 * phi2 + + phi4 * + (-0.013791 + + phi4 * + (0.003971 * phi2 - 0.001529 * phi4))), + phi * + (1.007226 + + phi2 * + (0.015085 + + phi4 * + (-0.044475 + + 0.028874 * phi2 - + 0.005916 * phi4))), + ]; + } + + naturalEarth1Raw.invert = function (x, y) { + var phi = y, + i = 25, + delta; + + do { + var phi2 = phi * phi, + phi4 = phi2 * phi2; + phi -= delta = + (phi * + (1.007226 + + phi2 * + (0.015085 + + phi4 * + (-0.044475 + + 0.028874 * phi2 - + 0.005916 * phi4))) - + y) / + (1.007226 + + phi2 * + (0.015085 * 3 + + phi4 * + (-0.044475 * 7 + + 0.028874 * 9 * phi2 - + 0.005916 * 11 * phi4))); + } while ( + Object(_math__WEBPACK_IMPORTED_MODULE_1__.abs)(delta) > + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon && + --i > 0 + ); + + return [ + x / + (0.8707 + + (phi2 = phi * phi) * + (-0.131979 + + phi2 * + (-0.013791 + + phi2 * + phi2 * + phi2 * + (0.003971 - 0.001529 * phi2)))), + phi, + ]; + }; + + /* Harmony default export */ __webpack_exports__.default = function () { + return Object(_index__WEBPACK_IMPORTED_MODULE_0__.default)( + naturalEarth1Raw + ).scale(175.295); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/orthographic.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/orthographic.js ***! + \************************************************************/ + /* ! exports provided: orthographicRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "orthographicRaw", + function () { + return orthographicRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + + function orthographicRaw(x, y) { + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(y) * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(x), + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(y), + ]; + } + orthographicRaw.invert = Object( + _azimuthal__WEBPACK_IMPORTED_MODULE_1__.azimuthalInvert + )(_math__WEBPACK_IMPORTED_MODULE_0__.asin); + /* Harmony default export */ __webpack_exports__.default = function () { + return Object(_index__WEBPACK_IMPORTED_MODULE_2__.default)( + orthographicRaw + ) + .scale(249.5) + .clipAngle( + 90 + _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/resample.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/resample.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../cartesian */ "./node_modules/d3-geo/src/cartesian.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../transform */ "./node_modules/d3-geo/src/transform.js" + ); + + var maxDepth = 16, + // Maximum depth of subdivision + cosMinDistance = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(30 * _math__WEBPACK_IMPORTED_MODULE_1__.radians); // Cos(minimum angular distance) + + /* harmony default export */ __webpack_exports__.default = function (project, delta2) { + return Number(delta2) + ? resample(project, delta2) + : resampleNone(project); + }; + + function resampleNone(project) { + return Object( + _transform__WEBPACK_IMPORTED_MODULE_2__.transformer + )({ + point: function point(x, y) { + x = project(x, y); + this.stream.point(x[0], x[1]); + }, + }); + } + + function resample(project, delta2) { + function resampleLineTo( + x0, + y0, + lambda0, + a0, + b0, + c0, + x1, + y1, + lambda1, + a1, + b1, + c1, + depth, + stream + ) { + var dx = x1 - x0, + dy = y1 - y0, + d2 = dx * dx + dy * dy; + + if (d2 > 4 * delta2 && depth--) { + var a = a0 + a1, + b = b0 + b1, + c = c0 + c1, + m = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.sqrt + )(a * a + b * b + c * c), + phi2 = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.asin + )((c /= m)), + lambda2 = + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.abs + )( + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.abs + )(c) - 1 + ) < + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon || + Object( + _math__WEBPACK_IMPORTED_MODULE_1__.abs + )(lambda0 - lambda1) < + _math__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? (lambda0 + lambda1) / 2 + : Object( + _math__WEBPACK_IMPORTED_MODULE_1__.atan2 + )(b, a), + p = project(lambda2, phi2), + x2 = p[0], + y2 = p[1], + dx2 = x2 - x0, + dy2 = y2 - y0, + dz = dy * dx2 - dx * dy2; + + if ( + (dz * dz) / d2 > delta2 || // Perpendicular projected distance + Object(_math__WEBPACK_IMPORTED_MODULE_1__.abs)( + (dx * dx2 + dy * dy2) / d2 - 0.5 + ) > 0.3 || // Midpoint close to an end + a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance + ) { + // Angular distance + resampleLineTo( + x0, + y0, + lambda0, + a0, + b0, + c0, + x2, + y2, + lambda2, + (a /= m), + (b /= m), + c, + depth, + stream + ); + stream.point(x2, y2); + resampleLineTo( + x2, + y2, + lambda2, + a, + b, + c, + x1, + y1, + lambda1, + a1, + b1, + c1, + depth, + stream + ); + } + } + } + + return function (stream) { + var lambda00, + x00, + y00, + a00, + b00, + c00, // First point + lambda0, + x0, + y0, + a0, + b0, + c0; // Previous point + + var resampleStream = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: function polygonStart() { + stream.polygonStart(); + resampleStream.lineStart = ringStart; + }, + polygonEnd: function polygonEnd() { + stream.polygonEnd(); + resampleStream.lineStart = lineStart; + }, + }; + + function point(x, y) { + x = project(x, y); + stream.point(x[0], x[1]); + } + + function lineStart() { + x0 = NaN; + resampleStream.point = linePoint; + stream.lineStart(); + } + + function linePoint(lambda, phi) { + var c = Object( + _cartesian__WEBPACK_IMPORTED_MODULE_0__.cartesian + )([lambda, phi]), + p = project(lambda, phi); + resampleLineTo( + x0, + y0, + lambda0, + a0, + b0, + c0, + (x0 = p[0]), + (y0 = p[1]), + (lambda0 = lambda), + (a0 = c[0]), + (b0 = c[1]), + (c0 = c[2]), + maxDepth, + stream + ); + stream.point(x0, y0); + } + + function lineEnd() { + resampleStream.point = point; + stream.lineEnd(); + } + + function ringStart() { + lineStart(); + resampleStream.point = ringPoint; + resampleStream.lineEnd = ringEnd; + } + + function ringPoint(lambda, phi) { + linePoint((lambda00 = lambda), phi), + (x00 = x0), + (y00 = y0), + (a00 = a0), + (b00 = b0), + (c00 = c0); + resampleStream.point = linePoint; + } + + function ringEnd() { + resampleLineTo( + x0, + y0, + lambda0, + a0, + b0, + c0, + x00, + y00, + lambda00, + a00, + b00, + c00, + maxDepth, + stream + ); + resampleStream.lineEnd = lineEnd; + lineEnd(); + } + + return resampleStream; + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/stereographic.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/stereographic.js ***! + \*************************************************************/ + /* ! exports provided: stereographicRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "stereographicRaw", + function () { + return stereographicRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-geo/src/projection/index.js" + ); + + function stereographicRaw(x, y) { + var cy = Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(y), + k = + 1 + + Object(_math__WEBPACK_IMPORTED_MODULE_0__.cos)(x) * + cy; + return [ + (cy * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(x)) / + k, + Object(_math__WEBPACK_IMPORTED_MODULE_0__.sin)(y) / k, + ]; + } + stereographicRaw.invert = Object( + _azimuthal__WEBPACK_IMPORTED_MODULE_1__.azimuthalInvert + )(function (z) { + return ( + 2 * Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan)(z) + ); + }); + /* Harmony default export */ __webpack_exports__.default = function () { + return Object(_index__WEBPACK_IMPORTED_MODULE_2__.default)( + stereographicRaw + ) + .scale(250) + .clipAngle(142); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/projection/transverseMercator.js": + /* !******************************************************************!*\ + !*** ./node_modules/d3-geo/src/projection/transverseMercator.js ***! + \******************************************************************/ + /* ! exports provided: transverseMercatorRaw, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "transverseMercatorRaw", + function () { + return transverseMercatorRaw; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-geo/src/math.js" + ); + /* Harmony import */ var _mercator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./mercator */ "./node_modules/d3-geo/src/projection/mercator.js" + ); + + function transverseMercatorRaw(lambda, phi) { + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_0__.log)( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.tan)( + (_math__WEBPACK_IMPORTED_MODULE_0__.halfPi + + phi) / + 2 + ) + ), + -lambda, + ]; + } + + transverseMercatorRaw.invert = function (x, y) { + return [ + -y, + 2 * + Object(_math__WEBPACK_IMPORTED_MODULE_0__.atan)( + Object(_math__WEBPACK_IMPORTED_MODULE_0__.exp)(x) + ) - + _math__WEBPACK_IMPORTED_MODULE_0__.halfPi, + ]; + }; + + /* Harmony default export */ __webpack_exports__.default = function () { + var m = Object( + _mercator__WEBPACK_IMPORTED_MODULE_1__.mercatorProjection + )(transverseMercatorRaw), + center = m.center, + rotate = m.rotate; + + m.center = function (_) { + return arguments.length + ? center([-_[1], _[0]]) + : ((_ = center()), [_[1], -_[0]]); + }; + + m.rotate = function (_) { + return arguments.length + ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) + : ((_ = rotate()), [_[0], _[1], _[2] - 90]); + }; + + return rotate([0, 0, 90]).scale(159.155); + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/rotation.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-geo/src/rotation.js ***! + \*********************************************/ + /* ! exports provided: rotateRadians, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "rotateRadians", + function () { + return rotateRadians; + } + ); + /* Harmony import */ var _compose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./compose */ "./node_modules/d3-geo/src/compose.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-geo/src/math.js" + ); + + function rotationIdentity(lambda, phi) { + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_1__.abs)(lambda) > + _math__WEBPACK_IMPORTED_MODULE_1__.pi + ? lambda + + Math.round( + -lambda / + _math__WEBPACK_IMPORTED_MODULE_1__.tau + ) * + _math__WEBPACK_IMPORTED_MODULE_1__.tau + : lambda, + phi, + ]; + } + + rotationIdentity.invert = rotationIdentity; + function rotateRadians(deltaLambda, deltaPhi, deltaGamma) { + return (deltaLambda %= + _math__WEBPACK_IMPORTED_MODULE_1__.tau) + ? deltaPhi || deltaGamma + ? Object( + _compose__WEBPACK_IMPORTED_MODULE_0__.default + )( + rotationLambda(deltaLambda), + rotationPhiGamma(deltaPhi, deltaGamma) + ) + : rotationLambda(deltaLambda) + : deltaPhi || deltaGamma + ? rotationPhiGamma(deltaPhi, deltaGamma) + : rotationIdentity; + } + + function forwardRotationLambda(deltaLambda) { + return function (lambda, phi) { + return ( + (lambda += deltaLambda), + [ + lambda > _math__WEBPACK_IMPORTED_MODULE_1__.pi + ? lambda - + _math__WEBPACK_IMPORTED_MODULE_1__.tau + : lambda < + -_math__WEBPACK_IMPORTED_MODULE_1__.pi + ? lambda + + _math__WEBPACK_IMPORTED_MODULE_1__.tau + : lambda, + phi, + ] + ); + }; + } + + function rotationLambda(deltaLambda) { + var rotation = forwardRotationLambda(deltaLambda); + rotation.invert = forwardRotationLambda(-deltaLambda); + return rotation; + } + + function rotationPhiGamma(deltaPhi, deltaGamma) { + var cosDeltaPhi = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(deltaPhi), + sinDeltaPhi = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.sin + )(deltaPhi), + cosDeltaGamma = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(deltaGamma), + sinDeltaGamma = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.sin + )(deltaGamma); + + function rotation(lambda, phi) { + var cosPhi = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(phi), + x = + Object(_math__WEBPACK_IMPORTED_MODULE_1__.cos)( + lambda + ) * cosPhi, + y = + Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + lambda + ) * cosPhi, + z = Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + phi + ), + k = z * cosDeltaPhi + x * sinDeltaPhi; + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_1__.atan2)( + y * cosDeltaGamma - k * sinDeltaGamma, + x * cosDeltaPhi - z * sinDeltaPhi + ), + Object(_math__WEBPACK_IMPORTED_MODULE_1__.asin)( + k * cosDeltaGamma + y * sinDeltaGamma + ), + ]; + } + + rotation.invert = function (lambda, phi) { + var cosPhi = Object( + _math__WEBPACK_IMPORTED_MODULE_1__.cos + )(phi), + x = + Object(_math__WEBPACK_IMPORTED_MODULE_1__.cos)( + lambda + ) * cosPhi, + y = + Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + lambda + ) * cosPhi, + z = Object(_math__WEBPACK_IMPORTED_MODULE_1__.sin)( + phi + ), + k = z * cosDeltaGamma - y * sinDeltaGamma; + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_1__.atan2)( + y * cosDeltaGamma + z * sinDeltaGamma, + x * cosDeltaPhi + k * sinDeltaPhi + ), + Object(_math__WEBPACK_IMPORTED_MODULE_1__.asin)( + k * cosDeltaPhi - x * sinDeltaPhi + ), + ]; + }; + + return rotation; + } + + /* Harmony default export */ __webpack_exports__.default = function (rotate) { + rotate = rotateRadians( + rotate[0] * _math__WEBPACK_IMPORTED_MODULE_1__.radians, + rotate[1] * _math__WEBPACK_IMPORTED_MODULE_1__.radians, + rotate.length > 2 + ? rotate[2] * + _math__WEBPACK_IMPORTED_MODULE_1__.radians + : 0 + ); + + function forward(coordinates) { + coordinates = rotate( + coordinates[0] * + _math__WEBPACK_IMPORTED_MODULE_1__.radians, + coordinates[1] * + _math__WEBPACK_IMPORTED_MODULE_1__.radians + ); + return ( + (coordinates[0] *= + _math__WEBPACK_IMPORTED_MODULE_1__.degrees), + (coordinates[1] *= + _math__WEBPACK_IMPORTED_MODULE_1__.degrees), + coordinates + ); + } + + forward.invert = function (coordinates) { + coordinates = rotate.invert( + coordinates[0] * + _math__WEBPACK_IMPORTED_MODULE_1__.radians, + coordinates[1] * + _math__WEBPACK_IMPORTED_MODULE_1__.radians + ); + return ( + (coordinates[0] *= + _math__WEBPACK_IMPORTED_MODULE_1__.degrees), + (coordinates[1] *= + _math__WEBPACK_IMPORTED_MODULE_1__.degrees), + coordinates + ); + }; + + return forward; + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/stream.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-geo/src/stream.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function streamGeometry(geometry, stream) { + if ( + geometry && + streamGeometryType.hasOwnProperty(geometry.type) + ) { + streamGeometryType[geometry.type](geometry, stream); + } + } + + var streamObjectType = { + Feature: function Feature(object, stream) { + streamGeometry(object.geometry, stream); + }, + FeatureCollection: function FeatureCollection(object, stream) { + var features = object.features, + i = -1, + n = features.length; + + while (++i < n) { + streamGeometry(features[i].geometry, stream); + } + }, + }; + var streamGeometryType = { + Sphere: function Sphere(object, stream) { + stream.sphere(); + }, + Point: function Point(object, stream) { + object = object.coordinates; + stream.point(object[0], object[1], object[2]); + }, + MultiPoint: function MultiPoint(object, stream) { + var coordinates = object.coordinates, + i = -1, + n = coordinates.length; + + while (++i < n) { + (object = coordinates[i]), + stream.point(object[0], object[1], object[2]); + } + }, + LineString: function LineString(object, stream) { + streamLine(object.coordinates, stream, 0); + }, + MultiLineString: function MultiLineString(object, stream) { + var coordinates = object.coordinates, + i = -1, + n = coordinates.length; + + while (++i < n) { + streamLine(coordinates[i], stream, 0); + } + }, + Polygon: function Polygon(object, stream) { + streamPolygon(object.coordinates, stream); + }, + MultiPolygon: function MultiPolygon(object, stream) { + var coordinates = object.coordinates, + i = -1, + n = coordinates.length; + + while (++i < n) { + streamPolygon(coordinates[i], stream); + } + }, + GeometryCollection: function GeometryCollection( + object, + stream + ) { + var geometries = object.geometries, + i = -1, + n = geometries.length; + + while (++i < n) { + streamGeometry(geometries[i], stream); + } + }, + }; + + function streamLine(coordinates, stream, closed) { + var i = -1, + n = coordinates.length - closed, + coordinate; + stream.lineStart(); + + while (++i < n) { + (coordinate = coordinates[i]), + stream.point( + coordinate[0], + coordinate[1], + coordinate[2] + ); + } + + stream.lineEnd(); + } + + function streamPolygon(coordinates, stream) { + var i = -1, + n = coordinates.length; + stream.polygonStart(); + + while (++i < n) { + streamLine(coordinates[i], stream, 1); + } + + stream.polygonEnd(); + } + + /* Harmony default export */ __webpack_exports__.default = function (object, stream) { + if (object && streamObjectType.hasOwnProperty(object.type)) { + streamObjectType[object.type](object, stream); + } else { + streamGeometry(object, stream); + } + }; + + /***/ + }, + + /***/ "./node_modules/d3-geo/src/transform.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-geo/src/transform.js ***! + \**********************************************/ + /* ! exports provided: default, transformer */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "transformer", + function () { + return transformer; + } + ); + /* Harmony default export */ __webpack_exports__.default = function (methods) { + return { + stream: transformer(methods), + }; + }; + function transformer(methods) { + return function (stream) { + var s = new TransformStream(); + + for (var key in methods) { + s[key] = methods[key]; + } + + s.stream = stream; + return s; + }; + } + + function TransformStream() {} + + TransformStream.prototype = { + constructor: TransformStream, + point: function point(x, y) { + this.stream.point(x, y); + }, + sphere: function sphere() { + this.stream.sphere(); + }, + lineStart: function lineStart() { + this.stream.lineStart(); + }, + lineEnd: function lineEnd() { + this.stream.lineEnd(); + }, + polygonStart: function polygonStart() { + this.stream.polygonStart(); + }, + polygonEnd: function polygonEnd() { + this.stream.polygonEnd(); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/accessors.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/accessors.js ***! + \****************************************************/ + /* ! exports provided: optional, required */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "optional", + function () { + return optional; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "required", + function () { + return required; + } + ); + function optional(f) { + return f == null ? null : required(f); + } + function required(f) { + if (typeof f !== "function") throw new Error(); + return f; + } + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/array.js": + /* !************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/array.js ***! + \************************************************/ + /* ! exports provided: slice, shuffle */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "slice", + function () { + return slice; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "shuffle", + function () { + return shuffle; + } + ); + var slice = Array.prototype.slice; + function shuffle(array) { + var m = array.length, + t, + i; + + while (m) { + i = (Math.random() * m--) | 0; + t = array[m]; + array[m] = array[i]; + array[i] = t; + } + + return array; + } + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/cluster.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/cluster.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function defaultSeparation(a, b) { + return a.parent === b.parent ? 1 : 2; + } + + function meanX(children) { + return children.reduce(meanXReduce, 0) / children.length; + } + + function meanXReduce(x, c) { + return x + c.x; + } + + function maxY(children) { + return 1 + children.reduce(maxYReduce, 0); + } + + function maxYReduce(y, c) { + return Math.max(y, c.y); + } + + function leafLeft(node) { + var children; + + while ((children = node.children)) { + node = children[0]; + } + + return node; + } + + function leafRight(node) { + var children; + + while ((children = node.children)) { + node = children[children.length - 1]; + } + + return node; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var separation = defaultSeparation, + dx = 1, + dy = 1, + nodeSize = false; + + function cluster(root) { + var previousNode, + x = 0; // First walk, computing the initial x & y values. + + root.eachAfter(function (node) { + var children = node.children; + + if (children) { + node.x = meanX(children); + node.y = maxY(children); + } else { + node.x = previousNode + ? (x += separation(node, previousNode)) + : 0; + node.y = 0; + previousNode = node; + } + }); + var left = leafLeft(root), + right = leafRight(root), + x0 = left.x - separation(left, right) / 2, + x1 = right.x + separation(right, left) / 2; // Second walk, normalizing x & y to the desired size. + + return root.eachAfter( + nodeSize + ? function (node) { + node.x = (node.x - root.x) * dx; + node.y = (root.y - node.y) * dy; + } + : function (node) { + node.x = ((node.x - x0) / (x1 - x0)) * dx; + node.y = + (1 - (root.y ? node.y / root.y : 1)) * dy; + } + ); + } + + cluster.separation = function (x) { + return arguments.length + ? ((separation = x), cluster) + : separation; + }; + + cluster.size = function (x) { + return arguments.length + ? ((nodeSize = false), + (dx = Number(x[0])), + (dy = Number(x[1])), + cluster) + : nodeSize + ? null + : [dx, dy]; + }; + + cluster.nodeSize = function (x) { + return arguments.length + ? ((nodeSize = true), + (dx = Number(x[0])), + (dy = Number(x[1])), + cluster) + : nodeSize + ? [dx, dy] + : null; + }; + + return cluster; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/constant.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/constant.js ***! + \***************************************************/ + /* ! exports provided: constantZero, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "constantZero", + function () { + return constantZero; + } + ); + function constantZero() { + return 0; + } + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/ancestors.js": + /* !**************************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/ancestors.js ***! + \**************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var node = this, + nodes = [node]; + + while ((node = node.parent)) { + nodes.push(node); + } + + return nodes; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/count.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/count.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function count(node) { + var sum = 0, + children = node.children, + i = children && children.length; + if (!i) sum = 1; + else + while (--i >= 0) { + sum += children[i].value; + } + node.value = sum; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + return this.eachAfter(count); + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/descendants.js": + /* !****************************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/descendants.js ***! + \****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var nodes = []; + this.each(function (node) { + nodes.push(node); + }); + return nodes; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/each.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/each.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (callback) { + var node = this, + current, + next = [node], + children, + i, + n; + + do { + (current = next.reverse()), (next = []); + + while ((node = current.pop())) { + callback(node), (children = node.children); + if (children) + for (i = 0, n = children.length; i < n; ++i) { + next.push(children[i]); + } + } + } while (next.length); + + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/eachAfter.js": + /* !**************************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/eachAfter.js ***! + \**************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (callback) { + var node = this, + nodes = [node], + next = [], + children, + i, + n; + + while ((node = nodes.pop())) { + next.push(node), (children = node.children); + if (children) + for (i = 0, n = children.length; i < n; ++i) { + nodes.push(children[i]); + } + } + + while ((node = next.pop())) { + callback(node); + } + + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/eachBefore.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/eachBefore.js ***! + \***************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (callback) { + var node = this, + nodes = [node], + children, + i; + + while ((node = nodes.pop())) { + callback(node), (children = node.children); + if (children) + for (i = children.length - 1; i >= 0; --i) { + nodes.push(children[i]); + } + } + + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/index.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/index.js ***! + \**********************************************************/ + /* ! exports provided: default, computeHeight, Node */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return hierarchy; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "computeHeight", + function () { + return computeHeight; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Node", + function () { + return Node; + } + ); + /* Harmony import */ var _count__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./count */ "./node_modules/d3-hierarchy/src/hierarchy/count.js" + ); + /* Harmony import */ var _each__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./each */ "./node_modules/d3-hierarchy/src/hierarchy/each.js" + ); + /* Harmony import */ var _eachBefore__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./eachBefore */ "./node_modules/d3-hierarchy/src/hierarchy/eachBefore.js" + ); + /* Harmony import */ var _eachAfter__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./eachAfter */ "./node_modules/d3-hierarchy/src/hierarchy/eachAfter.js" + ); + /* Harmony import */ var _sum__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./sum */ "./node_modules/d3-hierarchy/src/hierarchy/sum.js" + ); + /* Harmony import */ var _sort__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./sort */ "./node_modules/d3-hierarchy/src/hierarchy/sort.js" + ); + /* Harmony import */ var _path__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./path */ "./node_modules/d3-hierarchy/src/hierarchy/path.js" + ); + /* Harmony import */ var _ancestors__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./ancestors */ "./node_modules/d3-hierarchy/src/hierarchy/ancestors.js" + ); + /* Harmony import */ var _descendants__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./descendants */ "./node_modules/d3-hierarchy/src/hierarchy/descendants.js" + ); + /* Harmony import */ var _leaves__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./leaves */ "./node_modules/d3-hierarchy/src/hierarchy/leaves.js" + ); + /* Harmony import */ var _links__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./links */ "./node_modules/d3-hierarchy/src/hierarchy/links.js" + ); + + function hierarchy(data, children) { + var root = new Node(data), + valued = Number(data.value) && (root.value = data.value), + node, + nodes = [root], + child, + childs, + i, + n; + if (children == null) children = defaultChildren; + + while ((node = nodes.pop())) { + if (valued) node.value = Number(node.data.value); + + if ((childs = children(node.data)) && (n = childs.length)) { + node.children = new Array(n); + + for (i = n - 1; i >= 0; --i) { + nodes.push( + (child = node.children[i] = new Node(childs[i])) + ); + child.parent = node; + child.depth = node.depth + 1; + } + } + } + + return root.eachBefore(computeHeight); + } + + function node_copy() { + return hierarchy(this).eachBefore(copyData); + } + + function defaultChildren(d) { + return d.children; + } + + function copyData(node) { + node.data = node.data.data; + } + + function computeHeight(node) { + var height = 0; + + do { + node.height = height; + } while ((node = node.parent) && node.height < ++height); + } + function Node(data) { + this.data = data; + this.depth = this.height = 0; + this.parent = null; + } + Node.prototype = hierarchy.prototype = { + constructor: Node, + count: _count__WEBPACK_IMPORTED_MODULE_0__.default, + each: _each__WEBPACK_IMPORTED_MODULE_1__.default, + eachAfter: _eachAfter__WEBPACK_IMPORTED_MODULE_3__.default, + eachBefore: _eachBefore__WEBPACK_IMPORTED_MODULE_2__.default, + sum: _sum__WEBPACK_IMPORTED_MODULE_4__.default, + sort: _sort__WEBPACK_IMPORTED_MODULE_5__.default, + path: _path__WEBPACK_IMPORTED_MODULE_6__.default, + ancestors: _ancestors__WEBPACK_IMPORTED_MODULE_7__.default, + descendants: + _descendants__WEBPACK_IMPORTED_MODULE_8__.default, + leaves: _leaves__WEBPACK_IMPORTED_MODULE_9__.default, + links: _links__WEBPACK_IMPORTED_MODULE_10__.default, + copy: node_copy, + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/leaves.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/leaves.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var leaves = []; + this.eachBefore(function (node) { + if (!node.children) { + leaves.push(node); + } + }); + return leaves; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/links.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/links.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var root = this, + links = []; + root.each(function (node) { + if (node !== root) { + // Don’t include the root’s parent, if any. + links.push({ + source: node.parent, + target: node, + }); + } + }); + return links; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/path.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/path.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (end) { + var start = this, + ancestor = leastCommonAncestor(start, end), + nodes = [start]; + + while (start !== ancestor) { + start = start.parent; + nodes.push(start); + } + + var k = nodes.length; + + while (end !== ancestor) { + nodes.splice(k, 0, end); + end = end.parent; + } + + return nodes; + }; + + function leastCommonAncestor(a, b) { + if (a === b) return a; + var aNodes = a.ancestors(), + bNodes = b.ancestors(), + c = null; + a = aNodes.pop(); + b = bNodes.pop(); + + while (a === b) { + c = a; + a = aNodes.pop(); + b = bNodes.pop(); + } + + return c; + } + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/sort.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/sort.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (compare) { + return this.eachBefore(function (node) { + if (node.children) { + node.children.sort(compare); + } + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/hierarchy/sum.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/hierarchy/sum.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (value) { + return this.eachAfter(function (node) { + var sum = Number(value(node.data)) || 0, + children = node.children, + i = children && children.length; + + while (--i >= 0) { + sum += children[i].value; + } + + node.value = sum; + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/index.js": + /* !************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/index.js ***! + \************************************************/ + /* ! exports provided: cluster, hierarchy, pack, packSiblings, packEnclose, partition, stratify, tree, treemap, treemapBinary, treemapDice, treemapSlice, treemapSliceDice, treemapSquarify, treemapResquarify */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _cluster__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./cluster */ "./node_modules/d3-hierarchy/src/cluster.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "cluster", + function () { + return _cluster__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./hierarchy/index */ "./node_modules/d3-hierarchy/src/hierarchy/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "hierarchy", + function () { + return _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _pack_index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./pack/index */ "./node_modules/d3-hierarchy/src/pack/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "pack", + function () { + return _pack_index__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _pack_siblings__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./pack/siblings */ "./node_modules/d3-hierarchy/src/pack/siblings.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "packSiblings", + function () { + return _pack_siblings__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _pack_enclose__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./pack/enclose */ "./node_modules/d3-hierarchy/src/pack/enclose.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "packEnclose", + function () { + return _pack_enclose__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _partition__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./partition */ "./node_modules/d3-hierarchy/src/partition.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "partition", + function () { + return _partition__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _stratify__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./stratify */ "./node_modules/d3-hierarchy/src/stratify.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stratify", + function () { + return _stratify__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony import */ var _tree__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./tree */ "./node_modules/d3-hierarchy/src/tree.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tree", + function () { + return _tree__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /* Harmony import */ var _treemap_index__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./treemap/index */ "./node_modules/d3-hierarchy/src/treemap/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemap", + function () { + return _treemap_index__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony import */ var _treemap_binary__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./treemap/binary */ "./node_modules/d3-hierarchy/src/treemap/binary.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapBinary", + function () { + return _treemap_binary__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony import */ var _treemap_dice__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./treemap/dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapDice", + function () { + return _treemap_dice__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony import */ var _treemap_slice__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./treemap/slice */ "./node_modules/d3-hierarchy/src/treemap/slice.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapSlice", + function () { + return _treemap_slice__WEBPACK_IMPORTED_MODULE_11__.default; + } + ); + + /* Harmony import */ var _treemap_sliceDice__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./treemap/sliceDice */ "./node_modules/d3-hierarchy/src/treemap/sliceDice.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapSliceDice", + function () { + return _treemap_sliceDice__WEBPACK_IMPORTED_MODULE_12__.default; + } + ); + + /* Harmony import */ var _treemap_squarify__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./treemap/squarify */ "./node_modules/d3-hierarchy/src/treemap/squarify.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapSquarify", + function () { + return _treemap_squarify__WEBPACK_IMPORTED_MODULE_13__.default; + } + ); + + /* Harmony import */ var _treemap_resquarify__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./treemap/resquarify */ "./node_modules/d3-hierarchy/src/treemap/resquarify.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapResquarify", + function () { + return _treemap_resquarify__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/pack/enclose.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/pack/enclose.js ***! + \*******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../array */ "./node_modules/d3-hierarchy/src/array.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (circles) { + var i = 0, + n = (circles = Object( + _array__WEBPACK_IMPORTED_MODULE_0__.shuffle + )( + _array__WEBPACK_IMPORTED_MODULE_0__.slice.call( + circles + ) + )).length, + B = [], + p, + e; + + while (i < n) { + p = circles[i]; + if (e && enclosesWeak(e, p)) ++i; + else (e = encloseBasis((B = extendBasis(B, p)))), (i = 0); + } + + return e; + }; + + function extendBasis(B, p) { + var i, j; + if (enclosesWeakAll(p, B)) return [p]; // If we get here then B must have at least one element. + + for (i = 0; i < B.length; ++i) { + if ( + enclosesNot(p, B[i]) && + enclosesWeakAll(encloseBasis2(B[i], p), B) + ) { + return [B[i], p]; + } + } // If we get here then B must have at least two elements. + + for (i = 0; i < B.length - 1; ++i) { + for (j = i + 1; j < B.length; ++j) { + if ( + enclosesNot(encloseBasis2(B[i], B[j]), p) && + enclosesNot(encloseBasis2(B[i], p), B[j]) && + enclosesNot(encloseBasis2(B[j], p), B[i]) && + enclosesWeakAll(encloseBasis3(B[i], B[j], p), B) + ) { + return [B[i], B[j], p]; + } + } + } // If we get here then something is very wrong. + + throw new Error(); + } + + function enclosesNot(a, b) { + var dr = a.r - b.r, + dx = b.x - a.x, + dy = b.y - a.y; + return dr < 0 || dr * dr < dx * dx + dy * dy; + } + + function enclosesWeak(a, b) { + var dr = a.r - b.r + 1e-6, + dx = b.x - a.x, + dy = b.y - a.y; + return dr > 0 && dr * dr > dx * dx + dy * dy; + } + + function enclosesWeakAll(a, B) { + for (var i = 0; i < B.length; ++i) { + if (!enclosesWeak(a, B[i])) { + return false; + } + } + + return true; + } + + function encloseBasis(B) { + switch (B.length) { + case 1: + return encloseBasis1(B[0]); + + case 2: + return encloseBasis2(B[0], B[1]); + + case 3: + return encloseBasis3(B[0], B[1], B[2]); + } + } + + function encloseBasis1(a) { + return { + x: a.x, + y: a.y, + r: a.r, + }; + } + + function encloseBasis2(a, b) { + var x1 = a.x, + y1 = a.y, + r1 = a.r, + x2 = b.x, + y2 = b.y, + r2 = b.r, + x21 = x2 - x1, + y21 = y2 - y1, + r21 = r2 - r1, + l = Math.sqrt(x21 * x21 + y21 * y21); + return { + x: (x1 + x2 + (x21 / l) * r21) / 2, + y: (y1 + y2 + (y21 / l) * r21) / 2, + r: (l + r1 + r2) / 2, + }; + } + + function encloseBasis3(a, b, c) { + var x1 = a.x, + y1 = a.y, + r1 = a.r, + x2 = b.x, + y2 = b.y, + r2 = b.r, + x3 = c.x, + y3 = c.y, + r3 = c.r, + a2 = x1 - x2, + a3 = x1 - x3, + b2 = y1 - y2, + b3 = y1 - y3, + c2 = r2 - r1, + c3 = r3 - r1, + d1 = x1 * x1 + y1 * y1 - r1 * r1, + d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2, + d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3, + ab = a3 * b2 - a2 * b3, + xa = (b2 * d3 - b3 * d2) / (ab * 2) - x1, + xb = (b3 * c2 - b2 * c3) / ab, + ya = (a3 * d2 - a2 * d3) / (ab * 2) - y1, + yb = (a2 * c3 - a3 * c2) / ab, + A = xb * xb + yb * yb - 1, + B = 2 * (r1 + xa * xb + ya * yb), + C = xa * xa + ya * ya - r1 * r1, + r = -(A + ? (B + Math.sqrt(B * B - 4 * A * C)) / (2 * A) + : C / B); + return { + x: x1 + xa + xb * r, + y: y1 + ya + yb * r, + r: r, + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/pack/index.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/pack/index.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _siblings__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./siblings */ "./node_modules/d3-hierarchy/src/pack/siblings.js" + ); + /* Harmony import */ var _accessors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../accessors */ "./node_modules/d3-hierarchy/src/accessors.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../constant */ "./node_modules/d3-hierarchy/src/constant.js" + ); + + function defaultRadius(d) { + return Math.sqrt(d.value); + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var radius = null, + dx = 1, + dy = 1, + padding = + _constant__WEBPACK_IMPORTED_MODULE_2__.constantZero; + + function pack(root) { + (root.x = dx / 2), (root.y = dy / 2); + + if (radius) { + root.eachBefore(radiusLeaf(radius)) + .eachAfter(packChildren(padding, 0.5)) + .eachBefore(translateChild(1)); + } else { + root.eachBefore(radiusLeaf(defaultRadius)) + .eachAfter( + packChildren( + _constant__WEBPACK_IMPORTED_MODULE_2__.constantZero, + 1 + ) + ) + .eachAfter( + packChildren(padding, root.r / Math.min(dx, dy)) + ) + .eachBefore( + translateChild(Math.min(dx, dy) / (2 * root.r)) + ); + } + + return root; + } + + pack.radius = function (x) { + return arguments.length + ? ((radius = Object( + _accessors__WEBPACK_IMPORTED_MODULE_1__.optional + )(x)), + pack) + : radius; + }; + + pack.size = function (x) { + return arguments.length + ? ((dx = Number(x[0])), (dy = Number(x[1])), pack) + : [dx, dy]; + }; + + pack.padding = function (x) { + return arguments.length + ? ((padding = + typeof x === "function" + ? x + : Object( + _constant__WEBPACK_IMPORTED_MODULE_2__.default + )(Number(x))), + pack) + : padding; + }; + + return pack; + }; + + function radiusLeaf(radius) { + return function (node) { + if (!node.children) { + node.r = Math.max(0, Number(radius(node)) || 0); + } + }; + } + + function packChildren(padding, k) { + return function (node) { + if ((children = node.children)) { + var children, + i, + n = children.length, + r = padding(node) * k || 0, + e; + if (r) + for (i = 0; i < n; ++i) { + children[i].r += r; + } + e = Object( + _siblings__WEBPACK_IMPORTED_MODULE_0__.packEnclose + )(children); + if (r) + for (i = 0; i < n; ++i) { + children[i].r -= r; + } + node.r = e + r; + } + }; + } + + function translateChild(k) { + return function (node) { + var parent = node.parent; + node.r *= k; + + if (parent) { + node.x = parent.x + k * node.x; + node.y = parent.y + k * node.y; + } + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/pack/siblings.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/pack/siblings.js ***! + \********************************************************/ + /* ! exports provided: packEnclose, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "packEnclose", + function () { + return packEnclose; + } + ); + /* Harmony import */ var _enclose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./enclose */ "./node_modules/d3-hierarchy/src/pack/enclose.js" + ); + + function place(b, a, c) { + var dx = b.x - a.x, + x, + a2, + dy = b.y - a.y, + y, + b2, + d2 = dx * dx + dy * dy; + + if (d2) { + (a2 = a.r + c.r), (a2 *= a2); + (b2 = b.r + c.r), (b2 *= b2); + + if (a2 > b2) { + x = (d2 + b2 - a2) / (2 * d2); + y = Math.sqrt(Math.max(0, b2 / d2 - x * x)); + c.x = b.x - x * dx - y * dy; + c.y = b.y - x * dy + y * dx; + } else { + x = (d2 + a2 - b2) / (2 * d2); + y = Math.sqrt(Math.max(0, a2 / d2 - x * x)); + c.x = a.x + x * dx - y * dy; + c.y = a.y + x * dy + y * dx; + } + } else { + c.x = a.x + c.r; + c.y = a.y; + } + } + + function intersects(a, b) { + var dr = a.r + b.r - 1e-6, + dx = b.x - a.x, + dy = b.y - a.y; + return dr > 0 && dr * dr > dx * dx + dy * dy; + } + + function score(node) { + var a = node._, + b = node.next._, + ab = a.r + b.r, + dx = (a.x * b.r + b.x * a.r) / ab, + dy = (a.y * b.r + b.y * a.r) / ab; + return dx * dx + dy * dy; + } + + function Node(circle) { + this._ = circle; + this.next = null; + this.previous = null; + } + + function packEnclose(circles) { + if (!(n = circles.length)) return 0; + var a, b, c, n, aa, ca, i, j, k, sj, sk; // Place the first circle. + + (a = circles[0]), (a.x = 0), (a.y = 0); + if (!(n > 1)) return a.r; // Place the second circle. + + (b = circles[1]), (a.x = -b.r), (b.x = a.r), (b.y = 0); + if (!(n > 2)) return a.r + b.r; // Place the third circle. + + place(b, a, (c = circles[2])); // Initialize the front-chain using the first three circles a, b and c. + + (a = new Node(a)), (b = new Node(b)), (c = new Node(c)); + a.next = c.previous = b; + b.next = a.previous = c; + c.next = b.previous = a; // Attempt to place each remaining circle… + + pack: for (i = 3; i < n; ++i) { + place(a._, b._, (c = circles[i])), (c = new Node(c)); // Find the closest intersecting circle on the front-chain, if any. + // “Closeness” is determined by linear distance along the front-chain. + // “Ahead” or “behind” is likewise determined by linear distance. + + (j = b.next), (k = a.previous), (sj = b._.r), (sk = a._.r); + + do { + if (sj <= sk) { + if (intersects(j._, c._)) { + (b = j), (a.next = b), (b.previous = a), --i; + continue pack; + } + + (sj += j._.r), (j = j.next); + } else { + if (intersects(k._, c._)) { + (a = k), (a.next = b), (b.previous = a), --i; + continue pack; + } + + (sk += k._.r), (k = k.previous); + } + } while (j !== k.next); // Success! Insert the new circle c between a and b. + + (c.previous = a), + (c.next = b), + (a.next = b.previous = b = c); // Compute the new closest circle pair to the centroid. + + aa = score(a); + + while ((c = c.next) !== b) { + if ((ca = score(c)) < aa) { + (a = c), (aa = ca); + } + } + + b = a.next; + } // Compute the enclosing circle of the front chain. + + (a = [b._]), (c = b); + + while ((c = c.next) !== b) { + a.push(c._); + } + + c = Object(_enclose__WEBPACK_IMPORTED_MODULE_0__.default)(a); // Translate the circles to put the enclosing circle around the origin. + + for (i = 0; i < n; ++i) { + (a = circles[i]), (a.x -= c.x), (a.y -= c.y); + } + + return c.r; + } + /* Harmony default export */ __webpack_exports__.default = function (circles) { + packEnclose(circles); + return circles; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/partition.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/partition.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _treemap_round__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./treemap/round */ "./node_modules/d3-hierarchy/src/treemap/round.js" + ); + /* Harmony import */ var _treemap_dice__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./treemap/dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var dx = 1, + dy = 1, + padding = 0, + round = false; + + function partition(root) { + var n = root.height + 1; + root.x0 = root.y0 = padding; + root.x1 = dx; + root.y1 = dy / n; + root.eachBefore(positionNode(dy, n)); + if (round) + root.eachBefore( + _treemap_round__WEBPACK_IMPORTED_MODULE_0__.default + ); + return root; + } + + function positionNode(dy, n) { + return function (node) { + if (node.children) { + Object( + _treemap_dice__WEBPACK_IMPORTED_MODULE_1__.default + )( + node, + node.x0, + (dy * (node.depth + 1)) / n, + node.x1, + (dy * (node.depth + 2)) / n + ); + } + + var x0 = node.x0, + y0 = node.y0, + x1 = node.x1 - padding, + y1 = node.y1 - padding; + if (x1 < x0) x0 = x1 = (x0 + x1) / 2; + if (y1 < y0) y0 = y1 = (y0 + y1) / 2; + node.x0 = x0; + node.y0 = y0; + node.x1 = x1; + node.y1 = y1; + }; + } + + partition.round = function (x) { + return arguments.length + ? ((round = Boolean(x)), partition) + : round; + }; + + partition.size = function (x) { + return arguments.length + ? ((dx = Number(x[0])), (dy = Number(x[1])), partition) + : [dx, dy]; + }; + + partition.padding = function (x) { + return arguments.length + ? ((padding = Number(x)), partition) + : padding; + }; + + return partition; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/stratify.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/stratify.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _accessors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./accessors */ "./node_modules/d3-hierarchy/src/accessors.js" + ); + /* Harmony import */ var _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./hierarchy/index */ "./node_modules/d3-hierarchy/src/hierarchy/index.js" + ); + + var keyPrefix = "$", + // Protect against keys like “__proto__”. + preroot = { + depth: -1, + }, + ambiguous = {}; + + function defaultId(d) { + return d.id; + } + + function defaultParentId(d) { + return d.parentId; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var id = defaultId, + parentId = defaultParentId; + + function stratify(data) { + var d, + i, + n = data.length, + root, + parent, + node, + nodes = new Array(n), + nodeId, + nodeKey, + nodeByKey = {}; + + for (i = 0; i < n; ++i) { + (d = data[i]), + (node = nodes[ + i + ] = new _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__.Node(d)); + + if ( + (nodeId = id(d, i, data)) != null && + (nodeId = String(nodeId)) + ) { + nodeKey = keyPrefix + (node.id = nodeId); + nodeByKey[nodeKey] = + nodeKey in nodeByKey ? ambiguous : node; + } + } + + for (i = 0; i < n; ++i) { + (node = nodes[i]), + (nodeId = parentId(data[i], i, data)); + + if (nodeId == null || !(nodeId = String(nodeId))) { + if (root) throw new Error("multiple roots"); + root = node; + } else { + parent = nodeByKey[keyPrefix + nodeId]; + if (!parent) throw new Error("missing: " + nodeId); + if (parent === ambiguous) + throw new Error("ambiguous: " + nodeId); + if (parent.children) parent.children.push(node); + else parent.children = [node]; + node.parent = parent; + } + } + + if (!root) throw new Error("no root"); + root.parent = preroot; + root.eachBefore(function (node) { + node.depth = node.parent.depth + 1; + --n; + }).eachBefore( + _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__.computeHeight + ); + root.parent = null; + if (n > 0) throw new Error("cycle"); + return root; + } + + stratify.id = function (x) { + return arguments.length + ? ((id = Object( + _accessors__WEBPACK_IMPORTED_MODULE_0__.required + )(x)), + stratify) + : id; + }; + + stratify.parentId = function (x) { + return arguments.length + ? ((parentId = Object( + _accessors__WEBPACK_IMPORTED_MODULE_0__.required + )(x)), + stratify) + : parentId; + }; + + return stratify; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/tree.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-hierarchy/src/tree.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _hierarchy_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./hierarchy/index */ "./node_modules/d3-hierarchy/src/hierarchy/index.js" + ); + + function defaultSeparation(a, b) { + return a.parent === b.parent ? 1 : 2; + } // Function radialSeparation(a, b) { + // return (a.parent === b.parent ? 1 : 2) / a.depth; + // } + // This function is used to traverse the left contour of a subtree (or + // subforest). It returns the successor of v on this contour. This successor is + // either given by the leftmost child of v or by the thread of v. The function + // returns null if and only if v is on the highest level of its subtree. + + function nextLeft(v) { + var children = v.children; + return children ? children[0] : v.t; + } // This function works analogously to nextLeft. + + function nextRight(v) { + var children = v.children; + return children ? children[children.length - 1] : v.t; + } // Shifts the current subtree rooted at w+. This is done by increasing + // prelim(w+) and mod(w+) by shift. + + function moveSubtree(wm, wp, shift) { + var change = shift / (wp.i - wm.i); + wp.c -= change; + wp.s += shift; + wm.c += change; + wp.z += shift; + wp.m += shift; + } // All other shifts, applied to the smaller subtrees between w- and w+, are + // performed by this function. To prepare the shifts, we have to adjust + // change(w+), shift(w+), and change(w-). + + function executeShifts(v) { + var shift = 0, + change = 0, + children = v.children, + i = children.length, + w; + + while (--i >= 0) { + w = children[i]; + w.z += shift; + w.m += shift; + shift += w.s + (change += w.c); + } + } // If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise, + // returns the specified (default) ancestor. + + function nextAncestor(vim, v, ancestor) { + return vim.a.parent === v.parent ? vim.a : ancestor; + } + + function TreeNode(node, i) { + this._ = node; + this.parent = null; + this.children = null; + this.A = null; // Default ancestor + + this.a = this; // Ancestor + + this.z = 0; // Prelim + + this.m = 0; // Mod + + this.c = 0; // Change + + this.s = 0; // Shift + + this.t = null; // Thread + + this.i = i; // Number + } + + TreeNode.prototype = Object.create( + _hierarchy_index__WEBPACK_IMPORTED_MODULE_0__.Node.prototype + ); + + function treeRoot(root) { + var tree = new TreeNode(root, 0), + node, + nodes = [tree], + child, + children, + i, + n; + + while ((node = nodes.pop())) { + if ((children = node._.children)) { + node.children = new Array((n = children.length)); + + for (i = n - 1; i >= 0; --i) { + nodes.push( + (child = node.children[i] = new TreeNode( + children[i], + i + )) + ); + child.parent = node; + } + } + } + + (tree.parent = new TreeNode(null, 0)).children = [tree]; + return tree; + } // Node-link tree diagram using the Reingold-Tilford "tidy" algorithm + + /* harmony default export */ __webpack_exports__.default = function () { + var separation = defaultSeparation, + dx = 1, + dy = 1, + nodeSize = null; + + function tree(root) { + var t = treeRoot(root); // Compute the layout using Buchheim et al.’s algorithm. + + t.eachAfter(firstWalk), (t.parent.m = -t.z); + t.eachBefore(secondWalk); // If a fixed node size is specified, scale x and y. + + if (nodeSize) root.eachBefore(sizeNode); + // If a fixed tree size is specified, scale x and y based on the extent. + // Compute the left-most, right-most, and depth-most nodes for extents. + else { + var left = root, + right = root, + bottom = root; + root.eachBefore(function (node) { + if (node.x < left.x) left = node; + if (node.x > right.x) right = node; + if (node.depth > bottom.depth) bottom = node; + }); + var s = + left === right + ? 1 + : separation(left, right) / 2, + tx = s - left.x, + kx = dx / (right.x + s + tx), + ky = dy / (bottom.depth || 1); + root.eachBefore(function (node) { + node.x = (node.x + tx) * kx; + node.y = node.depth * ky; + }); + } + return root; + } // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is + // applied recursively to the children of v, as well as the function + // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the + // node v is placed to the midpoint of its outermost children. + + function firstWalk(v) { + var children = v.children, + siblings = v.parent.children, + w = v.i ? siblings[v.i - 1] : null; + + if (children) { + executeShifts(v); + var midpoint = + (children[0].z + children[children.length - 1].z) / + 2; + + if (w) { + v.z = w.z + separation(v._, w._); + v.m = v.z - midpoint; + } else { + v.z = midpoint; + } + } else if (w) { + v.z = w.z + separation(v._, w._); + } + + v.parent.A = apportion(v, w, v.parent.A || siblings[0]); + } // Computes all real x-coordinates by summing up the modifiers recursively. + + function secondWalk(v) { + v._.x = v.z + v.parent.m; + v.m += v.parent.m; + } // The core of the algorithm. Here, a new subtree is combined with the + // previous subtrees. Threads are used to traverse the inside and outside + // contours of the left and right subtree up to the highest common level. The + // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the + // superscript o means outside and i means inside, the subscript - means left + // subtree and + means right subtree. For summing up the modifiers along the + // contour, we use respective variables si+, si-, so-, and so+. Whenever two + // nodes of the inside contours conflict, we compute the left one of the + // greatest uncommon ancestors using the function ANCESTOR and call MOVE + // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees. + // Finally, we add a new thread (if necessary). + + function apportion(v, w, ancestor) { + if (w) { + var vip = v, + vop = v, + vim = w, + vom = vip.parent.children[0], + sip = vip.m, + sop = vop.m, + sim = vim.m, + som = vom.m, + shift; + + while ( + ((vim = nextRight(vim)), + (vip = nextLeft(vip)), + vim && vip) + ) { + vom = nextLeft(vom); + vop = nextRight(vop); + vop.a = v; + shift = + vim.z + + sim - + vip.z - + sip + + separation(vim._, vip._); + + if (shift > 0) { + moveSubtree( + nextAncestor(vim, v, ancestor), + v, + shift + ); + sip += shift; + sop += shift; + } + + sim += vim.m; + sip += vip.m; + som += vom.m; + sop += vop.m; + } + + if (vim && !nextRight(vop)) { + vop.t = vim; + vop.m += sim - sop; + } + + if (vip && !nextLeft(vom)) { + vom.t = vip; + vom.m += sip - som; + ancestor = v; + } + } + + return ancestor; + } + + function sizeNode(node) { + node.x *= dx; + node.y = node.depth * dy; + } + + tree.separation = function (x) { + return arguments.length + ? ((separation = x), tree) + : separation; + }; + + tree.size = function (x) { + return arguments.length + ? ((nodeSize = false), (dx = Number(x[0])), (dy = Number(x[1])), tree) + : nodeSize + ? null + : [dx, dy]; + }; + + tree.nodeSize = function (x) { + return arguments.length + ? ((nodeSize = true), (dx = Number(x[0])), (dy = Number(x[1])), tree) + : nodeSize + ? [dx, dy] + : null; + }; + + return tree; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/treemap/binary.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/treemap/binary.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (parent, x0, y0, x1, y1) { + var nodes = parent.children, + i, + n = nodes.length, + sum, + sums = new Array(n + 1); + + for (sums[0] = sum = i = 0; i < n; ++i) { + sums[i + 1] = sum += nodes[i].value; + } + + partition(0, n, parent.value, x0, y0, x1, y1); + + function partition(i, j, value, x0, y0, x1, y1) { + if (i >= j - 1) { + var node = nodes[i]; + (node.x0 = x0), (node.y0 = y0); + (node.x1 = x1), (node.y1 = y1); + return; + } + + var valueOffset = sums[i], + valueTarget = value / 2 + valueOffset, + k = i + 1, + hi = j - 1; + + while (k < hi) { + var mid = (k + hi) >>> 1; + if (sums[mid] < valueTarget) k = mid + 1; + else hi = mid; + } + + if ( + valueTarget - sums[k - 1] < sums[k] - valueTarget && + i + 1 < k + ) + --k; + var valueLeft = sums[k] - valueOffset, + valueRight = value - valueLeft; + + if (x1 - x0 > y1 - y0) { + var xk = (x0 * valueRight + x1 * valueLeft) / value; + partition(i, k, valueLeft, x0, y0, xk, y1); + partition(k, j, valueRight, xk, y0, x1, y1); + } else { + var yk = (y0 * valueRight + y1 * valueLeft) / value; + partition(i, k, valueLeft, x0, y0, x1, yk); + partition(k, j, valueRight, x0, yk, x1, y1); + } + } + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/treemap/dice.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/treemap/dice.js ***! + \*******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (parent, x0, y0, x1, y1) { + var nodes = parent.children, + node, + i = -1, + n = nodes.length, + k = parent.value && (x1 - x0) / parent.value; + + while (++i < n) { + (node = nodes[i]), (node.y0 = y0), (node.y1 = y1); + (node.x0 = x0), (node.x1 = x0 += node.value * k); + } + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/treemap/index.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/treemap/index.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _round__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./round */ "./node_modules/d3-hierarchy/src/treemap/round.js" + ); + /* Harmony import */ var _squarify__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./squarify */ "./node_modules/d3-hierarchy/src/treemap/squarify.js" + ); + /* Harmony import */ var _accessors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../accessors */ "./node_modules/d3-hierarchy/src/accessors.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ../constant */ "./node_modules/d3-hierarchy/src/constant.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var tile = _squarify__WEBPACK_IMPORTED_MODULE_1__.default, + round = false, + dx = 1, + dy = 1, + paddingStack = [0], + paddingInner = + _constant__WEBPACK_IMPORTED_MODULE_3__.constantZero, + paddingTop = + _constant__WEBPACK_IMPORTED_MODULE_3__.constantZero, + paddingRight = + _constant__WEBPACK_IMPORTED_MODULE_3__.constantZero, + paddingBottom = + _constant__WEBPACK_IMPORTED_MODULE_3__.constantZero, + paddingLeft = + _constant__WEBPACK_IMPORTED_MODULE_3__.constantZero; + + function treemap(root) { + root.x0 = root.y0 = 0; + root.x1 = dx; + root.y1 = dy; + root.eachBefore(positionNode); + paddingStack = [0]; + if (round) + root.eachBefore( + _round__WEBPACK_IMPORTED_MODULE_0__.default + ); + return root; + } + + function positionNode(node) { + var p = paddingStack[node.depth], + x0 = node.x0 + p, + y0 = node.y0 + p, + x1 = node.x1 - p, + y1 = node.y1 - p; + if (x1 < x0) x0 = x1 = (x0 + x1) / 2; + if (y1 < y0) y0 = y1 = (y0 + y1) / 2; + node.x0 = x0; + node.y0 = y0; + node.x1 = x1; + node.y1 = y1; + + if (node.children) { + p = paddingStack[node.depth + 1] = + paddingInner(node) / 2; + x0 += paddingLeft(node) - p; + y0 += paddingTop(node) - p; + x1 -= paddingRight(node) - p; + y1 -= paddingBottom(node) - p; + if (x1 < x0) x0 = x1 = (x0 + x1) / 2; + if (y1 < y0) y0 = y1 = (y0 + y1) / 2; + tile(node, x0, y0, x1, y1); + } + } + + treemap.round = function (x) { + return arguments.length ? ((round = Boolean(x)), treemap) : round; + }; + + treemap.size = function (x) { + return arguments.length + ? ((dx = Number(x[0])), (dy = Number(x[1])), treemap) + : [dx, dy]; + }; + + treemap.tile = function (x) { + return arguments.length + ? ((tile = Object( + _accessors__WEBPACK_IMPORTED_MODULE_2__.required + )(x)), + treemap) + : tile; + }; + + treemap.padding = function (x) { + return arguments.length + ? treemap.paddingInner(x).paddingOuter(x) + : treemap.paddingInner(); + }; + + treemap.paddingInner = function (x) { + return arguments.length + ? ((paddingInner = + typeof x === "function" + ? x + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(Number(x))), + treemap) + : paddingInner; + }; + + treemap.paddingOuter = function (x) { + return arguments.length + ? treemap + .paddingTop(x) + .paddingRight(x) + .paddingBottom(x) + .paddingLeft(x) + : treemap.paddingTop(); + }; + + treemap.paddingTop = function (x) { + return arguments.length + ? ((paddingTop = + typeof x === "function" + ? x + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(Number(x))), + treemap) + : paddingTop; + }; + + treemap.paddingRight = function (x) { + return arguments.length + ? ((paddingRight = + typeof x === "function" + ? x + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(Number(x))), + treemap) + : paddingRight; + }; + + treemap.paddingBottom = function (x) { + return arguments.length + ? ((paddingBottom = + typeof x === "function" + ? x + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(Number(x))), + treemap) + : paddingBottom; + }; + + treemap.paddingLeft = function (x) { + return arguments.length + ? ((paddingLeft = + typeof x === "function" + ? x + : Object( + _constant__WEBPACK_IMPORTED_MODULE_3__.default + )(Number(x))), + treemap) + : paddingLeft; + }; + + return treemap; + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/treemap/resquarify.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/treemap/resquarify.js ***! + \*************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _dice__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js" + ); + /* Harmony import */ var _slice__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./slice */ "./node_modules/d3-hierarchy/src/treemap/slice.js" + ); + /* Harmony import */ var _squarify__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./squarify */ "./node_modules/d3-hierarchy/src/treemap/squarify.js" + ); + + /* Harmony default export */ __webpack_exports__.default = (function custom(ratio) { + function resquarify(parent, x0, y0, x1, y1) { + if ((rows = parent._squarify) && rows.ratio === ratio) { + var rows, + row, + nodes, + i, + j = -1, + n, + m = rows.length, + value = parent.value; + + while (++j < m) { + (row = rows[j]), (nodes = row.children); + + for ( + i = row.value = 0, n = nodes.length; + i < n; + ++i + ) { + row.value += nodes[i].value; + } + + if (row.dice) + Object( + _dice__WEBPACK_IMPORTED_MODULE_0__.default + )( + row, + x0, + y0, + x1, + (y0 += ((y1 - y0) * row.value) / value) + ); + else + Object( + _slice__WEBPACK_IMPORTED_MODULE_1__.default + )( + row, + x0, + y0, + (x0 += ((x1 - x0) * row.value) / value), + y1 + ); + value -= row.value; + } + } else { + parent._squarify = rows = Object( + _squarify__WEBPACK_IMPORTED_MODULE_2__.squarifyRatio + )(ratio, parent, x0, y0, x1, y1); + rows.ratio = ratio; + } + } + + resquarify.ratio = function (x) { + return custom((x = Number(x)) > 1 ? x : 1); + }; + + return resquarify; + })(_squarify__WEBPACK_IMPORTED_MODULE_2__.phi); + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/treemap/round.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/treemap/round.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (node) { + node.x0 = Math.round(node.x0); + node.y0 = Math.round(node.y0); + node.x1 = Math.round(node.x1); + node.y1 = Math.round(node.y1); + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/treemap/slice.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/treemap/slice.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (parent, x0, y0, x1, y1) { + var nodes = parent.children, + node, + i = -1, + n = nodes.length, + k = parent.value && (y1 - y0) / parent.value; + + while (++i < n) { + (node = nodes[i]), (node.x0 = x0), (node.x1 = x1); + (node.y0 = y0), (node.y1 = y0 += node.value * k); + } + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/treemap/sliceDice.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/treemap/sliceDice.js ***! + \************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _dice__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js" + ); + /* Harmony import */ var _slice__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./slice */ "./node_modules/d3-hierarchy/src/treemap/slice.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (parent, x0, y0, x1, y1) { + (parent.depth & 1 + ? _slice__WEBPACK_IMPORTED_MODULE_1__.default + : _dice__WEBPACK_IMPORTED_MODULE_0__.default)( + parent, + x0, + y0, + x1, + y1 + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-hierarchy/src/treemap/squarify.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-hierarchy/src/treemap/squarify.js ***! + \***********************************************************/ + /* ! exports provided: phi, squarifyRatio, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "phi", + function () { + return phi; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "squarifyRatio", + function () { + return squarifyRatio; + } + ); + /* Harmony import */ var _dice__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js" + ); + /* Harmony import */ var _slice__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./slice */ "./node_modules/d3-hierarchy/src/treemap/slice.js" + ); + + var phi = (1 + Math.sqrt(5)) / 2; + function squarifyRatio(ratio, parent, x0, y0, x1, y1) { + var rows = [], + nodes = parent.children, + row, + nodeValue, + i0 = 0, + i1 = 0, + n = nodes.length, + dx, + dy, + value = parent.value, + sumValue, + minValue, + maxValue, + newRatio, + minRatio, + alpha, + beta; + + while (i0 < n) { + (dx = x1 - x0), (dy = y1 - y0); // Find the next non-empty node. + + do { + sumValue = nodes[i1++].value; + } while (!sumValue && i1 < n); + + minValue = maxValue = sumValue; + alpha = Math.max(dy / dx, dx / dy) / (value * ratio); + beta = sumValue * sumValue * alpha; + minRatio = Math.max(maxValue / beta, beta / minValue); // Keep adding nodes while the aspect ratio maintains or improves. + + for (; i1 < n; ++i1) { + sumValue += nodeValue = nodes[i1].value; + if (nodeValue < minValue) minValue = nodeValue; + if (nodeValue > maxValue) maxValue = nodeValue; + beta = sumValue * sumValue * alpha; + newRatio = Math.max(maxValue / beta, beta / minValue); + + if (newRatio > minRatio) { + sumValue -= nodeValue; + break; + } + + minRatio = newRatio; + } // Position and record the row orientation. + + rows.push( + (row = { + value: sumValue, + dice: dx < dy, + children: nodes.slice(i0, i1), + }) + ); + if (row.dice) + Object(_dice__WEBPACK_IMPORTED_MODULE_0__.default)( + row, + x0, + y0, + x1, + value ? (y0 += (dy * sumValue) / value) : y1 + ); + else + Object(_slice__WEBPACK_IMPORTED_MODULE_1__.default)( + row, + x0, + y0, + value ? (x0 += (dx * sumValue) / value) : x1, + y1 + ); + (value -= sumValue), (i0 = i1); + } + + return rows; + } + /* Harmony default export */ __webpack_exports__.default = (function custom(ratio) { + function squarify(parent, x0, y0, x1, y1) { + squarifyRatio(ratio, parent, x0, y0, x1, y1); + } + + squarify.ratio = function (x) { + return custom((x = Number(x)) > 1 ? x : 1); + }; + + return squarify; + })(phi); + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/array.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-interpolate/src/array.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _value__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./value */ "./node_modules/d3-interpolate/src/value.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + var nb = b ? b.length : 0, + na = a ? Math.min(nb, a.length) : 0, + x = new Array(na), + c = new Array(nb), + i; + + for (i = 0; i < na; ++i) { + x[i] = Object( + _value__WEBPACK_IMPORTED_MODULE_0__.default + )(a[i], b[i]); + } + + for (; i < nb; ++i) { + c[i] = b[i]; + } + + return function (t) { + for (i = 0; i < na; ++i) { + c[i] = x[i](t); + } + + return c; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/basis.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-interpolate/src/basis.js ***! + \**************************************************/ + /* ! exports provided: basis, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "basis", + function () { + return basis; + } + ); + function basis(t1, v0, v1, v2, v3) { + var t2 = t1 * t1, + t3 = t2 * t1; + return ( + ((1 - 3 * t1 + 3 * t2 - t3) * v0 + + (4 - 6 * t2 + 3 * t3) * v1 + + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 + + t3 * v3) / + 6 + ); + } + /* Harmony default export */ __webpack_exports__.default = function (values) { + var n = values.length - 1; + return function (t) { + var i = + t <= 0 + ? (t = 0) + : t >= 1 + ? ((t = 1), n - 1) + : Math.floor(t * n), + v1 = values[i], + v2 = values[i + 1], + v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, + v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1; + return basis((t - i / n) * n, v0, v1, v2, v3); + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/basisClosed.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-interpolate/src/basisClosed.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./basis */ "./node_modules/d3-interpolate/src/basis.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (values) { + var n = values.length; + return function (t) { + var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), + v0 = values[(i + n - 1) % n], + v1 = values[i % n], + v2 = values[(i + 1) % n], + v3 = values[(i + 2) % n]; + return Object(_basis__WEBPACK_IMPORTED_MODULE_0__.basis)( + (t - i / n) * n, + v0, + v1, + v2, + v3 + ); + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/color.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-interpolate/src/color.js ***! + \**************************************************/ + /* ! exports provided: hue, gamma, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "hue", + function () { + return hue; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "gamma", + function () { + return gamma; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return nogamma; + } + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-interpolate/src/constant.js" + ); + + function linear(a, d) { + return function (t) { + return a + t * d; + }; + } + + function exponential(a, b, y) { + return ( + (a = Math.pow(a, y)), + (b = Math.pow(b, y) - a), + (y = 1 / y), + function (t) { + return Math.pow(a + t * b, y); + } + ); + } + + function hue(a, b) { + var d = b - a; + return d + ? linear( + a, + d > 180 || d < -180 + ? d - 360 * Math.round(d / 360) + : d + ) + : Object(_constant__WEBPACK_IMPORTED_MODULE_0__.default)( + isNaN(a) ? b : a + ); + } + function gamma(y) { + return (y = Number(y)) === 1 + ? nogamma + : function (a, b) { + return b - a + ? exponential(a, b, y) + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(isNaN(a) ? b : a); + }; + } + function nogamma(a, b) { + var d = b - a; + return d + ? linear(a, d) + : Object(_constant__WEBPACK_IMPORTED_MODULE_0__.default)( + isNaN(a) ? b : a + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/constant.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-interpolate/src/constant.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/cubehelix.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-interpolate/src/cubehelix.js ***! + \******************************************************/ + /* ! exports provided: default, cubehelixLong */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cubehelixLong", + function () { + return cubehelixLong; + } + ); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./color */ "./node_modules/d3-interpolate/src/color.js" + ); + + function cubehelix(hue) { + return (function cubehelixGamma(y) { + y = Number(y); + + function cubehelix(start, end) { + var h = hue( + (start = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix + )(start)).h, + (end = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix + )(end)).h + ), + s = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.s, end.s), + l = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.l, end.l), + opacity = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.opacity, end.opacity); + return function (t) { + start.h = h(t); + start.s = s(t); + start.l = l(Math.pow(t, y)); + start.opacity = opacity(t); + return String(start); + }; + } + + cubehelix.gamma = cubehelixGamma; + return cubehelix; + })(1); + } + + /* Harmony default export */ __webpack_exports__.default = cubehelix(_color__WEBPACK_IMPORTED_MODULE_1__.hue); + var cubehelixLong = cubehelix( + _color__WEBPACK_IMPORTED_MODULE_1__.default + ); + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/date.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-interpolate/src/date.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + var d = new Date(); + return ( + (a = Number(a)), + (b -= a), + function (t) { + return d.setTime(a + b * t), d; + } + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/discrete.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-interpolate/src/discrete.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (range) { + var n = range.length; + return function (t) { + return range[ + Math.max(0, Math.min(n - 1, Math.floor(t * n))) + ]; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/hcl.js": + /* !************************************************!*\ + !*** ./node_modules/d3-interpolate/src/hcl.js ***! + \************************************************/ + /* ! exports provided: default, hclLong */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "hclLong", + function () { + return hclLong; + } + ); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./color */ "./node_modules/d3-interpolate/src/color.js" + ); + + function hcl(hue) { + return function (start, end) { + var h = hue( + (start = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.hcl + )(start)).h, + (end = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.hcl + )(end)).h + ), + c = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.c, end.c), + l = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.l, end.l), + opacity = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.opacity, end.opacity); + return function (t) { + start.h = h(t); + start.c = c(t); + start.l = l(t); + start.opacity = opacity(t); + return String(start); + }; + }; + } + + /* Harmony default export */ __webpack_exports__.default = hcl( + _color__WEBPACK_IMPORTED_MODULE_1__.hue + ); + var hclLong = hcl(_color__WEBPACK_IMPORTED_MODULE_1__.default); + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/hsl.js": + /* !************************************************!*\ + !*** ./node_modules/d3-interpolate/src/hsl.js ***! + \************************************************/ + /* ! exports provided: default, hslLong */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "hslLong", + function () { + return hslLong; + } + ); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./color */ "./node_modules/d3-interpolate/src/color.js" + ); + + function hsl(hue) { + return function (start, end) { + var h = hue( + (start = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.hsl + )(start)).h, + (end = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.hsl + )(end)).h + ), + s = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.s, end.s), + l = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.l, end.l), + opacity = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.opacity, end.opacity); + return function (t) { + start.h = h(t); + start.s = s(t); + start.l = l(t); + start.opacity = opacity(t); + return String(start); + }; + }; + } + + /* Harmony default export */ __webpack_exports__.default = hsl( + _color__WEBPACK_IMPORTED_MODULE_1__.hue + ); + var hslLong = hsl(_color__WEBPACK_IMPORTED_MODULE_1__.default); + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/hue.js": + /* !************************************************!*\ + !*** ./node_modules/d3-interpolate/src/hue.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./color */ "./node_modules/d3-interpolate/src/color.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + var i = Object(_color__WEBPACK_IMPORTED_MODULE_0__.hue)( + Number(a), + Number(b) + ); + return function (t) { + var x = i(t); + return x - 360 * Math.floor(x / 360); + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/index.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-interpolate/src/index.js ***! + \**************************************************/ + /* ! exports provided: interpolate, interpolateArray, interpolateBasis, interpolateBasisClosed, interpolateDate, interpolateDiscrete, interpolateHue, interpolateNumber, interpolateObject, interpolateRound, interpolateString, interpolateTransformCss, interpolateTransformSvg, interpolateZoom, interpolateRgb, interpolateRgbBasis, interpolateRgbBasisClosed, interpolateHsl, interpolateHslLong, interpolateLab, interpolateHcl, interpolateHclLong, interpolateCubehelix, interpolateCubehelixLong, piecewise, quantize */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _value__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./value */ "./node_modules/d3-interpolate/src/value.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolate", + function () { + return _value__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-interpolate/src/array.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateArray", + function () { + return _array__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./basis */ "./node_modules/d3-interpolate/src/basis.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBasis", + function () { + return _basis__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _basisClosed__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./basisClosed */ "./node_modules/d3-interpolate/src/basisClosed.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBasisClosed", + function () { + return _basisClosed__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _date__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./date */ "./node_modules/d3-interpolate/src/date.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateDate", + function () { + return _date__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _discrete__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./discrete */ "./node_modules/d3-interpolate/src/discrete.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateDiscrete", + function () { + return _discrete__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _hue__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./hue */ "./node_modules/d3-interpolate/src/hue.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHue", + function () { + return _hue__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-interpolate/src/number.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateNumber", + function () { + return _number__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /* Harmony import */ var _object__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./object */ "./node_modules/d3-interpolate/src/object.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateObject", + function () { + return _object__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony import */ var _round__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./round */ "./node_modules/d3-interpolate/src/round.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRound", + function () { + return _round__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony import */ var _string__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./string */ "./node_modules/d3-interpolate/src/string.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateString", + function () { + return _string__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony import */ var _transform_index__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./transform/index */ "./node_modules/d3-interpolate/src/transform/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateTransformCss", + function () { + return _transform_index__WEBPACK_IMPORTED_MODULE_11__.interpolateTransformCss; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateTransformSvg", + function () { + return _transform_index__WEBPACK_IMPORTED_MODULE_11__.interpolateTransformSvg; + } + ); + + /* Harmony import */ var _zoom__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./zoom */ "./node_modules/d3-interpolate/src/zoom.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateZoom", + function () { + return _zoom__WEBPACK_IMPORTED_MODULE_12__.default; + } + ); + + /* Harmony import */ var _rgb__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./rgb */ "./node_modules/d3-interpolate/src/rgb.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRgb", + function () { + return _rgb__WEBPACK_IMPORTED_MODULE_13__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRgbBasis", + function () { + return _rgb__WEBPACK_IMPORTED_MODULE_13__.rgbBasis; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRgbBasisClosed", + function () { + return _rgb__WEBPACK_IMPORTED_MODULE_13__.rgbBasisClosed; + } + ); + + /* Harmony import */ var _hsl__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./hsl */ "./node_modules/d3-interpolate/src/hsl.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHsl", + function () { + return _hsl__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHslLong", + function () { + return _hsl__WEBPACK_IMPORTED_MODULE_14__.hslLong; + } + ); + + /* Harmony import */ var _lab__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./lab */ "./node_modules/d3-interpolate/src/lab.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateLab", + function () { + return _lab__WEBPACK_IMPORTED_MODULE_15__.default; + } + ); + + /* Harmony import */ var _hcl__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! ./hcl */ "./node_modules/d3-interpolate/src/hcl.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHcl", + function () { + return _hcl__WEBPACK_IMPORTED_MODULE_16__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHclLong", + function () { + return _hcl__WEBPACK_IMPORTED_MODULE_16__.hclLong; + } + ); + + /* Harmony import */ var _cubehelix__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! ./cubehelix */ "./node_modules/d3-interpolate/src/cubehelix.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCubehelix", + function () { + return _cubehelix__WEBPACK_IMPORTED_MODULE_17__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCubehelixLong", + function () { + return _cubehelix__WEBPACK_IMPORTED_MODULE_17__.cubehelixLong; + } + ); + + /* Harmony import */ var _piecewise__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__( + /* ! ./piecewise */ "./node_modules/d3-interpolate/src/piecewise.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "piecewise", + function () { + return _piecewise__WEBPACK_IMPORTED_MODULE_18__.default; + } + ); + + /* Harmony import */ var _quantize__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__( + /* ! ./quantize */ "./node_modules/d3-interpolate/src/quantize.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "quantize", + function () { + return _quantize__WEBPACK_IMPORTED_MODULE_19__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/lab.js": + /* !************************************************!*\ + !*** ./node_modules/d3-interpolate/src/lab.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return lab; + } + ); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./color */ "./node_modules/d3-interpolate/src/color.js" + ); + + function lab(start, end) { + var l = Object(_color__WEBPACK_IMPORTED_MODULE_1__.default)( + (start = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.lab + )(start)).l, + (end = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.lab + )(end)).l + ), + a = Object(_color__WEBPACK_IMPORTED_MODULE_1__.default)( + start.a, + end.a + ), + b = Object(_color__WEBPACK_IMPORTED_MODULE_1__.default)( + start.b, + end.b + ), + opacity = Object( + _color__WEBPACK_IMPORTED_MODULE_1__.default + )(start.opacity, end.opacity); + return function (t) { + start.l = l(t); + start.a = a(t); + start.b = b(t); + start.opacity = opacity(t); + return String(start); + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/number.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-interpolate/src/number.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + return ( + (a = Number(a)), + (b -= a), + function (t) { + return a + b * t; + } + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/object.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-interpolate/src/object.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _value__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./value */ "./node_modules/d3-interpolate/src/value.js" + ); + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + var i = {}, + c = {}, + k; + if (a === null || _typeof(a) !== "object") a = {}; + if (b === null || _typeof(b) !== "object") b = {}; + + for (k in b) { + if (k in a) { + i[k] = Object( + _value__WEBPACK_IMPORTED_MODULE_0__.default + )(a[k], b[k]); + } else { + c[k] = b[k]; + } + } + + return function (t) { + for (k in i) { + c[k] = i[k](t); + } + + return c; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/piecewise.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-interpolate/src/piecewise.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return piecewise; + } + ); + function piecewise(interpolate, values) { + var i = 0, + n = values.length - 1, + v = values[0], + I = new Array(n < 0 ? 0 : n); + + while (i < n) { + I[i] = interpolate(v, (v = values[++i])); + } + + return function (t) { + var i = Math.max(0, Math.min(n - 1, Math.floor((t *= n)))); + return I[i](t - i); + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/quantize.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-interpolate/src/quantize.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (interpolator, n) { + var samples = new Array(n); + + for (var i = 0; i < n; ++i) { + samples[i] = interpolator(i / (n - 1)); + } + + return samples; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/rgb.js": + /* !************************************************!*\ + !*** ./node_modules/d3-interpolate/src/rgb.js ***! + \************************************************/ + /* ! exports provided: default, rgbBasis, rgbBasisClosed */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "rgbBasis", + function () { + return rgbBasis; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "rgbBasisClosed", + function () { + return rgbBasisClosed; + } + ); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./basis */ "./node_modules/d3-interpolate/src/basis.js" + ); + /* Harmony import */ var _basisClosed__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./basisClosed */ "./node_modules/d3-interpolate/src/basisClosed.js" + ); + /* Harmony import */ var _color__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./color */ "./node_modules/d3-interpolate/src/color.js" + ); + + /* Harmony default export */ __webpack_exports__.default = (function rgbGamma(y) { + var color = Object( + _color__WEBPACK_IMPORTED_MODULE_3__.gamma + )(y); + + function rgb(start, end) { + var r = color( + (start = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.rgb + )(start)).r, + (end = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.rgb + )(end)).r + ), + g = color(start.g, end.g), + b = color(start.b, end.b), + opacity = Object( + _color__WEBPACK_IMPORTED_MODULE_3__.default + )(start.opacity, end.opacity); + return function (t) { + start.r = r(t); + start.g = g(t); + start.b = b(t); + start.opacity = opacity(t); + return String(start); + }; + } + + rgb.gamma = rgbGamma; + return rgb; + })(1); + + function rgbSpline(spline) { + return function (colors) { + var n = colors.length, + r = new Array(n), + g = new Array(n), + b = new Array(n), + i, + color; + + for (i = 0; i < n; ++i) { + color = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.rgb + )(colors[i]); + r[i] = color.r || 0; + g[i] = color.g || 0; + b[i] = color.b || 0; + } + + r = spline(r); + g = spline(g); + b = spline(b); + color.opacity = 1; + return function (t) { + color.r = r(t); + color.g = g(t); + color.b = b(t); + return String(color); + }; + }; + } + + var rgbBasis = rgbSpline( + _basis__WEBPACK_IMPORTED_MODULE_1__.default + ); + var rgbBasisClosed = rgbSpline( + _basisClosed__WEBPACK_IMPORTED_MODULE_2__.default + ); + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/round.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-interpolate/src/round.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + return ( + (a = Number(a)), + (b -= a), + function (t) { + return Math.round(a + b * t); + } + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/string.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-interpolate/src/string.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-interpolate/src/number.js" + ); + + var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, + reB = new RegExp(reA.source, "g"); + + function zero(b) { + return function () { + return b; + }; + } + + function one(b) { + return function (t) { + return String(b(t)); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + var bi = (reA.lastIndex = reB.lastIndex = 0), + // Scan index for next number in b + am, + // Current match in a + bm, + // Current match in b + bs, + // String preceding current number in b, if any + i = -1, + // Index in s + s = [], + // String constants and placeholders + q = []; // Number interpolators + // Coerce inputs to strings. + + (a = String(a)), (b = String(b)); // Interpolate pairs of numbers in a & b. + + while ((am = reA.exec(a)) && (bm = reB.exec(b))) { + if ((bs = bm.index) > bi) { + // A string precedes the next number in b + bs = b.slice(bi, bs); + if (s[i]) s[i] += bs; + // Coalesce with previous string + else s[++i] = bs; + } + + if ((am = am[0]) === (bm = bm[0])) { + // Numbers in a & b match + if (s[i]) s[i] += bm; + // Coalesce with previous string + else s[++i] = bm; + } else { + // Interpolate non-matching numbers + s[++i] = null; + q.push({ + i: i, + x: Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(am, bm), + }); + } + + bi = reB.lastIndex; + } // Add remains of b. + + if (bi < b.length) { + bs = b.slice(bi); + if (s[i]) s[i] += bs; + // Coalesce with previous string + else s[++i] = bs; + } // Special optimization for only a single match. + // Otherwise, interpolate each of the numbers and rejoin the string. + + return s.length < 2 + ? q[0] + ? one(q[0].x) + : zero(b) + : ((b = q.length), + function (t) { + for (var i = 0, o; i < b; ++i) { + s[(o = q[i]).i] = o.x(t); + } + + return s.join(""); + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/transform/decompose.js": + /* !****************************************************************!*\ + !*** ./node_modules/d3-interpolate/src/transform/decompose.js ***! + \****************************************************************/ + /* ! exports provided: identity, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "identity", + function () { + return identity; + } + ); + var degrees = 180 / Math.PI; + var identity = { + translateX: 0, + translateY: 0, + rotate: 0, + skewX: 0, + scaleX: 1, + scaleY: 1, + }; + /* Harmony default export */ __webpack_exports__.default = function (a, b, c, d, e, f) { + var scaleX, scaleY, skewX; + if ((scaleX = Math.sqrt(a * a + b * b))) + (a /= scaleX), (b /= scaleX); + if ((skewX = a * c + b * d)) (c -= a * skewX), (d -= b * skewX); + if ((scaleY = Math.sqrt(c * c + d * d))) + (c /= scaleY), (d /= scaleY), (skewX /= scaleY); + if (a * d < b * c) + (a = -a), (b = -b), (skewX = -skewX), (scaleX = -scaleX); + return { + translateX: e, + translateY: f, + rotate: Math.atan2(b, a) * degrees, + skewX: Math.atan(skewX) * degrees, + scaleX: scaleX, + scaleY: scaleY, + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/transform/index.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-interpolate/src/transform/index.js ***! + \************************************************************/ + /* ! exports provided: interpolateTransformCss, interpolateTransformSvg */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "interpolateTransformCss", + function () { + return interpolateTransformCss; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "interpolateTransformSvg", + function () { + return interpolateTransformSvg; + } + ); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../number */ "./node_modules/d3-interpolate/src/number.js" + ); + /* Harmony import */ var _parse__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./parse */ "./node_modules/d3-interpolate/src/transform/parse.js" + ); + + function interpolateTransform(parse, pxComma, pxParen, degParen) { + function pop(s) { + return s.length ? s.pop() + " " : ""; + } + + function translate(xa, ya, xb, yb, s, q) { + if (xa !== xb || ya !== yb) { + var i = s.push( + "translate(", + null, + pxComma, + null, + pxParen + ); + q.push( + { + i: i - 4, + x: Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(xa, xb), + }, + { + i: i - 2, + x: Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(ya, yb), + } + ); + } else if (xb || yb) { + s.push("translate(" + xb + pxComma + yb + pxParen); + } + } + + function rotate(a, b, s, q) { + if (a !== b) { + if (a - b > 180) b += 360; + else if (b - a > 180) a += 360; // Shortest path + + q.push({ + i: s.push(pop(s) + "rotate(", null, degParen) - 2, + x: Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(a, b), + }); + } else if (b) { + s.push(pop(s) + "rotate(" + b + degParen); + } + } + + function skewX(a, b, s, q) { + if (a !== b) { + q.push({ + i: s.push(pop(s) + "skewX(", null, degParen) - 2, + x: Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(a, b), + }); + } else if (b) { + s.push(pop(s) + "skewX(" + b + degParen); + } + } + + function scale(xa, ya, xb, yb, s, q) { + if (xa !== xb || ya !== yb) { + var i = s.push(pop(s) + "scale(", null, ",", null, ")"); + q.push( + { + i: i - 4, + x: Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(xa, xb), + }, + { + i: i - 2, + x: Object( + _number__WEBPACK_IMPORTED_MODULE_0__.default + )(ya, yb), + } + ); + } else if (xb !== 1 || yb !== 1) { + s.push(pop(s) + "scale(" + xb + "," + yb + ")"); + } + } + + return function (a, b) { + var s = [], + // String constants and placeholders + q = []; // Number interpolators + + (a = parse(a)), (b = parse(b)); + translate( + a.translateX, + a.translateY, + b.translateX, + b.translateY, + s, + q + ); + rotate(a.rotate, b.rotate, s, q); + skewX(a.skewX, b.skewX, s, q); + scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q); + a = b = null; // Gc + + return function (t) { + var i = -1, + n = q.length, + o; + + while (++i < n) { + s[(o = q[i]).i] = o.x(t); + } + + return s.join(""); + }; + }; + } + + var interpolateTransformCss = interpolateTransform( + _parse__WEBPACK_IMPORTED_MODULE_1__.parseCss, + "px, ", + "px)", + "deg)" + ); + var interpolateTransformSvg = interpolateTransform( + _parse__WEBPACK_IMPORTED_MODULE_1__.parseSvg, + ", ", + ")", + ")" + ); + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/transform/parse.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-interpolate/src/transform/parse.js ***! + \************************************************************/ + /* ! exports provided: parseCss, parseSvg */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "parseCss", + function () { + return parseCss; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "parseSvg", + function () { + return parseSvg; + } + ); + /* Harmony import */ var _decompose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./decompose */ "./node_modules/d3-interpolate/src/transform/decompose.js" + ); + + var cssNode, cssRoot, cssView, svgNode; + function parseCss(value) { + if (value === "none") + return _decompose__WEBPACK_IMPORTED_MODULE_0__.identity; + if (!cssNode) + (cssNode = document.createElement("DIV")), + (cssRoot = document.documentElement), + (cssView = document.defaultView); + cssNode.style.transform = value; + value = cssView + .getComputedStyle(cssRoot.appendChild(cssNode), null) + .getPropertyValue("transform"); + cssRoot.removeChild(cssNode); + value = value.slice(7, -1).split(","); + return Object( + _decompose__WEBPACK_IMPORTED_MODULE_0__.default + )( + Number(value[0]), + Number(value[1]), + Number(value[2]), + Number(value[3]), + Number(value[4]), + Number(value[5]) + ); + } + function parseSvg(value) { + if (value == null) + return _decompose__WEBPACK_IMPORTED_MODULE_0__.identity; + if (!svgNode) + svgNode = document.createElementNS( + "http://www.w3.org/2000/svg", + "g" + ); + svgNode.setAttribute("transform", value); + if (!(value = svgNode.transform.baseVal.consolidate())) + return _decompose__WEBPACK_IMPORTED_MODULE_0__.identity; + value = value.matrix; + return Object( + _decompose__WEBPACK_IMPORTED_MODULE_0__.default + )(value.a, value.b, value.c, value.d, value.e, value.f); + } + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/value.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-interpolate/src/value.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var _rgb__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./rgb */ "./node_modules/d3-interpolate/src/rgb.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-interpolate/src/array.js" + ); + /* Harmony import */ var _date__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./date */ "./node_modules/d3-interpolate/src/date.js" + ); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-interpolate/src/number.js" + ); + /* Harmony import */ var _object__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./object */ "./node_modules/d3-interpolate/src/object.js" + ); + /* Harmony import */ var _string__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./string */ "./node_modules/d3-interpolate/src/string.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-interpolate/src/constant.js" + ); + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + var t = _typeof(b), + c; + + return b == null || t === "boolean" + ? Object(_constant__WEBPACK_IMPORTED_MODULE_7__.default)( + b + ) + : (t === "number" + ? _number__WEBPACK_IMPORTED_MODULE_4__.default + : t === "string" + ? (c = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.color + )(b)) + ? ((b = c), + _rgb__WEBPACK_IMPORTED_MODULE_1__.default) + : _string__WEBPACK_IMPORTED_MODULE_6__.default + : b instanceof + d3_color__WEBPACK_IMPORTED_MODULE_0__.color + ? _rgb__WEBPACK_IMPORTED_MODULE_1__.default + : b instanceof Date + ? _date__WEBPACK_IMPORTED_MODULE_3__.default + : Array.isArray(b) + ? _array__WEBPACK_IMPORTED_MODULE_2__.default + : (typeof b.valueOf !== "function" && + typeof b.toString !== "function") || + isNaN(b) + ? _object__WEBPACK_IMPORTED_MODULE_5__.default + : _number__WEBPACK_IMPORTED_MODULE_4__.default)( + a, + b + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-interpolate/src/zoom.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-interpolate/src/zoom.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + var rho = Math.SQRT2, + rho2 = 2, + rho4 = 4, + epsilon2 = 1e-12; + + function cosh(x) { + return ((x = Math.exp(x)) + 1 / x) / 2; + } + + function sinh(x) { + return ((x = Math.exp(x)) - 1 / x) / 2; + } + + function tanh(x) { + return ((x = Math.exp(2 * x)) - 1) / (x + 1); + } // P0 = [ux0, uy0, w0] + // p1 = [ux1, uy1, w1] + + /* harmony default export */ __webpack_exports__.default = function (p0, p1) { + var ux0 = p0[0], + uy0 = p0[1], + w0 = p0[2], + ux1 = p1[0], + uy1 = p1[1], + w1 = p1[2], + dx = ux1 - ux0, + dy = uy1 - uy0, + d2 = dx * dx + dy * dy, + i, + S; // Special case for u0 ≅ u1. + + if (d2 < epsilon2) { + S = Math.log(w1 / w0) / rho; + + i = function i(t) { + return [ + ux0 + t * dx, + uy0 + t * dy, + w0 * Math.exp(rho * t * S), + ]; + }; + } // General case. + else { + var d1 = Math.sqrt(d2), + b0 = + (w1 * w1 - w0 * w0 + rho4 * d2) / + (2 * w0 * rho2 * d1), + b1 = + (w1 * w1 - w0 * w0 - rho4 * d2) / + (2 * w1 * rho2 * d1), + r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), + r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); + S = (r1 - r0) / rho; + + i = function i(t) { + var s = t * S, + coshr0 = cosh(r0), + u = + (w0 / (rho2 * d1)) * + (coshr0 * tanh(rho * s + r0) - sinh(r0)); + return [ + ux0 + u * dx, + uy0 + u * dy, + (w0 * coshr0) / cosh(rho * s + r0), + ]; + }; + } + + i.duration = S * 1000; + return i; + }; + + /***/ + }, + + /***/ "./node_modules/d3-path/src/index.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-path/src/index.js ***! + \*******************************************/ + /* ! exports provided: path */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./path */ "./node_modules/d3-path/src/path.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "path", + function () { + return _path__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-path/src/path.js": + /* !******************************************!*\ + !*** ./node_modules/d3-path/src/path.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + var pi = Math.PI, + tau = 2 * pi, + epsilon = 1e-6, + tauEpsilon = tau - epsilon; + + function Path() { + this._x0 = this._y0 = this._x1 = this._y1 = null; // Start of current subpath // end of current subpath + + this._ = ""; + } + + function path() { + return new Path(); + } + + Path.prototype = path.prototype = { + constructor: Path, + moveTo: function moveTo(x, y) { + this._ += + "M" + + (this._x0 = this._x1 = Number(x)) + + "," + + (this._y0 = this._y1 = Number(y)); + }, + closePath: function closePath() { + if (this._x1 !== null) { + (this._x1 = this._x0), (this._y1 = this._y0); + this._ += "Z"; + } + }, + lineTo: function lineTo(x, y) { + this._ += "L" + (this._x1 = Number(x)) + "," + (this._y1 = Number(y)); + }, + quadraticCurveTo: function quadraticCurveTo(x1, y1, x, y) { + this._ += + "Q" + + Number(x1) + + "," + + Number(y1) + + "," + + (this._x1 = Number(x)) + + "," + + (this._y1 = Number(y)); + }, + bezierCurveTo: function bezierCurveTo(x1, y1, x2, y2, x, y) { + this._ += + "C" + + Number(x1) + + "," + + Number(y1) + + "," + + Number(x2) + + "," + + Number(y2) + + "," + + (this._x1 = Number(x)) + + "," + + (this._y1 = Number(y)); + }, + arcTo: function arcTo(x1, y1, x2, y2, r) { + (x1 = Number(x1)), (y1 = Number(y1)), (x2 = Number(x2)), (y2 = Number(y2)), (r = Number(r)); + var x0 = this._x1, + y0 = this._y1, + x21 = x2 - x1, + y21 = y2 - y1, + x01 = x0 - x1, + y01 = y0 - y1, + l01_2 = x01 * x01 + y01 * y01; // Is the radius negative? Error. + + if (r < 0) throw new Error("negative radius: " + r); // Is this path empty? Move to (x1,y1). + + if (this._x1 === null) { + this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1); + } // Or, is (x1,y1) coincident with (x0,y0)? Do nothing. + else if (!(l01_2 > epsilon)); + else if ( + !(Math.abs(y01 * x21 - y21 * x01) > epsilon) || + !r + ) { + // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear? + // Equivalently, is (x1,y1) coincident with (x2,y2)? + // Or, is the radius zero? Line to (x1,y1). + this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1); + } // Otherwise, draw an arc! + else { + var x20 = x2 - x0, + y20 = y2 - y0, + l21_2 = x21 * x21 + y21 * y21, + l20_2 = x20 * x20 + y20 * y20, + l21 = Math.sqrt(l21_2), + l01 = Math.sqrt(l01_2), + l = + r * + Math.tan( + (pi - + Math.acos( + (l21_2 + l01_2 - l20_2) / + (2 * l21 * l01) + )) / + 2 + ), + t01 = l / l01, + t21 = l / l21; // If the start tangent is not coincident with (x0,y0), line to. + + if (Math.abs(t01 - 1) > epsilon) { + this._ += + "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01); + } + + this._ += + "A" + + r + + "," + + r + + ",0,0," + + Number(y01 * x20 > x01 * y20) + + "," + + (this._x1 = x1 + t21 * x21) + + "," + + (this._y1 = y1 + t21 * y21); + } + }, + arc: function arc(x, y, r, a0, a1, ccw) { + (x = Number(x)), (y = Number(y)), (r = Number(r)), (ccw = Boolean(ccw)); + var dx = r * Math.cos(a0), + dy = r * Math.sin(a0), + x0 = x + dx, + y0 = y + dy, + cw = 1 ^ ccw, + da = ccw ? a0 - a1 : a1 - a0; // Is the radius negative? Error. + + if (r < 0) throw new Error("negative radius: " + r); // Is this path empty? Move to (x0,y0). + + if (this._x1 === null) { + this._ += "M" + x0 + "," + y0; + } // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0). + else if ( + Math.abs(this._x1 - x0) > epsilon || + Math.abs(this._y1 - y0) > epsilon + ) { + this._ += "L" + x0 + "," + y0; + } // Is this arc empty? We’re done. + + if (!r) return; // Does the angle go the wrong way? Flip the direction. + + if (da < 0) da = (da % tau) + tau; // Is this a complete circle? Draw two arcs to complete the circle. + + if (da > tauEpsilon) { + this._ += + "A" + + r + + "," + + r + + ",0,1," + + cw + + "," + + (x - dx) + + "," + + (y - dy) + + "A" + + r + + "," + + r + + ",0,1," + + cw + + "," + + (this._x1 = x0) + + "," + + (this._y1 = y0); + } // Is this arc non-empty? Draw an arc! + else if (da > epsilon) { + this._ += + "A" + + r + + "," + + r + + ",0," + + Number(da >= pi) + + "," + + cw + + "," + + (this._x1 = x + r * Math.cos(a1)) + + "," + + (this._y1 = y + r * Math.sin(a1)); + } + }, + rect: function rect(x, y, w, h) { + this._ += + "M" + + (this._x0 = this._x1 = Number(x)) + + "," + + (this._y0 = this._y1 = Number(y)) + + "h" + + Number(w) + + "v" + + Number(h) + + "h" + + -w + + "Z"; + }, + toString: function toString() { + return this._; + }, + }; + /* Harmony default export */ __webpack_exports__.default = path; + + /***/ + }, + + /***/ "./node_modules/d3-polygon/src/area.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-polygon/src/area.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (polygon) { + var i = -1, + n = polygon.length, + a, + b = polygon[n - 1], + area = 0; + + while (++i < n) { + a = b; + b = polygon[i]; + area += a[1] * b[0] - a[0] * b[1]; + } + + return area / 2; + }; + + /***/ + }, + + /***/ "./node_modules/d3-polygon/src/centroid.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-polygon/src/centroid.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (polygon) { + var i = -1, + n = polygon.length, + x = 0, + y = 0, + a, + b = polygon[n - 1], + c, + k = 0; + + while (++i < n) { + a = b; + b = polygon[i]; + k += c = a[0] * b[1] - b[0] * a[1]; + x += (a[0] + b[0]) * c; + y += (a[1] + b[1]) * c; + } + + return (k *= 3), [x / k, y / k]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-polygon/src/contains.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-polygon/src/contains.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (polygon, point) { + var n = polygon.length, + p = polygon[n - 1], + x = point[0], + y = point[1], + x0 = p[0], + y0 = p[1], + x1, + y1, + inside = false; + + for (var i = 0; i < n; ++i) { + (p = polygon[i]), (x1 = p[0]), (y1 = p[1]); + if ( + y1 > y !== y0 > y && + x < ((x0 - x1) * (y - y1)) / (y0 - y1) + x1 + ) + inside = !inside; + (x0 = x1), (y0 = y1); + } + + return inside; + }; + + /***/ + }, + + /***/ "./node_modules/d3-polygon/src/cross.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-polygon/src/cross.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + // Returns the 2D cross product of AB and AC vectors, i.e., the z-component of + // the 3D cross product in a quadrant I Cartesian coordinate system (+x is + // right, +y is up). Returns a positive value if ABC is counter-clockwise, + // negative if clockwise, and zero if the points are collinear. + /* harmony default export */ __webpack_exports__.default = function (a, b, c) { + return ( + (b[0] - a[0]) * (c[1] - a[1]) - + (b[1] - a[1]) * (c[0] - a[0]) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-polygon/src/hull.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-polygon/src/hull.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _cross__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./cross */ "./node_modules/d3-polygon/src/cross.js" + ); + + function lexicographicOrder(a, b) { + return a[0] - b[0] || a[1] - b[1]; + } // Computes the upper convex hull per the monotone chain algorithm. + // Assumes points.length >= 3, is sorted by x, unique in y. + // Returns an array of indices into points in left-to-right order. + + function computeUpperHullIndexes(points) { + var n = points.length, + indexes = [0, 1], + size = 2; + + for (var i = 2; i < n; ++i) { + while ( + size > 1 && + Object(_cross__WEBPACK_IMPORTED_MODULE_0__.default)( + points[indexes[size - 2]], + points[indexes[size - 1]], + points[i] + ) <= 0 + ) { + --size; + } + + indexes[size++] = i; + } + + return indexes.slice(0, size); // Remove popped points + } + + /* Harmony default export */ __webpack_exports__.default = function (points) { + if ((n = points.length) < 3) return null; + var i, + n, + sortedPoints = new Array(n), + flippedPoints = new Array(n); + + for (i = 0; i < n; ++i) { + sortedPoints[i] = [Number(points[i][0]), Number(points[i][1]), i]; + } + + sortedPoints.sort(lexicographicOrder); + + for (i = 0; i < n; ++i) { + flippedPoints[i] = [ + sortedPoints[i][0], + -sortedPoints[i][1], + ]; + } + + var upperIndexes = computeUpperHullIndexes(sortedPoints), + lowerIndexes = computeUpperHullIndexes(flippedPoints); // Construct the hull polygon, removing possible duplicate endpoints. + + var skipLeft = lowerIndexes[0] === upperIndexes[0], + skipRight = + lowerIndexes[lowerIndexes.length - 1] === + upperIndexes[upperIndexes.length - 1], + hull = []; // Add upper hull in right-to-l order. + // Then add lower hull in left-to-right order. + + for (i = upperIndexes.length - 1; i >= 0; --i) { + hull.push(points[sortedPoints[upperIndexes[i]][2]]); + } + + for (i = Number(skipLeft); i < lowerIndexes.length - skipRight; ++i) { + hull.push(points[sortedPoints[lowerIndexes[i]][2]]); + } + + return hull; + }; + + /***/ + }, + + /***/ "./node_modules/d3-polygon/src/index.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-polygon/src/index.js ***! + \**********************************************/ + /* ! exports provided: polygonArea, polygonCentroid, polygonHull, polygonContains, polygonLength */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _area__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./area */ "./node_modules/d3-polygon/src/area.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonArea", + function () { + return _area__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _centroid__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./centroid */ "./node_modules/d3-polygon/src/centroid.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonCentroid", + function () { + return _centroid__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _hull__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./hull */ "./node_modules/d3-polygon/src/hull.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonHull", + function () { + return _hull__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _contains__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./contains */ "./node_modules/d3-polygon/src/contains.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonContains", + function () { + return _contains__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _length__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./length */ "./node_modules/d3-polygon/src/length.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonLength", + function () { + return _length__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-polygon/src/length.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-polygon/src/length.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (polygon) { + var i = -1, + n = polygon.length, + b = polygon[n - 1], + xa, + ya, + xb = b[0], + yb = b[1], + perimeter = 0; + + while (++i < n) { + xa = xb; + ya = yb; + b = polygon[i]; + xb = b[0]; + yb = b[1]; + xa -= xb; + ya -= yb; + perimeter += Math.sqrt(xa * xa + ya * ya); + } + + return perimeter; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/add.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-quadtree/src/add.js ***! + \*********************************************/ + /* ! exports provided: default, addAll */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "addAll", + function () { + return addAll; + } + ); + /* Harmony default export */ __webpack_exports__.default = function (d) { + var x = Number(this._x.call(null, d)), + y = Number(this._y.call(null, d)); + return add(this.cover(x, y), x, y, d); + }; + + function add(tree, x, y, d) { + if (isNaN(x) || isNaN(y)) return tree; // Ignore invalid points + + var parent, + node = tree._root, + leaf = { + data: d, + }, + x0 = tree._x0, + y0 = tree._y0, + x1 = tree._x1, + y1 = tree._y1, + xm, + ym, + xp, + yp, + right, + bottom, + i, + j; // If the tree is empty, initialize the root as a leaf. + + if (!node) return (tree._root = leaf), tree; // Find the existing leaf for the new point, or add it. + + while (node.length) { + if ((right = x >= (xm = (x0 + x1) / 2))) x0 = xm; + else x1 = xm; + if ((bottom = y >= (ym = (y0 + y1) / 2))) y0 = ym; + else y1 = ym; + if ( + ((parent = node), + !(node = node[(i = (bottom << 1) | right)])) + ) + return (parent[i] = leaf), tree; + } // Is the new point is exactly coincident with the existing point? + + xp = Number(tree._x.call(null, node.data)); + yp = Number(tree._y.call(null, node.data)); + if (x === xp && y === yp) + return ( + (leaf.next = node), + parent ? (parent[i] = leaf) : (tree._root = leaf), + tree + ); // Otherwise, split the leaf node until the old and new point are separated. + + do { + parent = parent + ? (parent[i] = new Array(4)) + : (tree._root = new Array(4)); + if ((right = x >= (xm = (x0 + x1) / 2))) x0 = xm; + else x1 = xm; + if ((bottom = y >= (ym = (y0 + y1) / 2))) y0 = ym; + else y1 = ym; + } while ( + (i = (bottom << 1) | right) === + (j = ((yp >= ym) << 1) | (xp >= xm)) + ); + + return (parent[j] = node), (parent[i] = leaf), tree; + } + + function addAll(data) { + var d, + i, + n = data.length, + x, + y, + xz = new Array(n), + yz = new Array(n), + x0 = Infinity, + y0 = Infinity, + x1 = -Infinity, + y1 = -Infinity; // Compute the points and their extent. + + for (i = 0; i < n; ++i) { + if ( + isNaN((x = Number(this._x.call(null, (d = data[i]))))) || + isNaN((y = Number(this._y.call(null, d)))) + ) + continue; + xz[i] = x; + yz[i] = y; + if (x < x0) x0 = x; + if (x > x1) x1 = x; + if (y < y0) y0 = y; + if (y > y1) y1 = y; + } // If there were no (valid) points, abort. + + if (x0 > x1 || y0 > y1) return this; // Expand the tree to cover the new points. + + this.cover(x0, y0).cover(x1, y1); // Add the new points. + + for (i = 0; i < n; ++i) { + add(this, xz[i], yz[i], data[i]); + } + + return this; + } + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/cover.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-quadtree/src/cover.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x, y) { + if (isNaN((x = Number(x))) || isNaN((y = Number(y)))) return this; // Ignore invalid points + + var x0 = this._x0, + y0 = this._y0, + x1 = this._x1, + y1 = this._y1; // If the quadtree has no extent, initialize them. + // Integer extent are necessary so that if we later double the extent, + // the existing quadrant boundaries don’t change due to floating point error! + + if (isNaN(x0)) { + x1 = (x0 = Math.floor(x)) + 1; + y1 = (y0 = Math.floor(y)) + 1; + } // Otherwise, double repeatedly to cover. + else { + var z = x1 - x0, + node = this._root, + parent, + i; + + while (x0 > x || x >= x1 || y0 > y || y >= y1) { + i = ((y < y0) << 1) | (x < x0); + (parent = new Array(4)), + (parent[i] = node), + (node = parent), + (z *= 2); + + switch (i) { + case 0: + (x1 = x0 + z), (y1 = y0 + z); + break; + + case 1: + (x0 = x1 - z), (y1 = y0 + z); + break; + + case 2: + (x1 = x0 + z), (y0 = y1 - z); + break; + + case 3: + (x0 = x1 - z), (y0 = y1 - z); + break; + } + } + + if (this._root && this._root.length) this._root = node; + } + + this._x0 = x0; + this._y0 = y0; + this._x1 = x1; + this._y1 = y1; + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/data.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-quadtree/src/data.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var data = []; + this.visit(function (node) { + if (!node.length) + do { + data.push(node.data); + } while ((node = node.next)); + }); + return data; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/extent.js": + /* !************************************************!*\ + !*** ./node_modules/d3-quadtree/src/extent.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (_) { + return arguments.length + ? this.cover(Number(_[0][0]), Number(_[0][1])).cover(Number(_[1][0]), Number(_[1][1])) + : isNaN(this._x0) + ? undefined + : [ + [this._x0, this._y0], + [this._x1, this._y1], + ]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/find.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-quadtree/src/find.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _quad__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./quad */ "./node_modules/d3-quadtree/src/quad.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (x, y, radius) { + var data, + x0 = this._x0, + y0 = this._y0, + x1, + y1, + x2, + y2, + x3 = this._x1, + y3 = this._y1, + quads = [], + node = this._root, + q, + i; + if (node) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default( + node, + x0, + y0, + x3, + y3 + ) + ); + if (radius == null) radius = Infinity; + else { + (x0 = x - radius), (y0 = y - radius); + (x3 = x + radius), (y3 = y + radius); + radius *= radius; + } + + while ((q = quads.pop())) { + // Stop searching if this quadrant can’t contain a closer node. + if ( + !(node = q.node) || + (x1 = q.x0) > x3 || + (y1 = q.y0) > y3 || + (x2 = q.x1) < x0 || + (y2 = q.y1) < y0 + ) + continue; // Bisect the current quadrant. + + if (node.length) { + var xm = (x1 + x2) / 2, + ym = (y1 + y2) / 2; + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default( + node[3], + xm, + ym, + x2, + y2 + ), + new _quad__WEBPACK_IMPORTED_MODULE_0__.default( + node[2], + x1, + ym, + xm, + y2 + ), + new _quad__WEBPACK_IMPORTED_MODULE_0__.default( + node[1], + xm, + y1, + x2, + ym + ), + new _quad__WEBPACK_IMPORTED_MODULE_0__.default( + node[0], + x1, + y1, + xm, + ym + ) + ); // Visit the closest quadrant first. + + if ((i = ((y >= ym) << 1) | (x >= xm))) { + q = quads[quads.length - 1]; + quads[quads.length - 1] = + quads[quads.length - 1 - i]; + quads[quads.length - 1 - i] = q; + } + } // Visit this point. (Visiting coincident points isn’t necessary!) + else { + var dx = x - Number(this._x.call(null, node.data)), + dy = y - Number(this._y.call(null, node.data)), + d2 = dx * dx + dy * dy; + + if (d2 < radius) { + var d = Math.sqrt((radius = d2)); + (x0 = x - d), (y0 = y - d); + (x3 = x + d), (y3 = y + d); + data = node.data; + } + } + } + + return data; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/index.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-quadtree/src/index.js ***! + \***********************************************/ + /* ! exports provided: quadtree */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _quadtree__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./quadtree */ "./node_modules/d3-quadtree/src/quadtree.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "quadtree", + function () { + return _quadtree__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/quad.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-quadtree/src/quad.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (node, x0, y0, x1, y1) { + this.node = node; + this.x0 = x0; + this.y0 = y0; + this.x1 = x1; + this.y1 = y1; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/quadtree.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-quadtree/src/quadtree.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return quadtree; + } + ); + /* Harmony import */ var _add__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./add */ "./node_modules/d3-quadtree/src/add.js" + ); + /* Harmony import */ var _cover__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./cover */ "./node_modules/d3-quadtree/src/cover.js" + ); + /* Harmony import */ var _data__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./data */ "./node_modules/d3-quadtree/src/data.js" + ); + /* Harmony import */ var _extent__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./extent */ "./node_modules/d3-quadtree/src/extent.js" + ); + /* Harmony import */ var _find__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./find */ "./node_modules/d3-quadtree/src/find.js" + ); + /* Harmony import */ var _remove__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./remove */ "./node_modules/d3-quadtree/src/remove.js" + ); + /* Harmony import */ var _root__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./root */ "./node_modules/d3-quadtree/src/root.js" + ); + /* Harmony import */ var _size__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./size */ "./node_modules/d3-quadtree/src/size.js" + ); + /* Harmony import */ var _visit__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./visit */ "./node_modules/d3-quadtree/src/visit.js" + ); + /* Harmony import */ var _visitAfter__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./visitAfter */ "./node_modules/d3-quadtree/src/visitAfter.js" + ); + /* Harmony import */ var _x__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./x */ "./node_modules/d3-quadtree/src/x.js" + ); + /* Harmony import */ var _y__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./y */ "./node_modules/d3-quadtree/src/y.js" + ); + + function quadtree(nodes, x, y) { + var tree = new Quadtree( + x == null + ? _x__WEBPACK_IMPORTED_MODULE_10__.defaultX + : x, + y == null + ? _y__WEBPACK_IMPORTED_MODULE_11__.defaultY + : y, + NaN, + NaN, + NaN, + NaN + ); + return nodes == null ? tree : tree.addAll(nodes); + } + + function Quadtree(x, y, x0, y0, x1, y1) { + this._x = x; + this._y = y; + this._x0 = x0; + this._y0 = y0; + this._x1 = x1; + this._y1 = y1; + this._root = undefined; + } + + function leaf_copy(leaf) { + var copy = { + data: leaf.data, + }, + next = copy; + + while ((leaf = leaf.next)) { + next = next.next = { + data: leaf.data, + }; + } + + return copy; + } + + var treeProto = (quadtree.prototype = Quadtree.prototype); + + treeProto.copy = function () { + var copy = new Quadtree( + this._x, + this._y, + this._x0, + this._y0, + this._x1, + this._y1 + ), + node = this._root, + nodes, + child; + if (!node) return copy; + if (!node.length) return (copy._root = leaf_copy(node)), copy; + nodes = [ + { + source: node, + target: (copy._root = new Array(4)), + }, + ]; + + while ((node = nodes.pop())) { + for (var i = 0; i < 4; ++i) { + if ((child = node.source[i])) { + if (child.length) + nodes.push({ + source: child, + target: (node.target[i] = new Array(4)), + }); + else node.target[i] = leaf_copy(child); + } + } + } + + return copy; + }; + + treeProto.add = _add__WEBPACK_IMPORTED_MODULE_0__.default; + treeProto.addAll = _add__WEBPACK_IMPORTED_MODULE_0__.addAll; + treeProto.cover = _cover__WEBPACK_IMPORTED_MODULE_1__.default; + treeProto.data = _data__WEBPACK_IMPORTED_MODULE_2__.default; + treeProto.extent = _extent__WEBPACK_IMPORTED_MODULE_3__.default; + treeProto.find = _find__WEBPACK_IMPORTED_MODULE_4__.default; + treeProto.remove = _remove__WEBPACK_IMPORTED_MODULE_5__.default; + treeProto.removeAll = + _remove__WEBPACK_IMPORTED_MODULE_5__.removeAll; + treeProto.root = _root__WEBPACK_IMPORTED_MODULE_6__.default; + treeProto.size = _size__WEBPACK_IMPORTED_MODULE_7__.default; + treeProto.visit = _visit__WEBPACK_IMPORTED_MODULE_8__.default; + treeProto.visitAfter = + _visitAfter__WEBPACK_IMPORTED_MODULE_9__.default; + treeProto.x = _x__WEBPACK_IMPORTED_MODULE_10__.default; + treeProto.y = _y__WEBPACK_IMPORTED_MODULE_11__.default; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/remove.js": + /* !************************************************!*\ + !*** ./node_modules/d3-quadtree/src/remove.js ***! + \************************************************/ + /* ! exports provided: default, removeAll */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "removeAll", + function () { + return removeAll; + } + ); + /* Harmony default export */ __webpack_exports__.default = function (d) { + if ( + isNaN((x = Number(this._x.call(null, d)))) || + isNaN((y = Number(this._y.call(null, d)))) + ) + return this; // Ignore invalid points + + var parent, + node = this._root, + retainer, + previous, + next, + x0 = this._x0, + y0 = this._y0, + x1 = this._x1, + y1 = this._y1, + x, + y, + xm, + ym, + right, + bottom, + i, + j; // If the tree is empty, initialize the root as a leaf. + + if (!node) return this; // Find the leaf node for the point. + // While descending, also retain the deepest parent with a non-removed sibling. + + if (node.length) + while (true) { + if ((right = x >= (xm = (x0 + x1) / 2))) x0 = xm; + else x1 = xm; + if ((bottom = y >= (ym = (y0 + y1) / 2))) y0 = ym; + else y1 = ym; + if ( + !((parent = node), + (node = node[(i = (bottom << 1) | right)])) + ) + return this; + if (!node.length) break; + if ( + parent[(i + 1) & 3] || + parent[(i + 2) & 3] || + parent[(i + 3) & 3] + ) + (retainer = parent), (j = i); + } // Find the point to remove. + + while (node.data !== d) { + if (!((previous = node), (node = node.next))) return this; + } + + if ((next = node.next)) delete node.next; // If there are multiple coincident points, remove just the point. + + if (previous) + return ( + next ? (previous.next = next) : delete previous.next, + this + ); // If this is the root point, remove it. + + if (!parent) return (this._root = next), this; // Remove this leaf. + + next ? (parent[i] = next) : delete parent[i]; // If the parent now contains exactly one leaf, collapse superfluous parents. + + if ( + (node = parent[0] || parent[1] || parent[2] || parent[3]) && + node === + (parent[3] || parent[2] || parent[1] || parent[0]) && + !node.length + ) { + if (retainer) retainer[j] = node; + else this._root = node; + } + + return this; + }; + function removeAll(data) { + for (var i = 0, n = data.length; i < n; ++i) { + this.remove(data[i]); + } + + return this; + } + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/root.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-quadtree/src/root.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + return this._root; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/size.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-quadtree/src/size.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var size = 0; + this.visit(function (node) { + if (!node.length) + do { + ++size; + } while ((node = node.next)); + }); + return size; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/visit.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-quadtree/src/visit.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _quad__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./quad */ "./node_modules/d3-quadtree/src/quad.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (callback) { + var quads = [], + q, + node = this._root, + child, + x0, + y0, + x1, + y1; + if (node) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default( + node, + this._x0, + this._y0, + this._x1, + this._y1 + ) + ); + + while ((q = quads.pop())) { + if ( + !callback( + (node = q.node), + (x0 = q.x0), + (y0 = q.y0), + (x1 = q.x1), + (y1 = q.y1) + ) && + node.length + ) { + var xm = (x0 + x1) / 2, + ym = (y0 + y1) / 2; + if ((child = node[3])) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default(child, xm, ym, x1, y1) + ); + if ((child = node[2])) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default(child, x0, ym, xm, y1) + ); + if ((child = node[1])) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default(child, xm, y0, x1, ym) + ); + if ((child = node[0])) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default(child, x0, y0, xm, ym) + ); + } + } + + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/visitAfter.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-quadtree/src/visitAfter.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _quad__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./quad */ "./node_modules/d3-quadtree/src/quad.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (callback) { + var quads = [], + next = [], + q; + if (this._root) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default( + this._root, + this._x0, + this._y0, + this._x1, + this._y1 + ) + ); + + while ((q = quads.pop())) { + var node = q.node; + + if (node.length) { + var child, + x0 = q.x0, + y0 = q.y0, + x1 = q.x1, + y1 = q.y1, + xm = (x0 + x1) / 2, + ym = (y0 + y1) / 2; + if ((child = node[0])) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default(child, x0, y0, xm, ym) + ); + if ((child = node[1])) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default(child, xm, y0, x1, ym) + ); + if ((child = node[2])) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default(child, x0, ym, xm, y1) + ); + if ((child = node[3])) + quads.push( + new _quad__WEBPACK_IMPORTED_MODULE_0__.default(child, xm, ym, x1, y1) + ); + } + + next.push(q); + } + + while ((q = next.pop())) { + callback(q.node, q.x0, q.y0, q.x1, q.y1); + } + + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/x.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-quadtree/src/x.js ***! + \*******************************************/ + /* ! exports provided: defaultX, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "defaultX", + function () { + return defaultX; + } + ); + function defaultX(d) { + return d[0]; + } + /* Harmony default export */ __webpack_exports__.default = function (_) { + return arguments.length ? ((this._x = _), this) : this._x; + }; + + /***/ + }, + + /***/ "./node_modules/d3-quadtree/src/y.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-quadtree/src/y.js ***! + \*******************************************/ + /* ! exports provided: defaultY, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "defaultY", + function () { + return defaultY; + } + ); + function defaultY(d) { + return d[1]; + } + /* Harmony default export */ __webpack_exports__.default = function (_) { + return arguments.length ? ((this._y = _), this) : this._y; + }; + + /***/ + }, + + /***/ "./node_modules/d3-random/src/bates.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-random/src/bates.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js" + ); + /* Harmony import */ var _irwinHall__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./irwinHall */ "./node_modules/d3-random/src/irwinHall.js" + ); + + /* Harmony default export */ __webpack_exports__.default = (function sourceRandomBates(source) { + function randomBates(n) { + var randomIrwinHall = _irwinHall__WEBPACK_IMPORTED_MODULE_1__.default.source(source)(n); + return function () { + return randomIrwinHall() / n; + }; + } + + randomBates.source = sourceRandomBates; + return randomBates; + })(_defaultSource__WEBPACK_IMPORTED_MODULE_0__.default); + + /***/ + }, + + /***/ "./node_modules/d3-random/src/defaultSource.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-random/src/defaultSource.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + return Math.random(); + }; + + /***/ + }, + + /***/ "./node_modules/d3-random/src/exponential.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-random/src/exponential.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js" + ); + + /* Harmony default export */ __webpack_exports__.default = (function sourceRandomExponential(source) { + function randomExponential(lambda) { + return function () { + return -Math.log(1 - source()) / lambda; + }; + } + + randomExponential.source = sourceRandomExponential; + return randomExponential; + })(_defaultSource__WEBPACK_IMPORTED_MODULE_0__.default); + + /***/ + }, + + /***/ "./node_modules/d3-random/src/index.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-random/src/index.js ***! + \*********************************************/ + /* ! exports provided: randomUniform, randomNormal, randomLogNormal, randomBates, randomIrwinHall, randomExponential */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _uniform__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./uniform */ "./node_modules/d3-random/src/uniform.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomUniform", + function () { + return _uniform__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _normal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./normal */ "./node_modules/d3-random/src/normal.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomNormal", + function () { + return _normal__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _logNormal__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./logNormal */ "./node_modules/d3-random/src/logNormal.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomLogNormal", + function () { + return _logNormal__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _bates__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./bates */ "./node_modules/d3-random/src/bates.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomBates", + function () { + return _bates__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _irwinHall__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./irwinHall */ "./node_modules/d3-random/src/irwinHall.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomIrwinHall", + function () { + return _irwinHall__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _exponential__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./exponential */ "./node_modules/d3-random/src/exponential.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomExponential", + function () { + return _exponential__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-random/src/irwinHall.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-random/src/irwinHall.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js" + ); + + /* Harmony default export */ __webpack_exports__.default = (function sourceRandomIrwinHall(source) { + function randomIrwinHall(n) { + return function () { + for (var sum = 0, i = 0; i < n; ++i) { + sum += source(); + } + + return sum; + }; + } + + randomIrwinHall.source = sourceRandomIrwinHall; + return randomIrwinHall; + })(_defaultSource__WEBPACK_IMPORTED_MODULE_0__.default); + + /***/ + }, + + /***/ "./node_modules/d3-random/src/logNormal.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-random/src/logNormal.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js" + ); + /* Harmony import */ var _normal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./normal */ "./node_modules/d3-random/src/normal.js" + ); + + /* Harmony default export */ __webpack_exports__.default = (function sourceRandomLogNormal(source) { + function randomLogNormal() { + var randomNormal = _normal__WEBPACK_IMPORTED_MODULE_1__.default + .source(source) + .apply(this, arguments); + return function () { + return Math.exp(randomNormal()); + }; + } + + randomLogNormal.source = sourceRandomLogNormal; + return randomLogNormal; + })(_defaultSource__WEBPACK_IMPORTED_MODULE_0__.default); + + /***/ + }, + + /***/ "./node_modules/d3-random/src/normal.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-random/src/normal.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js" + ); + + /* Harmony default export */ __webpack_exports__.default = (function sourceRandomNormal(source) { + function randomNormal(mu, sigma) { + var x, r; + mu = mu == null ? 0 : Number(mu); + sigma = sigma == null ? 1 : Number(sigma); + return function () { + var y; // If available, use the second previously-generated uniform random. + + if (x != null) (y = x), (x = null); + // Otherwise, generate a new x and y. + else + do { + x = source() * 2 - 1; + y = source() * 2 - 1; + r = x * x + y * y; + } while (!r || r > 1); + return ( + mu + sigma * y * Math.sqrt((-2 * Math.log(r)) / r) + ); + }; + } + + randomNormal.source = sourceRandomNormal; + return randomNormal; + })(_defaultSource__WEBPACK_IMPORTED_MODULE_0__.default); + + /***/ + }, + + /***/ "./node_modules/d3-random/src/uniform.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-random/src/uniform.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js" + ); + + /* Harmony default export */ __webpack_exports__.default = (function sourceRandomUniform(source) { + function randomUniform(min, max) { + min = min == null ? 0 : Number(min); + max = max == null ? 1 : Number(max); + if (arguments.length === 1) (max = min), (min = 0); + else max -= min; + return function () { + return source() * max + min; + }; + } + + randomUniform.source = sourceRandomUniform; + return randomUniform; + })(_defaultSource__WEBPACK_IMPORTED_MODULE_0__.default); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Accent.js": + /* !*******************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Accent.js ***! + \*******************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Dark2.js": + /* !******************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Dark2.js ***! + \******************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Paired.js": + /* !*******************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Paired.js ***! + \*******************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Pastel1.js": + /* !********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Pastel1.js ***! + \********************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Pastel2.js": + /* !********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Pastel2.js ***! + \********************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Set1.js": + /* !*****************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Set1.js ***! + \*****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Set2.js": + /* !*****************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Set2.js ***! + \*****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Set3.js": + /* !*****************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Set3.js ***! + \*****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/Tableau10.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/Tableau10.js ***! + \**********************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/categorical/category10.js": + /* !***********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/categorical/category10.js ***! + \***********************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf" + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/colors.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/colors.js ***! + \*******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (specifier) { + var n = (specifier.length / 6) | 0, + colors = new Array(n), + i = 0; + + while (i < n) { + colors[i] = "#" + specifier.slice(i * 6, ++i * 6); + } + + return colors; + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/BrBG.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/BrBG.js ***! + \***************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "d8b365f5f5f55ab4ac", + "a6611adfc27d80cdc1018571", + "a6611adfc27df5f5f580cdc1018571", + "8c510ad8b365f6e8c3c7eae55ab4ac01665e", + "8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e", + "8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e", + "8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e", + "5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30", + "5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/PRGn.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/PRGn.js ***! + \***************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "af8dc3f7f7f77fbf7b", + "7b3294c2a5cfa6dba0008837", + "7b3294c2a5cff7f7f7a6dba0008837", + "762a83af8dc3e7d4e8d9f0d37fbf7b1b7837", + "762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837", + "762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837", + "762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837", + "40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b", + "40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/PiYG.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/PiYG.js ***! + \***************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "e9a3c9f7f7f7a1d76a", + "d01c8bf1b6dab8e1864dac26", + "d01c8bf1b6daf7f7f7b8e1864dac26", + "c51b7de9a3c9fde0efe6f5d0a1d76a4d9221", + "c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221", + "c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221", + "c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221", + "8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419", + "8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/PuOr.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/PuOr.js ***! + \***************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "998ec3f7f7f7f1a340", + "5e3c99b2abd2fdb863e66101", + "5e3c99b2abd2f7f7f7fdb863e66101", + "542788998ec3d8daebfee0b6f1a340b35806", + "542788998ec3d8daebf7f7f7fee0b6f1a340b35806", + "5427888073acb2abd2d8daebfee0b6fdb863e08214b35806", + "5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806", + "2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08", + "2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/RdBu.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/RdBu.js ***! + \***************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "ef8a62f7f7f767a9cf", + "ca0020f4a58292c5de0571b0", + "ca0020f4a582f7f7f792c5de0571b0", + "b2182bef8a62fddbc7d1e5f067a9cf2166ac", + "b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac", + "b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac", + "b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac", + "67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061", + "67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/RdGy.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/RdGy.js ***! + \***************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "ef8a62ffffff999999", + "ca0020f4a582bababa404040", + "ca0020f4a582ffffffbababa404040", + "b2182bef8a62fddbc7e0e0e09999994d4d4d", + "b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d", + "b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d", + "b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d", + "67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a", + "67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/RdYlBu.js": + /* !*****************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/RdYlBu.js ***! + \*****************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "fc8d59ffffbf91bfdb", + "d7191cfdae61abd9e92c7bb6", + "d7191cfdae61ffffbfabd9e92c7bb6", + "d73027fc8d59fee090e0f3f891bfdb4575b4", + "d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4", + "d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4", + "d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4", + "a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695", + "a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/RdYlGn.js": + /* !*****************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/RdYlGn.js ***! + \*****************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "fc8d59ffffbf91cf60", + "d7191cfdae61a6d96a1a9641", + "d7191cfdae61ffffbfa6d96a1a9641", + "d73027fc8d59fee08bd9ef8b91cf601a9850", + "d73027fc8d59fee08bffffbfd9ef8b91cf601a9850", + "d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850", + "d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850", + "a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837", + "a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/diverging/Spectral.js": + /* !*******************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/diverging/Spectral.js ***! + \*******************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "fc8d59ffffbf99d594", + "d7191cfdae61abdda42b83ba", + "d7191cfdae61ffffbfabdda42b83ba", + "d53e4ffc8d59fee08be6f59899d5943288bd", + "d53e4ffc8d59fee08bffffbfe6f59899d5943288bd", + "d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd", + "d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd", + "9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2", + "9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/index.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/index.js ***! + \******************************************************/ + /* ! exports provided: schemeCategory10, schemeAccent, schemeDark2, schemePaired, schemePastel1, schemePastel2, schemeSet1, schemeSet2, schemeSet3, schemeTableau10, interpolateBrBG, schemeBrBG, interpolatePRGn, schemePRGn, interpolatePiYG, schemePiYG, interpolatePuOr, schemePuOr, interpolateRdBu, schemeRdBu, interpolateRdGy, schemeRdGy, interpolateRdYlBu, schemeRdYlBu, interpolateRdYlGn, schemeRdYlGn, interpolateSpectral, schemeSpectral, interpolateBuGn, schemeBuGn, interpolateBuPu, schemeBuPu, interpolateGnBu, schemeGnBu, interpolateOrRd, schemeOrRd, interpolatePuBuGn, schemePuBuGn, interpolatePuBu, schemePuBu, interpolatePuRd, schemePuRd, interpolateRdPu, schemeRdPu, interpolateYlGnBu, schemeYlGnBu, interpolateYlGn, schemeYlGn, interpolateYlOrBr, schemeYlOrBr, interpolateYlOrRd, schemeYlOrRd, interpolateBlues, schemeBlues, interpolateGreens, schemeGreens, interpolateGreys, schemeGreys, interpolatePurples, schemePurples, interpolateReds, schemeReds, interpolateOranges, schemeOranges, interpolateCividis, interpolateCubehelixDefault, interpolateRainbow, interpolateWarm, interpolateCool, interpolateSinebow, interpolateTurbo, interpolateViridis, interpolateMagma, interpolateInferno, interpolatePlasma */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _categorical_category10_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./categorical/category10.js */ "./node_modules/d3-scale-chromatic/src/categorical/category10.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeCategory10", + function () { + return _categorical_category10_js__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _categorical_Accent_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./categorical/Accent.js */ "./node_modules/d3-scale-chromatic/src/categorical/Accent.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeAccent", + function () { + return _categorical_Accent_js__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _categorical_Dark2_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./categorical/Dark2.js */ "./node_modules/d3-scale-chromatic/src/categorical/Dark2.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeDark2", + function () { + return _categorical_Dark2_js__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _categorical_Paired_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./categorical/Paired.js */ "./node_modules/d3-scale-chromatic/src/categorical/Paired.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePaired", + function () { + return _categorical_Paired_js__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _categorical_Pastel1_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./categorical/Pastel1.js */ "./node_modules/d3-scale-chromatic/src/categorical/Pastel1.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePastel1", + function () { + return _categorical_Pastel1_js__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _categorical_Pastel2_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./categorical/Pastel2.js */ "./node_modules/d3-scale-chromatic/src/categorical/Pastel2.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePastel2", + function () { + return _categorical_Pastel2_js__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _categorical_Set1_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./categorical/Set1.js */ "./node_modules/d3-scale-chromatic/src/categorical/Set1.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeSet1", + function () { + return _categorical_Set1_js__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony import */ var _categorical_Set2_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./categorical/Set2.js */ "./node_modules/d3-scale-chromatic/src/categorical/Set2.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeSet2", + function () { + return _categorical_Set2_js__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /* Harmony import */ var _categorical_Set3_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./categorical/Set3.js */ "./node_modules/d3-scale-chromatic/src/categorical/Set3.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeSet3", + function () { + return _categorical_Set3_js__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony import */ var _categorical_Tableau10_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./categorical/Tableau10.js */ "./node_modules/d3-scale-chromatic/src/categorical/Tableau10.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeTableau10", + function () { + return _categorical_Tableau10_js__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony import */ var _diverging_BrBG_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./diverging/BrBG.js */ "./node_modules/d3-scale-chromatic/src/diverging/BrBG.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBrBG", + function () { + return _diverging_BrBG_js__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeBrBG", + function () { + return _diverging_BrBG_js__WEBPACK_IMPORTED_MODULE_10__.scheme; + } + ); + + /* Harmony import */ var _diverging_PRGn_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./diverging/PRGn.js */ "./node_modules/d3-scale-chromatic/src/diverging/PRGn.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePRGn", + function () { + return _diverging_PRGn_js__WEBPACK_IMPORTED_MODULE_11__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePRGn", + function () { + return _diverging_PRGn_js__WEBPACK_IMPORTED_MODULE_11__.scheme; + } + ); + + /* Harmony import */ var _diverging_PiYG_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./diverging/PiYG.js */ "./node_modules/d3-scale-chromatic/src/diverging/PiYG.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePiYG", + function () { + return _diverging_PiYG_js__WEBPACK_IMPORTED_MODULE_12__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePiYG", + function () { + return _diverging_PiYG_js__WEBPACK_IMPORTED_MODULE_12__.scheme; + } + ); + + /* Harmony import */ var _diverging_PuOr_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./diverging/PuOr.js */ "./node_modules/d3-scale-chromatic/src/diverging/PuOr.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePuOr", + function () { + return _diverging_PuOr_js__WEBPACK_IMPORTED_MODULE_13__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePuOr", + function () { + return _diverging_PuOr_js__WEBPACK_IMPORTED_MODULE_13__.scheme; + } + ); + + /* Harmony import */ var _diverging_RdBu_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./diverging/RdBu.js */ "./node_modules/d3-scale-chromatic/src/diverging/RdBu.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdBu", + function () { + return _diverging_RdBu_js__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdBu", + function () { + return _diverging_RdBu_js__WEBPACK_IMPORTED_MODULE_14__.scheme; + } + ); + + /* Harmony import */ var _diverging_RdGy_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./diverging/RdGy.js */ "./node_modules/d3-scale-chromatic/src/diverging/RdGy.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdGy", + function () { + return _diverging_RdGy_js__WEBPACK_IMPORTED_MODULE_15__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdGy", + function () { + return _diverging_RdGy_js__WEBPACK_IMPORTED_MODULE_15__.scheme; + } + ); + + /* Harmony import */ var _diverging_RdYlBu_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! ./diverging/RdYlBu.js */ "./node_modules/d3-scale-chromatic/src/diverging/RdYlBu.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdYlBu", + function () { + return _diverging_RdYlBu_js__WEBPACK_IMPORTED_MODULE_16__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdYlBu", + function () { + return _diverging_RdYlBu_js__WEBPACK_IMPORTED_MODULE_16__.scheme; + } + ); + + /* Harmony import */ var _diverging_RdYlGn_js__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! ./diverging/RdYlGn.js */ "./node_modules/d3-scale-chromatic/src/diverging/RdYlGn.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdYlGn", + function () { + return _diverging_RdYlGn_js__WEBPACK_IMPORTED_MODULE_17__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdYlGn", + function () { + return _diverging_RdYlGn_js__WEBPACK_IMPORTED_MODULE_17__.scheme; + } + ); + + /* Harmony import */ var _diverging_Spectral_js__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__( + /* ! ./diverging/Spectral.js */ "./node_modules/d3-scale-chromatic/src/diverging/Spectral.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateSpectral", + function () { + return _diverging_Spectral_js__WEBPACK_IMPORTED_MODULE_18__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeSpectral", + function () { + return _diverging_Spectral_js__WEBPACK_IMPORTED_MODULE_18__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_BuGn_js__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__( + /* ! ./sequential-multi/BuGn.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/BuGn.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBuGn", + function () { + return _sequential_multi_BuGn_js__WEBPACK_IMPORTED_MODULE_19__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeBuGn", + function () { + return _sequential_multi_BuGn_js__WEBPACK_IMPORTED_MODULE_19__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_BuPu_js__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__( + /* ! ./sequential-multi/BuPu.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/BuPu.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBuPu", + function () { + return _sequential_multi_BuPu_js__WEBPACK_IMPORTED_MODULE_20__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeBuPu", + function () { + return _sequential_multi_BuPu_js__WEBPACK_IMPORTED_MODULE_20__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_GnBu_js__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__( + /* ! ./sequential-multi/GnBu.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/GnBu.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateGnBu", + function () { + return _sequential_multi_GnBu_js__WEBPACK_IMPORTED_MODULE_21__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeGnBu", + function () { + return _sequential_multi_GnBu_js__WEBPACK_IMPORTED_MODULE_21__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_OrRd_js__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__( + /* ! ./sequential-multi/OrRd.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/OrRd.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateOrRd", + function () { + return _sequential_multi_OrRd_js__WEBPACK_IMPORTED_MODULE_22__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeOrRd", + function () { + return _sequential_multi_OrRd_js__WEBPACK_IMPORTED_MODULE_22__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_PuBuGn_js__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__( + /* ! ./sequential-multi/PuBuGn.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuBuGn.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePuBuGn", + function () { + return _sequential_multi_PuBuGn_js__WEBPACK_IMPORTED_MODULE_23__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePuBuGn", + function () { + return _sequential_multi_PuBuGn_js__WEBPACK_IMPORTED_MODULE_23__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_PuBu_js__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__( + /* ! ./sequential-multi/PuBu.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuBu.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePuBu", + function () { + return _sequential_multi_PuBu_js__WEBPACK_IMPORTED_MODULE_24__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePuBu", + function () { + return _sequential_multi_PuBu_js__WEBPACK_IMPORTED_MODULE_24__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_PuRd_js__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__( + /* ! ./sequential-multi/PuRd.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuRd.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePuRd", + function () { + return _sequential_multi_PuRd_js__WEBPACK_IMPORTED_MODULE_25__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePuRd", + function () { + return _sequential_multi_PuRd_js__WEBPACK_IMPORTED_MODULE_25__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_RdPu_js__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__( + /* ! ./sequential-multi/RdPu.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/RdPu.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdPu", + function () { + return _sequential_multi_RdPu_js__WEBPACK_IMPORTED_MODULE_26__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdPu", + function () { + return _sequential_multi_RdPu_js__WEBPACK_IMPORTED_MODULE_26__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_YlGnBu_js__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__( + /* ! ./sequential-multi/YlGnBu.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlGnBu.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateYlGnBu", + function () { + return _sequential_multi_YlGnBu_js__WEBPACK_IMPORTED_MODULE_27__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeYlGnBu", + function () { + return _sequential_multi_YlGnBu_js__WEBPACK_IMPORTED_MODULE_27__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_YlGn_js__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__( + /* ! ./sequential-multi/YlGn.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlGn.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateYlGn", + function () { + return _sequential_multi_YlGn_js__WEBPACK_IMPORTED_MODULE_28__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeYlGn", + function () { + return _sequential_multi_YlGn_js__WEBPACK_IMPORTED_MODULE_28__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_YlOrBr_js__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__( + /* ! ./sequential-multi/YlOrBr.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrBr.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateYlOrBr", + function () { + return _sequential_multi_YlOrBr_js__WEBPACK_IMPORTED_MODULE_29__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeYlOrBr", + function () { + return _sequential_multi_YlOrBr_js__WEBPACK_IMPORTED_MODULE_29__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_YlOrRd_js__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__( + /* ! ./sequential-multi/YlOrRd.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrRd.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateYlOrRd", + function () { + return _sequential_multi_YlOrRd_js__WEBPACK_IMPORTED_MODULE_30__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeYlOrRd", + function () { + return _sequential_multi_YlOrRd_js__WEBPACK_IMPORTED_MODULE_30__.scheme; + } + ); + + /* Harmony import */ var _sequential_single_Blues_js__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__( + /* ! ./sequential-single/Blues.js */ "./node_modules/d3-scale-chromatic/src/sequential-single/Blues.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBlues", + function () { + return _sequential_single_Blues_js__WEBPACK_IMPORTED_MODULE_31__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeBlues", + function () { + return _sequential_single_Blues_js__WEBPACK_IMPORTED_MODULE_31__.scheme; + } + ); + + /* Harmony import */ var _sequential_single_Greens_js__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__( + /* ! ./sequential-single/Greens.js */ "./node_modules/d3-scale-chromatic/src/sequential-single/Greens.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateGreens", + function () { + return _sequential_single_Greens_js__WEBPACK_IMPORTED_MODULE_32__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeGreens", + function () { + return _sequential_single_Greens_js__WEBPACK_IMPORTED_MODULE_32__.scheme; + } + ); + + /* Harmony import */ var _sequential_single_Greys_js__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__( + /* ! ./sequential-single/Greys.js */ "./node_modules/d3-scale-chromatic/src/sequential-single/Greys.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateGreys", + function () { + return _sequential_single_Greys_js__WEBPACK_IMPORTED_MODULE_33__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeGreys", + function () { + return _sequential_single_Greys_js__WEBPACK_IMPORTED_MODULE_33__.scheme; + } + ); + + /* Harmony import */ var _sequential_single_Purples_js__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__( + /* ! ./sequential-single/Purples.js */ "./node_modules/d3-scale-chromatic/src/sequential-single/Purples.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePurples", + function () { + return _sequential_single_Purples_js__WEBPACK_IMPORTED_MODULE_34__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePurples", + function () { + return _sequential_single_Purples_js__WEBPACK_IMPORTED_MODULE_34__.scheme; + } + ); + + /* Harmony import */ var _sequential_single_Reds_js__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__( + /* ! ./sequential-single/Reds.js */ "./node_modules/d3-scale-chromatic/src/sequential-single/Reds.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateReds", + function () { + return _sequential_single_Reds_js__WEBPACK_IMPORTED_MODULE_35__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeReds", + function () { + return _sequential_single_Reds_js__WEBPACK_IMPORTED_MODULE_35__.scheme; + } + ); + + /* Harmony import */ var _sequential_single_Oranges_js__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__( + /* ! ./sequential-single/Oranges.js */ "./node_modules/d3-scale-chromatic/src/sequential-single/Oranges.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateOranges", + function () { + return _sequential_single_Oranges_js__WEBPACK_IMPORTED_MODULE_36__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeOranges", + function () { + return _sequential_single_Oranges_js__WEBPACK_IMPORTED_MODULE_36__.scheme; + } + ); + + /* Harmony import */ var _sequential_multi_cividis_js__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__( + /* ! ./sequential-multi/cividis.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/cividis.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCividis", + function () { + return _sequential_multi_cividis_js__WEBPACK_IMPORTED_MODULE_37__.default; + } + ); + + /* Harmony import */ var _sequential_multi_cubehelix_js__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__( + /* ! ./sequential-multi/cubehelix.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/cubehelix.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCubehelixDefault", + function () { + return _sequential_multi_cubehelix_js__WEBPACK_IMPORTED_MODULE_38__.default; + } + ); + + /* Harmony import */ var _sequential_multi_rainbow_js__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__( + /* ! ./sequential-multi/rainbow.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/rainbow.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRainbow", + function () { + return _sequential_multi_rainbow_js__WEBPACK_IMPORTED_MODULE_39__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateWarm", + function () { + return _sequential_multi_rainbow_js__WEBPACK_IMPORTED_MODULE_39__.warm; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCool", + function () { + return _sequential_multi_rainbow_js__WEBPACK_IMPORTED_MODULE_39__.cool; + } + ); + + /* Harmony import */ var _sequential_multi_sinebow_js__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__( + /* ! ./sequential-multi/sinebow.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/sinebow.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateSinebow", + function () { + return _sequential_multi_sinebow_js__WEBPACK_IMPORTED_MODULE_40__.default; + } + ); + + /* Harmony import */ var _sequential_multi_turbo_js__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__( + /* ! ./sequential-multi/turbo.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/turbo.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateTurbo", + function () { + return _sequential_multi_turbo_js__WEBPACK_IMPORTED_MODULE_41__.default; + } + ); + + /* Harmony import */ var _sequential_multi_viridis_js__WEBPACK_IMPORTED_MODULE_42__ = __webpack_require__( + /* ! ./sequential-multi/viridis.js */ "./node_modules/d3-scale-chromatic/src/sequential-multi/viridis.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateViridis", + function () { + return _sequential_multi_viridis_js__WEBPACK_IMPORTED_MODULE_42__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateMagma", + function () { + return _sequential_multi_viridis_js__WEBPACK_IMPORTED_MODULE_42__.magma; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateInferno", + function () { + return _sequential_multi_viridis_js__WEBPACK_IMPORTED_MODULE_42__.inferno; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePlasma", + function () { + return _sequential_multi_viridis_js__WEBPACK_IMPORTED_MODULE_42__.plasma; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/ramp.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/ramp.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (scheme) { + return Object( + d3_interpolate__WEBPACK_IMPORTED_MODULE_0__.interpolateRgbBasis + )(scheme[scheme.length - 1]); + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/BuGn.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/BuGn.js ***! + \**********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "e5f5f999d8c92ca25f", + "edf8fbb2e2e266c2a4238b45", + "edf8fbb2e2e266c2a42ca25f006d2c", + "edf8fbccece699d8c966c2a42ca25f006d2c", + "edf8fbccece699d8c966c2a441ae76238b45005824", + "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824", + "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/BuPu.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/BuPu.js ***! + \**********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "e0ecf49ebcda8856a7", + "edf8fbb3cde38c96c688419d", + "edf8fbb3cde38c96c68856a7810f7c", + "edf8fbbfd3e69ebcda8c96c68856a7810f7c", + "edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b", + "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b", + "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/GnBu.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/GnBu.js ***! + \**********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "e0f3dba8ddb543a2ca", + "f0f9e8bae4bc7bccc42b8cbe", + "f0f9e8bae4bc7bccc443a2ca0868ac", + "f0f9e8ccebc5a8ddb57bccc443a2ca0868ac", + "f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e", + "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e", + "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/OrRd.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/OrRd.js ***! + \**********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "fee8c8fdbb84e34a33", + "fef0d9fdcc8afc8d59d7301f", + "fef0d9fdcc8afc8d59e34a33b30000", + "fef0d9fdd49efdbb84fc8d59e34a33b30000", + "fef0d9fdd49efdbb84fc8d59ef6548d7301f990000", + "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000", + "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuBu.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/PuBu.js ***! + \**********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "ece7f2a6bddb2b8cbe", + "f1eef6bdc9e174a9cf0570b0", + "f1eef6bdc9e174a9cf2b8cbe045a8d", + "f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d", + "f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b", + "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b", + "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuBuGn.js": + /* !************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/PuBuGn.js ***! + \************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "ece2f0a6bddb1c9099", + "f6eff7bdc9e167a9cf02818a", + "f6eff7bdc9e167a9cf1c9099016c59", + "f6eff7d0d1e6a6bddb67a9cf1c9099016c59", + "f6eff7d0d1e6a6bddb67a9cf3690c002818a016450", + "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450", + "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuRd.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/PuRd.js ***! + \**********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "e7e1efc994c7dd1c77", + "f1eef6d7b5d8df65b0ce1256", + "f1eef6d7b5d8df65b0dd1c77980043", + "f1eef6d4b9dac994c7df65b0dd1c77980043", + "f1eef6d4b9dac994c7df65b0e7298ace125691003f", + "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f", + "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/RdPu.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/RdPu.js ***! + \**********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "fde0ddfa9fb5c51b8a", + "feebe2fbb4b9f768a1ae017e", + "feebe2fbb4b9f768a1c51b8a7a0177", + "feebe2fcc5c0fa9fb5f768a1c51b8a7a0177", + "feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177", + "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177", + "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlGn.js": + /* !**********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/YlGn.js ***! + \**********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "f7fcb9addd8e31a354", + "ffffccc2e69978c679238443", + "ffffccc2e69978c67931a354006837", + "ffffccd9f0a3addd8e78c67931a354006837", + "ffffccd9f0a3addd8e78c67941ab5d238443005a32", + "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32", + "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlGnBu.js": + /* !************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/YlGnBu.js ***! + \************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "edf8b17fcdbb2c7fb8", + "ffffcca1dab441b6c4225ea8", + "ffffcca1dab441b6c42c7fb8253494", + "ffffccc7e9b47fcdbb41b6c42c7fb8253494", + "ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84", + "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84", + "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrBr.js": + /* !************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrBr.js ***! + \************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "fff7bcfec44fd95f0e", + "ffffd4fed98efe9929cc4c02", + "ffffd4fed98efe9929d95f0e993404", + "ffffd4fee391fec44ffe9929d95f0e993404", + "ffffd4fee391fec44ffe9929ec7014cc4c028c2d04", + "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04", + "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrRd.js": + /* !************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrRd.js ***! + \************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "ffeda0feb24cf03b20", + "ffffb2fecc5cfd8d3ce31a1c", + "ffffb2fecc5cfd8d3cf03b20bd0026", + "ffffb2fed976feb24cfd8d3cf03b20bd0026", + "ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026", + "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026", + "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/cividis.js": + /* !*************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/cividis.js ***! + \*************************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (t) { + t = Math.max(0, Math.min(1, t)); + return ( + "rgb(" + + Math.max( + 0, + Math.min( + 255, + Math.round( + -4.54 - + t * + (35.34 - + t * + (2381.73 - + t * + (6402.7 - + t * + (7024.72 - + t * + 2710.57)))) + ) + ) + ) + + ", " + + Math.max( + 0, + Math.min( + 255, + Math.round( + 32.49 + + t * + (170.73 + + t * + (52.82 - + t * + (131.46 - + t * + (176.58 - + t * + 67.37)))) + ) + ) + ) + + ", " + + Math.max( + 0, + Math.min( + 255, + Math.round( + 81.24 + + t * + (442.36 - + t * + (2482.43 - + t * + (6167.24 - + t * + (6614.94 - + t * + 2475.67)))) + ) + ) + ) + + ")" + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/cubehelix.js": + /* !***************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/cubehelix.js ***! + \***************************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = Object( + d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateCubehelixLong + )( + Object(d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix)( + 300, + 0.5, + 0.0 + ), + Object(d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix)( + -240, + 0.5, + 1.0 + ) + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/rainbow.js": + /* !*************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/rainbow.js ***! + \*************************************************************************/ + /* ! exports provided: warm, cool, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "warm", + function () { + return warm; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cool", + function () { + return cool; + } + ); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + + var warm = Object( + d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateCubehelixLong + )( + Object(d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix)( + -100, + 0.75, + 0.35 + ), + Object(d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix)( + 80, + 1.5, + 0.8 + ) + ); + var cool = Object( + d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateCubehelixLong + )( + Object(d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix)( + 260, + 0.75, + 0.35 + ), + Object(d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix)( + 80, + 1.5, + 0.8 + ) + ); + var c = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.cubehelix + )(); + /* Harmony default export */ __webpack_exports__.default = function (t) { + if (t < 0 || t > 1) t -= Math.floor(t); + var ts = Math.abs(t - 0.5); + c.h = 360 * t - 100; + c.s = 1.5 - 1.5 * ts; + c.l = 0.8 - 0.9 * ts; + return String(c); + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/sinebow.js": + /* !*************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/sinebow.js ***! + \*************************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + + var c = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__.rgb)(), + pi_1_3 = Math.PI / 3, + pi_2_3 = (Math.PI * 2) / 3; + /* Harmony default export */ __webpack_exports__.default = function (t) { + var x; + t = (0.5 - t) * Math.PI; + c.r = 255 * (x = Math.sin(t)) * x; + c.g = 255 * (x = Math.sin(t + pi_1_3)) * x; + c.b = 255 * (x = Math.sin(t + pi_2_3)) * x; + return String(c); + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/turbo.js": + /* !***********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/turbo.js ***! + \***********************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (t) { + t = Math.max(0, Math.min(1, t)); + return ( + "rgb(" + + Math.max( + 0, + Math.min( + 255, + Math.round( + 34.61 + + t * + (1172.33 - + t * + (10793.56 - + t * + (33300.12 - + t * + (38394.49 - + t * + 14825.05)))) + ) + ) + ) + + ", " + + Math.max( + 0, + Math.min( + 255, + Math.round( + 23.31 + + t * + (557.33 + + t * + (1225.33 - + t * + (3574.96 - + t * + (1073.77 + + t * + 707.56)))) + ) + ) + ) + + ", " + + Math.max( + 0, + Math.min( + 255, + Math.round( + 27.2 + + t * + (3211.1 - + t * + (15327.97 - + t * + (27814 - + t * + (22569.18 - + t * + 6838.66)))) + ) + ) + ) + + ")" + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/viridis.js": + /* !*************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/viridis.js ***! + \*************************************************************************/ + /* ! exports provided: default, magma, inferno, plasma */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "magma", + function () { + return magma; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "inferno", + function () { + return inferno; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "plasma", + function () { + return plasma; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + + function ramp(range) { + var n = range.length; + return function (t) { + return range[ + Math.max(0, Math.min(n - 1, Math.floor(t * n))) + ]; + }; + } + + /* Harmony default export */ __webpack_exports__.default = ramp( + Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725" + ) + ); + var magma = ramp( + Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf" + ) + ); + var inferno = ramp( + Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4" + ) + ); + var plasma = ramp( + Object(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default)( + "0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921" + ) + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Blues.js": + /* !************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Blues.js ***! + \************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "deebf79ecae13182bd", + "eff3ffbdd7e76baed62171b5", + "eff3ffbdd7e76baed63182bd08519c", + "eff3ffc6dbef9ecae16baed63182bd08519c", + "eff3ffc6dbef9ecae16baed64292c62171b5084594", + "f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594", + "f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Greens.js": + /* !*************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Greens.js ***! + \*************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "e5f5e0a1d99b31a354", + "edf8e9bae4b374c476238b45", + "edf8e9bae4b374c47631a354006d2c", + "edf8e9c7e9c0a1d99b74c47631a354006d2c", + "edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32", + "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32", + "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Greys.js": + /* !************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Greys.js ***! + \************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "f0f0f0bdbdbd636363", + "f7f7f7cccccc969696525252", + "f7f7f7cccccc969696636363252525", + "f7f7f7d9d9d9bdbdbd969696636363252525", + "f7f7f7d9d9d9bdbdbd969696737373525252252525", + "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525", + "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Oranges.js": + /* !**************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Oranges.js ***! + \**************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "fee6cefdae6be6550d", + "feeddefdbe85fd8d3cd94701", + "feeddefdbe85fd8d3ce6550da63603", + "feeddefdd0a2fdae6bfd8d3ce6550da63603", + "feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04", + "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04", + "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Purples.js": + /* !**************************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Purples.js ***! + \**************************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "efedf5bcbddc756bb1", + "f2f0f7cbc9e29e9ac86a51a3", + "f2f0f7cbc9e29e9ac8756bb154278f", + "f2f0f7dadaebbcbddc9e9ac8756bb154278f", + "f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486", + "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486", + "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Reds.js": + /* !***********************************************************************!*\ + !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Reds.js ***! + \***********************************************************************/ + /* ! exports provided: scheme, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scheme", + function () { + return scheme; + } + ); + /* Harmony import */ var _colors_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../colors.js */ "./node_modules/d3-scale-chromatic/src/colors.js" + ); + /* Harmony import */ var _ramp_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../ramp.js */ "./node_modules/d3-scale-chromatic/src/ramp.js" + ); + + var scheme = new Array(3) + .concat( + "fee0d2fc9272de2d26", + "fee5d9fcae91fb6a4acb181d", + "fee5d9fcae91fb6a4ade2d26a50f15", + "fee5d9fcbba1fc9272fb6a4ade2d26a50f15", + "fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d", + "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d", + "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d" + ) + .map(_colors_js__WEBPACK_IMPORTED_MODULE_0__.default); + /* Harmony default export */ __webpack_exports__.default = Object(_ramp_js__WEBPACK_IMPORTED_MODULE_1__.default)( + scheme + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/array.js": + /* !********************************************!*\ + !*** ./node_modules/d3-scale/src/array.js ***! + \********************************************/ + /* ! exports provided: map, slice */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "map", + function () { + return map; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "slice", + function () { + return slice; + } + ); + var array = Array.prototype; + var map = array.map; + var slice = array.slice; + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/band.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-scale/src/band.js ***! + \*******************************************/ + /* ! exports provided: default, point */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return band; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "point", + function () { + return point; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + /* Harmony import */ var _ordinal__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./ordinal */ "./node_modules/d3-scale/src/ordinal.js" + ); + + function band() { + var scale = Object( + _ordinal__WEBPACK_IMPORTED_MODULE_2__.default + )().unknown(undefined), + domain = scale.domain, + ordinalRange = scale.range, + range = [0, 1], + step, + bandwidth, + round = false, + paddingInner = 0, + paddingOuter = 0, + align = 0.5; + delete scale.unknown; + + function rescale() { + var n = domain().length, + reverse = range[1] < range[0], + start = range[reverse - 0], + stop = range[1 - reverse]; + step = + (stop - start) / + Math.max(1, n - paddingInner + paddingOuter * 2); + if (round) step = Math.floor(step); + start += (stop - start - step * (n - paddingInner)) * align; + bandwidth = step * (1 - paddingInner); + if (round) + (start = Math.round(start)), + (bandwidth = Math.round(bandwidth)); + var values = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.range + )(n).map(function (i) { + return start + step * i; + }); + return ordinalRange(reverse ? values.reverse() : values); + } + + scale.domain = function (_) { + return arguments.length ? (domain(_), rescale()) : domain(); + }; + + scale.range = function (_) { + return arguments.length + ? ((range = [Number(_[0]), Number(_[1])]), rescale()) + : range.slice(); + }; + + scale.rangeRound = function (_) { + return (range = [Number(_[0]), Number(_[1])]), (round = true), rescale(); + }; + + scale.bandwidth = function () { + return bandwidth; + }; + + scale.step = function () { + return step; + }; + + scale.round = function (_) { + return arguments.length + ? ((round = Boolean(_)), rescale()) + : round; + }; + + scale.padding = function (_) { + return arguments.length + ? ((paddingInner = Math.min(1, (paddingOuter = Number(_)))), + rescale()) + : paddingInner; + }; + + scale.paddingInner = function (_) { + return arguments.length + ? ((paddingInner = Math.min(1, _)), rescale()) + : paddingInner; + }; + + scale.paddingOuter = function (_) { + return arguments.length + ? ((paddingOuter = Number(_)), rescale()) + : paddingOuter; + }; + + scale.align = function (_) { + return arguments.length + ? ((align = Math.max(0, Math.min(1, _))), rescale()) + : align; + }; + + scale.copy = function () { + return band(domain(), range) + .round(round) + .paddingInner(paddingInner) + .paddingOuter(paddingOuter) + .align(align); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initRange.apply( + rescale(), + arguments + ); + } + + function pointish(scale) { + var copy = scale.copy; + scale.padding = scale.paddingOuter; + delete scale.paddingInner; + delete scale.paddingOuter; + + scale.copy = function () { + return pointish(copy()); + }; + + return scale; + } + + function point() { + return pointish(band.apply(null, arguments).paddingInner(1)); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/constant.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-scale/src/constant.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/continuous.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-scale/src/continuous.js ***! + \*************************************************/ + /* ! exports provided: identity, copy, transformer, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "identity", + function () { + return identity; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "copy", + function () { + return copy; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "transformer", + function () { + return transformer; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return continuous; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-scale/src/array.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-scale/src/constant.js" + ); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-scale/src/number.js" + ); + + var unit = [0, 1]; + function identity(x) { + return x; + } + + function normalize(a, b) { + return (b -= a = Number(a)) + ? function (x) { + return (x - a) / b; + } + : Object(_constant__WEBPACK_IMPORTED_MODULE_3__.default)( + isNaN(b) ? NaN : 0.5 + ); + } + + function clamper(domain) { + var a = domain[0], + b = domain[domain.length - 1], + t; + if (a > b) (t = a), (a = b), (b = t); + return function (x) { + return Math.max(a, Math.min(b, x)); + }; + } // Normalize(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1]. + // interpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding range value x in [a,b]. + + function bimap(domain, range, interpolate) { + var d0 = domain[0], + d1 = domain[1], + r0 = range[0], + r1 = range[1]; + if (d1 < d0) + (d0 = normalize(d1, d0)), (r0 = interpolate(r1, r0)); + else (d0 = normalize(d0, d1)), (r0 = interpolate(r0, r1)); + return function (x) { + return r0(d0(x)); + }; + } + + function polymap(domain, range, interpolate) { + var j = Math.min(domain.length, range.length) - 1, + d = new Array(j), + r = new Array(j), + i = -1; // Reverse descending domains. + + if (domain[j] < domain[0]) { + domain = domain.slice().reverse(); + range = range.slice().reverse(); + } + + while (++i < j) { + d[i] = normalize(domain[i], domain[i + 1]); + r[i] = interpolate(range[i], range[i + 1]); + } + + return function (x) { + var i = + Object(d3_array__WEBPACK_IMPORTED_MODULE_0__.bisect)( + domain, + x, + 1, + j + ) - 1; + return r[i](d[i](x)); + }; + } + + function copy(source, target) { + return target + .domain(source.domain()) + .range(source.range()) + .interpolate(source.interpolate()) + .clamp(source.clamp()) + .unknown(source.unknown()); + } + function transformer() { + var domain = unit, + range = unit, + interpolate = + d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolate, + transform, + untransform, + unknown, + clamp = identity, + piecewise, + output, + input; + + function rescale() { + piecewise = + Math.min(domain.length, range.length) > 2 + ? polymap + : bimap; + output = input = null; + return scale; + } + + function scale(x) { + return isNaN((x = Number(x))) + ? unknown + : ( + output || + (output = piecewise( + domain.map(transform), + range, + interpolate + )) + )(transform(clamp(x))); + } + + scale.invert = function (y) { + return clamp( + untransform( + ( + input || + (input = piecewise( + range, + domain.map(transform), + d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateNumber + )) + )(y) + ) + ); + }; + + scale.domain = function (_) { + return arguments.length + ? ((domain = _array__WEBPACK_IMPORTED_MODULE_2__.map.call( + _, + _number__WEBPACK_IMPORTED_MODULE_4__.default + )), + clamp === identity || (clamp = clamper(domain)), + rescale()) + : domain.slice(); + }; + + scale.range = function (_) { + return arguments.length + ? ((range = _array__WEBPACK_IMPORTED_MODULE_2__.slice.call(_)), + rescale()) + : range.slice(); + }; + + scale.rangeRound = function (_) { + return ( + (range = _array__WEBPACK_IMPORTED_MODULE_2__.slice.call(_)), + (interpolate = + d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateRound), + rescale() + ); + }; + + scale.clamp = function (_) { + return arguments.length + ? ((clamp = _ ? clamper(domain) : identity), scale) + : clamp !== identity; + }; + + scale.interpolate = function (_) { + return arguments.length + ? ((interpolate = _), rescale()) + : interpolate; + }; + + scale.unknown = function (_) { + return arguments.length ? ((unknown = _), scale) : unknown; + }; + + return function (t, u) { + (transform = t), (untransform = u); + return rescale(); + }; + } + function continuous(transform, untransform) { + return transformer()(transform, untransform); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/diverging.js": + /* !************************************************!*\ + !*** ./node_modules/d3-scale/src/diverging.js ***! + \************************************************/ + /* ! exports provided: default, divergingLog, divergingSymlog, divergingPow, divergingSqrt */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return diverging; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "divergingLog", + function () { + return divergingLog; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "divergingSymlog", + function () { + return divergingSymlog; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "divergingPow", + function () { + return divergingPow; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "divergingSqrt", + function () { + return divergingSqrt; + } + ); + /* Harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./continuous */ "./node_modules/d3-scale/src/continuous.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-scale/src/linear.js" + ); + /* Harmony import */ var _log__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./log */ "./node_modules/d3-scale/src/log.js" + ); + /* Harmony import */ var _sequential__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./sequential */ "./node_modules/d3-scale/src/sequential.js" + ); + /* Harmony import */ var _symlog__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./symlog */ "./node_modules/d3-scale/src/symlog.js" + ); + /* Harmony import */ var _pow__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./pow */ "./node_modules/d3-scale/src/pow.js" + ); + + function transformer() { + var x0 = 0, + x1 = 0.5, + x2 = 1, + t0, + t1, + t2, + k10, + k21, + interpolator = + _continuous__WEBPACK_IMPORTED_MODULE_0__.identity, + transform, + clamp = false, + unknown; + + function scale(x) { + return isNaN((x = Number(x))) + ? unknown + : ((x = + 0.5 + + ((x = Number(transform(x))) - t1) * + (x < t1 ? k10 : k21)), + interpolator( + clamp ? Math.max(0, Math.min(1, x)) : x + )); + } + + scale.domain = function (_) { + return arguments.length + ? ((t0 = transform((x0 = Number(_[0])))), + (t1 = transform((x1 = Number(_[1])))), + (t2 = transform((x2 = Number(_[2])))), + (k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0)), + (k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1)), + scale) + : [x0, x1, x2]; + }; + + scale.clamp = function (_) { + return arguments.length ? ((clamp = Boolean(_)), scale) : clamp; + }; + + scale.interpolator = function (_) { + return arguments.length + ? ((interpolator = _), scale) + : interpolator; + }; + + scale.unknown = function (_) { + return arguments.length ? ((unknown = _), scale) : unknown; + }; + + return function (t) { + (transform = t), + (t0 = t(x0)), + (t1 = t(x1)), + (t2 = t(x2)), + (k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0)), + (k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1)); + return scale; + }; + } + + function diverging() { + var scale = Object( + _linear__WEBPACK_IMPORTED_MODULE_2__.linearish + )( + transformer()( + _continuous__WEBPACK_IMPORTED_MODULE_0__.identity + ) + ); + + scale.copy = function () { + return Object( + _sequential__WEBPACK_IMPORTED_MODULE_4__.copy + )(scale, diverging()); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initInterpolator.apply(scale, arguments); + } + function divergingLog() { + var scale = Object( + _log__WEBPACK_IMPORTED_MODULE_3__.loggish + )(transformer()).domain([0.1, 1, 10]); + + scale.copy = function () { + return Object( + _sequential__WEBPACK_IMPORTED_MODULE_4__.copy + )(scale, divergingLog()).base(scale.base()); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initInterpolator.apply(scale, arguments); + } + function divergingSymlog() { + var scale = Object( + _symlog__WEBPACK_IMPORTED_MODULE_5__.symlogish + )(transformer()); + + scale.copy = function () { + return Object( + _sequential__WEBPACK_IMPORTED_MODULE_4__.copy + )(scale, divergingSymlog()).constant(scale.constant()); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initInterpolator.apply(scale, arguments); + } + function divergingPow() { + var scale = Object(_pow__WEBPACK_IMPORTED_MODULE_6__.powish)( + transformer() + ); + + scale.copy = function () { + return Object( + _sequential__WEBPACK_IMPORTED_MODULE_4__.copy + )(scale, divergingPow()).exponent(scale.exponent()); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initInterpolator.apply(scale, arguments); + } + function divergingSqrt() { + return divergingPow.apply(null, arguments).exponent(0.5); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/identity.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-scale/src/identity.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return identity; + } + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-scale/src/array.js" + ); + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-scale/src/linear.js" + ); + /* Harmony import */ var _number__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./number */ "./node_modules/d3-scale/src/number.js" + ); + + function identity(domain) { + var unknown; + + function scale(x) { + return isNaN((x = Number(x))) ? unknown : x; + } + + scale.invert = scale; + + scale.domain = scale.range = function (_) { + return arguments.length + ? ((domain = _array__WEBPACK_IMPORTED_MODULE_0__.map.call( + _, + _number__WEBPACK_IMPORTED_MODULE_2__.default + )), + scale) + : domain.slice(); + }; + + scale.unknown = function (_) { + return arguments.length ? ((unknown = _), scale) : unknown; + }; + + scale.copy = function () { + return identity(domain).unknown(unknown); + }; + + domain = arguments.length + ? _array__WEBPACK_IMPORTED_MODULE_0__.map.call( + domain, + _number__WEBPACK_IMPORTED_MODULE_2__.default + ) + : [0, 1]; + return Object( + _linear__WEBPACK_IMPORTED_MODULE_1__.linearish + )(scale); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-scale/src/index.js ***! + \********************************************/ + /* ! exports provided: scaleBand, scalePoint, scaleIdentity, scaleLinear, scaleLog, scaleSymlog, scaleOrdinal, scaleImplicit, scalePow, scaleSqrt, scaleQuantile, scaleQuantize, scaleThreshold, scaleTime, scaleUtc, scaleSequential, scaleSequentialLog, scaleSequentialPow, scaleSequentialSqrt, scaleSequentialSymlog, scaleSequentialQuantile, scaleDiverging, scaleDivergingLog, scaleDivergingPow, scaleDivergingSqrt, scaleDivergingSymlog, tickFormat */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _band__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./band */ "./node_modules/d3-scale/src/band.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleBand", + function () { + return _band__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scalePoint", + function () { + return _band__WEBPACK_IMPORTED_MODULE_0__.point; + } + ); + + /* Harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./identity */ "./node_modules/d3-scale/src/identity.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleIdentity", + function () { + return _identity__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-scale/src/linear.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleLinear", + function () { + return _linear__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _log__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./log */ "./node_modules/d3-scale/src/log.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleLog", + function () { + return _log__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _symlog__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./symlog */ "./node_modules/d3-scale/src/symlog.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSymlog", + function () { + return _symlog__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _ordinal__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./ordinal */ "./node_modules/d3-scale/src/ordinal.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleOrdinal", + function () { + return _ordinal__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleImplicit", + function () { + return _ordinal__WEBPACK_IMPORTED_MODULE_5__.implicit; + } + ); + + /* Harmony import */ var _pow__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./pow */ "./node_modules/d3-scale/src/pow.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scalePow", + function () { + return _pow__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSqrt", + function () { + return _pow__WEBPACK_IMPORTED_MODULE_6__.sqrt; + } + ); + + /* Harmony import */ var _quantile__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./quantile */ "./node_modules/d3-scale/src/quantile.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleQuantile", + function () { + return _quantile__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /* Harmony import */ var _quantize__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./quantize */ "./node_modules/d3-scale/src/quantize.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleQuantize", + function () { + return _quantize__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony import */ var _threshold__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./threshold */ "./node_modules/d3-scale/src/threshold.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleThreshold", + function () { + return _threshold__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony import */ var _time__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./time */ "./node_modules/d3-scale/src/time.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleTime", + function () { + return _time__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony import */ var _utcTime__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./utcTime */ "./node_modules/d3-scale/src/utcTime.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleUtc", + function () { + return _utcTime__WEBPACK_IMPORTED_MODULE_11__.default; + } + ); + + /* Harmony import */ var _sequential__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./sequential */ "./node_modules/d3-scale/src/sequential.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequential", + function () { + return _sequential__WEBPACK_IMPORTED_MODULE_12__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialLog", + function () { + return _sequential__WEBPACK_IMPORTED_MODULE_12__.sequentialLog; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialPow", + function () { + return _sequential__WEBPACK_IMPORTED_MODULE_12__.sequentialPow; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialSqrt", + function () { + return _sequential__WEBPACK_IMPORTED_MODULE_12__.sequentialSqrt; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialSymlog", + function () { + return _sequential__WEBPACK_IMPORTED_MODULE_12__.sequentialSymlog; + } + ); + + /* Harmony import */ var _sequentialQuantile__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./sequentialQuantile */ "./node_modules/d3-scale/src/sequentialQuantile.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialQuantile", + function () { + return _sequentialQuantile__WEBPACK_IMPORTED_MODULE_13__.default; + } + ); + + /* Harmony import */ var _diverging__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./diverging */ "./node_modules/d3-scale/src/diverging.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDiverging", + function () { + return _diverging__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDivergingLog", + function () { + return _diverging__WEBPACK_IMPORTED_MODULE_14__.divergingLog; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDivergingPow", + function () { + return _diverging__WEBPACK_IMPORTED_MODULE_14__.divergingPow; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDivergingSqrt", + function () { + return _diverging__WEBPACK_IMPORTED_MODULE_14__.divergingSqrt; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDivergingSymlog", + function () { + return _diverging__WEBPACK_IMPORTED_MODULE_14__.divergingSymlog; + } + ); + + /* Harmony import */ var _tickFormat__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./tickFormat */ "./node_modules/d3-scale/src/tickFormat.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tickFormat", + function () { + return _tickFormat__WEBPACK_IMPORTED_MODULE_15__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/init.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-scale/src/init.js ***! + \*******************************************/ + /* ! exports provided: initRange, initInterpolator */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "initRange", + function () { + return initRange; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "initInterpolator", + function () { + return initInterpolator; + } + ); + function initRange(domain, range) { + switch (arguments.length) { + case 0: + break; + + case 1: + this.range(domain); + break; + + default: + this.range(range).domain(domain); + break; + } + + return this; + } + function initInterpolator(domain, interpolator) { + switch (arguments.length) { + case 0: + break; + + case 1: + this.interpolator(domain); + break; + + default: + this.interpolator(interpolator).domain(domain); + break; + } + + return this; + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/linear.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-scale/src/linear.js ***! + \*********************************************/ + /* ! exports provided: linearish, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "linearish", + function () { + return linearish; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return linear; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./continuous */ "./node_modules/d3-scale/src/continuous.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + /* Harmony import */ var _tickFormat__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./tickFormat */ "./node_modules/d3-scale/src/tickFormat.js" + ); + + function linearish(scale) { + var domain = scale.domain; + + scale.ticks = function (count) { + var d = domain(); + return Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.ticks + )(d[0], d[d.length - 1], count == null ? 10 : count); + }; + + scale.tickFormat = function (count, specifier) { + var d = domain(); + return Object( + _tickFormat__WEBPACK_IMPORTED_MODULE_3__.default + )( + d[0], + d[d.length - 1], + count == null ? 10 : count, + specifier + ); + }; + + scale.nice = function (count) { + if (count == null) count = 10; + var d = domain(), + i0 = 0, + i1 = d.length - 1, + start = d[i0], + stop = d[i1], + step; + + if (stop < start) { + (step = start), (start = stop), (stop = step); + (step = i0), (i0 = i1), (i1 = step); + } + + step = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.tickIncrement + )(start, stop, count); + + if (step > 0) { + start = Math.floor(start / step) * step; + stop = Math.ceil(stop / step) * step; + step = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.tickIncrement + )(start, stop, count); + } else if (step < 0) { + start = Math.ceil(start * step) / step; + stop = Math.floor(stop * step) / step; + step = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.tickIncrement + )(start, stop, count); + } + + if (step > 0) { + d[i0] = Math.floor(start / step) * step; + d[i1] = Math.ceil(stop / step) * step; + domain(d); + } else if (step < 0) { + d[i0] = Math.ceil(start * step) / step; + d[i1] = Math.floor(stop * step) / step; + domain(d); + } + + return scale; + }; + + return scale; + } + function linear() { + var scale = Object( + _continuous__WEBPACK_IMPORTED_MODULE_1__.default + )( + _continuous__WEBPACK_IMPORTED_MODULE_1__.identity, + _continuous__WEBPACK_IMPORTED_MODULE_1__.identity + ); + + scale.copy = function () { + return Object( + _continuous__WEBPACK_IMPORTED_MODULE_1__.copy + )(scale, linear()); + }; + + _init__WEBPACK_IMPORTED_MODULE_2__.initRange.apply( + scale, + arguments + ); + return linearish(scale); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/log.js": + /* !******************************************!*\ + !*** ./node_modules/d3-scale/src/log.js ***! + \******************************************/ + /* ! exports provided: loggish, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "loggish", + function () { + return loggish; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return log; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-format */ "./node_modules/d3-format/src/index.js" + ); + /* Harmony import */ var _nice__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./nice */ "./node_modules/d3-scale/src/nice.js" + ); + /* Harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./continuous */ "./node_modules/d3-scale/src/continuous.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + function transformLog(x) { + return Math.log(x); + } + + function transformExp(x) { + return Math.exp(x); + } + + function transformLogn(x) { + return -Math.log(-x); + } + + function transformExpn(x) { + return -Math.exp(-x); + } + + function pow10(x) { + return isFinite(x) ? Number("1e" + x) : x < 0 ? 0 : x; + } + + function powp(base) { + return base === 10 + ? pow10 + : base === Math.E + ? Math.exp + : function (x) { + return Math.pow(base, x); + }; + } + + function logp(base) { + return base === Math.E + ? Math.log + : (base === 10 && Math.log10) || + (base === 2 && Math.log2) || + ((base = Math.log(base)), + function (x) { + return Math.log(x) / base; + }); + } + + function reflect(f) { + return function (x) { + return -f(-x); + }; + } + + function loggish(transform) { + var scale = transform(transformLog, transformExp), + domain = scale.domain, + base = 10, + logs, + pows; + + function rescale() { + (logs = logp(base)), (pows = powp(base)); + + if (domain()[0] < 0) { + (logs = reflect(logs)), (pows = reflect(pows)); + transform(transformLogn, transformExpn); + } else { + transform(transformLog, transformExp); + } + + return scale; + } + + scale.base = function (_) { + return arguments.length ? ((base = Number(_)), rescale()) : base; + }; + + scale.domain = function (_) { + return arguments.length ? (domain(_), rescale()) : domain(); + }; + + scale.ticks = function (count) { + var d = domain(), + u = d[0], + v = d[d.length - 1], + r; + if ((r = v < u)) (i = u), (u = v), (v = i); + var i = logs(u), + j = logs(v), + p, + k, + t, + n = count == null ? 10 : Number(count), + z = []; + + if (!(base % 1) && j - i < n) { + (i = Math.round(i) - 1), (j = Math.round(j) + 1); + if (u > 0) + for (; i < j; ++i) { + for (k = 1, p = pows(i); k < base; ++k) { + t = p * k; + if (t < u) continue; + if (t > v) break; + z.push(t); + } + } + else + for (; i < j; ++i) { + for (k = base - 1, p = pows(i); k >= 1; --k) { + t = p * k; + if (t < u) continue; + if (t > v) break; + z.push(t); + } + } + } else { + z = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.ticks + )(i, j, Math.min(j - i, n)).map(pows); + } + + return r ? z.reverse() : z; + }; + + scale.tickFormat = function (count, specifier) { + if (specifier == null) + specifier = base === 10 ? ".0e" : ","; + if (typeof specifier !== "function") + specifier = Object( + d3_format__WEBPACK_IMPORTED_MODULE_1__.format + )(specifier); + if (count === Infinity) return specifier; + if (count == null) count = 10; + var k = Math.max(1, (base * count) / scale.ticks().length); // TODO fast estimate? + + return function (d) { + var i = d / pows(Math.round(logs(d))); + if (i * base < base - 0.5) i *= base; + return i <= k ? specifier(d) : ""; + }; + }; + + scale.nice = function () { + return domain( + Object(_nice__WEBPACK_IMPORTED_MODULE_2__.default)( + domain(), + { + floor: function floor(x) { + return pows(Math.floor(logs(x))); + }, + ceil: function ceil(x) { + return pows(Math.ceil(logs(x))); + }, + } + ) + ); + }; + + return scale; + } + function log() { + var scale = loggish( + Object( + _continuous__WEBPACK_IMPORTED_MODULE_3__.transformer + )() + ).domain([1, 10]); + + scale.copy = function () { + return Object( + _continuous__WEBPACK_IMPORTED_MODULE_3__.copy + )(scale, log()).base(scale.base()); + }; + + _init__WEBPACK_IMPORTED_MODULE_4__.initRange.apply( + scale, + arguments + ); + return scale; + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/nice.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-scale/src/nice.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (domain, interval) { + domain = domain.slice(); + var i0 = 0, + i1 = domain.length - 1, + x0 = domain[i0], + x1 = domain[i1], + t; + + if (x1 < x0) { + (t = i0), (i0 = i1), (i1 = t); + (t = x0), (x0 = x1), (x1 = t); + } + + domain[i0] = interval.floor(x0); + domain[i1] = interval.ceil(x1); + return domain; + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/number.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-scale/src/number.js ***! + \*********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return Number(x); + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/ordinal.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-scale/src/ordinal.js ***! + \**********************************************/ + /* ! exports provided: implicit, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "implicit", + function () { + return implicit; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return ordinal; + } + ); + /* Harmony import */ var d3_collection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-collection */ "./node_modules/d3-collection/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-scale/src/array.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + var implicit = { + name: "implicit", + }; + function ordinal() { + var index = Object( + d3_collection__WEBPACK_IMPORTED_MODULE_0__.map + )(), + domain = [], + range = [], + unknown = implicit; + + function scale(d) { + var key = String(d), + i = index.get(key); + + if (!i) { + if (unknown !== implicit) return unknown; + index.set(key, (i = domain.push(d))); + } + + return range[(i - 1) % range.length]; + } + + scale.domain = function (_) { + if (!arguments.length) return domain.slice(); + (domain = []), + (index = Object( + d3_collection__WEBPACK_IMPORTED_MODULE_0__.map + )()); + var i = -1, + n = _.length, + d, + key; + + while (++i < n) { + if (!index.has((key = String(d = _[i])))) + index.set(key, domain.push(d)); + } + + return scale; + }; + + scale.range = function (_) { + return arguments.length + ? ((range = _array__WEBPACK_IMPORTED_MODULE_1__.slice.call(_)), + scale) + : range.slice(); + }; + + scale.unknown = function (_) { + return arguments.length ? ((unknown = _), scale) : unknown; + }; + + scale.copy = function () { + return ordinal(domain, range).unknown(unknown); + }; + + _init__WEBPACK_IMPORTED_MODULE_2__.initRange.apply( + scale, + arguments + ); + return scale; + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/pow.js": + /* !******************************************!*\ + !*** ./node_modules/d3-scale/src/pow.js ***! + \******************************************/ + /* ! exports provided: powish, default, sqrt */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "powish", + function () { + return powish; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return pow; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sqrt", + function () { + return sqrt; + } + ); + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-scale/src/linear.js" + ); + /* Harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./continuous */ "./node_modules/d3-scale/src/continuous.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + function transformPow(exponent) { + return function (x) { + return x < 0 + ? -Math.pow(-x, exponent) + : Math.pow(x, exponent); + }; + } + + function transformSqrt(x) { + return x < 0 ? -Math.sqrt(-x) : Math.sqrt(x); + } + + function transformSquare(x) { + return x < 0 ? -x * x : x * x; + } + + function powish(transform) { + var scale = transform( + _continuous__WEBPACK_IMPORTED_MODULE_1__.identity, + _continuous__WEBPACK_IMPORTED_MODULE_1__.identity + ), + exponent = 1; + + function rescale() { + return exponent === 1 + ? transform( + _continuous__WEBPACK_IMPORTED_MODULE_1__.identity, + _continuous__WEBPACK_IMPORTED_MODULE_1__.identity + ) + : exponent === 0.5 + ? transform(transformSqrt, transformSquare) + : transform( + transformPow(exponent), + transformPow(1 / exponent) + ); + } + + scale.exponent = function (_) { + return arguments.length + ? ((exponent = Number(_)), rescale()) + : exponent; + }; + + return Object( + _linear__WEBPACK_IMPORTED_MODULE_0__.linearish + )(scale); + } + function pow() { + var scale = powish( + Object( + _continuous__WEBPACK_IMPORTED_MODULE_1__.transformer + )() + ); + + scale.copy = function () { + return Object( + _continuous__WEBPACK_IMPORTED_MODULE_1__.copy + )(scale, pow()).exponent(scale.exponent()); + }; + + _init__WEBPACK_IMPORTED_MODULE_2__.initRange.apply( + scale, + arguments + ); + return scale; + } + function sqrt() { + return pow.apply(null, arguments).exponent(0.5); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/quantile.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-scale/src/quantile.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return quantile; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-scale/src/array.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + function quantile() { + var domain = [], + range = [], + thresholds = [], + unknown; + + function rescale() { + var i = 0, + n = Math.max(1, range.length); + thresholds = new Array(n - 1); + + while (++i < n) { + thresholds[i - 1] = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.quantile + )(domain, i / n); + } + + return scale; + } + + function scale(x) { + return isNaN((x = Number(x))) + ? unknown + : range[ + Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.bisect + )(thresholds, x) + ]; + } + + scale.invertExtent = function (y) { + var i = range.indexOf(y); + return i < 0 + ? [NaN, NaN] + : [ + i > 0 ? thresholds[i - 1] : domain[0], + i < thresholds.length + ? thresholds[i] + : domain[domain.length - 1], + ]; + }; + + scale.domain = function (_) { + if (!arguments.length) return domain.slice(); + domain = []; + + for (var i = 0, n = _.length, d; i < n; ++i) { + if (((d = _[i]), d != null && !isNaN((d = Number(d))))) + domain.push(d); + } + + domain.sort( + d3_array__WEBPACK_IMPORTED_MODULE_0__.ascending + ); + return rescale(); + }; + + scale.range = function (_) { + return arguments.length + ? ((range = _array__WEBPACK_IMPORTED_MODULE_1__.slice.call(_)), + rescale()) + : range.slice(); + }; + + scale.unknown = function (_) { + return arguments.length ? ((unknown = _), scale) : unknown; + }; + + scale.quantiles = function () { + return thresholds.slice(); + }; + + scale.copy = function () { + return quantile() + .domain(domain) + .range(range) + .unknown(unknown); + }; + + return _init__WEBPACK_IMPORTED_MODULE_2__.initRange.apply( + scale, + arguments + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/quantize.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-scale/src/quantize.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return quantize; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-scale/src/array.js" + ); + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-scale/src/linear.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + function quantize() { + var x0 = 0, + x1 = 1, + n = 1, + domain = [0.5], + range = [0, 1], + unknown; + + function scale(x) { + return x <= x + ? range[ + Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.bisect + )(domain, x, 0, n) + ] + : unknown; + } + + function rescale() { + var i = -1; + domain = new Array(n); + + while (++i < n) { + domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1); + } + + return scale; + } + + scale.domain = function (_) { + return arguments.length + ? ((x0 = Number(_[0])), (x1 = Number(_[1])), rescale()) + : [x0, x1]; + }; + + scale.range = function (_) { + return arguments.length + ? ((n = + (range = _array__WEBPACK_IMPORTED_MODULE_1__.slice.call(_)).length - 1), + rescale()) + : range.slice(); + }; + + scale.invertExtent = function (y) { + var i = range.indexOf(y); + return i < 0 + ? [NaN, NaN] + : i < 1 + ? [x0, domain[0]] + : i >= n + ? [domain[n - 1], x1] + : [domain[i - 1], domain[i]]; + }; + + scale.unknown = function (_) { + return arguments.length ? ((unknown = _), scale) : scale; + }; + + scale.thresholds = function () { + return domain.slice(); + }; + + scale.copy = function () { + return quantize() + .domain([x0, x1]) + .range(range) + .unknown(unknown); + }; + + return _init__WEBPACK_IMPORTED_MODULE_3__.initRange.apply( + Object(_linear__WEBPACK_IMPORTED_MODULE_2__.linearish)( + scale + ), + arguments + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/sequential.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-scale/src/sequential.js ***! + \*************************************************/ + /* ! exports provided: copy, default, sequentialLog, sequentialSymlog, sequentialPow, sequentialSqrt */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "copy", + function () { + return copy; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return sequential; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sequentialLog", + function () { + return sequentialLog; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sequentialSymlog", + function () { + return sequentialSymlog; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sequentialPow", + function () { + return sequentialPow; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sequentialSqrt", + function () { + return sequentialSqrt; + } + ); + /* Harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./continuous */ "./node_modules/d3-scale/src/continuous.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-scale/src/linear.js" + ); + /* Harmony import */ var _log__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./log */ "./node_modules/d3-scale/src/log.js" + ); + /* Harmony import */ var _symlog__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./symlog */ "./node_modules/d3-scale/src/symlog.js" + ); + /* Harmony import */ var _pow__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./pow */ "./node_modules/d3-scale/src/pow.js" + ); + + function transformer() { + var x0 = 0, + x1 = 1, + t0, + t1, + k10, + transform, + interpolator = + _continuous__WEBPACK_IMPORTED_MODULE_0__.identity, + clamp = false, + unknown; + + function scale(x) { + return isNaN((x = Number(x))) + ? unknown + : interpolator( + k10 === 0 + ? 0.5 + : ((x = (transform(x) - t0) * k10), + clamp ? Math.max(0, Math.min(1, x)) : x) + ); + } + + scale.domain = function (_) { + return arguments.length + ? ((t0 = transform((x0 = Number(_[0])))), + (t1 = transform((x1 = Number(_[1])))), + (k10 = t0 === t1 ? 0 : 1 / (t1 - t0)), + scale) + : [x0, x1]; + }; + + scale.clamp = function (_) { + return arguments.length ? ((clamp = Boolean(_)), scale) : clamp; + }; + + scale.interpolator = function (_) { + return arguments.length + ? ((interpolator = _), scale) + : interpolator; + }; + + scale.unknown = function (_) { + return arguments.length ? ((unknown = _), scale) : unknown; + }; + + return function (t) { + (transform = t), + (t0 = t(x0)), + (t1 = t(x1)), + (k10 = t0 === t1 ? 0 : 1 / (t1 - t0)); + return scale; + }; + } + + function copy(source, target) { + return target + .domain(source.domain()) + .interpolator(source.interpolator()) + .clamp(source.clamp()) + .unknown(source.unknown()); + } + function sequential() { + var scale = Object( + _linear__WEBPACK_IMPORTED_MODULE_2__.linearish + )( + transformer()( + _continuous__WEBPACK_IMPORTED_MODULE_0__.identity + ) + ); + + scale.copy = function () { + return copy(scale, sequential()); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initInterpolator.apply(scale, arguments); + } + function sequentialLog() { + var scale = Object( + _log__WEBPACK_IMPORTED_MODULE_3__.loggish + )(transformer()).domain([1, 10]); + + scale.copy = function () { + return copy(scale, sequentialLog()).base(scale.base()); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initInterpolator.apply(scale, arguments); + } + function sequentialSymlog() { + var scale = Object( + _symlog__WEBPACK_IMPORTED_MODULE_4__.symlogish + )(transformer()); + + scale.copy = function () { + return copy(scale, sequentialSymlog()).constant( + scale.constant() + ); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initInterpolator.apply(scale, arguments); + } + function sequentialPow() { + var scale = Object(_pow__WEBPACK_IMPORTED_MODULE_5__.powish)( + transformer() + ); + + scale.copy = function () { + return copy(scale, sequentialPow()).exponent( + scale.exponent() + ); + }; + + return _init__WEBPACK_IMPORTED_MODULE_1__.initInterpolator.apply(scale, arguments); + } + function sequentialSqrt() { + return sequentialPow.apply(null, arguments).exponent(0.5); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/sequentialQuantile.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-scale/src/sequentialQuantile.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return sequentialQuantile; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./continuous */ "./node_modules/d3-scale/src/continuous.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + function sequentialQuantile() { + var domain = [], + interpolator = + _continuous__WEBPACK_IMPORTED_MODULE_1__.identity; + + function scale(x) { + if (!isNaN((x = Number(x)))) + return interpolator( + (Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.bisect + )(domain, x) - + 1) / + (domain.length - 1) + ); + } + + scale.domain = function (_) { + if (!arguments.length) return domain.slice(); + domain = []; + + for (var i = 0, n = _.length, d; i < n; ++i) { + if (((d = _[i]), d != null && !isNaN((d = Number(d))))) + domain.push(d); + } + + domain.sort( + d3_array__WEBPACK_IMPORTED_MODULE_0__.ascending + ); + return scale; + }; + + scale.interpolator = function (_) { + return arguments.length + ? ((interpolator = _), scale) + : interpolator; + }; + + scale.copy = function () { + return sequentialQuantile(interpolator).domain(domain); + }; + + return _init__WEBPACK_IMPORTED_MODULE_2__.initInterpolator.apply(scale, arguments); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/symlog.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-scale/src/symlog.js ***! + \*********************************************/ + /* ! exports provided: symlogish, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "symlogish", + function () { + return symlogish; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return symlog; + } + ); + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-scale/src/linear.js" + ); + /* Harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./continuous */ "./node_modules/d3-scale/src/continuous.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + function transformSymlog(c) { + return function (x) { + return Math.sign(x) * Math.log1p(Math.abs(x / c)); + }; + } + + function transformSymexp(c) { + return function (x) { + return Math.sign(x) * Math.expm1(Math.abs(x)) * c; + }; + } + + function symlogish(transform) { + var c = 1, + scale = transform(transformSymlog(c), transformSymexp(c)); + + scale.constant = function (_) { + return arguments.length + ? transform( + transformSymlog((c = Number(_))), + transformSymexp(c) + ) + : c; + }; + + return Object( + _linear__WEBPACK_IMPORTED_MODULE_0__.linearish + )(scale); + } + function symlog() { + var scale = symlogish( + Object( + _continuous__WEBPACK_IMPORTED_MODULE_1__.transformer + )() + ); + + scale.copy = function () { + return Object( + _continuous__WEBPACK_IMPORTED_MODULE_1__.copy + )(scale, symlog()).constant(scale.constant()); + }; + + return _init__WEBPACK_IMPORTED_MODULE_2__.initRange.apply( + scale, + arguments + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/threshold.js": + /* !************************************************!*\ + !*** ./node_modules/d3-scale/src/threshold.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return threshold; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-scale/src/array.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + function threshold() { + var domain = [0.5], + range = [0, 1], + unknown, + n = 1; + + function scale(x) { + return x <= x + ? range[ + Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.bisect + )(domain, x, 0, n) + ] + : unknown; + } + + scale.domain = function (_) { + return arguments.length + ? ((domain = _array__WEBPACK_IMPORTED_MODULE_1__.slice.call(_)), + (n = Math.min(domain.length, range.length - 1)), + scale) + : domain.slice(); + }; + + scale.range = function (_) { + return arguments.length + ? ((range = _array__WEBPACK_IMPORTED_MODULE_1__.slice.call(_)), + (n = Math.min(domain.length, range.length - 1)), + scale) + : range.slice(); + }; + + scale.invertExtent = function (y) { + var i = range.indexOf(y); + return [domain[i - 1], domain[i]]; + }; + + scale.unknown = function (_) { + return arguments.length ? ((unknown = _), scale) : unknown; + }; + + scale.copy = function () { + return threshold() + .domain(domain) + .range(range) + .unknown(unknown); + }; + + return _init__WEBPACK_IMPORTED_MODULE_2__.initRange.apply( + scale, + arguments + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/tickFormat.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-scale/src/tickFormat.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-format */ "./node_modules/d3-format/src/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (start, stop, count, specifier) { + var step = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.tickStep + )(start, stop, count), + precision; + specifier = Object( + d3_format__WEBPACK_IMPORTED_MODULE_1__.formatSpecifier + )(specifier == null ? ",f" : specifier); + + switch (specifier.type) { + case "s": { + var value = Math.max(Math.abs(start), Math.abs(stop)); + if ( + specifier.precision == null && + !isNaN( + (precision = Object( + d3_format__WEBPACK_IMPORTED_MODULE_1__.precisionPrefix + )(step, value)) + ) + ) + specifier.precision = precision; + return Object( + d3_format__WEBPACK_IMPORTED_MODULE_1__.formatPrefix + )(specifier, value); + } + + case "": + case "e": + case "g": + case "p": + case "r": { + if ( + specifier.precision == null && + !isNaN( + (precision = Object( + d3_format__WEBPACK_IMPORTED_MODULE_1__.precisionRound + )( + step, + Math.max(Math.abs(start), Math.abs(stop)) + )) + ) + ) + specifier.precision = + precision - (specifier.type === "e"); + break; + } + + case "f": + case "%": { + if ( + specifier.precision == null && + !isNaN( + (precision = Object( + d3_format__WEBPACK_IMPORTED_MODULE_1__.precisionFixed + )(step)) + ) + ) + specifier.precision = + precision - (specifier.type === "%") * 2; + break; + } + } + + return Object(d3_format__WEBPACK_IMPORTED_MODULE_1__.format)( + specifier + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/time.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-scale/src/time.js ***! + \*******************************************/ + /* ! exports provided: calendar, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "calendar", + function () { + return calendar; + } + ); + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-time */ "./node_modules/d3-time/src/index.js" + ); + /* Harmony import */ var d3_time_format__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-time-format */ "./node_modules/d3-time-format/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-scale/src/array.js" + ); + /* Harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./continuous */ "./node_modules/d3-scale/src/continuous.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + /* Harmony import */ var _nice__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./nice */ "./node_modules/d3-scale/src/nice.js" + ); + + var durationSecond = 1000, + durationMinute = durationSecond * 60, + durationHour = durationMinute * 60, + durationDay = durationHour * 24, + durationWeek = durationDay * 7, + durationMonth = durationDay * 30, + durationYear = durationDay * 365; + + function date(t) { + return new Date(t); + } + + function number(t) { + return t instanceof Date ? Number(t) : Number(new Date(Number(t))); + } + + function calendar( + year, + month, + week, + day, + hour, + minute, + second, + millisecond, + format + ) { + var scale = Object( + _continuous__WEBPACK_IMPORTED_MODULE_4__.default + )( + _continuous__WEBPACK_IMPORTED_MODULE_4__.identity, + _continuous__WEBPACK_IMPORTED_MODULE_4__.identity + ), + invert = scale.invert, + domain = scale.domain; + var formatMillisecond = format(".%L"), + formatSecond = format(":%S"), + formatMinute = format("%I:%M"), + formatHour = format("%I %p"), + formatDay = format("%a %d"), + formatWeek = format("%b %d"), + formatMonth = format("%B"), + formatYear = format("%Y"); + var tickIntervals = [ + [second, 1, durationSecond], + [second, 5, 5 * durationSecond], + [second, 15, 15 * durationSecond], + [second, 30, 30 * durationSecond], + [minute, 1, durationMinute], + [minute, 5, 5 * durationMinute], + [minute, 15, 15 * durationMinute], + [minute, 30, 30 * durationMinute], + [hour, 1, durationHour], + [hour, 3, 3 * durationHour], + [hour, 6, 6 * durationHour], + [hour, 12, 12 * durationHour], + [day, 1, durationDay], + [day, 2, 2 * durationDay], + [week, 1, durationWeek], + [month, 1, durationMonth], + [month, 3, 3 * durationMonth], + [year, 1, durationYear], + ]; + + function tickFormat(date) { + return (second(date) < date + ? formatMillisecond + : minute(date) < date + ? formatSecond + : hour(date) < date + ? formatMinute + : day(date) < date + ? formatHour + : month(date) < date + ? week(date) < date + ? formatDay + : formatWeek + : year(date) < date + ? formatMonth + : formatYear)(date); + } + + function tickInterval(interval, start, stop, step) { + if (interval == null) interval = 10; // If a desired tick count is specified, pick a reasonable tick interval + // based on the extent of the domain and a rough estimate of tick size. + // Otherwise, assume interval is already a time interval and use it. + + if (typeof interval === "number") { + var target = Math.abs(stop - start) / interval, + i = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.bisector + )(function (i) { + return i[2]; + }).right(tickIntervals, target); + + if (i === tickIntervals.length) { + step = Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.tickStep + )( + start / durationYear, + stop / durationYear, + interval + ); + interval = year; + } else if (i) { + i = + tickIntervals[ + target / tickIntervals[i - 1][2] < + tickIntervals[i][2] / target + ? i - 1 + : i + ]; + step = i[1]; + interval = i[0]; + } else { + step = Math.max( + Object( + d3_array__WEBPACK_IMPORTED_MODULE_0__.tickStep + )(start, stop, interval), + 1 + ); + interval = millisecond; + } + } + + return step == null ? interval : interval.every(step); + } + + scale.invert = function (y) { + return new Date(invert(y)); + }; + + scale.domain = function (_) { + return arguments.length + ? domain( + _array__WEBPACK_IMPORTED_MODULE_3__.map.call( + _, + number + ) + ) + : domain().map(date); + }; + + scale.ticks = function (interval, step) { + var d = domain(), + t0 = d[0], + t1 = d[d.length - 1], + r = t1 < t0, + t; + if (r) (t = t0), (t0 = t1), (t1 = t); + t = tickInterval(interval, t0, t1, step); + t = t ? t.range(t0, t1 + 1) : []; // Inclusive stop + + return r ? t.reverse() : t; + }; + + scale.tickFormat = function (count, specifier) { + return specifier == null ? tickFormat : format(specifier); + }; + + scale.nice = function (interval, step) { + var d = domain(); + return (interval = tickInterval( + interval, + d[0], + d[d.length - 1], + step + )) + ? domain( + Object( + _nice__WEBPACK_IMPORTED_MODULE_6__.default + )(d, interval) + ) + : scale; + }; + + scale.copy = function () { + return Object( + _continuous__WEBPACK_IMPORTED_MODULE_4__.copy + )( + scale, + calendar( + year, + month, + week, + day, + hour, + minute, + second, + millisecond, + format + ) + ); + }; + + return scale; + } + /* Harmony default export */ __webpack_exports__.default = function () { + return _init__WEBPACK_IMPORTED_MODULE_5__.initRange.apply( + calendar( + d3_time__WEBPACK_IMPORTED_MODULE_1__.timeYear, + d3_time__WEBPACK_IMPORTED_MODULE_1__.timeMonth, + d3_time__WEBPACK_IMPORTED_MODULE_1__.timeWeek, + d3_time__WEBPACK_IMPORTED_MODULE_1__.timeDay, + d3_time__WEBPACK_IMPORTED_MODULE_1__.timeHour, + d3_time__WEBPACK_IMPORTED_MODULE_1__.timeMinute, + d3_time__WEBPACK_IMPORTED_MODULE_1__.timeSecond, + d3_time__WEBPACK_IMPORTED_MODULE_1__.timeMillisecond, + d3_time_format__WEBPACK_IMPORTED_MODULE_2__.timeFormat + ).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]), + arguments + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-scale/src/utcTime.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-scale/src/utcTime.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _time__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./time */ "./node_modules/d3-scale/src/time.js" + ); + /* Harmony import */ var d3_time_format__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-time-format */ "./node_modules/d3-time-format/src/index.js" + ); + /* Harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-time */ "./node_modules/d3-time/src/index.js" + ); + /* Harmony import */ var _init__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./init */ "./node_modules/d3-scale/src/init.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + return _init__WEBPACK_IMPORTED_MODULE_3__.initRange.apply( + Object(_time__WEBPACK_IMPORTED_MODULE_0__.calendar)( + d3_time__WEBPACK_IMPORTED_MODULE_2__.utcYear, + d3_time__WEBPACK_IMPORTED_MODULE_2__.utcMonth, + d3_time__WEBPACK_IMPORTED_MODULE_2__.utcWeek, + d3_time__WEBPACK_IMPORTED_MODULE_2__.utcDay, + d3_time__WEBPACK_IMPORTED_MODULE_2__.utcHour, + d3_time__WEBPACK_IMPORTED_MODULE_2__.utcMinute, + d3_time__WEBPACK_IMPORTED_MODULE_2__.utcSecond, + d3_time__WEBPACK_IMPORTED_MODULE_2__.utcMillisecond, + d3_time_format__WEBPACK_IMPORTED_MODULE_1__.utcFormat + ).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]), + arguments + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/constant.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-selection/src/constant.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/create.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-selection/src/create.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _creator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./creator */ "./node_modules/d3-selection/src/creator.js" + ); + /* Harmony import */ var _select__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./select */ "./node_modules/d3-selection/src/select.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (name) { + return Object(_select__WEBPACK_IMPORTED_MODULE_1__.default)( + Object(_creator__WEBPACK_IMPORTED_MODULE_0__.default)( + name + ).call(document.documentElement) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/creator.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-selection/src/creator.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _namespace__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./namespace */ "./node_modules/d3-selection/src/namespace.js" + ); + /* Harmony import */ var _namespaces__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./namespaces */ "./node_modules/d3-selection/src/namespaces.js" + ); + + function creatorInherit(name) { + return function () { + var document = this.ownerDocument, + uri = this.namespaceURI; + return uri === + _namespaces__WEBPACK_IMPORTED_MODULE_1__.xhtml && + document.documentElement.namespaceURI === + _namespaces__WEBPACK_IMPORTED_MODULE_1__.xhtml + ? document.createElement(name) + : document.createElementNS(uri, name); + }; + } + + function creatorFixed(fullname) { + return function () { + return this.ownerDocument.createElementNS( + fullname.space, + fullname.local + ); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name) { + var fullname = Object( + _namespace__WEBPACK_IMPORTED_MODULE_0__.default + )(name); + return (fullname.local ? creatorFixed : creatorInherit)( + fullname + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/index.js": + /* !************************************************!*\ + !*** ./node_modules/d3-selection/src/index.js ***! + \************************************************/ + /* ! exports provided: create, creator, local, matcher, mouse, namespace, namespaces, clientPoint, select, selectAll, selection, selector, selectorAll, style, touch, touches, window, event, customEvent */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _create__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./create */ "./node_modules/d3-selection/src/create.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "create", + function () { + return _create__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _creator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./creator */ "./node_modules/d3-selection/src/creator.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "creator", + function () { + return _creator__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _local__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./local */ "./node_modules/d3-selection/src/local.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "local", + function () { + return _local__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _matcher__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./matcher */ "./node_modules/d3-selection/src/matcher.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "matcher", + function () { + return _matcher__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _mouse__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./mouse */ "./node_modules/d3-selection/src/mouse.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "mouse", + function () { + return _mouse__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _namespace__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./namespace */ "./node_modules/d3-selection/src/namespace.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "namespace", + function () { + return _namespace__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _namespaces__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./namespaces */ "./node_modules/d3-selection/src/namespaces.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "namespaces", + function () { + return _namespaces__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony import */ var _point__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./point */ "./node_modules/d3-selection/src/point.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "clientPoint", + function () { + return _point__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /* Harmony import */ var _select__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./select */ "./node_modules/d3-selection/src/select.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "select", + function () { + return _select__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony import */ var _selectAll__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./selectAll */ "./node_modules/d3-selection/src/selectAll.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "selectAll", + function () { + return _selectAll__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony import */ var _selection_index__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./selection/index */ "./node_modules/d3-selection/src/selection/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "selection", + function () { + return _selection_index__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony import */ var _selector__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./selector */ "./node_modules/d3-selection/src/selector.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "selector", + function () { + return _selector__WEBPACK_IMPORTED_MODULE_11__.default; + } + ); + + /* Harmony import */ var _selectorAll__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./selectorAll */ "./node_modules/d3-selection/src/selectorAll.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "selectorAll", + function () { + return _selectorAll__WEBPACK_IMPORTED_MODULE_12__.default; + } + ); + + /* Harmony import */ var _selection_style__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./selection/style */ "./node_modules/d3-selection/src/selection/style.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "style", + function () { + return _selection_style__WEBPACK_IMPORTED_MODULE_13__.styleValue; + } + ); + + /* Harmony import */ var _touch__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./touch */ "./node_modules/d3-selection/src/touch.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "touch", + function () { + return _touch__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /* Harmony import */ var _touches__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./touches */ "./node_modules/d3-selection/src/touches.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "touches", + function () { + return _touches__WEBPACK_IMPORTED_MODULE_15__.default; + } + ); + + /* Harmony import */ var _window__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! ./window */ "./node_modules/d3-selection/src/window.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "window", + function () { + return _window__WEBPACK_IMPORTED_MODULE_16__.default; + } + ); + + /* Harmony import */ var _selection_on__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! ./selection/on */ "./node_modules/d3-selection/src/selection/on.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "event", + function () { + return _selection_on__WEBPACK_IMPORTED_MODULE_17__.event; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "customEvent", + function () { + return _selection_on__WEBPACK_IMPORTED_MODULE_17__.customEvent; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/local.js": + /* !************************************************!*\ + !*** ./node_modules/d3-selection/src/local.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return local; + } + ); + var nextId = 0; + function local() { + return new Local(); + } + + function Local() { + this._ = "@" + (++nextId).toString(36); + } + + Local.prototype = local.prototype = { + constructor: Local, + get: function get(node) { + var id = this._; + + while (!(id in node)) { + if (!(node = node.parentNode)) return; + } + + return node[id]; + }, + set: function set(node, value) { + return (node[this._] = value); + }, + remove: function remove(node) { + return this._ in node && delete node[this._]; + }, + toString: function toString() { + return this._; + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/matcher.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-selection/src/matcher.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (selector) { + return function () { + return this.matches(selector); + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/mouse.js": + /* !************************************************!*\ + !*** ./node_modules/d3-selection/src/mouse.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _sourceEvent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./sourceEvent */ "./node_modules/d3-selection/src/sourceEvent.js" + ); + /* Harmony import */ var _point__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./point */ "./node_modules/d3-selection/src/point.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (node) { + var event = Object( + _sourceEvent__WEBPACK_IMPORTED_MODULE_0__.default + )(); + if (event.changedTouches) event = event.changedTouches[0]; + return Object(_point__WEBPACK_IMPORTED_MODULE_1__.default)( + node, + event + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/namespace.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-selection/src/namespace.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _namespaces__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./namespaces */ "./node_modules/d3-selection/src/namespaces.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (name) { + var prefix = (name = String(name)), + i = prefix.indexOf(":"); + if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") + name = name.slice(i + 1); + return _namespaces__WEBPACK_IMPORTED_MODULE_0__.default.hasOwnProperty(prefix) + ? { + space: + _namespaces__WEBPACK_IMPORTED_MODULE_0__.default[prefix], + local: name, + } + : name; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/namespaces.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-selection/src/namespaces.js ***! + \*****************************************************/ + /* ! exports provided: xhtml, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "xhtml", + function () { + return xhtml; + } + ); + var xhtml = "http://www.w3.org/1999/xhtml"; + /* Harmony default export */ __webpack_exports__.default = { + svg: "http://www.w3.org/2000/svg", + xhtml: xhtml, + xlink: "http://www.w3.org/1999/xlink", + xml: "http://www.w3.org/XML/1998/namespace", + xmlns: "http://www.w3.org/2000/xmlns/", + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/point.js": + /* !************************************************!*\ + !*** ./node_modules/d3-selection/src/point.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (node, event) { + var svg = node.ownerSVGElement || node; + + if (svg.createSVGPoint) { + var point = svg.createSVGPoint(); + (point.x = event.clientX), (point.y = event.clientY); + point = point.matrixTransform( + node.getScreenCTM().inverse() + ); + return [point.x, point.y]; + } + + var rect = node.getBoundingClientRect(); + return [ + event.clientX - rect.left - node.clientLeft, + event.clientY - rect.top - node.clientTop, + ]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/select.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-selection/src/select.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _selection_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./selection/index */ "./node_modules/d3-selection/src/selection/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (selector) { + return typeof selector === "string" + ? new _selection_index__WEBPACK_IMPORTED_MODULE_0__.Selection( + [[document.querySelector(selector)]], + [document.documentElement] + ) + : new _selection_index__WEBPACK_IMPORTED_MODULE_0__.Selection( + [[selector]], + _selection_index__WEBPACK_IMPORTED_MODULE_0__.root + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selectAll.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-selection/src/selectAll.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _selection_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./selection/index */ "./node_modules/d3-selection/src/selection/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (selector) { + return typeof selector === "string" + ? new _selection_index__WEBPACK_IMPORTED_MODULE_0__.Selection( + [document.querySelectorAll(selector)], + [document.documentElement] + ) + : new _selection_index__WEBPACK_IMPORTED_MODULE_0__.Selection( + [selector == null ? [] : selector], + _selection_index__WEBPACK_IMPORTED_MODULE_0__.root + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/append.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/append.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _creator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../creator */ "./node_modules/d3-selection/src/creator.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (name) { + var create = + typeof name === "function" + ? name + : Object( + _creator__WEBPACK_IMPORTED_MODULE_0__.default + )(name); + return this.select(function () { + return this.appendChild(create.apply(this, arguments)); + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/attr.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/attr.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _namespace__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../namespace */ "./node_modules/d3-selection/src/namespace.js" + ); + + function attrRemove(name) { + return function () { + this.removeAttribute(name); + }; + } + + function attrRemoveNS(fullname) { + return function () { + this.removeAttributeNS(fullname.space, fullname.local); + }; + } + + function attrConstant(name, value) { + return function () { + this.setAttribute(name, value); + }; + } + + function attrConstantNS(fullname, value) { + return function () { + this.setAttributeNS(fullname.space, fullname.local, value); + }; + } + + function attrFunction(name, value) { + return function () { + var v = value.apply(this, arguments); + if (v == null) this.removeAttribute(name); + else this.setAttribute(name, v); + }; + } + + function attrFunctionNS(fullname, value) { + return function () { + var v = value.apply(this, arguments); + if (v == null) + this.removeAttributeNS(fullname.space, fullname.local); + else this.setAttributeNS(fullname.space, fullname.local, v); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value) { + var fullname = Object( + _namespace__WEBPACK_IMPORTED_MODULE_0__.default + )(name); + + if (arguments.length < 2) { + var node = this.node(); + return fullname.local + ? node.getAttributeNS(fullname.space, fullname.local) + : node.getAttribute(fullname); + } + + return this.each( + (value == null + ? fullname.local + ? attrRemoveNS + : attrRemove + : typeof value === "function" + ? fullname.local + ? attrFunctionNS + : attrFunction + : fullname.local + ? attrConstantNS + : attrConstant)(fullname, value) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/call.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/call.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var callback = arguments[0]; + arguments[0] = this; + callback.apply(null, arguments); + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/classed.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/classed.js ***! + \************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function classArray(string) { + return string.trim().split(/^|\s+/); + } + + function classList(node) { + return node.classList || new ClassList(node); + } + + function ClassList(node) { + this._node = node; + this._names = classArray(node.getAttribute("class") || ""); + } + + ClassList.prototype = { + add: function add(name) { + var i = this._names.indexOf(name); + + if (i < 0) { + this._names.push(name); + + this._node.setAttribute("class", this._names.join(" ")); + } + }, + remove: function remove(name) { + var i = this._names.indexOf(name); + + if (i >= 0) { + this._names.splice(i, 1); + + this._node.setAttribute("class", this._names.join(" ")); + } + }, + contains: function contains(name) { + return this._names.indexOf(name) >= 0; + }, + }; + + function classedAdd(node, names) { + var list = classList(node), + i = -1, + n = names.length; + + while (++i < n) { + list.add(names[i]); + } + } + + function classedRemove(node, names) { + var list = classList(node), + i = -1, + n = names.length; + + while (++i < n) { + list.remove(names[i]); + } + } + + function classedTrue(names) { + return function () { + classedAdd(this, names); + }; + } + + function classedFalse(names) { + return function () { + classedRemove(this, names); + }; + } + + function classedFunction(names, value) { + return function () { + (value.apply(this, arguments) ? classedAdd : classedRemove)( + this, + names + ); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value) { + var names = classArray(String(name)); + + if (arguments.length < 2) { + var list = classList(this.node()), + i = -1, + n = names.length; + + while (++i < n) { + if (!list.contains(names[i])) return false; + } + + return true; + } + + return this.each( + (typeof value === "function" + ? classedFunction + : value + ? classedTrue + : classedFalse)(names, value) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/clone.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/clone.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function selection_cloneShallow() { + return this.parentNode.insertBefore( + this.cloneNode(false), + this.nextSibling + ); + } + + function selection_cloneDeep() { + return this.parentNode.insertBefore( + this.cloneNode(true), + this.nextSibling + ); + } + + /* Harmony default export */ __webpack_exports__.default = function (deep) { + return this.select( + deep ? selection_cloneDeep : selection_cloneShallow + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/data.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/data.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-selection/src/selection/index.js" + ); + /* Harmony import */ var _enter__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./enter */ "./node_modules/d3-selection/src/selection/enter.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../constant */ "./node_modules/d3-selection/src/constant.js" + ); + + var keyPrefix = "$"; // Protect against keys like “__proto__”. + + function bindIndex(parent, group, enter, update, exit, data) { + var i = 0, + node, + groupLength = group.length, + dataLength = data.length; // Put any non-null nodes that fit into update. + // Put any null nodes into enter. + // Put any remaining data into enter. + + for (; i < dataLength; ++i) { + if ((node = group[i])) { + node.__data__ = data[i]; + update[i] = node; + } else { + enter[i] = new _enter__WEBPACK_IMPORTED_MODULE_1__.EnterNode(parent, data[i]); + } + } // Put any non-null nodes that don’t fit into exit. + + for (; i < groupLength; ++i) { + if ((node = group[i])) { + exit[i] = node; + } + } + } + + function bindKey(parent, group, enter, update, exit, data, key) { + var i, + node, + nodeByKeyValue = {}, + groupLength = group.length, + dataLength = data.length, + keyValues = new Array(groupLength), + keyValue; // Compute the key for each node. + // If multiple nodes have the same key, the duplicates are added to exit. + + for (i = 0; i < groupLength; ++i) { + if ((node = group[i])) { + keyValues[i] = keyValue = + keyPrefix + key.call(node, node.__data__, i, group); + + if (keyValue in nodeByKeyValue) { + exit[i] = node; + } else { + nodeByKeyValue[keyValue] = node; + } + } + } // Compute the key for each datum. + // If there a node associated with this key, join and add it to update. + // If there is not (or the key is a duplicate), add it to enter. + + for (i = 0; i < dataLength; ++i) { + keyValue = keyPrefix + key.call(parent, data[i], i, data); + + if ((node = nodeByKeyValue[keyValue])) { + update[i] = node; + node.__data__ = data[i]; + nodeByKeyValue[keyValue] = null; + } else { + enter[i] = new _enter__WEBPACK_IMPORTED_MODULE_1__.EnterNode(parent, data[i]); + } + } // Add any remaining nodes that were not bound to data to exit. + + for (i = 0; i < groupLength; ++i) { + if ( + (node = group[i]) && + nodeByKeyValue[keyValues[i]] === node + ) { + exit[i] = node; + } + } + } + + /* Harmony default export */ __webpack_exports__.default = function (value, key) { + if (!value) { + (data = new Array(this.size())), (j = -1); + this.each(function (d) { + data[++j] = d; + }); + return data; + } + + var bind = key ? bindKey : bindIndex, + parents = this._parents, + groups = this._groups; + if (typeof value !== "function") + value = Object( + _constant__WEBPACK_IMPORTED_MODULE_2__.default + )(value); + + for ( + var m = groups.length, + update = new Array(m), + enter = new Array(m), + exit = new Array(m), + j = 0; + j < m; + ++j + ) { + var parent = parents[j], + group = groups[j], + groupLength = group.length, + data = value.call( + parent, + parent && parent.__data__, + j, + parents + ), + dataLength = data.length, + enterGroup = (enter[j] = new Array(dataLength)), + updateGroup = (update[j] = new Array(dataLength)), + exitGroup = (exit[j] = new Array(groupLength)); + bind( + parent, + group, + enterGroup, + updateGroup, + exitGroup, + data, + key + ); // Now connect the enter nodes to their following update node, such that + // appendChild can insert the materialized enter node before this node, + // rather than at the end of the parent node. + + for ( + var i0 = 0, i1 = 0, previous, next; + i0 < dataLength; + ++i0 + ) { + if ((previous = enterGroup[i0])) { + if (i0 >= i1) i1 = i0 + 1; + + while ( + !(next = updateGroup[i1]) && + ++i1 < dataLength + ) {} + + previous._next = next || null; + } + } + } + + update = new _index__WEBPACK_IMPORTED_MODULE_0__.Selection( + update, + parents + ); + update._enter = enter; + update._exit = exit; + return update; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/datum.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/datum.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (value) { + return arguments.length + ? this.property("__data__", value) + : this.node().__data__; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/dispatch.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/dispatch.js ***! + \*************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _window__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../window */ "./node_modules/d3-selection/src/window.js" + ); + + function dispatchEvent(node, type, params) { + var window = Object( + _window__WEBPACK_IMPORTED_MODULE_0__.default + )(node), + event = window.CustomEvent; + + if (typeof event === "function") { + event = new event(type, params); + } else { + event = window.document.createEvent("Event"); + if (params) + event.initEvent( + type, + params.bubbles, + params.cancelable + ), + (event.detail = params.detail); + else event.initEvent(type, false, false); + } + + node.dispatchEvent(event); + } + + function dispatchConstant(type, params) { + return function () { + return dispatchEvent(this, type, params); + }; + } + + function dispatchFunction(type, params) { + return function () { + return dispatchEvent( + this, + type, + params.apply(this, arguments) + ); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (type, params) { + return this.each( + (typeof params === "function" + ? dispatchFunction + : dispatchConstant)(type, params) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/each.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/each.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (callback) { + for ( + var groups = this._groups, j = 0, m = groups.length; + j < m; + ++j + ) { + for ( + var group = groups[j], i = 0, n = group.length, node; + i < n; + ++i + ) { + if ((node = group[i])) + callback.call(node, node.__data__, i, group); + } + } + + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/empty.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/empty.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + return !this.node(); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/enter.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/enter.js ***! + \**********************************************************/ + /* ! exports provided: default, EnterNode */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "EnterNode", + function () { + return EnterNode; + } + ); + /* Harmony import */ var _sparse__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./sparse */ "./node_modules/d3-selection/src/selection/sparse.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-selection/src/selection/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + return new _index__WEBPACK_IMPORTED_MODULE_1__.Selection( + this._enter || + this._groups.map( + _sparse__WEBPACK_IMPORTED_MODULE_0__.default + ), + this._parents + ); + }; + function EnterNode(parent, datum) { + this.ownerDocument = parent.ownerDocument; + this.namespaceURI = parent.namespaceURI; + this._next = null; + this._parent = parent; + this.__data__ = datum; + } + EnterNode.prototype = { + constructor: EnterNode, + appendChild: function appendChild(child) { + return this._parent.insertBefore(child, this._next); + }, + insertBefore: function insertBefore(child, next) { + return this._parent.insertBefore(child, next); + }, + querySelector: function querySelector(selector) { + return this._parent.querySelector(selector); + }, + querySelectorAll: function querySelectorAll(selector) { + return this._parent.querySelectorAll(selector); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/exit.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/exit.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _sparse__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./sparse */ "./node_modules/d3-selection/src/selection/sparse.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-selection/src/selection/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + return new _index__WEBPACK_IMPORTED_MODULE_1__.Selection( + this._exit || + this._groups.map( + _sparse__WEBPACK_IMPORTED_MODULE_0__.default + ), + this._parents + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/filter.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/filter.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-selection/src/selection/index.js" + ); + /* Harmony import */ var _matcher__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../matcher */ "./node_modules/d3-selection/src/matcher.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (match) { + if (typeof match !== "function") + match = Object( + _matcher__WEBPACK_IMPORTED_MODULE_1__.default + )(match); + + for ( + var groups = this._groups, + m = groups.length, + subgroups = new Array(m), + j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], + n = group.length, + subgroup = (subgroups[j] = []), + node, + i = 0; + i < n; + ++i + ) { + if ( + (node = group[i]) && + match.call(node, node.__data__, i, group) + ) { + subgroup.push(node); + } + } + } + + return new _index__WEBPACK_IMPORTED_MODULE_0__.Selection( + subgroups, + this._parents + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/html.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/html.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function htmlRemove() { + this.innerHTML = ""; + } + + function htmlConstant(value) { + return function () { + this.innerHTML = value; + }; + } + + function htmlFunction(value) { + return function () { + var v = value.apply(this, arguments); + this.innerHTML = v == null ? "" : v; + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (value) { + return arguments.length + ? this.each( + value == null + ? htmlRemove + : (typeof value === "function" + ? htmlFunction + : htmlConstant)(value) + ) + : this.node().innerHTML; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/index.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/index.js ***! + \**********************************************************/ + /* ! exports provided: root, Selection, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "root", + function () { + return root; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Selection", + function () { + return Selection; + } + ); + /* Harmony import */ var _select__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./select */ "./node_modules/d3-selection/src/selection/select.js" + ); + /* Harmony import */ var _selectAll__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./selectAll */ "./node_modules/d3-selection/src/selection/selectAll.js" + ); + /* Harmony import */ var _filter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./filter */ "./node_modules/d3-selection/src/selection/filter.js" + ); + /* Harmony import */ var _data__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./data */ "./node_modules/d3-selection/src/selection/data.js" + ); + /* Harmony import */ var _enter__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./enter */ "./node_modules/d3-selection/src/selection/enter.js" + ); + /* Harmony import */ var _exit__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./exit */ "./node_modules/d3-selection/src/selection/exit.js" + ); + /* Harmony import */ var _join__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./join */ "./node_modules/d3-selection/src/selection/join.js" + ); + /* Harmony import */ var _merge__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./merge */ "./node_modules/d3-selection/src/selection/merge.js" + ); + /* Harmony import */ var _order__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./order */ "./node_modules/d3-selection/src/selection/order.js" + ); + /* Harmony import */ var _sort__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./sort */ "./node_modules/d3-selection/src/selection/sort.js" + ); + /* Harmony import */ var _call__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./call */ "./node_modules/d3-selection/src/selection/call.js" + ); + /* Harmony import */ var _nodes__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./nodes */ "./node_modules/d3-selection/src/selection/nodes.js" + ); + /* Harmony import */ var _node__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./node */ "./node_modules/d3-selection/src/selection/node.js" + ); + /* Harmony import */ var _size__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./size */ "./node_modules/d3-selection/src/selection/size.js" + ); + /* Harmony import */ var _empty__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./empty */ "./node_modules/d3-selection/src/selection/empty.js" + ); + /* Harmony import */ var _each__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./each */ "./node_modules/d3-selection/src/selection/each.js" + ); + /* Harmony import */ var _attr__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! ./attr */ "./node_modules/d3-selection/src/selection/attr.js" + ); + /* Harmony import */ var _style__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! ./style */ "./node_modules/d3-selection/src/selection/style.js" + ); + /* Harmony import */ var _property__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__( + /* ! ./property */ "./node_modules/d3-selection/src/selection/property.js" + ); + /* Harmony import */ var _classed__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__( + /* ! ./classed */ "./node_modules/d3-selection/src/selection/classed.js" + ); + /* Harmony import */ var _text__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__( + /* ! ./text */ "./node_modules/d3-selection/src/selection/text.js" + ); + /* Harmony import */ var _html__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__( + /* ! ./html */ "./node_modules/d3-selection/src/selection/html.js" + ); + /* Harmony import */ var _raise__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__( + /* ! ./raise */ "./node_modules/d3-selection/src/selection/raise.js" + ); + /* Harmony import */ var _lower__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__( + /* ! ./lower */ "./node_modules/d3-selection/src/selection/lower.js" + ); + /* Harmony import */ var _append__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__( + /* ! ./append */ "./node_modules/d3-selection/src/selection/append.js" + ); + /* Harmony import */ var _insert__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__( + /* ! ./insert */ "./node_modules/d3-selection/src/selection/insert.js" + ); + /* Harmony import */ var _remove__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__( + /* ! ./remove */ "./node_modules/d3-selection/src/selection/remove.js" + ); + /* Harmony import */ var _clone__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__( + /* ! ./clone */ "./node_modules/d3-selection/src/selection/clone.js" + ); + /* Harmony import */ var _datum__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__( + /* ! ./datum */ "./node_modules/d3-selection/src/selection/datum.js" + ); + /* Harmony import */ var _on__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__( + /* ! ./on */ "./node_modules/d3-selection/src/selection/on.js" + ); + /* Harmony import */ var _dispatch__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__( + /* ! ./dispatch */ "./node_modules/d3-selection/src/selection/dispatch.js" + ); + + var root = [null]; + function Selection(groups, parents) { + this._groups = groups; + this._parents = parents; + } + + function selection() { + return new Selection([[document.documentElement]], root); + } + + Selection.prototype = selection.prototype = { + constructor: Selection, + select: _select__WEBPACK_IMPORTED_MODULE_0__.default, + selectAll: _selectAll__WEBPACK_IMPORTED_MODULE_1__.default, + filter: _filter__WEBPACK_IMPORTED_MODULE_2__.default, + data: _data__WEBPACK_IMPORTED_MODULE_3__.default, + enter: _enter__WEBPACK_IMPORTED_MODULE_4__.default, + exit: _exit__WEBPACK_IMPORTED_MODULE_5__.default, + join: _join__WEBPACK_IMPORTED_MODULE_6__.default, + merge: _merge__WEBPACK_IMPORTED_MODULE_7__.default, + order: _order__WEBPACK_IMPORTED_MODULE_8__.default, + sort: _sort__WEBPACK_IMPORTED_MODULE_9__.default, + call: _call__WEBPACK_IMPORTED_MODULE_10__.default, + nodes: _nodes__WEBPACK_IMPORTED_MODULE_11__.default, + node: _node__WEBPACK_IMPORTED_MODULE_12__.default, + size: _size__WEBPACK_IMPORTED_MODULE_13__.default, + empty: _empty__WEBPACK_IMPORTED_MODULE_14__.default, + each: _each__WEBPACK_IMPORTED_MODULE_15__.default, + attr: _attr__WEBPACK_IMPORTED_MODULE_16__.default, + style: _style__WEBPACK_IMPORTED_MODULE_17__.default, + property: _property__WEBPACK_IMPORTED_MODULE_18__.default, + classed: _classed__WEBPACK_IMPORTED_MODULE_19__.default, + text: _text__WEBPACK_IMPORTED_MODULE_20__.default, + html: _html__WEBPACK_IMPORTED_MODULE_21__.default, + raise: _raise__WEBPACK_IMPORTED_MODULE_22__.default, + lower: _lower__WEBPACK_IMPORTED_MODULE_23__.default, + append: _append__WEBPACK_IMPORTED_MODULE_24__.default, + insert: _insert__WEBPACK_IMPORTED_MODULE_25__.default, + remove: _remove__WEBPACK_IMPORTED_MODULE_26__.default, + clone: _clone__WEBPACK_IMPORTED_MODULE_27__.default, + datum: _datum__WEBPACK_IMPORTED_MODULE_28__.default, + on: _on__WEBPACK_IMPORTED_MODULE_29__.default, + dispatch: _dispatch__WEBPACK_IMPORTED_MODULE_30__.default, + }; + /* Harmony default export */ __webpack_exports__.default = selection; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/insert.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/insert.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _creator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../creator */ "./node_modules/d3-selection/src/creator.js" + ); + /* Harmony import */ var _selector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../selector */ "./node_modules/d3-selection/src/selector.js" + ); + + function constantNull() { + return null; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, before) { + var create = + typeof name === "function" + ? name + : Object( + _creator__WEBPACK_IMPORTED_MODULE_0__.default + )(name), + select = + before == null + ? constantNull + : typeof before === "function" + ? before + : Object( + _selector__WEBPACK_IMPORTED_MODULE_1__.default + )(before); + return this.select(function () { + return this.insertBefore( + create.apply(this, arguments), + select.apply(this, arguments) || null + ); + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/join.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/join.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (onenter, onupdate, onexit) { + var enter = this.enter(), + update = this, + exit = this.exit(); + enter = + typeof onenter === "function" + ? onenter(enter) + : enter.append(String(onenter)); + if (onupdate != null) update = onupdate(update); + if (onexit == null) exit.remove(); + else onexit(exit); + return enter && update ? enter.merge(update).order() : update; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/lower.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/lower.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function lower() { + if (this.previousSibling) + this.parentNode.insertBefore( + this, + this.parentNode.firstChild + ); + } + + /* Harmony default export */ __webpack_exports__.default = function () { + return this.each(lower); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/merge.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/merge.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-selection/src/selection/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (selection) { + for ( + var groups0 = this._groups, + groups1 = selection._groups, + m0 = groups0.length, + m1 = groups1.length, + m = Math.min(m0, m1), + merges = new Array(m0), + j = 0; + j < m; + ++j + ) { + for ( + var group0 = groups0[j], + group1 = groups1[j], + n = group0.length, + merge = (merges[j] = new Array(n)), + node, + i = 0; + i < n; + ++i + ) { + if ((node = group0[i] || group1[i])) { + merge[i] = node; + } + } + } + + for (; j < m0; ++j) { + merges[j] = groups0[j]; + } + + return new _index__WEBPACK_IMPORTED_MODULE_0__.Selection( + merges, + this._parents + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/node.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/node.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + for ( + var groups = this._groups, j = 0, m = groups.length; + j < m; + ++j + ) { + for ( + var group = groups[j], i = 0, n = group.length; + i < n; + ++i + ) { + var node = group[i]; + if (node) return node; + } + } + + return null; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/nodes.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/nodes.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var nodes = new Array(this.size()), + i = -1; + this.each(function () { + nodes[++i] = this; + }); + return nodes; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/on.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/on.js ***! + \*******************************************************/ + /* ! exports provided: event, default, customEvent */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "event", + function () { + return event; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "customEvent", + function () { + return customEvent; + } + ); + var filterEvents = {}; + var event = null; + + if (typeof document !== "undefined") { + var element = document.documentElement; + + if (!("onmouseenter" in element)) { + filterEvents = { + mouseenter: "mouseover", + mouseleave: "mouseout", + }; + } + } + + function filterContextListener(listener, index, group) { + listener = contextListener(listener, index, group); + return function (event) { + var related = event.relatedTarget; + + if ( + !related || + (related !== this && + !(related.compareDocumentPosition(this) & 8)) + ) { + listener.call(this, event); + } + }; + } + + function contextListener(listener, index, group) { + return function (event1) { + var event0 = event; // Events can be reentrant (e.g., focus). + + event = event1; + + try { + listener.call(this, this.__data__, index, group); + } finally { + event = event0; + } + }; + } + + function parseTypenames(typenames) { + return typenames + .trim() + .split(/^|\s+/) + .map(function (t) { + var name = "", + i = t.indexOf("."); + if (i >= 0) + (name = t.slice(i + 1)), (t = t.slice(0, i)); + return { + type: t, + name: name, + }; + }); + } + + function onRemove(typename) { + return function () { + var on = this.__on; + if (!on) return; + + for (var j = 0, i = -1, m = on.length, o; j < m; ++j) { + if ( + ((o = on[j]), + (!typename.type || o.type === typename.type) && + o.name === typename.name) + ) { + this.removeEventListener( + o.type, + o.listener, + o.capture + ); + } else { + on[++i] = o; + } + } + + if (++i) on.length = i; + else delete this.__on; + }; + } + + function onAdd(typename, value, capture) { + var wrap = filterEvents.hasOwnProperty(typename.type) + ? filterContextListener + : contextListener; + return function (d, i, group) { + var on = this.__on, + o, + listener = wrap(value, i, group); + if (on) + for (var j = 0, m = on.length; j < m; ++j) { + if ( + (o = on[j]).type === typename.type && + o.name === typename.name + ) { + this.removeEventListener( + o.type, + o.listener, + o.capture + ); + this.addEventListener( + o.type, + (o.listener = listener), + (o.capture = capture) + ); + o.value = value; + return; + } + } + this.addEventListener(typename.type, listener, capture); + o = { + type: typename.type, + name: typename.name, + value: value, + listener: listener, + capture: capture, + }; + if (!on) this.__on = [o]; + else on.push(o); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (typename, value, capture) { + var typenames = parseTypenames(String(typename)), + i, + n = typenames.length, + t; + + if (arguments.length < 2) { + var on = this.node().__on; + + if (on) + for (var j = 0, m = on.length, o; j < m; ++j) { + for (i = 0, o = on[j]; i < n; ++i) { + if ( + (t = typenames[i]).type === o.type && + t.name === o.name + ) { + return o.value; + } + } + } + return; + } + + on = value ? onAdd : onRemove; + if (capture == null) capture = false; + + for (i = 0; i < n; ++i) { + this.each(on(typenames[i], value, capture)); + } + + return this; + }; + function customEvent(event1, listener, that, args) { + var event0 = event; + event1.sourceEvent = event; + event = event1; + + try { + return listener.apply(that, args); + } finally { + event = event0; + } + } + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/order.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/order.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + for ( + var groups = this._groups, j = -1, m = groups.length; + ++j < m; + + ) { + for ( + var group = groups[j], + i = group.length - 1, + next = group[i], + node; + --i >= 0; + + ) { + if ((node = group[i])) { + if (next && node.compareDocumentPosition(next) ^ 4) + next.parentNode.insertBefore(node, next); + next = node; + } + } + } + + return this; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/property.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/property.js ***! + \*************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function propertyRemove(name) { + return function () { + delete this[name]; + }; + } + + function propertyConstant(name, value) { + return function () { + this[name] = value; + }; + } + + function propertyFunction(name, value) { + return function () { + var v = value.apply(this, arguments); + if (v == null) delete this[name]; + else this[name] = v; + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value) { + return arguments.length > 1 + ? this.each( + (value == null + ? propertyRemove + : typeof value === "function" + ? propertyFunction + : propertyConstant)(name, value) + ) + : this.node()[name]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/raise.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/raise.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function raise() { + if (this.nextSibling) this.parentNode.appendChild(this); + } + + /* Harmony default export */ __webpack_exports__.default = function () { + return this.each(raise); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/remove.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/remove.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function remove() { + var parent = this.parentNode; + if (parent) parent.removeChild(this); + } + + /* Harmony default export */ __webpack_exports__.default = function () { + return this.each(remove); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/select.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/select.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-selection/src/selection/index.js" + ); + /* Harmony import */ var _selector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../selector */ "./node_modules/d3-selection/src/selector.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (select) { + if (typeof select !== "function") + select = Object( + _selector__WEBPACK_IMPORTED_MODULE_1__.default + )(select); + + for ( + var groups = this._groups, + m = groups.length, + subgroups = new Array(m), + j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], + n = group.length, + subgroup = (subgroups[j] = new Array(n)), + node, + subnode, + i = 0; + i < n; + ++i + ) { + if ( + (node = group[i]) && + (subnode = select.call( + node, + node.__data__, + i, + group + )) + ) { + if ("__data__" in node) + subnode.__data__ = node.__data__; + subgroup[i] = subnode; + } + } + } + + return new _index__WEBPACK_IMPORTED_MODULE_0__.Selection( + subgroups, + this._parents + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/selectAll.js": + /* !**************************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/selectAll.js ***! + \**************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-selection/src/selection/index.js" + ); + /* Harmony import */ var _selectorAll__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../selectorAll */ "./node_modules/d3-selection/src/selectorAll.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (select) { + if (typeof select !== "function") + select = Object( + _selectorAll__WEBPACK_IMPORTED_MODULE_1__.default + )(select); + + for ( + var groups = this._groups, + m = groups.length, + subgroups = [], + parents = [], + j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], n = group.length, node, i = 0; + i < n; + ++i + ) { + if ((node = group[i])) { + subgroups.push( + select.call(node, node.__data__, i, group) + ); + parents.push(node); + } + } + } + + return new _index__WEBPACK_IMPORTED_MODULE_0__.Selection( + subgroups, + parents + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/size.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/size.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () { + var size = 0; + this.each(function () { + ++size; + }); + return size; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/sort.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/sort.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-selection/src/selection/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (compare) { + if (!compare) compare = ascending; + + function compareNode(a, b) { + return a && b ? compare(a.__data__, b.__data__) : !a - !b; + } + + for ( + var groups = this._groups, + m = groups.length, + sortgroups = new Array(m), + j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], + n = group.length, + sortgroup = (sortgroups[j] = new Array(n)), + node, + i = 0; + i < n; + ++i + ) { + if ((node = group[i])) { + sortgroup[i] = node; + } + } + + sortgroup.sort(compareNode); + } + + return new _index__WEBPACK_IMPORTED_MODULE_0__.Selection( + sortgroups, + this._parents + ).order(); + }; + + function ascending(a, b) { + return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; + } + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/sparse.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/sparse.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (update) { + return new Array(update.length); + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/style.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/style.js ***! + \**********************************************************/ + /* ! exports provided: default, styleValue */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "styleValue", + function () { + return styleValue; + } + ); + /* Harmony import */ var _window__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../window */ "./node_modules/d3-selection/src/window.js" + ); + + function styleRemove(name) { + return function () { + this.style.removeProperty(name); + }; + } + + function styleConstant(name, value, priority) { + return function () { + this.style.setProperty(name, value, priority); + }; + } + + function styleFunction(name, value, priority) { + return function () { + var v = value.apply(this, arguments); + if (v == null) this.style.removeProperty(name); + else this.style.setProperty(name, v, priority); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value, priority) { + return arguments.length > 1 + ? this.each( + (value == null + ? styleRemove + : typeof value === "function" + ? styleFunction + : styleConstant)( + name, + value, + priority == null ? "" : priority + ) + ) + : styleValue(this.node(), name); + }; + function styleValue(node, name) { + return ( + node.style.getPropertyValue(name) || + Object(_window__WEBPACK_IMPORTED_MODULE_0__.default)( + node + ) + .getComputedStyle(node, null) + .getPropertyValue(name) + ); + } + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selection/text.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-selection/src/selection/text.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function textRemove() { + this.textContent = ""; + } + + function textConstant(value) { + return function () { + this.textContent = value; + }; + } + + function textFunction(value) { + return function () { + var v = value.apply(this, arguments); + this.textContent = v == null ? "" : v; + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (value) { + return arguments.length + ? this.each( + value == null + ? textRemove + : (typeof value === "function" + ? textFunction + : textConstant)(value) + ) + : this.node().textContent; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selector.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-selection/src/selector.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function none() {} + + /* Harmony default export */ __webpack_exports__.default = function (selector) { + return selector == null + ? none + : function () { + return this.querySelector(selector); + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/selectorAll.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-selection/src/selectorAll.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function empty() { + return []; + } + + /* Harmony default export */ __webpack_exports__.default = function (selector) { + return selector == null + ? empty + : function () { + return this.querySelectorAll(selector); + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/sourceEvent.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-selection/src/sourceEvent.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _selection_on__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./selection/on */ "./node_modules/d3-selection/src/selection/on.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var current = + _selection_on__WEBPACK_IMPORTED_MODULE_0__.event, + source; + + while ((source = current.sourceEvent)) { + current = source; + } + + return current; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/touch.js": + /* !************************************************!*\ + !*** ./node_modules/d3-selection/src/touch.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _sourceEvent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./sourceEvent */ "./node_modules/d3-selection/src/sourceEvent.js" + ); + /* Harmony import */ var _point__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./point */ "./node_modules/d3-selection/src/point.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (node, touches, identifier) { + if (arguments.length < 3) + (identifier = touches), + (touches = Object( + _sourceEvent__WEBPACK_IMPORTED_MODULE_0__.default + )().changedTouches); + + for ( + var i = 0, n = touches ? touches.length : 0, touch; + i < n; + ++i + ) { + if ((touch = touches[i]).identifier === identifier) { + return Object( + _point__WEBPACK_IMPORTED_MODULE_1__.default + )(node, touch); + } + } + + return null; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/touches.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-selection/src/touches.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _sourceEvent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./sourceEvent */ "./node_modules/d3-selection/src/sourceEvent.js" + ); + /* Harmony import */ var _point__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./point */ "./node_modules/d3-selection/src/point.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (node, touches) { + if (touches == null) + touches = Object( + _sourceEvent__WEBPACK_IMPORTED_MODULE_0__.default + )().touches; + + for ( + var i = 0, + n = touches ? touches.length : 0, + points = new Array(n); + i < n; + ++i + ) { + points[i] = Object( + _point__WEBPACK_IMPORTED_MODULE_1__.default + )(node, touches[i]); + } + + return points; + }; + + /***/ + }, + + /***/ "./node_modules/d3-selection/src/window.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-selection/src/window.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (node) { + return ( + (node.ownerDocument && node.ownerDocument.defaultView) || // Node is a Node + (node.document && node) || // Node is a Window + node.defaultView + ); // Node is a Document + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/arc.js": + /* !******************************************!*\ + !*** ./node_modules/d3-shape/src/arc.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-path */ "./node_modules/d3-path/src/index.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-shape/src/constant.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-shape/src/math.js" + ); + + function arcInnerRadius(d) { + return d.innerRadius; + } + + function arcOuterRadius(d) { + return d.outerRadius; + } + + function arcStartAngle(d) { + return d.startAngle; + } + + function arcEndAngle(d) { + return d.endAngle; + } + + function arcPadAngle(d) { + return d && d.padAngle; // Note: optional! + } + + function intersect(x0, y0, x1, y1, x2, y2, x3, y3) { + var x10 = x1 - x0, + y10 = y1 - y0, + x32 = x3 - x2, + y32 = y3 - y2, + t = y32 * x10 - x32 * y10; + if (t * t < _math__WEBPACK_IMPORTED_MODULE_2__.epsilon) + return; + t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t; + return [x0 + t * x10, y0 + t * y10]; + } // Compute perpendicular offset line of length rc. + // http://mathworld.wolfram.com/Circle-LineIntersection.html + + function cornerTangents(x0, y0, x1, y1, r1, rc, cw) { + var x01 = x0 - x1, + y01 = y0 - y1, + lo = + (cw ? rc : -rc) / + Object(_math__WEBPACK_IMPORTED_MODULE_2__.sqrt)( + x01 * x01 + y01 * y01 + ), + ox = lo * y01, + oy = -lo * x01, + x11 = x0 + ox, + y11 = y0 + oy, + x10 = x1 + ox, + y10 = y1 + oy, + x00 = (x11 + x10) / 2, + y00 = (y11 + y10) / 2, + dx = x10 - x11, + dy = y10 - y11, + d2 = dx * dx + dy * dy, + r = r1 - rc, + D = x11 * y10 - x10 * y11, + d = + (dy < 0 ? -1 : 1) * + Object(_math__WEBPACK_IMPORTED_MODULE_2__.sqrt)( + Object(_math__WEBPACK_IMPORTED_MODULE_2__.max)( + 0, + r * r * d2 - D * D + ) + ), + cx0 = (D * dy - dx * d) / d2, + cy0 = (-D * dx - dy * d) / d2, + cx1 = (D * dy + dx * d) / d2, + cy1 = (-D * dx + dy * d) / d2, + dx0 = cx0 - x00, + dy0 = cy0 - y00, + dx1 = cx1 - x00, + dy1 = cy1 - y00; // Pick the closer of the two intersection points. + // TODO Is there a faster way to determine which intersection to use? + + if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) + (cx0 = cx1), (cy0 = cy1); + return { + cx: cx0, + cy: cy0, + x01: -ox, + y01: -oy, + x11: cx0 * (r1 / r - 1), + y11: cy0 * (r1 / r - 1), + }; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var innerRadius = arcInnerRadius, + outerRadius = arcOuterRadius, + cornerRadius = Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(0), + padRadius = null, + startAngle = arcStartAngle, + endAngle = arcEndAngle, + padAngle = arcPadAngle, + context = null; + + function arc() { + var buffer, + r, + r0 = Number(innerRadius.apply(this, arguments)), + r1 = Number(outerRadius.apply(this, arguments)), + a0 = + startAngle.apply(this, arguments) - + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi, + a1 = + endAngle.apply(this, arguments) - + _math__WEBPACK_IMPORTED_MODULE_2__.halfPi, + da = Object(_math__WEBPACK_IMPORTED_MODULE_2__.abs)( + a1 - a0 + ), + cw = a1 > a0; + if (!context) + context = buffer = Object( + d3_path__WEBPACK_IMPORTED_MODULE_0__.path + )(); // Ensure that the outer radius is always larger than the inner radius. + + if (r1 < r0) (r = r1), (r1 = r0), (r0 = r); // Is it a point? + + if (!(r1 > _math__WEBPACK_IMPORTED_MODULE_2__.epsilon)) + context.moveTo(0, 0); + // Or is it a circle or annulus? + else if ( + da > + _math__WEBPACK_IMPORTED_MODULE_2__.tau - + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) { + context.moveTo( + r1 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(a0), + r1 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(a0) + ); + context.arc(0, 0, r1, a0, a1, !cw); + + if ( + r0 > _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) { + context.moveTo( + r0 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(a1), + r0 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(a1) + ); + context.arc(0, 0, r0, a1, a0, cw); + } + } // Or is it a circular or annular sector? + else { + var a01 = a0, + a11 = a1, + a00 = a0, + a10 = a1, + da0 = da, + da1 = da, + ap = padAngle.apply(this, arguments) / 2, + rp = + ap > + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon && + (padRadius + ? Number(padRadius.apply(this, arguments)) + : Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sqrt + )(r0 * r0 + r1 * r1)), + rc = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.min + )( + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.abs + )(r1 - r0) / 2, + Number(cornerRadius.apply(this, arguments)) + ), + rc0 = rc, + rc1 = rc, + t0, + t1; // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0. + + if ( + rp > _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) { + var p0 = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.asin + )( + (rp / r0) * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(ap) + ), + p1 = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.asin + )( + (rp / r1) * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(ap) + ); + if ( + (da0 -= p0 * 2) > + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) + (p0 *= cw ? 1 : -1), (a00 += p0), (a10 -= p0); + else (da0 = 0), (a00 = a10 = (a0 + a1) / 2); + if ( + (da1 -= p1 * 2) > + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) + (p1 *= cw ? 1 : -1), (a01 += p1), (a11 -= p1); + else (da1 = 0), (a01 = a11 = (a0 + a1) / 2); + } + + var x01 = + r1 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(a01), + y01 = + r1 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(a01), + x10 = + r0 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(a10), + y10 = + r0 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(a10); // Apply rounded corners? + + if ( + rc > _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) { + var x11 = + r1 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(a11), + y11 = + r1 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(a11), + x00 = + r0 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.cos + )(a00), + y00 = + r0 * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )(a00), + oc; // Restrict the corner radius according to the sector angle. + + if ( + da < _math__WEBPACK_IMPORTED_MODULE_2__.pi && + (oc = intersect( + x01, + y01, + x00, + y00, + x11, + y11, + x10, + y10 + )) + ) { + var ax = x01 - oc[0], + ay = y01 - oc[1], + bx = x11 - oc[0], + by = y11 - oc[1], + kc = + 1 / + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sin + )( + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.acos + )( + (ax * bx + ay * by) / + (Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sqrt + )(ax * ax + ay * ay) * + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sqrt + )(bx * bx + by * by)) + ) / 2 + ), + lc = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.sqrt + )(oc[0] * oc[0] + oc[1] * oc[1]); + rc0 = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.min + )(rc, (r0 - lc) / (kc - 1)); + rc1 = Object( + _math__WEBPACK_IMPORTED_MODULE_2__.min + )(rc, (r1 - lc) / (kc + 1)); + } + } // Is the sector collapsed to a line? + + if ( + !( + da1 > + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) + ) + context.moveTo(x01, y01); + // Does the sector’s outer ring have rounded corners? + else if ( + rc1 > _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) { + t0 = cornerTangents( + x00, + y00, + x01, + y01, + r1, + rc1, + cw + ); + t1 = cornerTangents( + x11, + y11, + x10, + y10, + r1, + rc1, + cw + ); + context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01); // Have the corners merged? + + if (rc1 < rc) + context.arc( + t0.cx, + t0.cy, + rc1, + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t0.y01, t0.x01), + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t1.y01, t1.x01), + !cw + ); + // Otherwise, draw the two corners and the ring. + else { + context.arc( + t0.cx, + t0.cy, + rc1, + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t0.y01, t0.x01), + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t0.y11, t0.x11), + !cw + ); + context.arc( + 0, + 0, + r1, + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t0.cy + t0.y11, t0.cx + t0.x11), + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t1.cy + t1.y11, t1.cx + t1.x11), + !cw + ); + context.arc( + t1.cx, + t1.cy, + rc1, + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t1.y11, t1.x11), + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t1.y01, t1.x01), + !cw + ); + } + } // Or is the outer ring just a circular arc? + else + context.moveTo(x01, y01), + context.arc(0, 0, r1, a01, a11, !cw); // Is there no inner ring, and it’s a circular sector? + // Or perhaps it’s an annular sector collapsed due to padding? + + if ( + !( + r0 > + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) || + !( + da0 > + _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) + ) + context.lineTo(x10, y10); + // Does the sector’s inner ring (or point) have rounded corners? + else if ( + rc0 > _math__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) { + t0 = cornerTangents( + x10, + y10, + x11, + y11, + r0, + -rc0, + cw + ); + t1 = cornerTangents( + x01, + y01, + x00, + y00, + r0, + -rc0, + cw + ); + context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01); // Have the corners merged? + + if (rc0 < rc) + context.arc( + t0.cx, + t0.cy, + rc0, + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t0.y01, t0.x01), + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t1.y01, t1.x01), + !cw + ); + // Otherwise, draw the two corners and the ring. + else { + context.arc( + t0.cx, + t0.cy, + rc0, + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t0.y01, t0.x01), + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t0.y11, t0.x11), + !cw + ); + context.arc( + 0, + 0, + r0, + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t0.cy + t0.y11, t0.cx + t0.x11), + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t1.cy + t1.y11, t1.cx + t1.x11), + cw + ); + context.arc( + t1.cx, + t1.cy, + rc0, + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t1.y11, t1.x11), + Object( + _math__WEBPACK_IMPORTED_MODULE_2__.atan2 + )(t1.y01, t1.x01), + !cw + ); + } + } // Or is the inner ring just a circular arc? + else context.arc(0, 0, r0, a10, a00, cw); + } + context.closePath(); + if (buffer) return (context = null), String(buffer) || null; + } + + arc.centroid = function () { + var r = + (Number(innerRadius.apply(this, arguments)) + + Number(outerRadius.apply(this, arguments))) / + 2, + a = + (Number(startAngle.apply(this, arguments)) + + Number(endAngle.apply(this, arguments))) / + 2 - + _math__WEBPACK_IMPORTED_MODULE_2__.pi / 2; + return [ + Object(_math__WEBPACK_IMPORTED_MODULE_2__.cos)(a) * + r, + Object(_math__WEBPACK_IMPORTED_MODULE_2__.sin)(a) * + r, + ]; + }; + + arc.innerRadius = function (_) { + return arguments.length + ? ((innerRadius = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + arc) + : innerRadius; + }; + + arc.outerRadius = function (_) { + return arguments.length + ? ((outerRadius = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + arc) + : outerRadius; + }; + + arc.cornerRadius = function (_) { + return arguments.length + ? ((cornerRadius = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + arc) + : cornerRadius; + }; + + arc.padRadius = function (_) { + return arguments.length + ? ((padRadius = + _ == null + ? null + : typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + arc) + : padRadius; + }; + + arc.startAngle = function (_) { + return arguments.length + ? ((startAngle = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + arc) + : startAngle; + }; + + arc.endAngle = function (_) { + return arguments.length + ? ((endAngle = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + arc) + : endAngle; + }; + + arc.padAngle = function (_) { + return arguments.length + ? ((padAngle = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + arc) + : padAngle; + }; + + arc.context = function (_) { + return arguments.length + ? ((context = _ == null ? null : _), arc) + : context; + }; + + return arc; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/area.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-shape/src/area.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-path */ "./node_modules/d3-path/src/index.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-shape/src/constant.js" + ); + /* Harmony import */ var _curve_linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./curve/linear */ "./node_modules/d3-shape/src/curve/linear.js" + ); + /* Harmony import */ var _line__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./line */ "./node_modules/d3-shape/src/line.js" + ); + /* Harmony import */ var _point__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./point */ "./node_modules/d3-shape/src/point.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var x0 = _point__WEBPACK_IMPORTED_MODULE_4__.x, + x1 = null, + y0 = Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(0), + y1 = _point__WEBPACK_IMPORTED_MODULE_4__.y, + defined = Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(true), + context = null, + curve = + _curve_linear__WEBPACK_IMPORTED_MODULE_2__.default, + output = null; + + function area(data) { + var i, + j, + k, + n = data.length, + d, + defined0 = false, + buffer, + x0z = new Array(n), + y0z = new Array(n); + if (context == null) + output = curve( + (buffer = Object( + d3_path__WEBPACK_IMPORTED_MODULE_0__.path + )()) + ); + + for (i = 0; i <= n; ++i) { + if ( + !(i < n && defined((d = data[i]), i, data)) === + defined0 + ) { + if ((defined0 = !defined0)) { + j = i; + output.areaStart(); + output.lineStart(); + } else { + output.lineEnd(); + output.lineStart(); + + for (k = i - 1; k >= j; --k) { + output.point(x0z[k], y0z[k]); + } + + output.lineEnd(); + output.areaEnd(); + } + } + + if (defined0) { + (x0z[i] = Number(x0(d, i, data))), + (y0z[i] = Number(y0(d, i, data))); + output.point( + x1 ? Number(x1(d, i, data)) : x0z[i], + y1 ? Number(y1(d, i, data)) : y0z[i] + ); + } + } + + if (buffer) return (output = null), String(buffer) || null; + } + + function arealine() { + return Object( + _line__WEBPACK_IMPORTED_MODULE_3__.default + )() + .defined(defined) + .curve(curve) + .context(context); + } + + area.x = function (_) { + return arguments.length + ? ((x0 = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + (x1 = null), + area) + : x0; + }; + + area.x0 = function (_) { + return arguments.length + ? ((x0 = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + area) + : x0; + }; + + area.x1 = function (_) { + return arguments.length + ? ((x1 = + _ == null + ? null + : typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + area) + : x1; + }; + + area.y = function (_) { + return arguments.length + ? ((y0 = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + (y1 = null), + area) + : y0; + }; + + area.y0 = function (_) { + return arguments.length + ? ((y0 = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + area) + : y0; + }; + + area.y1 = function (_) { + return arguments.length + ? ((y1 = + _ == null + ? null + : typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + area) + : y1; + }; + + area.lineX0 = area.lineY0 = function () { + return arealine().x(x0).y(y0); + }; + + area.lineY1 = function () { + return arealine().x(x0).y(y1); + }; + + area.lineX1 = function () { + return arealine().x(x1).y(y0); + }; + + area.defined = function (_) { + return arguments.length + ? ((defined = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Boolean(_))), + area) + : defined; + }; + + area.curve = function (_) { + return arguments.length + ? ((curve = _), + context != null && (output = curve(context)), + area) + : curve; + }; + + area.context = function (_) { + return arguments.length + ? (_ == null + ? (context = output = null) + : (output = curve((context = _))), + area) + : context; + }; + + return area; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/areaRadial.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-shape/src/areaRadial.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _curve_radial__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./curve/radial */ "./node_modules/d3-shape/src/curve/radial.js" + ); + /* Harmony import */ var _area__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./area */ "./node_modules/d3-shape/src/area.js" + ); + /* Harmony import */ var _lineRadial__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./lineRadial */ "./node_modules/d3-shape/src/lineRadial.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var a = Object( + _area__WEBPACK_IMPORTED_MODULE_1__.default + )().curve( + _curve_radial__WEBPACK_IMPORTED_MODULE_0__.curveRadialLinear + ), + c = a.curve, + x0 = a.lineX0, + x1 = a.lineX1, + y0 = a.lineY0, + y1 = a.lineY1; + (a.angle = a.x), delete a.x; + (a.startAngle = a.x0), delete a.x0; + (a.endAngle = a.x1), delete a.x1; + (a.radius = a.y), delete a.y; + (a.innerRadius = a.y0), delete a.y0; + (a.outerRadius = a.y1), delete a.y1; + (a.lineStartAngle = function () { + return Object( + _lineRadial__WEBPACK_IMPORTED_MODULE_2__.lineRadial + )(x0()); + }), + delete a.lineX0; + (a.lineEndAngle = function () { + return Object( + _lineRadial__WEBPACK_IMPORTED_MODULE_2__.lineRadial + )(x1()); + }), + delete a.lineX1; + (a.lineInnerRadius = function () { + return Object( + _lineRadial__WEBPACK_IMPORTED_MODULE_2__.lineRadial + )(y0()); + }), + delete a.lineY0; + (a.lineOuterRadius = function () { + return Object( + _lineRadial__WEBPACK_IMPORTED_MODULE_2__.lineRadial + )(y1()); + }), + delete a.lineY1; + + a.curve = function (_) { + return arguments.length + ? c( + Object( + _curve_radial__WEBPACK_IMPORTED_MODULE_0__.default + )(_) + ) + : c()._curve; + }; + + return a; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/array.js": + /* !********************************************!*\ + !*** ./node_modules/d3-shape/src/array.js ***! + \********************************************/ + /* ! exports provided: slice */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "slice", + function () { + return slice; + } + ); + var slice = Array.prototype.slice; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/constant.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-shape/src/constant.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function constant() { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/basis.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/basis.js ***! + \**************************************************/ + /* ! exports provided: point, Basis, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "point", + function () { + return _point; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Basis", + function () { + return Basis; + } + ); + function _point(that, x, y) { + that._context.bezierCurveTo( + (2 * that._x0 + that._x1) / 3, + (2 * that._y0 + that._y1) / 3, + (that._x0 + 2 * that._x1) / 3, + (that._y0 + 2 * that._y1) / 3, + (that._x0 + 4 * that._x1 + x) / 6, + (that._y0 + 4 * that._y1 + y) / 6 + ); + } + + function Basis(context) { + this._context = context; + } + Basis.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x0 = this._x1 = this._y0 = this._y1 = NaN; + this._point = 0; + }, + lineEnd: function lineEnd() { + switch (this._point) { + case 3: + _point(this, this._x1, this._y1); + + // Proceed + + case 2: + this._context.lineTo(this._x1, this._y1); + + break; + } + + if (this._line || (this._line !== 0 && this._point === 1)) + this._context.closePath(); + this._line = 1 - this._line; + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + switch (this._point) { + case 0: + this._point = 1; + this._line + ? this._context.lineTo(x, y) + : this._context.moveTo(x, y); + break; + + case 1: + this._point = 2; + break; + + case 2: + this._point = 3; + + this._context.lineTo( + (5 * this._x0 + this._x1) / 6, + (5 * this._y0 + this._y1) / 6 + ); + + // Proceed + + default: + _point(this, x, y); + + break; + } + + (this._x0 = this._x1), (this._x1 = x); + (this._y0 = this._y1), (this._y1 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = function (context) { + return new Basis(context); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/basisClosed.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/basisClosed.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-shape/src/noop.js" + ); + /* Harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./basis */ "./node_modules/d3-shape/src/curve/basis.js" + ); + + function BasisClosed(context) { + this._context = context; + } + + BasisClosed.prototype = { + areaStart: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + areaEnd: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + lineStart: function lineStart() { + this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN; + this._point = 0; + }, + lineEnd: function lineEnd() { + switch (this._point) { + case 1: { + this._context.moveTo(this._x2, this._y2); + + this._context.closePath(); + + break; + } + + case 2: { + this._context.moveTo( + (this._x2 + 2 * this._x3) / 3, + (this._y2 + 2 * this._y3) / 3 + ); + + this._context.lineTo( + (this._x3 + 2 * this._x2) / 3, + (this._y3 + 2 * this._y2) / 3 + ); + + this._context.closePath(); + + break; + } + + case 3: { + this.point(this._x2, this._y2); + this.point(this._x3, this._y3); + this.point(this._x4, this._y4); + break; + } + } + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + switch (this._point) { + case 0: + this._point = 1; + (this._x2 = x), (this._y2 = y); + break; + + case 1: + this._point = 2; + (this._x3 = x), (this._y3 = y); + break; + + case 2: + this._point = 3; + (this._x4 = x), (this._y4 = y); + + this._context.moveTo( + (this._x0 + 4 * this._x1 + x) / 6, + (this._y0 + 4 * this._y1 + y) / 6 + ); + + break; + + default: + Object( + _basis__WEBPACK_IMPORTED_MODULE_1__.point + )(this, x, y); + + break; + } + + (this._x0 = this._x1), (this._x1 = x); + (this._y0 = this._y1), (this._y1 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = function (context) { + return new BasisClosed(context); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/basisOpen.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/basisOpen.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./basis */ "./node_modules/d3-shape/src/curve/basis.js" + ); + + function BasisOpen(context) { + this._context = context; + } + + BasisOpen.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x0 = this._x1 = this._y0 = this._y1 = NaN; + this._point = 0; + }, + lineEnd: function lineEnd() { + if (this._line || (this._line !== 0 && this._point === 3)) + this._context.closePath(); + this._line = 1 - this._line; + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + switch (this._point) { + case 0: + this._point = 1; + break; + + case 1: + this._point = 2; + break; + + case 2: + this._point = 3; + var x0 = (this._x0 + 4 * this._x1 + x) / 6, + y0 = (this._y0 + 4 * this._y1 + y) / 6; + this._line + ? this._context.lineTo(x0, y0) + : this._context.moveTo(x0, y0); + break; + + case 3: + this._point = 4; + // Proceed + + default: + Object( + _basis__WEBPACK_IMPORTED_MODULE_0__.point + )(this, x, y); + + break; + } + + (this._x0 = this._x1), (this._x1 = x); + (this._y0 = this._y1), (this._y1 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = function (context) { + return new BasisOpen(context); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/bundle.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/bundle.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./basis */ "./node_modules/d3-shape/src/curve/basis.js" + ); + + function Bundle(context, beta) { + this._basis = new _basis__WEBPACK_IMPORTED_MODULE_0__.Basis( + context + ); + this._beta = beta; + } + + Bundle.prototype = { + lineStart: function lineStart() { + this._x = []; + this._y = []; + + this._basis.lineStart(); + }, + lineEnd: function lineEnd() { + var x = this._x, + y = this._y, + j = x.length - 1; + + if (j > 0) { + var x0 = x[0], + y0 = y[0], + dx = x[j] - x0, + dy = y[j] - y0, + i = -1, + t; + + while (++i <= j) { + t = i / j; + + this._basis.point( + this._beta * x[i] + + (1 - this._beta) * (x0 + t * dx), + this._beta * y[i] + + (1 - this._beta) * (y0 + t * dy) + ); + } + } + + this._x = this._y = null; + + this._basis.lineEnd(); + }, + point: function point(x, y) { + this._x.push(Number(x)); + + this._y.push(Number(y)); + }, + }; + /* Harmony default export */ __webpack_exports__.default = (function custom(beta) { + function bundle(context) { + return beta === 1 + ? new _basis__WEBPACK_IMPORTED_MODULE_0__.Basis( + context + ) + : new Bundle(context, beta); + } + + bundle.beta = function (beta) { + return custom(Number(beta)); + }; + + return bundle; + })(0.85); + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/cardinal.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/cardinal.js ***! + \*****************************************************/ + /* ! exports provided: point, Cardinal, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "point", + function () { + return _point; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Cardinal", + function () { + return Cardinal; + } + ); + function _point(that, x, y) { + that._context.bezierCurveTo( + that._x1 + that._k * (that._x2 - that._x0), + that._y1 + that._k * (that._y2 - that._y0), + that._x2 + that._k * (that._x1 - x), + that._y2 + that._k * (that._y1 - y), + that._x2, + that._y2 + ); + } + + function Cardinal(context, tension) { + this._context = context; + this._k = (1 - tension) / 6; + } + Cardinal.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN; + this._point = 0; + }, + lineEnd: function lineEnd() { + switch (this._point) { + case 2: + this._context.lineTo(this._x2, this._y2); + + break; + + case 3: + _point(this, this._x1, this._y1); + + break; + } + + if (this._line || (this._line !== 0 && this._point === 1)) + this._context.closePath(); + this._line = 1 - this._line; + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + switch (this._point) { + case 0: + this._point = 1; + this._line + ? this._context.lineTo(x, y) + : this._context.moveTo(x, y); + break; + + case 1: + this._point = 2; + (this._x1 = x), (this._y1 = y); + break; + + case 2: + this._point = 3; + // Proceed + + default: + _point(this, x, y); + + break; + } + + (this._x0 = this._x1), + (this._x1 = this._x2), + (this._x2 = x); + (this._y0 = this._y1), + (this._y1 = this._y2), + (this._y2 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = (function custom(tension) { + function cardinal(context) { + return new Cardinal(context, tension); + } + + cardinal.tension = function (tension) { + return custom(Number(tension)); + }; + + return cardinal; + })(0); + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/cardinalClosed.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/cardinalClosed.js ***! + \***********************************************************/ + /* ! exports provided: CardinalClosed, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "CardinalClosed", + function () { + return CardinalClosed; + } + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-shape/src/noop.js" + ); + /* Harmony import */ var _cardinal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./cardinal */ "./node_modules/d3-shape/src/curve/cardinal.js" + ); + + function CardinalClosed(context, tension) { + this._context = context; + this._k = (1 - tension) / 6; + } + CardinalClosed.prototype = { + areaStart: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + areaEnd: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + lineStart: function lineStart() { + this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN; + this._point = 0; + }, + lineEnd: function lineEnd() { + switch (this._point) { + case 1: { + this._context.moveTo(this._x3, this._y3); + + this._context.closePath(); + + break; + } + + case 2: { + this._context.lineTo(this._x3, this._y3); + + this._context.closePath(); + + break; + } + + case 3: { + this.point(this._x3, this._y3); + this.point(this._x4, this._y4); + this.point(this._x5, this._y5); + break; + } + } + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + switch (this._point) { + case 0: + this._point = 1; + (this._x3 = x), (this._y3 = y); + break; + + case 1: + this._point = 2; + + this._context.moveTo( + (this._x4 = x), + (this._y4 = y) + ); + + break; + + case 2: + this._point = 3; + (this._x5 = x), (this._y5 = y); + break; + + default: + Object( + _cardinal__WEBPACK_IMPORTED_MODULE_1__.point + )(this, x, y); + + break; + } + + (this._x0 = this._x1), + (this._x1 = this._x2), + (this._x2 = x); + (this._y0 = this._y1), + (this._y1 = this._y2), + (this._y2 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = (function custom(tension) { + function cardinal(context) { + return new CardinalClosed(context, tension); + } + + cardinal.tension = function (tension) { + return custom(Number(tension)); + }; + + return cardinal; + })(0); + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/cardinalOpen.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/cardinalOpen.js ***! + \*********************************************************/ + /* ! exports provided: CardinalOpen, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "CardinalOpen", + function () { + return CardinalOpen; + } + ); + /* Harmony import */ var _cardinal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./cardinal */ "./node_modules/d3-shape/src/curve/cardinal.js" + ); + + function CardinalOpen(context, tension) { + this._context = context; + this._k = (1 - tension) / 6; + } + CardinalOpen.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN; + this._point = 0; + }, + lineEnd: function lineEnd() { + if (this._line || (this._line !== 0 && this._point === 3)) + this._context.closePath(); + this._line = 1 - this._line; + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + switch (this._point) { + case 0: + this._point = 1; + break; + + case 1: + this._point = 2; + break; + + case 2: + this._point = 3; + this._line + ? this._context.lineTo(this._x2, this._y2) + : this._context.moveTo(this._x2, this._y2); + break; + + case 3: + this._point = 4; + // Proceed + + default: + Object( + _cardinal__WEBPACK_IMPORTED_MODULE_0__.point + )(this, x, y); + + break; + } + + (this._x0 = this._x1), + (this._x1 = this._x2), + (this._x2 = x); + (this._y0 = this._y1), + (this._y1 = this._y2), + (this._y2 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = (function custom(tension) { + function cardinal(context) { + return new CardinalOpen(context, tension); + } + + cardinal.tension = function (tension) { + return custom(Number(tension)); + }; + + return cardinal; + })(0); + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/catmullRom.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/catmullRom.js ***! + \*******************************************************/ + /* ! exports provided: point, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "point", + function () { + return _point; + } + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-shape/src/math.js" + ); + /* Harmony import */ var _cardinal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./cardinal */ "./node_modules/d3-shape/src/curve/cardinal.js" + ); + + function _point(that, x, y) { + var x1 = that._x1, + y1 = that._y1, + x2 = that._x2, + y2 = that._y2; + + if ( + that._l01_a > _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ) { + var a = + 2 * that._l01_2a + + 3 * that._l01_a * that._l12_a + + that._l12_2a, + n = 3 * that._l01_a * (that._l01_a + that._l12_a); + x1 = + (x1 * a - + that._x0 * that._l12_2a + + that._x2 * that._l01_2a) / + n; + y1 = + (y1 * a - + that._y0 * that._l12_2a + + that._y2 * that._l01_2a) / + n; + } + + if ( + that._l23_a > _math__WEBPACK_IMPORTED_MODULE_0__.epsilon + ) { + var b = + 2 * that._l23_2a + + 3 * that._l23_a * that._l12_a + + that._l12_2a, + m = 3 * that._l23_a * (that._l23_a + that._l12_a); + x2 = + (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / + m; + y2 = + (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / + m; + } + + that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2); + } + + function CatmullRom(context, alpha) { + this._context = context; + this._alpha = alpha; + } + + CatmullRom.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN; + this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0; + }, + lineEnd: function lineEnd() { + switch (this._point) { + case 2: + this._context.lineTo(this._x2, this._y2); + + break; + + case 3: + this.point(this._x2, this._y2); + break; + } + + if (this._line || (this._line !== 0 && this._point === 1)) + this._context.closePath(); + this._line = 1 - this._line; + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + if (this._point) { + var x23 = this._x2 - x, + y23 = this._y2 - y; + this._l23_a = Math.sqrt( + (this._l23_2a = Math.pow( + x23 * x23 + y23 * y23, + this._alpha + )) + ); + } + + switch (this._point) { + case 0: + this._point = 1; + this._line + ? this._context.lineTo(x, y) + : this._context.moveTo(x, y); + break; + + case 1: + this._point = 2; + break; + + case 2: + this._point = 3; + // Proceed + + default: + _point(this, x, y); + + break; + } + + (this._l01_a = this._l12_a), (this._l12_a = this._l23_a); + (this._l01_2a = this._l12_2a), + (this._l12_2a = this._l23_2a); + (this._x0 = this._x1), + (this._x1 = this._x2), + (this._x2 = x); + (this._y0 = this._y1), + (this._y1 = this._y2), + (this._y2 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = (function custom(alpha) { + function catmullRom(context) { + return alpha + ? new CatmullRom(context, alpha) + : new _cardinal__WEBPACK_IMPORTED_MODULE_1__.Cardinal(context, 0); + } + + catmullRom.alpha = function (alpha) { + return custom(Number(alpha)); + }; + + return catmullRom; + })(0.5); + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/catmullRomClosed.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/catmullRomClosed.js ***! + \*************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _cardinalClosed__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./cardinalClosed */ "./node_modules/d3-shape/src/curve/cardinalClosed.js" + ); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-shape/src/noop.js" + ); + /* Harmony import */ var _catmullRom__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./catmullRom */ "./node_modules/d3-shape/src/curve/catmullRom.js" + ); + + function CatmullRomClosed(context, alpha) { + this._context = context; + this._alpha = alpha; + } + + CatmullRomClosed.prototype = { + areaStart: _noop__WEBPACK_IMPORTED_MODULE_1__.default, + areaEnd: _noop__WEBPACK_IMPORTED_MODULE_1__.default, + lineStart: function lineStart() { + this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN; + this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0; + }, + lineEnd: function lineEnd() { + switch (this._point) { + case 1: { + this._context.moveTo(this._x3, this._y3); + + this._context.closePath(); + + break; + } + + case 2: { + this._context.lineTo(this._x3, this._y3); + + this._context.closePath(); + + break; + } + + case 3: { + this.point(this._x3, this._y3); + this.point(this._x4, this._y4); + this.point(this._x5, this._y5); + break; + } + } + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + if (this._point) { + var x23 = this._x2 - x, + y23 = this._y2 - y; + this._l23_a = Math.sqrt( + (this._l23_2a = Math.pow( + x23 * x23 + y23 * y23, + this._alpha + )) + ); + } + + switch (this._point) { + case 0: + this._point = 1; + (this._x3 = x), (this._y3 = y); + break; + + case 1: + this._point = 2; + + this._context.moveTo( + (this._x4 = x), + (this._y4 = y) + ); + + break; + + case 2: + this._point = 3; + (this._x5 = x), (this._y5 = y); + break; + + default: + Object( + _catmullRom__WEBPACK_IMPORTED_MODULE_2__.point + )(this, x, y); + + break; + } + + (this._l01_a = this._l12_a), (this._l12_a = this._l23_a); + (this._l01_2a = this._l12_2a), + (this._l12_2a = this._l23_2a); + (this._x0 = this._x1), + (this._x1 = this._x2), + (this._x2 = x); + (this._y0 = this._y1), + (this._y1 = this._y2), + (this._y2 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = (function custom(alpha) { + function catmullRom(context) { + return alpha + ? new CatmullRomClosed(context, alpha) + : new _cardinalClosed__WEBPACK_IMPORTED_MODULE_0__.CardinalClosed(context, 0); + } + + catmullRom.alpha = function (alpha) { + return custom(Number(alpha)); + }; + + return catmullRom; + })(0.5); + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/catmullRomOpen.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/catmullRomOpen.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _cardinalOpen__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./cardinalOpen */ "./node_modules/d3-shape/src/curve/cardinalOpen.js" + ); + /* Harmony import */ var _catmullRom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./catmullRom */ "./node_modules/d3-shape/src/curve/catmullRom.js" + ); + + function CatmullRomOpen(context, alpha) { + this._context = context; + this._alpha = alpha; + } + + CatmullRomOpen.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN; + this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0; + }, + lineEnd: function lineEnd() { + if (this._line || (this._line !== 0 && this._point === 3)) + this._context.closePath(); + this._line = 1 - this._line; + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + if (this._point) { + var x23 = this._x2 - x, + y23 = this._y2 - y; + this._l23_a = Math.sqrt( + (this._l23_2a = Math.pow( + x23 * x23 + y23 * y23, + this._alpha + )) + ); + } + + switch (this._point) { + case 0: + this._point = 1; + break; + + case 1: + this._point = 2; + break; + + case 2: + this._point = 3; + this._line + ? this._context.lineTo(this._x2, this._y2) + : this._context.moveTo(this._x2, this._y2); + break; + + case 3: + this._point = 4; + // Proceed + + default: + Object( + _catmullRom__WEBPACK_IMPORTED_MODULE_1__.point + )(this, x, y); + + break; + } + + (this._l01_a = this._l12_a), (this._l12_a = this._l23_a); + (this._l01_2a = this._l12_2a), + (this._l12_2a = this._l23_2a); + (this._x0 = this._x1), + (this._x1 = this._x2), + (this._x2 = x); + (this._y0 = this._y1), + (this._y1 = this._y2), + (this._y2 = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = (function custom(alpha) { + function catmullRom(context) { + return alpha + ? new CatmullRomOpen(context, alpha) + : new _cardinalOpen__WEBPACK_IMPORTED_MODULE_0__.CardinalOpen(context, 0); + } + + catmullRom.alpha = function (alpha) { + return custom(Number(alpha)); + }; + + return catmullRom; + })(0.5); + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/linear.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/linear.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function Linear(context) { + this._context = context; + } + + Linear.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._point = 0; + }, + lineEnd: function lineEnd() { + if (this._line || (this._line !== 0 && this._point === 1)) + this._context.closePath(); + this._line = 1 - this._line; + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + switch (this._point) { + case 0: + this._point = 1; + this._line + ? this._context.lineTo(x, y) + : this._context.moveTo(x, y); + break; + + case 1: + this._point = 2; + // Proceed + + default: + this._context.lineTo(x, y); + + break; + } + }, + }; + /* Harmony default export */ __webpack_exports__.default = function (context) { + return new Linear(context); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/linearClosed.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/linearClosed.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../noop */ "./node_modules/d3-shape/src/noop.js" + ); + + function LinearClosed(context) { + this._context = context; + } + + LinearClosed.prototype = { + areaStart: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + areaEnd: _noop__WEBPACK_IMPORTED_MODULE_0__.default, + lineStart: function lineStart() { + this._point = 0; + }, + lineEnd: function lineEnd() { + if (this._point) this._context.closePath(); + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + if (this._point) this._context.lineTo(x, y); + else (this._point = 1), this._context.moveTo(x, y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = function (context) { + return new LinearClosed(context); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/monotone.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/monotone.js ***! + \*****************************************************/ + /* ! exports provided: monotoneX, monotoneY */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "monotoneX", + function () { + return monotoneX; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "monotoneY", + function () { + return monotoneY; + } + ); + function sign(x) { + return x < 0 ? -1 : 1; + } // Calculate the slopes of the tangents (Hermite-type interpolation) based on + // the following paper: Steffen, M. 1990. A Simple Method for Monotonic + // Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO. + // NOV(II), P. 443, 1990. + + function slope3(that, x2, y2) { + var h0 = that._x1 - that._x0, + h1 = x2 - that._x1, + s0 = (that._y1 - that._y0) / (h0 || (h1 < 0 && -0)), + s1 = (y2 - that._y1) / (h1 || (h0 < 0 && -0)), + p = (s0 * h1 + s1 * h0) / (h0 + h1); + return ( + (sign(s0) + sign(s1)) * + Math.min( + Math.abs(s0), + Math.abs(s1), + 0.5 * Math.abs(p) + ) || 0 + ); + } // Calculate a one-sided slope. + + function slope2(that, t) { + var h = that._x1 - that._x0; + return h ? ((3 * (that._y1 - that._y0)) / h - t) / 2 : t; + } // According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations + // "you can express cubic Hermite interpolation in terms of cubic Bézier curves + // with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1". + + function _point(that, t0, t1) { + var x0 = that._x0, + y0 = that._y0, + x1 = that._x1, + y1 = that._y1, + dx = (x1 - x0) / 3; + + that._context.bezierCurveTo( + x0 + dx, + y0 + dx * t0, + x1 - dx, + y1 - dx * t1, + x1, + y1 + ); + } + + function MonotoneX(context) { + this._context = context; + } + + MonotoneX.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN; + this._point = 0; + }, + lineEnd: function lineEnd() { + switch (this._point) { + case 2: + this._context.lineTo(this._x1, this._y1); + + break; + + case 3: + _point(this, this._t0, slope2(this, this._t0)); + + break; + } + + if (this._line || (this._line !== 0 && this._point === 1)) + this._context.closePath(); + this._line = 1 - this._line; + }, + point: function point(x, y) { + var t1 = NaN; + (x = Number(x)), (y = Number(y)); + if (x === this._x1 && y === this._y1) return; // Ignore coincident points. + + switch (this._point) { + case 0: + this._point = 1; + this._line + ? this._context.lineTo(x, y) + : this._context.moveTo(x, y); + break; + + case 1: + this._point = 2; + break; + + case 2: + this._point = 3; + + _point( + this, + slope2(this, (t1 = slope3(this, x, y))), + t1 + ); + + break; + + default: + _point(this, this._t0, (t1 = slope3(this, x, y))); + + break; + } + + (this._x0 = this._x1), (this._x1 = x); + (this._y0 = this._y1), (this._y1 = y); + this._t0 = t1; + }, + }; + + function MonotoneY(context) { + this._context = new ReflectContext(context); + } + + (MonotoneY.prototype = Object.create( + MonotoneX.prototype + )).point = function (x, y) { + MonotoneX.prototype.point.call(this, y, x); + }; + + function ReflectContext(context) { + this._context = context; + } + + ReflectContext.prototype = { + moveTo: function moveTo(x, y) { + this._context.moveTo(y, x); + }, + closePath: function closePath() { + this._context.closePath(); + }, + lineTo: function lineTo(x, y) { + this._context.lineTo(y, x); + }, + bezierCurveTo: function bezierCurveTo(x1, y1, x2, y2, x, y) { + this._context.bezierCurveTo(y1, x1, y2, x2, y, x); + }, + }; + function monotoneX(context) { + return new MonotoneX(context); + } + function monotoneY(context) { + return new MonotoneY(context); + } + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/natural.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/natural.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function Natural(context) { + this._context = context; + } + + Natural.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x = []; + this._y = []; + }, + lineEnd: function lineEnd() { + var x = this._x, + y = this._y, + n = x.length; + + if (n) { + this._line + ? this._context.lineTo(x[0], y[0]) + : this._context.moveTo(x[0], y[0]); + + if (n === 2) { + this._context.lineTo(x[1], y[1]); + } else { + var px = controlPoints(x), + py = controlPoints(y); + + for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) { + this._context.bezierCurveTo( + px[0][i0], + py[0][i0], + px[1][i0], + py[1][i0], + x[i1], + y[i1] + ); + } + } + } + + if (this._line || (this._line !== 0 && n === 1)) + this._context.closePath(); + this._line = 1 - this._line; + this._x = this._y = null; + }, + point: function point(x, y) { + this._x.push(Number(x)); + + this._y.push(Number(y)); + }, + }; // See https://www.particleincell.com/2012/bezier-splines/ for derivation. + + function controlPoints(x) { + var i, + n = x.length - 1, + m, + a = new Array(n), + b = new Array(n), + r = new Array(n); + (a[0] = 0), (b[0] = 2), (r[0] = x[0] + 2 * x[1]); + + for (i = 1; i < n - 1; ++i) { + (a[i] = 1), (b[i] = 4), (r[i] = 4 * x[i] + 2 * x[i + 1]); + } + + (a[n - 1] = 2), + (b[n - 1] = 7), + (r[n - 1] = 8 * x[n - 1] + x[n]); + + for (i = 1; i < n; ++i) { + (m = a[i] / b[i - 1]), (b[i] -= m), (r[i] -= m * r[i - 1]); + } + + a[n - 1] = r[n - 1] / b[n - 1]; + + for (i = n - 2; i >= 0; --i) { + a[i] = (r[i] - a[i + 1]) / b[i]; + } + + b[n - 1] = (x[n] + a[n - 1]) / 2; + + for (i = 0; i < n - 1; ++i) { + b[i] = 2 * x[i + 1] - a[i + 1]; + } + + return [a, b]; + } + + /* Harmony default export */ __webpack_exports__.default = function (context) { + return new Natural(context); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/radial.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/radial.js ***! + \***************************************************/ + /* ! exports provided: curveRadialLinear, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "curveRadialLinear", + function () { + return curveRadialLinear; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return curveRadial; + } + ); + /* Harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./linear */ "./node_modules/d3-shape/src/curve/linear.js" + ); + + var curveRadialLinear = curveRadial( + _linear__WEBPACK_IMPORTED_MODULE_0__.default + ); + + function Radial(curve) { + this._curve = curve; + } + + Radial.prototype = { + areaStart: function areaStart() { + this._curve.areaStart(); + }, + areaEnd: function areaEnd() { + this._curve.areaEnd(); + }, + lineStart: function lineStart() { + this._curve.lineStart(); + }, + lineEnd: function lineEnd() { + this._curve.lineEnd(); + }, + point: function point(a, r) { + this._curve.point(r * Math.sin(a), r * -Math.cos(a)); + }, + }; + function curveRadial(curve) { + function radial(context) { + return new Radial(curve(context)); + } + + radial._curve = curve; + return radial; + } + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/curve/step.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-shape/src/curve/step.js ***! + \*************************************************/ + /* ! exports provided: default, stepBefore, stepAfter */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "stepBefore", + function () { + return stepBefore; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "stepAfter", + function () { + return stepAfter; + } + ); + function Step(context, t) { + this._context = context; + this._t = t; + } + + Step.prototype = { + areaStart: function areaStart() { + this._line = 0; + }, + areaEnd: function areaEnd() { + this._line = NaN; + }, + lineStart: function lineStart() { + this._x = this._y = NaN; + this._point = 0; + }, + lineEnd: function lineEnd() { + if (this._t > 0 && this._t < 1 && this._point === 2) + this._context.lineTo(this._x, this._y); + if (this._line || (this._line !== 0 && this._point === 1)) + this._context.closePath(); + if (this._line >= 0) + (this._t = 1 - this._t), (this._line = 1 - this._line); + }, + point: function point(x, y) { + (x = Number(x)), (y = Number(y)); + + switch (this._point) { + case 0: + this._point = 1; + this._line + ? this._context.lineTo(x, y) + : this._context.moveTo(x, y); + break; + + case 1: + this._point = 2; + // Proceed + + default: { + if (this._t <= 0) { + this._context.lineTo(this._x, y); + + this._context.lineTo(x, y); + } else { + var x1 = this._x * (1 - this._t) + x * this._t; + + this._context.lineTo(x1, this._y); + + this._context.lineTo(x1, y); + } + + break; + } + } + + (this._x = x), (this._y = y); + }, + }; + /* Harmony default export */ __webpack_exports__.default = function (context) { + return new Step(context, 0.5); + }; + function stepBefore(context) { + return new Step(context, 0); + } + function stepAfter(context) { + return new Step(context, 1); + } + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/descending.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-shape/src/descending.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/identity.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-shape/src/identity.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (d) { + return d; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-shape/src/index.js ***! + \********************************************/ + /* ! exports provided: arc, area, line, pie, areaRadial, radialArea, lineRadial, radialLine, pointRadial, linkHorizontal, linkVertical, linkRadial, symbol, symbols, symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye, curveBasisClosed, curveBasisOpen, curveBasis, curveBundle, curveCardinalClosed, curveCardinalOpen, curveCardinal, curveCatmullRomClosed, curveCatmullRomOpen, curveCatmullRom, curveLinearClosed, curveLinear, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, stack, stackOffsetExpand, stackOffsetDiverging, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAppearance, stackOrderAscending, stackOrderDescending, stackOrderInsideOut, stackOrderNone, stackOrderReverse */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _arc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./arc */ "./node_modules/d3-shape/src/arc.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "arc", + function () { + return _arc__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _area__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./area */ "./node_modules/d3-shape/src/area.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "area", + function () { + return _area__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _line__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./line */ "./node_modules/d3-shape/src/line.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "line", + function () { + return _line__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _pie__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./pie */ "./node_modules/d3-shape/src/pie.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "pie", + function () { + return _pie__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony import */ var _areaRadial__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./areaRadial */ "./node_modules/d3-shape/src/areaRadial.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "areaRadial", + function () { + return _areaRadial__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "radialArea", + function () { + return _areaRadial__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony import */ var _lineRadial__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./lineRadial */ "./node_modules/d3-shape/src/lineRadial.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "lineRadial", + function () { + return _lineRadial__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "radialLine", + function () { + return _lineRadial__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony import */ var _pointRadial__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./pointRadial */ "./node_modules/d3-shape/src/pointRadial.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "pointRadial", + function () { + return _pointRadial__WEBPACK_IMPORTED_MODULE_6__.default; + } + ); + + /* Harmony import */ var _link_index__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./link/index */ "./node_modules/d3-shape/src/link/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "linkHorizontal", + function () { + return _link_index__WEBPACK_IMPORTED_MODULE_7__.linkHorizontal; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "linkVertical", + function () { + return _link_index__WEBPACK_IMPORTED_MODULE_7__.linkVertical; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "linkRadial", + function () { + return _link_index__WEBPACK_IMPORTED_MODULE_7__.linkRadial; + } + ); + + /* Harmony import */ var _symbol__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./symbol */ "./node_modules/d3-shape/src/symbol.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbol", + function () { + return _symbol__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbols", + function () { + return _symbol__WEBPACK_IMPORTED_MODULE_8__.symbols; + } + ); + + /* Harmony import */ var _symbol_circle__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./symbol/circle */ "./node_modules/d3-shape/src/symbol/circle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolCircle", + function () { + return _symbol_circle__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony import */ var _symbol_cross__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./symbol/cross */ "./node_modules/d3-shape/src/symbol/cross.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolCross", + function () { + return _symbol_cross__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony import */ var _symbol_diamond__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./symbol/diamond */ "./node_modules/d3-shape/src/symbol/diamond.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolDiamond", + function () { + return _symbol_diamond__WEBPACK_IMPORTED_MODULE_11__.default; + } + ); + + /* Harmony import */ var _symbol_square__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./symbol/square */ "./node_modules/d3-shape/src/symbol/square.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolSquare", + function () { + return _symbol_square__WEBPACK_IMPORTED_MODULE_12__.default; + } + ); + + /* Harmony import */ var _symbol_star__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./symbol/star */ "./node_modules/d3-shape/src/symbol/star.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolStar", + function () { + return _symbol_star__WEBPACK_IMPORTED_MODULE_13__.default; + } + ); + + /* Harmony import */ var _symbol_triangle__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./symbol/triangle */ "./node_modules/d3-shape/src/symbol/triangle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolTriangle", + function () { + return _symbol_triangle__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /* Harmony import */ var _symbol_wye__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./symbol/wye */ "./node_modules/d3-shape/src/symbol/wye.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolWye", + function () { + return _symbol_wye__WEBPACK_IMPORTED_MODULE_15__.default; + } + ); + + /* Harmony import */ var _curve_basisClosed__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! ./curve/basisClosed */ "./node_modules/d3-shape/src/curve/basisClosed.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveBasisClosed", + function () { + return _curve_basisClosed__WEBPACK_IMPORTED_MODULE_16__.default; + } + ); + + /* Harmony import */ var _curve_basisOpen__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! ./curve/basisOpen */ "./node_modules/d3-shape/src/curve/basisOpen.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveBasisOpen", + function () { + return _curve_basisOpen__WEBPACK_IMPORTED_MODULE_17__.default; + } + ); + + /* Harmony import */ var _curve_basis__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__( + /* ! ./curve/basis */ "./node_modules/d3-shape/src/curve/basis.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveBasis", + function () { + return _curve_basis__WEBPACK_IMPORTED_MODULE_18__.default; + } + ); + + /* Harmony import */ var _curve_bundle__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__( + /* ! ./curve/bundle */ "./node_modules/d3-shape/src/curve/bundle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveBundle", + function () { + return _curve_bundle__WEBPACK_IMPORTED_MODULE_19__.default; + } + ); + + /* Harmony import */ var _curve_cardinalClosed__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__( + /* ! ./curve/cardinalClosed */ "./node_modules/d3-shape/src/curve/cardinalClosed.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCardinalClosed", + function () { + return _curve_cardinalClosed__WEBPACK_IMPORTED_MODULE_20__.default; + } + ); + + /* Harmony import */ var _curve_cardinalOpen__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__( + /* ! ./curve/cardinalOpen */ "./node_modules/d3-shape/src/curve/cardinalOpen.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCardinalOpen", + function () { + return _curve_cardinalOpen__WEBPACK_IMPORTED_MODULE_21__.default; + } + ); + + /* Harmony import */ var _curve_cardinal__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__( + /* ! ./curve/cardinal */ "./node_modules/d3-shape/src/curve/cardinal.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCardinal", + function () { + return _curve_cardinal__WEBPACK_IMPORTED_MODULE_22__.default; + } + ); + + /* Harmony import */ var _curve_catmullRomClosed__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__( + /* ! ./curve/catmullRomClosed */ "./node_modules/d3-shape/src/curve/catmullRomClosed.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCatmullRomClosed", + function () { + return _curve_catmullRomClosed__WEBPACK_IMPORTED_MODULE_23__.default; + } + ); + + /* Harmony import */ var _curve_catmullRomOpen__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__( + /* ! ./curve/catmullRomOpen */ "./node_modules/d3-shape/src/curve/catmullRomOpen.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCatmullRomOpen", + function () { + return _curve_catmullRomOpen__WEBPACK_IMPORTED_MODULE_24__.default; + } + ); + + /* Harmony import */ var _curve_catmullRom__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__( + /* ! ./curve/catmullRom */ "./node_modules/d3-shape/src/curve/catmullRom.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCatmullRom", + function () { + return _curve_catmullRom__WEBPACK_IMPORTED_MODULE_25__.default; + } + ); + + /* Harmony import */ var _curve_linearClosed__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__( + /* ! ./curve/linearClosed */ "./node_modules/d3-shape/src/curve/linearClosed.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveLinearClosed", + function () { + return _curve_linearClosed__WEBPACK_IMPORTED_MODULE_26__.default; + } + ); + + /* Harmony import */ var _curve_linear__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__( + /* ! ./curve/linear */ "./node_modules/d3-shape/src/curve/linear.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveLinear", + function () { + return _curve_linear__WEBPACK_IMPORTED_MODULE_27__.default; + } + ); + + /* Harmony import */ var _curve_monotone__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__( + /* ! ./curve/monotone */ "./node_modules/d3-shape/src/curve/monotone.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveMonotoneX", + function () { + return _curve_monotone__WEBPACK_IMPORTED_MODULE_28__.monotoneX; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveMonotoneY", + function () { + return _curve_monotone__WEBPACK_IMPORTED_MODULE_28__.monotoneY; + } + ); + + /* Harmony import */ var _curve_natural__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__( + /* ! ./curve/natural */ "./node_modules/d3-shape/src/curve/natural.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveNatural", + function () { + return _curve_natural__WEBPACK_IMPORTED_MODULE_29__.default; + } + ); + + /* Harmony import */ var _curve_step__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__( + /* ! ./curve/step */ "./node_modules/d3-shape/src/curve/step.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveStep", + function () { + return _curve_step__WEBPACK_IMPORTED_MODULE_30__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveStepAfter", + function () { + return _curve_step__WEBPACK_IMPORTED_MODULE_30__.stepAfter; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveStepBefore", + function () { + return _curve_step__WEBPACK_IMPORTED_MODULE_30__.stepBefore; + } + ); + + /* Harmony import */ var _stack__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__( + /* ! ./stack */ "./node_modules/d3-shape/src/stack.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stack", + function () { + return _stack__WEBPACK_IMPORTED_MODULE_31__.default; + } + ); + + /* Harmony import */ var _offset_expand__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__( + /* ! ./offset/expand */ "./node_modules/d3-shape/src/offset/expand.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetExpand", + function () { + return _offset_expand__WEBPACK_IMPORTED_MODULE_32__.default; + } + ); + + /* Harmony import */ var _offset_diverging__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__( + /* ! ./offset/diverging */ "./node_modules/d3-shape/src/offset/diverging.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetDiverging", + function () { + return _offset_diverging__WEBPACK_IMPORTED_MODULE_33__.default; + } + ); + + /* Harmony import */ var _offset_none__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__( + /* ! ./offset/none */ "./node_modules/d3-shape/src/offset/none.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetNone", + function () { + return _offset_none__WEBPACK_IMPORTED_MODULE_34__.default; + } + ); + + /* Harmony import */ var _offset_silhouette__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__( + /* ! ./offset/silhouette */ "./node_modules/d3-shape/src/offset/silhouette.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetSilhouette", + function () { + return _offset_silhouette__WEBPACK_IMPORTED_MODULE_35__.default; + } + ); + + /* Harmony import */ var _offset_wiggle__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__( + /* ! ./offset/wiggle */ "./node_modules/d3-shape/src/offset/wiggle.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetWiggle", + function () { + return _offset_wiggle__WEBPACK_IMPORTED_MODULE_36__.default; + } + ); + + /* Harmony import */ var _order_appearance__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__( + /* ! ./order/appearance */ "./node_modules/d3-shape/src/order/appearance.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderAppearance", + function () { + return _order_appearance__WEBPACK_IMPORTED_MODULE_37__.default; + } + ); + + /* Harmony import */ var _order_ascending__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__( + /* ! ./order/ascending */ "./node_modules/d3-shape/src/order/ascending.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderAscending", + function () { + return _order_ascending__WEBPACK_IMPORTED_MODULE_38__.default; + } + ); + + /* Harmony import */ var _order_descending__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__( + /* ! ./order/descending */ "./node_modules/d3-shape/src/order/descending.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderDescending", + function () { + return _order_descending__WEBPACK_IMPORTED_MODULE_39__.default; + } + ); + + /* Harmony import */ var _order_insideOut__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__( + /* ! ./order/insideOut */ "./node_modules/d3-shape/src/order/insideOut.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderInsideOut", + function () { + return _order_insideOut__WEBPACK_IMPORTED_MODULE_40__.default; + } + ); + + /* Harmony import */ var _order_none__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__( + /* ! ./order/none */ "./node_modules/d3-shape/src/order/none.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderNone", + function () { + return _order_none__WEBPACK_IMPORTED_MODULE_41__.default; + } + ); + + /* Harmony import */ var _order_reverse__WEBPACK_IMPORTED_MODULE_42__ = __webpack_require__( + /* ! ./order/reverse */ "./node_modules/d3-shape/src/order/reverse.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderReverse", + function () { + return _order_reverse__WEBPACK_IMPORTED_MODULE_42__.default; + } + ); + + // Note: radialArea is deprecated! + + // Note: radialLine is deprecated! + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/line.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-shape/src/line.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-path */ "./node_modules/d3-path/src/index.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-shape/src/constant.js" + ); + /* Harmony import */ var _curve_linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./curve/linear */ "./node_modules/d3-shape/src/curve/linear.js" + ); + /* Harmony import */ var _point__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./point */ "./node_modules/d3-shape/src/point.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var x = _point__WEBPACK_IMPORTED_MODULE_3__.x, + y = _point__WEBPACK_IMPORTED_MODULE_3__.y, + defined = Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(true), + context = null, + curve = + _curve_linear__WEBPACK_IMPORTED_MODULE_2__.default, + output = null; + + function line(data) { + var i, + n = data.length, + d, + defined0 = false, + buffer; + if (context == null) + output = curve( + (buffer = Object( + d3_path__WEBPACK_IMPORTED_MODULE_0__.path + )()) + ); + + for (i = 0; i <= n; ++i) { + if ( + !(i < n && defined((d = data[i]), i, data)) === + defined0 + ) { + if ((defined0 = !defined0)) output.lineStart(); + else output.lineEnd(); + } + + if (defined0) + output.point(Number(x(d, i, data)), Number(y(d, i, data))); + } + + if (buffer) return (output = null), String(buffer) || null; + } + + line.x = function (_) { + return arguments.length + ? ((x = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + line) + : x; + }; + + line.y = function (_) { + return arguments.length + ? ((y = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + line) + : y; + }; + + line.defined = function (_) { + return arguments.length + ? ((defined = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Boolean(_))), + line) + : defined; + }; + + line.curve = function (_) { + return arguments.length + ? ((curve = _), + context != null && (output = curve(context)), + line) + : curve; + }; + + line.context = function (_) { + return arguments.length + ? (_ == null + ? (context = output = null) + : (output = curve((context = _))), + line) + : context; + }; + + return line; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/lineRadial.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-shape/src/lineRadial.js ***! + \*************************************************/ + /* ! exports provided: lineRadial, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "lineRadial", + function () { + return lineRadial; + } + ); + /* Harmony import */ var _curve_radial__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./curve/radial */ "./node_modules/d3-shape/src/curve/radial.js" + ); + /* Harmony import */ var _line__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./line */ "./node_modules/d3-shape/src/line.js" + ); + + function lineRadial(l) { + var c = l.curve; + (l.angle = l.x), delete l.x; + (l.radius = l.y), delete l.y; + + l.curve = function (_) { + return arguments.length + ? c( + Object( + _curve_radial__WEBPACK_IMPORTED_MODULE_0__.default + )(_) + ) + : c()._curve; + }; + + return l; + } + /* Harmony default export */ __webpack_exports__.default = function () { + return lineRadial( + Object( + _line__WEBPACK_IMPORTED_MODULE_1__.default + )().curve( + _curve_radial__WEBPACK_IMPORTED_MODULE_0__.curveRadialLinear + ) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/link/index.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-shape/src/link/index.js ***! + \*************************************************/ + /* ! exports provided: linkHorizontal, linkVertical, linkRadial */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "linkHorizontal", + function () { + return linkHorizontal; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "linkVertical", + function () { + return linkVertical; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "linkRadial", + function () { + return linkRadial; + } + ); + /* Harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-path */ "./node_modules/d3-path/src/index.js" + ); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../array */ "./node_modules/d3-shape/src/array.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ../constant */ "./node_modules/d3-shape/src/constant.js" + ); + /* Harmony import */ var _point__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ../point */ "./node_modules/d3-shape/src/point.js" + ); + /* Harmony import */ var _pointRadial__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ../pointRadial */ "./node_modules/d3-shape/src/pointRadial.js" + ); + + function linkSource(d) { + return d.source; + } + + function linkTarget(d) { + return d.target; + } + + function link(curve) { + var source = linkSource, + target = linkTarget, + x = _point__WEBPACK_IMPORTED_MODULE_3__.x, + y = _point__WEBPACK_IMPORTED_MODULE_3__.y, + context = null; + + function link() { + var buffer, + argv = _array__WEBPACK_IMPORTED_MODULE_1__.slice.call(arguments), + s = source.apply(this, argv), + t = target.apply(this, argv); + if (!context) + context = buffer = Object( + d3_path__WEBPACK_IMPORTED_MODULE_0__.path + )(); + curve( + context, + Number(x.apply(this, ((argv[0] = s), argv))), + Number(y.apply(this, argv)), + Number(x.apply(this, ((argv[0] = t), argv))), + Number(y.apply(this, argv)) + ); + if (buffer) return (context = null), String(buffer) || null; + } + + link.source = function (_) { + return arguments.length ? ((source = _), link) : source; + }; + + link.target = function (_) { + return arguments.length ? ((target = _), link) : target; + }; + + link.x = function (_) { + return arguments.length + ? ((x = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_2__.default + )(Number(_))), + link) + : x; + }; + + link.y = function (_) { + return arguments.length + ? ((y = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_2__.default + )(Number(_))), + link) + : y; + }; + + link.context = function (_) { + return arguments.length + ? ((context = _ == null ? null : _), link) + : context; + }; + + return link; + } + + function curveHorizontal(context, x0, y0, x1, y1) { + context.moveTo(x0, y0); + context.bezierCurveTo((x0 = (x0 + x1) / 2), y0, x0, y1, x1, y1); + } + + function curveVertical(context, x0, y0, x1, y1) { + context.moveTo(x0, y0); + context.bezierCurveTo(x0, (y0 = (y0 + y1) / 2), x1, y0, x1, y1); + } + + function curveRadial(context, x0, y0, x1, y1) { + var p0 = Object( + _pointRadial__WEBPACK_IMPORTED_MODULE_4__.default + )(x0, y0), + p1 = Object( + _pointRadial__WEBPACK_IMPORTED_MODULE_4__.default + )(x0, (y0 = (y0 + y1) / 2)), + p2 = Object( + _pointRadial__WEBPACK_IMPORTED_MODULE_4__.default + )(x1, y0), + p3 = Object( + _pointRadial__WEBPACK_IMPORTED_MODULE_4__.default + )(x1, y1); + context.moveTo(p0[0], p0[1]); + context.bezierCurveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]); + } + + function linkHorizontal() { + return link(curveHorizontal); + } + function linkVertical() { + return link(curveVertical); + } + function linkRadial() { + var l = link(curveRadial); + (l.angle = l.x), delete l.x; + (l.radius = l.y), delete l.y; + return l; + } + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/math.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-shape/src/math.js ***! + \*******************************************/ + /* ! exports provided: abs, atan2, cos, max, min, sin, sqrt, epsilon, pi, halfPi, tau, acos, asin */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "abs", + function () { + return abs; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "atan2", + function () { + return atan2; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cos", + function () { + return cos; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "max", + function () { + return max; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "min", + function () { + return min; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sin", + function () { + return sin; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sqrt", + function () { + return sqrt; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "epsilon", + function () { + return epsilon; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "pi", + function () { + return pi; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "halfPi", + function () { + return halfPi; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tau", + function () { + return tau; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "acos", + function () { + return acos; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "asin", + function () { + return asin; + } + ); + var abs = Math.abs; + var atan2 = Math.atan2; + var cos = Math.cos; + var max = Math.max; + var min = Math.min; + var sin = Math.sin; + var sqrt = Math.sqrt; + var epsilon = 1e-12; + var pi = Math.PI; + var halfPi = pi / 2; + var tau = 2 * pi; + function acos(x) { + return x > 1 ? 0 : x < -1 ? pi : Math.acos(x); + } + function asin(x) { + return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x); + } + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/noop.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-shape/src/noop.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function () {}; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/offset/diverging.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-shape/src/offset/diverging.js ***! + \*******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (series, order) { + if (!((n = series.length) > 0)) return; + + for ( + var i, j = 0, d, dy, yp, yn, n, m = series[order[0]].length; + j < m; + ++j + ) { + for (yp = yn = 0, i = 0; i < n; ++i) { + if ((dy = (d = series[order[i]][j])[1] - d[0]) >= 0) { + (d[0] = yp), (d[1] = yp += dy); + } else if (dy < 0) { + (d[1] = yn), (d[0] = yn += dy); + } else { + d[0] = yp; + } + } + } + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/offset/expand.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-shape/src/offset/expand.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./none */ "./node_modules/d3-shape/src/offset/none.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (series, order) { + if (!((n = series.length) > 0)) return; + + for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) { + for (y = i = 0; i < n; ++i) { + y += series[i][j][1] || 0; + } + + if (y) + for (i = 0; i < n; ++i) { + series[i][j][1] /= y; + } + } + + Object(_none__WEBPACK_IMPORTED_MODULE_0__.default)( + series, + order + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/offset/none.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-shape/src/offset/none.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (series, order) { + if (!((n = series.length) > 1)) return; + + for ( + var i = 1, j, s0, s1 = series[order[0]], n, m = s1.length; + i < n; + ++i + ) { + (s0 = s1), (s1 = series[order[i]]); + + for (j = 0; j < m; ++j) { + s1[j][1] += s1[j][0] = isNaN(s0[j][1]) + ? s0[j][0] + : s0[j][1]; + } + } + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/offset/silhouette.js": + /* !********************************************************!*\ + !*** ./node_modules/d3-shape/src/offset/silhouette.js ***! + \********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./none */ "./node_modules/d3-shape/src/offset/none.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (series, order) { + if (!((n = series.length) > 0)) return; + + for ( + var j = 0, s0 = series[order[0]], n, m = s0.length; + j < m; + ++j + ) { + for (var i = 0, y = 0; i < n; ++i) { + y += series[i][j][1] || 0; + } + + s0[j][1] += s0[j][0] = -y / 2; + } + + Object(_none__WEBPACK_IMPORTED_MODULE_0__.default)( + series, + order + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/offset/wiggle.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-shape/src/offset/wiggle.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./none */ "./node_modules/d3-shape/src/offset/none.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (series, order) { + if ( + !((n = series.length) > 0) || + !((m = (s0 = series[order[0]]).length) > 0) + ) + return; + + for (var y = 0, j = 1, s0, m, n; j < m; ++j) { + for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) { + var si = series[order[i]], + sij0 = si[j][1] || 0, + sij1 = si[j - 1][1] || 0, + s3 = (sij0 - sij1) / 2; + + for (var k = 0; k < i; ++k) { + var sk = series[order[k]], + skj0 = sk[j][1] || 0, + skj1 = sk[j - 1][1] || 0; + s3 += skj0 - skj1; + } + + (s1 += sij0), (s2 += s3 * sij0); + } + + s0[j - 1][1] += s0[j - 1][0] = y; + if (s1) y -= s2 / s1; + } + + s0[j - 1][1] += s0[j - 1][0] = y; + Object(_none__WEBPACK_IMPORTED_MODULE_0__.default)( + series, + order + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/order/appearance.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-shape/src/order/appearance.js ***! + \*******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./none */ "./node_modules/d3-shape/src/order/none.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (series) { + var peaks = series.map(peak); + return Object(_none__WEBPACK_IMPORTED_MODULE_0__.default)( + series + ).sort(function (a, b) { + return peaks[a] - peaks[b]; + }); + }; + + function peak(series) { + var i = -1, + j = 0, + n = series.length, + vi, + vj = -Infinity; + + while (++i < n) { + if ((vi = Number(series[i][1])) > vj) (vj = vi), (j = i); + } + + return j; + } + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/order/ascending.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-shape/src/order/ascending.js ***! + \******************************************************/ + /* ! exports provided: default, sum */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sum", + function () { + return sum; + } + ); + /* Harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./none */ "./node_modules/d3-shape/src/order/none.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (series) { + var sums = series.map(sum); + return Object(_none__WEBPACK_IMPORTED_MODULE_0__.default)( + series + ).sort(function (a, b) { + return sums[a] - sums[b]; + }); + }; + function sum(series) { + var s = 0, + i = -1, + n = series.length, + v; + + while (++i < n) { + if ((v = Number(series[i][1]))) s += v; + } + + return s; + } + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/order/descending.js": + /* !*******************************************************!*\ + !*** ./node_modules/d3-shape/src/order/descending.js ***! + \*******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./ascending */ "./node_modules/d3-shape/src/order/ascending.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (series) { + return Object( + _ascending__WEBPACK_IMPORTED_MODULE_0__.default + )(series).reverse(); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/order/insideOut.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-shape/src/order/insideOut.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _appearance__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./appearance */ "./node_modules/d3-shape/src/order/appearance.js" + ); + /* Harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./ascending */ "./node_modules/d3-shape/src/order/ascending.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (series) { + var n = series.length, + i, + j, + sums = series.map( + _ascending__WEBPACK_IMPORTED_MODULE_1__.sum + ), + order = Object( + _appearance__WEBPACK_IMPORTED_MODULE_0__.default + )(series), + top = 0, + bottom = 0, + tops = [], + bottoms = []; + + for (i = 0; i < n; ++i) { + j = order[i]; + + if (top < bottom) { + top += sums[j]; + tops.push(j); + } else { + bottom += sums[j]; + bottoms.push(j); + } + } + + return bottoms.reverse().concat(tops); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/order/none.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-shape/src/order/none.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (series) { + var n = series.length, + o = new Array(n); + + while (--n >= 0) { + o[n] = n; + } + + return o; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/order/reverse.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-shape/src/order/reverse.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./none */ "./node_modules/d3-shape/src/order/none.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (series) { + return Object(_none__WEBPACK_IMPORTED_MODULE_0__.default)( + series + ).reverse(); + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/pie.js": + /* !******************************************!*\ + !*** ./node_modules/d3-shape/src/pie.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-shape/src/constant.js" + ); + /* Harmony import */ var _descending__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./descending */ "./node_modules/d3-shape/src/descending.js" + ); + /* Harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./identity */ "./node_modules/d3-shape/src/identity.js" + ); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./math */ "./node_modules/d3-shape/src/math.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var value = _identity__WEBPACK_IMPORTED_MODULE_2__.default, + sortValues = + _descending__WEBPACK_IMPORTED_MODULE_1__.default, + sort = null, + startAngle = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(0), + endAngle = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(_math__WEBPACK_IMPORTED_MODULE_3__.tau), + padAngle = Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(0); + + function pie(data) { + var i, + n = data.length, + j, + k, + sum = 0, + index = new Array(n), + arcs = new Array(n), + a0 = Number(startAngle.apply(this, arguments)), + da = Math.min( + _math__WEBPACK_IMPORTED_MODULE_3__.tau, + Math.max( + -_math__WEBPACK_IMPORTED_MODULE_3__.tau, + endAngle.apply(this, arguments) - a0 + ) + ), + a1, + p = Math.min( + Math.abs(da) / n, + padAngle.apply(this, arguments) + ), + pa = p * (da < 0 ? -1 : 1), + v; + + for (i = 0; i < n; ++i) { + if ( + (v = arcs[(index[i] = i)] = Number(value( + data[i], + i, + data + ))) > 0 + ) { + sum += v; + } + } // Optionally sort the arcs by previously-computed values or by data. + + if (sortValues != null) + index.sort(function (i, j) { + return sortValues(arcs[i], arcs[j]); + }); + else if (sort != null) + index.sort(function (i, j) { + return sort(data[i], data[j]); + }); // Compute the arcs! They are stored in the original data's order. + + for ( + i = 0, k = sum ? (da - n * pa) / sum : 0; + i < n; + ++i, a0 = a1 + ) { + (j = index[i]), + (v = arcs[j]), + (a1 = a0 + (v > 0 ? v * k : 0) + pa), + (arcs[j] = { + data: data[j], + index: i, + value: v, + startAngle: a0, + endAngle: a1, + padAngle: p, + }); + } + + return arcs; + } + + pie.value = function (_) { + return arguments.length + ? ((value = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + pie) + : value; + }; + + pie.sortValues = function (_) { + return arguments.length + ? ((sortValues = _), (sort = null), pie) + : sortValues; + }; + + pie.sort = function (_) { + return arguments.length + ? ((sort = _), (sortValues = null), pie) + : sort; + }; + + pie.startAngle = function (_) { + return arguments.length + ? ((startAngle = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + pie) + : startAngle; + }; + + pie.endAngle = function (_) { + return arguments.length + ? ((endAngle = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + pie) + : endAngle; + }; + + pie.padAngle = function (_) { + return arguments.length + ? ((padAngle = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + pie) + : padAngle; + }; + + return pie; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/point.js": + /* !********************************************!*\ + !*** ./node_modules/d3-shape/src/point.js ***! + \********************************************/ + /* ! exports provided: x, y */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "x", + function () { + return x; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "y", + function () { + return y; + } + ); + function x(p) { + return p[0]; + } + function y(p) { + return p[1]; + } + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/pointRadial.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-shape/src/pointRadial.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x, y) { + return [ + (y = Number(y)) * Math.cos((x -= Math.PI / 2)), + y * Math.sin(x), + ]; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/stack.js": + /* !********************************************!*\ + !*** ./node_modules/d3-shape/src/stack.js ***! + \********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./array */ "./node_modules/d3-shape/src/array.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-shape/src/constant.js" + ); + /* Harmony import */ var _offset_none__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./offset/none */ "./node_modules/d3-shape/src/offset/none.js" + ); + /* Harmony import */ var _order_none__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./order/none */ "./node_modules/d3-shape/src/order/none.js" + ); + + function stackValue(d, key) { + return d[key]; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var keys = Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )([]), + order = _order_none__WEBPACK_IMPORTED_MODULE_3__.default, + offset = + _offset_none__WEBPACK_IMPORTED_MODULE_2__.default, + value = stackValue; + + function stack(data) { + var kz = keys.apply(this, arguments), + i, + m = data.length, + n = kz.length, + sz = new Array(n), + oz; + + for (i = 0; i < n; ++i) { + for ( + var ki = kz[i], + si = (sz[i] = new Array(m)), + j = 0, + sij; + j < m; + ++j + ) { + si[j] = sij = [0, Number(value(data[j], ki, j, data))]; + sij.data = data[j]; + } + + si.key = ki; + } + + for (i = 0, oz = order(sz); i < n; ++i) { + sz[oz[i]].index = i; + } + + offset(sz, oz); + return sz; + } + + stack.keys = function (_) { + return arguments.length + ? ((keys = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )( + _array__WEBPACK_IMPORTED_MODULE_0__.slice.call(_) + )), + stack) + : keys; + }; + + stack.value = function (_) { + return arguments.length + ? ((value = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )(Number(_))), + stack) + : value; + }; + + stack.order = function (_) { + return arguments.length + ? ((order = + _ == null + ? _order_none__WEBPACK_IMPORTED_MODULE_3__.default + : typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_1__.default + )( + _array__WEBPACK_IMPORTED_MODULE_0__.slice.call(_) + )), + stack) + : order; + }; + + stack.offset = function (_) { + return arguments.length + ? ((offset = + _ == null + ? _offset_none__WEBPACK_IMPORTED_MODULE_2__.default + : _), + stack) + : offset; + }; + + return stack; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/symbol.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-shape/src/symbol.js ***! + \*********************************************/ + /* ! exports provided: symbols, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "symbols", + function () { + return symbols; + } + ); + /* Harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-path */ "./node_modules/d3-path/src/index.js" + ); + /* Harmony import */ var _symbol_circle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./symbol/circle */ "./node_modules/d3-shape/src/symbol/circle.js" + ); + /* Harmony import */ var _symbol_cross__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./symbol/cross */ "./node_modules/d3-shape/src/symbol/cross.js" + ); + /* Harmony import */ var _symbol_diamond__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./symbol/diamond */ "./node_modules/d3-shape/src/symbol/diamond.js" + ); + /* Harmony import */ var _symbol_star__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./symbol/star */ "./node_modules/d3-shape/src/symbol/star.js" + ); + /* Harmony import */ var _symbol_square__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./symbol/square */ "./node_modules/d3-shape/src/symbol/square.js" + ); + /* Harmony import */ var _symbol_triangle__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./symbol/triangle */ "./node_modules/d3-shape/src/symbol/triangle.js" + ); + /* Harmony import */ var _symbol_wye__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./symbol/wye */ "./node_modules/d3-shape/src/symbol/wye.js" + ); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-shape/src/constant.js" + ); + + var symbols = [ + _symbol_circle__WEBPACK_IMPORTED_MODULE_1__.default, + _symbol_cross__WEBPACK_IMPORTED_MODULE_2__.default, + _symbol_diamond__WEBPACK_IMPORTED_MODULE_3__.default, + _symbol_square__WEBPACK_IMPORTED_MODULE_5__.default, + _symbol_star__WEBPACK_IMPORTED_MODULE_4__.default, + _symbol_triangle__WEBPACK_IMPORTED_MODULE_6__.default, + _symbol_wye__WEBPACK_IMPORTED_MODULE_7__.default, + ]; + /* Harmony default export */ __webpack_exports__.default = function () { + var type = Object( + _constant__WEBPACK_IMPORTED_MODULE_8__.default + )(_symbol_circle__WEBPACK_IMPORTED_MODULE_1__.default), + size = Object( + _constant__WEBPACK_IMPORTED_MODULE_8__.default + )(64), + context = null; + + function symbol() { + var buffer; + if (!context) + context = buffer = Object( + d3_path__WEBPACK_IMPORTED_MODULE_0__.path + )(); + type.apply(this, arguments).draw( + context, + Number(size.apply(this, arguments)) + ); + if (buffer) return (context = null), String(buffer) || null; + } + + symbol.type = function (_) { + return arguments.length + ? ((type = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_8__.default + )(_)), + symbol) + : type; + }; + + symbol.size = function (_) { + return arguments.length + ? ((size = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_8__.default + )(Number(_))), + symbol) + : size; + }; + + symbol.context = function (_) { + return arguments.length + ? ((context = _ == null ? null : _), symbol) + : context; + }; + + return symbol; + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/symbol/circle.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-shape/src/symbol/circle.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-shape/src/math.js" + ); + + /* Harmony default export */ __webpack_exports__.default = { + draw: function draw(context, size) { + var r = Math.sqrt( + size / _math__WEBPACK_IMPORTED_MODULE_0__.pi + ); + context.moveTo(r, 0); + context.arc( + 0, + 0, + r, + 0, + _math__WEBPACK_IMPORTED_MODULE_0__.tau + ); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/symbol/cross.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-shape/src/symbol/cross.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = { + draw: function draw(context, size) { + var r = Math.sqrt(size / 5) / 2; + context.moveTo(-3 * r, -r); + context.lineTo(-r, -r); + context.lineTo(-r, -3 * r); + context.lineTo(r, -3 * r); + context.lineTo(r, -r); + context.lineTo(3 * r, -r); + context.lineTo(3 * r, r); + context.lineTo(r, r); + context.lineTo(r, 3 * r); + context.lineTo(-r, 3 * r); + context.lineTo(-r, r); + context.lineTo(-3 * r, r); + context.closePath(); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/symbol/diamond.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-shape/src/symbol/diamond.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + var tan30 = Math.sqrt(1 / 3), + tan30_2 = tan30 * 2; + /* Harmony default export */ __webpack_exports__.default = { + draw: function draw(context, size) { + var y = Math.sqrt(size / tan30_2), + x = y * tan30; + context.moveTo(0, -y); + context.lineTo(x, 0); + context.lineTo(0, y); + context.lineTo(-x, 0); + context.closePath(); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/symbol/square.js": + /* !****************************************************!*\ + !*** ./node_modules/d3-shape/src/symbol/square.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = { + draw: function draw(context, size) { + var w = Math.sqrt(size), + x = -w / 2; + context.rect(x, x, w, w); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/symbol/star.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-shape/src/symbol/star.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../math */ "./node_modules/d3-shape/src/math.js" + ); + + var ka = 0.8908130915292852281, + kr = + Math.sin(_math__WEBPACK_IMPORTED_MODULE_0__.pi / 10) / + Math.sin( + (7 * _math__WEBPACK_IMPORTED_MODULE_0__.pi) / 10 + ), + kx = + Math.sin(_math__WEBPACK_IMPORTED_MODULE_0__.tau / 10) * + kr, + ky = + -Math.cos(_math__WEBPACK_IMPORTED_MODULE_0__.tau / 10) * + kr; + /* Harmony default export */ __webpack_exports__.default = { + draw: function draw(context, size) { + var r = Math.sqrt(size * ka), + x = kx * r, + y = ky * r; + context.moveTo(0, -r); + context.lineTo(x, y); + + for (var i = 1; i < 5; ++i) { + var a = + (_math__WEBPACK_IMPORTED_MODULE_0__.tau * + i) / + 5, + c = Math.cos(a), + s = Math.sin(a); + context.lineTo(s * r, -c * r); + context.lineTo(c * x - s * y, s * x + c * y); + } + + context.closePath(); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/symbol/triangle.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-shape/src/symbol/triangle.js ***! + \******************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + var sqrt3 = Math.sqrt(3); + /* Harmony default export */ __webpack_exports__.default = { + draw: function draw(context, size) { + var y = -Math.sqrt(size / (sqrt3 * 3)); + context.moveTo(0, y * 2); + context.lineTo(-sqrt3 * y, -y); + context.lineTo(sqrt3 * y, -y); + context.closePath(); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-shape/src/symbol/wye.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-shape/src/symbol/wye.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + var c = -0.5, + s = Math.sqrt(3) / 2, + k = 1 / Math.sqrt(12), + a = (k / 2 + 1) * 3; + /* Harmony default export */ __webpack_exports__.default = { + draw: function draw(context, size) { + var r = Math.sqrt(size / a), + x0 = r / 2, + y0 = r * k, + x1 = x0, + y1 = r * k + r, + x2 = -x1, + y2 = y1; + context.moveTo(x0, y0); + context.lineTo(x1, y1); + context.lineTo(x2, y2); + context.lineTo(c * x0 - s * y0, s * x0 + c * y0); + context.lineTo(c * x1 - s * y1, s * x1 + c * y1); + context.lineTo(c * x2 - s * y2, s * x2 + c * y2); + context.lineTo(c * x0 + s * y0, c * y0 - s * x0); + context.lineTo(c * x1 + s * y1, c * y1 - s * x1); + context.lineTo(c * x2 + s * y2, c * y2 - s * x2); + context.closePath(); + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-time-format/src/defaultLocale.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-time-format/src/defaultLocale.js ***! + \**********************************************************/ + /* ! exports provided: timeFormat, timeParse, utcFormat, utcParse, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "timeFormat", + function () { + return timeFormat; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "timeParse", + function () { + return timeParse; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcFormat", + function () { + return utcFormat; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcParse", + function () { + return utcParse; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return defaultLocale; + } + ); + /* Harmony import */ var _locale__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./locale */ "./node_modules/d3-time-format/src/locale.js" + ); + + var locale; + var timeFormat; + var timeParse; + var utcFormat; + var utcParse; + defaultLocale({ + dateTime: "%x, %X", + date: "%-m/%-d/%Y", + time: "%-I:%M:%S %p", + periods: ["AM", "PM"], + days: [ + "Sunday", + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday", + ], + shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], + months: [ + "January", + "February", + "March", + "April", + "May", + "June", + "July", + "August", + "September", + "October", + "November", + "December", + ], + shortMonths: [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec", + ], + }); + function defaultLocale(definition) { + locale = Object( + _locale__WEBPACK_IMPORTED_MODULE_0__.default + )(definition); + timeFormat = locale.format; + timeParse = locale.parse; + utcFormat = locale.utcFormat; + utcParse = locale.utcParse; + return locale; + } + + /***/ + }, + + /***/ "./node_modules/d3-time-format/src/index.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-time-format/src/index.js ***! + \**************************************************/ + /* ! exports provided: timeFormatDefaultLocale, timeFormat, timeParse, utcFormat, utcParse, timeFormatLocale, isoFormat, isoParse */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _defaultLocale__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultLocale */ "./node_modules/d3-time-format/src/defaultLocale.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFormatDefaultLocale", + function () { + return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFormat", + function () { + return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__.timeFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeParse", + function () { + return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__.timeParse; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcFormat", + function () { + return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__.utcFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcParse", + function () { + return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__.utcParse; + } + ); + + /* Harmony import */ var _locale__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./locale */ "./node_modules/d3-time-format/src/locale.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFormatLocale", + function () { + return _locale__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _isoFormat__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./isoFormat */ "./node_modules/d3-time-format/src/isoFormat.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "isoFormat", + function () { + return _isoFormat__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _isoParse__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./isoParse */ "./node_modules/d3-time-format/src/isoParse.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "isoParse", + function () { + return _isoParse__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-time-format/src/isoFormat.js": + /* !******************************************************!*\ + !*** ./node_modules/d3-time-format/src/isoFormat.js ***! + \******************************************************/ + /* ! exports provided: isoSpecifier, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "isoSpecifier", + function () { + return isoSpecifier; + } + ); + /* Harmony import */ var _defaultLocale__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./defaultLocale */ "./node_modules/d3-time-format/src/defaultLocale.js" + ); + + var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ"; + + function formatIsoNative(date) { + return date.toISOString(); + } + + var formatIso = Date.prototype.toISOString + ? formatIsoNative + : Object( + _defaultLocale__WEBPACK_IMPORTED_MODULE_0__.utcFormat + )(isoSpecifier); + /* Harmony default export */ __webpack_exports__.default = formatIso; + + /***/ + }, + + /***/ "./node_modules/d3-time-format/src/isoParse.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-time-format/src/isoParse.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _isoFormat__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./isoFormat */ "./node_modules/d3-time-format/src/isoFormat.js" + ); + /* Harmony import */ var _defaultLocale__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./defaultLocale */ "./node_modules/d3-time-format/src/defaultLocale.js" + ); + + function parseIsoNative(string) { + var date = new Date(string); + return isNaN(date) ? null : date; + } + + var parseIso = Number(new Date("2000-01-01T00:00:00.000Z")) + ? parseIsoNative + : Object( + _defaultLocale__WEBPACK_IMPORTED_MODULE_1__.utcParse + )(_isoFormat__WEBPACK_IMPORTED_MODULE_0__.isoSpecifier); + /* Harmony default export */ __webpack_exports__.default = parseIso; + + /***/ + }, + + /***/ "./node_modules/d3-time-format/src/locale.js": + /* !***************************************************!*\ + !*** ./node_modules/d3-time-format/src/locale.js ***! + \***************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return formatLocale; + } + ); + /* Harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-time */ "./node_modules/d3-time/src/index.js" + ); + + function localDate(d) { + if (d.y >= 0 && d.y < 100) { + var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L); + date.setFullYear(d.y); + return date; + } + + return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L); + } + + function utcDate(d) { + if (d.y >= 0 && d.y < 100) { + var date = new Date( + Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L) + ); + date.setUTCFullYear(d.y); + return date; + } + + return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L)); + } + + function newYear(y) { + return { + y: y, + m: 0, + d: 1, + H: 0, + M: 0, + S: 0, + L: 0, + }; + } + + function formatLocale(locale) { + var locale_dateTime = locale.dateTime, + locale_date = locale.date, + locale_time = locale.time, + locale_periods = locale.periods, + locale_weekdays = locale.days, + locale_shortWeekdays = locale.shortDays, + locale_months = locale.months, + locale_shortMonths = locale.shortMonths; + var periodRe = formatRe(locale_periods), + periodLookup = formatLookup(locale_periods), + weekdayRe = formatRe(locale_weekdays), + weekdayLookup = formatLookup(locale_weekdays), + shortWeekdayRe = formatRe(locale_shortWeekdays), + shortWeekdayLookup = formatLookup(locale_shortWeekdays), + monthRe = formatRe(locale_months), + monthLookup = formatLookup(locale_months), + shortMonthRe = formatRe(locale_shortMonths), + shortMonthLookup = formatLookup(locale_shortMonths); + var formats = { + a: formatShortWeekday, + A: formatWeekday, + b: formatShortMonth, + B: formatMonth, + c: null, + d: formatDayOfMonth, + e: formatDayOfMonth, + f: formatMicroseconds, + H: formatHour24, + I: formatHour12, + j: formatDayOfYear, + L: formatMilliseconds, + m: formatMonthNumber, + M: formatMinutes, + p: formatPeriod, + Q: formatUnixTimestamp, + s: formatUnixTimestampSeconds, + S: formatSeconds, + u: formatWeekdayNumberMonday, + U: formatWeekNumberSunday, + V: formatWeekNumberISO, + w: formatWeekdayNumberSunday, + W: formatWeekNumberMonday, + x: null, + X: null, + y: formatYear, + Y: formatFullYear, + Z: formatZone, + "%": formatLiteralPercent, + }; + var utcFormats = { + a: formatUTCShortWeekday, + A: formatUTCWeekday, + b: formatUTCShortMonth, + B: formatUTCMonth, + c: null, + d: formatUTCDayOfMonth, + e: formatUTCDayOfMonth, + f: formatUTCMicroseconds, + H: formatUTCHour24, + I: formatUTCHour12, + j: formatUTCDayOfYear, + L: formatUTCMilliseconds, + m: formatUTCMonthNumber, + M: formatUTCMinutes, + p: formatUTCPeriod, + Q: formatUnixTimestamp, + s: formatUnixTimestampSeconds, + S: formatUTCSeconds, + u: formatUTCWeekdayNumberMonday, + U: formatUTCWeekNumberSunday, + V: formatUTCWeekNumberISO, + w: formatUTCWeekdayNumberSunday, + W: formatUTCWeekNumberMonday, + x: null, + X: null, + y: formatUTCYear, + Y: formatUTCFullYear, + Z: formatUTCZone, + "%": formatLiteralPercent, + }; + var parses = { + a: parseShortWeekday, + A: parseWeekday, + b: parseShortMonth, + B: parseMonth, + c: parseLocaleDateTime, + d: parseDayOfMonth, + e: parseDayOfMonth, + f: parseMicroseconds, + H: parseHour24, + I: parseHour24, + j: parseDayOfYear, + L: parseMilliseconds, + m: parseMonthNumber, + M: parseMinutes, + p: parsePeriod, + Q: parseUnixTimestamp, + s: parseUnixTimestampSeconds, + S: parseSeconds, + u: parseWeekdayNumberMonday, + U: parseWeekNumberSunday, + V: parseWeekNumberISO, + w: parseWeekdayNumberSunday, + W: parseWeekNumberMonday, + x: parseLocaleDate, + X: parseLocaleTime, + y: parseYear, + Y: parseFullYear, + Z: parseZone, + "%": parseLiteralPercent, + }; // These recursive directive definitions must be deferred. + + formats.x = newFormat(locale_date, formats); + formats.X = newFormat(locale_time, formats); + formats.c = newFormat(locale_dateTime, formats); + utcFormats.x = newFormat(locale_date, utcFormats); + utcFormats.X = newFormat(locale_time, utcFormats); + utcFormats.c = newFormat(locale_dateTime, utcFormats); + + function newFormat(specifier, formats) { + return function (date) { + var string = [], + i = -1, + j = 0, + n = specifier.length, + c, + pad, + format; + if (!(date instanceof Date)) date = new Date(Number(date)); + + while (++i < n) { + if (specifier.charCodeAt(i) === 37) { + string.push(specifier.slice(j, i)); + if ( + (pad = pads[(c = specifier.charAt(++i))]) != + null + ) + c = specifier.charAt(++i); + else pad = c === "e" ? " " : "0"; + if ((format = formats[c])) + c = format(date, pad); + string.push(c); + j = i + 1; + } + } + + string.push(specifier.slice(j, i)); + return string.join(""); + }; + } + + function newParse(specifier, newDate) { + return function (string) { + var d = newYear(1900), + i = parseSpecifier(d, specifier, (string = String(string)), 0), + week, + day; + if (i != string.length) return null; // If a UNIX timestamp is specified, return it. + + if ("Q" in d) return new Date(d.Q); // The am-pm flag is 0 for AM, and 1 for PM. + + if ("p" in d) d.H = (d.H % 12) + d.p * 12; // Convert day-of-week and week-of-year to day-of-year. + + if ("V" in d) { + if (d.V < 1 || d.V > 53) return null; + if (!("w" in d)) d.w = 1; + + if ("Z" in d) { + (week = utcDate(newYear(d.y))), + (day = week.getUTCDay()); + week = + day > 4 || day === 0 + ? d3_time__WEBPACK_IMPORTED_MODULE_0__.utcMonday.ceil(week) + : Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.utcMonday + )(week); + week = d3_time__WEBPACK_IMPORTED_MODULE_0__.utcDay.offset(week, (d.V - 1) * 7); + d.y = week.getUTCFullYear(); + d.m = week.getUTCMonth(); + d.d = week.getUTCDate() + ((d.w + 6) % 7); + } else { + (week = newDate(newYear(d.y))), + (day = week.getDay()); + week = + day > 4 || day === 0 + ? d3_time__WEBPACK_IMPORTED_MODULE_0__.timeMonday.ceil(week) + : Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeMonday + )(week); + week = d3_time__WEBPACK_IMPORTED_MODULE_0__.timeDay.offset(week, (d.V - 1) * 7); + d.y = week.getFullYear(); + d.m = week.getMonth(); + d.d = week.getDate() + ((d.w + 6) % 7); + } + } else if ("W" in d || "U" in d) { + if (!("w" in d)) + d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0; + day = + "Z" in d + ? utcDate(newYear(d.y)).getUTCDay() + : newDate(newYear(d.y)).getDay(); + d.m = 0; + d.d = + "W" in d + ? ((d.w + 6) % 7) + + d.W * 7 - + ((day + 5) % 7) + : d.w + d.U * 7 - ((day + 6) % 7); + } // If a time zone is specified, all fields are interpreted as UTC and then + // offset according to the specified time zone. + + if ("Z" in d) { + d.H += (d.Z / 100) | 0; + d.M += d.Z % 100; + return utcDate(d); + } // Otherwise, all fields are in local time. + + return newDate(d); + }; + } + + function parseSpecifier(d, specifier, string, j) { + var i = 0, + n = specifier.length, + m = string.length, + c, + parse; + + while (i < n) { + if (j >= m) return -1; + c = specifier.charCodeAt(i++); + + if (c === 37) { + c = specifier.charAt(i++); + parse = + parses[c in pads ? specifier.charAt(i++) : c]; + if (!parse || (j = parse(d, string, j)) < 0) + return -1; + } else if (c != string.charCodeAt(j++)) { + return -1; + } + } + + return j; + } + + function parsePeriod(d, string, i) { + var n = periodRe.exec(string.slice(i)); + return n + ? ((d.p = periodLookup[n[0].toLowerCase()]), + i + n[0].length) + : -1; + } + + function parseShortWeekday(d, string, i) { + var n = shortWeekdayRe.exec(string.slice(i)); + return n + ? ((d.w = shortWeekdayLookup[n[0].toLowerCase()]), + i + n[0].length) + : -1; + } + + function parseWeekday(d, string, i) { + var n = weekdayRe.exec(string.slice(i)); + return n + ? ((d.w = weekdayLookup[n[0].toLowerCase()]), + i + n[0].length) + : -1; + } + + function parseShortMonth(d, string, i) { + var n = shortMonthRe.exec(string.slice(i)); + return n + ? ((d.m = shortMonthLookup[n[0].toLowerCase()]), + i + n[0].length) + : -1; + } + + function parseMonth(d, string, i) { + var n = monthRe.exec(string.slice(i)); + return n + ? ((d.m = monthLookup[n[0].toLowerCase()]), + i + n[0].length) + : -1; + } + + function parseLocaleDateTime(d, string, i) { + return parseSpecifier(d, locale_dateTime, string, i); + } + + function parseLocaleDate(d, string, i) { + return parseSpecifier(d, locale_date, string, i); + } + + function parseLocaleTime(d, string, i) { + return parseSpecifier(d, locale_time, string, i); + } + + function formatShortWeekday(d) { + return locale_shortWeekdays[d.getDay()]; + } + + function formatWeekday(d) { + return locale_weekdays[d.getDay()]; + } + + function formatShortMonth(d) { + return locale_shortMonths[d.getMonth()]; + } + + function formatMonth(d) { + return locale_months[d.getMonth()]; + } + + function formatPeriod(d) { + return locale_periods[Number(d.getHours() >= 12)]; + } + + function formatUTCShortWeekday(d) { + return locale_shortWeekdays[d.getUTCDay()]; + } + + function formatUTCWeekday(d) { + return locale_weekdays[d.getUTCDay()]; + } + + function formatUTCShortMonth(d) { + return locale_shortMonths[d.getUTCMonth()]; + } + + function formatUTCMonth(d) { + return locale_months[d.getUTCMonth()]; + } + + function formatUTCPeriod(d) { + return locale_periods[Number(d.getUTCHours() >= 12)]; + } + + return { + format: function format(specifier) { + var f = newFormat((specifier = String(specifier)), formats); + + f.toString = function () { + return specifier; + }; + + return f; + }, + parse: function parse(specifier) { + var p = newParse((specifier = String(specifier)), localDate); + + p.toString = function () { + return specifier; + }; + + return p; + }, + utcFormat: function utcFormat(specifier) { + var f = newFormat((specifier = String(specifier)), utcFormats); + + f.toString = function () { + return specifier; + }; + + return f; + }, + utcParse: function utcParse(specifier) { + var p = newParse(specifier, utcDate); + + p.toString = function () { + return specifier; + }; + + return p; + }, + }; + } + var pads = { + "-": "", + _: " ", + 0: "0", + }, + numberRe = /^\s*\d+/, + // Note: ignores next directive + percentRe = /^%/, + requoteRe = /[\\^$*+?|[\]().{}]/g; + + function pad(value, fill, width) { + var sign = value < 0 ? "-" : "", + string = String(sign ? -value : value), + length = string.length; + return ( + sign + + (length < width + ? new Array(width - length + 1).join(fill) + string + : string) + ); + } + + function requote(s) { + return s.replace(requoteRe, "\\$&"); + } + + function formatRe(names) { + return new RegExp( + "^(?:" + names.map(requote).join("|") + ")", + "i" + ); + } + + function formatLookup(names) { + var map = {}, + i = -1, + n = names.length; + + while (++i < n) { + map[names[i].toLowerCase()] = i; + } + + return map; + } + + function parseWeekdayNumberSunday(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 1)); + return n ? ((d.w = Number(n[0])), i + n[0].length) : -1; + } + + function parseWeekdayNumberMonday(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 1)); + return n ? ((d.u = Number(n[0])), i + n[0].length) : -1; + } + + function parseWeekNumberSunday(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? ((d.U = Number(n[0])), i + n[0].length) : -1; + } + + function parseWeekNumberISO(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? ((d.V = Number(n[0])), i + n[0].length) : -1; + } + + function parseWeekNumberMonday(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? ((d.W = Number(n[0])), i + n[0].length) : -1; + } + + function parseFullYear(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 4)); + return n ? ((d.y = Number(n[0])), i + n[0].length) : -1; + } + + function parseYear(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n + ? ((d.y = Number(n[0]) + (Number(n[0]) > 68 ? 1900 : 2000)), + i + n[0].length) + : -1; + } + + function parseZone(d, string, i) { + var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec( + string.slice(i, i + 6) + ); + return n + ? ((d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00"))), + i + n[0].length) + : -1; + } + + function parseMonthNumber(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? ((d.m = n[0] - 1), i + n[0].length) : -1; + } + + function parseDayOfMonth(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? ((d.d = Number(n[0])), i + n[0].length) : -1; + } + + function parseDayOfYear(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 3)); + return n ? ((d.m = 0), (d.d = Number(n[0])), i + n[0].length) : -1; + } + + function parseHour24(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? ((d.H = Number(n[0])), i + n[0].length) : -1; + } + + function parseMinutes(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? ((d.M = Number(n[0])), i + n[0].length) : -1; + } + + function parseSeconds(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 2)); + return n ? ((d.S = Number(n[0])), i + n[0].length) : -1; + } + + function parseMilliseconds(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 3)); + return n ? ((d.L = Number(n[0])), i + n[0].length) : -1; + } + + function parseMicroseconds(d, string, i) { + var n = numberRe.exec(string.slice(i, i + 6)); + return n + ? ((d.L = Math.floor(n[0] / 1000)), i + n[0].length) + : -1; + } + + function parseLiteralPercent(d, string, i) { + var n = percentRe.exec(string.slice(i, i + 1)); + return n ? i + n[0].length : -1; + } + + function parseUnixTimestamp(d, string, i) { + var n = numberRe.exec(string.slice(i)); + return n ? ((d.Q = Number(n[0])), i + n[0].length) : -1; + } + + function parseUnixTimestampSeconds(d, string, i) { + var n = numberRe.exec(string.slice(i)); + return n ? ((d.Q = Number(n[0]) * 1000), i + n[0].length) : -1; + } + + function formatDayOfMonth(d, p) { + return pad(d.getDate(), p, 2); + } + + function formatHour24(d, p) { + return pad(d.getHours(), p, 2); + } + + function formatHour12(d, p) { + return pad(d.getHours() % 12 || 12, p, 2); + } + + function formatDayOfYear(d, p) { + return pad( + 1 + + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeDay.count( + Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeYear + )(d), + d + ), + p, + 3 + ); + } + + function formatMilliseconds(d, p) { + return pad(d.getMilliseconds(), p, 3); + } + + function formatMicroseconds(d, p) { + return formatMilliseconds(d, p) + "000"; + } + + function formatMonthNumber(d, p) { + return pad(d.getMonth() + 1, p, 2); + } + + function formatMinutes(d, p) { + return pad(d.getMinutes(), p, 2); + } + + function formatSeconds(d, p) { + return pad(d.getSeconds(), p, 2); + } + + function formatWeekdayNumberMonday(d) { + var day = d.getDay(); + return day === 0 ? 7 : day; + } + + function formatWeekNumberSunday(d, p) { + return pad( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeSunday.count( + Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeYear + )(d), + d + ), + p, + 2 + ); + } + + function formatWeekNumberISO(d, p) { + var day = d.getDay(); + d = + day >= 4 || day === 0 + ? Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeThursday + )(d) + : d3_time__WEBPACK_IMPORTED_MODULE_0__.timeThursday.ceil(d); + return pad( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeThursday.count( + Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeYear + )(d), + d + ) + + (Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeYear + )(d).getDay() === + 4), + p, + 2 + ); + } + + function formatWeekdayNumberSunday(d) { + return d.getDay(); + } + + function formatWeekNumberMonday(d, p) { + return pad( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeMonday.count( + Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.timeYear + )(d), + d + ), + p, + 2 + ); + } + + function formatYear(d, p) { + return pad(d.getFullYear() % 100, p, 2); + } + + function formatFullYear(d, p) { + return pad(d.getFullYear() % 10000, p, 4); + } + + function formatZone(d) { + var z = d.getTimezoneOffset(); + return ( + (z > 0 ? "-" : ((z *= -1), "+")) + + pad((z / 60) | 0, "0", 2) + + pad(z % 60, "0", 2) + ); + } + + function formatUTCDayOfMonth(d, p) { + return pad(d.getUTCDate(), p, 2); + } + + function formatUTCHour24(d, p) { + return pad(d.getUTCHours(), p, 2); + } + + function formatUTCHour12(d, p) { + return pad(d.getUTCHours() % 12 || 12, p, 2); + } + + function formatUTCDayOfYear(d, p) { + return pad( + 1 + + d3_time__WEBPACK_IMPORTED_MODULE_0__.utcDay.count( + Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.utcYear + )(d), + d + ), + p, + 3 + ); + } + + function formatUTCMilliseconds(d, p) { + return pad(d.getUTCMilliseconds(), p, 3); + } + + function formatUTCMicroseconds(d, p) { + return formatUTCMilliseconds(d, p) + "000"; + } + + function formatUTCMonthNumber(d, p) { + return pad(d.getUTCMonth() + 1, p, 2); + } + + function formatUTCMinutes(d, p) { + return pad(d.getUTCMinutes(), p, 2); + } + + function formatUTCSeconds(d, p) { + return pad(d.getUTCSeconds(), p, 2); + } + + function formatUTCWeekdayNumberMonday(d) { + var dow = d.getUTCDay(); + return dow === 0 ? 7 : dow; + } + + function formatUTCWeekNumberSunday(d, p) { + return pad( + d3_time__WEBPACK_IMPORTED_MODULE_0__.utcSunday.count( + Object(d3_time__WEBPACK_IMPORTED_MODULE_0__.utcYear)( + d + ), + d + ), + p, + 2 + ); + } + + function formatUTCWeekNumberISO(d, p) { + var day = d.getUTCDay(); + d = + day >= 4 || day === 0 + ? Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.utcThursday + )(d) + : d3_time__WEBPACK_IMPORTED_MODULE_0__.utcThursday.ceil(d); + return pad( + d3_time__WEBPACK_IMPORTED_MODULE_0__.utcThursday.count( + Object(d3_time__WEBPACK_IMPORTED_MODULE_0__.utcYear)( + d + ), + d + ) + + (Object( + d3_time__WEBPACK_IMPORTED_MODULE_0__.utcYear + )(d).getUTCDay() === + 4), + p, + 2 + ); + } + + function formatUTCWeekdayNumberSunday(d) { + return d.getUTCDay(); + } + + function formatUTCWeekNumberMonday(d, p) { + return pad( + d3_time__WEBPACK_IMPORTED_MODULE_0__.utcMonday.count( + Object(d3_time__WEBPACK_IMPORTED_MODULE_0__.utcYear)( + d + ), + d + ), + p, + 2 + ); + } + + function formatUTCYear(d, p) { + return pad(d.getUTCFullYear() % 100, p, 2); + } + + function formatUTCFullYear(d, p) { + return pad(d.getUTCFullYear() % 10000, p, 4); + } + + function formatUTCZone() { + return "+0000"; + } + + function formatLiteralPercent() { + return "%"; + } + + function formatUnixTimestamp(d) { + return Number(d); + } + + function formatUnixTimestampSeconds(d) { + return Math.floor(Number(d) / 1000); + } + + /***/ + }, + + /***/ "./node_modules/d3-time/src/day.js": + /* !*****************************************!*\ + !*** ./node_modules/d3-time/src/day.js ***! + \*****************************************/ + /* ! exports provided: default, days */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "days", + function () { + return days; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + var day = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setHours(0, 0, 0, 0); + }, + function (date, step) { + date.setDate(date.getDate() + step); + }, + function (start, end) { + return ( + (end - + start - + (end.getTimezoneOffset() - + start.getTimezoneOffset()) * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationMinute) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationDay + ); + }, + function (date) { + return date.getDate() - 1; + } + ); + /* Harmony default export */ __webpack_exports__.default = day; + var days = day.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/duration.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-time/src/duration.js ***! + \**********************************************/ + /* ! exports provided: durationSecond, durationMinute, durationHour, durationDay, durationWeek */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "durationSecond", + function () { + return durationSecond; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "durationMinute", + function () { + return durationMinute; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "durationHour", + function () { + return durationHour; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "durationDay", + function () { + return durationDay; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "durationWeek", + function () { + return durationWeek; + } + ); + var durationSecond = 1e3; + var durationMinute = 6e4; + var durationHour = 36e5; + var durationDay = 864e5; + var durationWeek = 6048e5; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/hour.js": + /* !******************************************!*\ + !*** ./node_modules/d3-time/src/hour.js ***! + \******************************************/ + /* ! exports provided: default, hours */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "hours", + function () { + return hours; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + var hour = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setTime( + date - + date.getMilliseconds() - + date.getSeconds() * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationSecond - + date.getMinutes() * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationMinute + ); + }, + function (date, step) { + date.setTime( + Number(date) + + step * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationHour + ); + }, + function (start, end) { + return ( + (end - start) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationHour + ); + }, + function (date) { + return date.getHours(); + } + ); + /* Harmony default export */ __webpack_exports__.default = hour; + var hours = hour.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/index.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-time/src/index.js ***! + \*******************************************/ + /* ! exports provided: timeInterval, timeMillisecond, timeMilliseconds, utcMillisecond, utcMilliseconds, timeSecond, timeSeconds, utcSecond, utcSeconds, timeMinute, timeMinutes, timeHour, timeHours, timeDay, timeDays, timeWeek, timeWeeks, timeSunday, timeSundays, timeMonday, timeMondays, timeTuesday, timeTuesdays, timeWednesday, timeWednesdays, timeThursday, timeThursdays, timeFriday, timeFridays, timeSaturday, timeSaturdays, timeMonth, timeMonths, timeYear, timeYears, utcMinute, utcMinutes, utcHour, utcHours, utcDay, utcDays, utcWeek, utcWeeks, utcSunday, utcSundays, utcMonday, utcMondays, utcTuesday, utcTuesdays, utcWednesday, utcWednesdays, utcThursday, utcThursdays, utcFriday, utcFridays, utcSaturday, utcSaturdays, utcMonth, utcMonths, utcYear, utcYears */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeInterval", + function () { + return _interval_js__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _millisecond_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./millisecond.js */ "./node_modules/d3-time/src/millisecond.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMillisecond", + function () { + return _millisecond_js__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMilliseconds", + function () { + return _millisecond_js__WEBPACK_IMPORTED_MODULE_1__.milliseconds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMillisecond", + function () { + return _millisecond_js__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMilliseconds", + function () { + return _millisecond_js__WEBPACK_IMPORTED_MODULE_1__.milliseconds; + } + ); + + /* Harmony import */ var _second_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./second.js */ "./node_modules/d3-time/src/second.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSecond", + function () { + return _second_js__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSeconds", + function () { + return _second_js__WEBPACK_IMPORTED_MODULE_2__.seconds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSecond", + function () { + return _second_js__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSeconds", + function () { + return _second_js__WEBPACK_IMPORTED_MODULE_2__.seconds; + } + ); + + /* Harmony import */ var _minute_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./minute.js */ "./node_modules/d3-time/src/minute.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMinute", + function () { + return _minute_js__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMinutes", + function () { + return _minute_js__WEBPACK_IMPORTED_MODULE_3__.minutes; + } + ); + + /* Harmony import */ var _hour_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./hour.js */ "./node_modules/d3-time/src/hour.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeHour", + function () { + return _hour_js__WEBPACK_IMPORTED_MODULE_4__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeHours", + function () { + return _hour_js__WEBPACK_IMPORTED_MODULE_4__.hours; + } + ); + + /* Harmony import */ var _day_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./day.js */ "./node_modules/d3-time/src/day.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeDay", + function () { + return _day_js__WEBPACK_IMPORTED_MODULE_5__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeDays", + function () { + return _day_js__WEBPACK_IMPORTED_MODULE_5__.days; + } + ); + + /* Harmony import */ var _week_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./week.js */ "./node_modules/d3-time/src/week.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeWeek", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.sunday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeWeeks", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.sundays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSunday", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.sunday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSundays", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.sundays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMonday", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.monday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMondays", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.mondays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeTuesday", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.tuesday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeTuesdays", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.tuesdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeWednesday", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.wednesday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeWednesdays", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.wednesdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeThursday", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.thursday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeThursdays", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.thursdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFriday", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.friday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFridays", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.fridays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSaturday", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.saturday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSaturdays", + function () { + return _week_js__WEBPACK_IMPORTED_MODULE_6__.saturdays; + } + ); + + /* Harmony import */ var _month_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./month.js */ "./node_modules/d3-time/src/month.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMonth", + function () { + return _month_js__WEBPACK_IMPORTED_MODULE_7__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMonths", + function () { + return _month_js__WEBPACK_IMPORTED_MODULE_7__.months; + } + ); + + /* Harmony import */ var _year_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./year.js */ "./node_modules/d3-time/src/year.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeYear", + function () { + return _year_js__WEBPACK_IMPORTED_MODULE_8__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeYears", + function () { + return _year_js__WEBPACK_IMPORTED_MODULE_8__.years; + } + ); + + /* Harmony import */ var _utcMinute_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./utcMinute.js */ "./node_modules/d3-time/src/utcMinute.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMinute", + function () { + return _utcMinute_js__WEBPACK_IMPORTED_MODULE_9__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMinutes", + function () { + return _utcMinute_js__WEBPACK_IMPORTED_MODULE_9__.utcMinutes; + } + ); + + /* Harmony import */ var _utcHour_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./utcHour.js */ "./node_modules/d3-time/src/utcHour.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcHour", + function () { + return _utcHour_js__WEBPACK_IMPORTED_MODULE_10__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcHours", + function () { + return _utcHour_js__WEBPACK_IMPORTED_MODULE_10__.utcHours; + } + ); + + /* Harmony import */ var _utcDay_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./utcDay.js */ "./node_modules/d3-time/src/utcDay.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcDay", + function () { + return _utcDay_js__WEBPACK_IMPORTED_MODULE_11__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcDays", + function () { + return _utcDay_js__WEBPACK_IMPORTED_MODULE_11__.utcDays; + } + ); + + /* Harmony import */ var _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./utcWeek.js */ "./node_modules/d3-time/src/utcWeek.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcWeek", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcSunday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcWeeks", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcSundays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSunday", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcSunday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSundays", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcSundays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMonday", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcMonday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMondays", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcMondays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcTuesday", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcTuesday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcTuesdays", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcTuesdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcWednesday", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcWednesday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcWednesdays", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcWednesdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcThursday", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcThursday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcThursdays", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcThursdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcFriday", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcFriday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcFridays", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcFridays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSaturday", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcSaturday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSaturdays", + function () { + return _utcWeek_js__WEBPACK_IMPORTED_MODULE_12__.utcSaturdays; + } + ); + + /* Harmony import */ var _utcMonth_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./utcMonth.js */ "./node_modules/d3-time/src/utcMonth.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMonth", + function () { + return _utcMonth_js__WEBPACK_IMPORTED_MODULE_13__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMonths", + function () { + return _utcMonth_js__WEBPACK_IMPORTED_MODULE_13__.utcMonths; + } + ); + + /* Harmony import */ var _utcYear_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./utcYear.js */ "./node_modules/d3-time/src/utcYear.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcYear", + function () { + return _utcYear_js__WEBPACK_IMPORTED_MODULE_14__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcYears", + function () { + return _utcYear_js__WEBPACK_IMPORTED_MODULE_14__.utcYears; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-time/src/interval.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-time/src/interval.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return newInterval; + } + ); + var t0 = new Date(), + t1 = new Date(); + function newInterval(floori, offseti, count, field) { + function interval(date) { + return ( + floori( + (date = + arguments.length === 0 + ? new Date() + : new Date(Number(date))) + ), + date + ); + } + + interval.floor = function (date) { + return floori((date = new Date(Number(date)))), date; + }; + + interval.ceil = function (date) { + return ( + floori((date = new Date(date - 1))), + offseti(date, 1), + floori(date), + date + ); + }; + + interval.round = function (date) { + var d0 = interval(date), + d1 = interval.ceil(date); + return date - d0 < d1 - date ? d0 : d1; + }; + + interval.offset = function (date, step) { + return ( + offseti( + (date = new Date(Number(date))), + step == null ? 1 : Math.floor(step) + ), + date + ); + }; + + interval.range = function (start, stop, step) { + var range = [], + previous; + start = interval.ceil(start); + step = step == null ? 1 : Math.floor(step); + if (!(start < stop) || !(step > 0)) return range; // Also handles Invalid Date + + do { + range.push((previous = new Date(Number(start)))), + offseti(start, step), + floori(start); + } while (previous < start && start < stop); + + return range; + }; + + interval.filter = function (test) { + return newInterval( + function (date) { + if (date >= date) + while ((floori(date), !test(date))) { + date.setTime(date - 1); + } + }, + function (date, step) { + if (date >= date) { + if (step < 0) + while (++step <= 0) { + while ( + (offseti(date, -1), !test(date)) + ) {} // eslint-disable-line no-empty + } + else + while (--step >= 0) { + while ( + (offseti(date, +1), !test(date)) + ) {} // eslint-disable-line no-empty + } + } + } + ); + }; + + if (count) { + interval.count = function (start, end) { + t0.setTime(Number(start)), t1.setTime(Number(end)); + floori(t0), floori(t1); + return Math.floor(count(t0, t1)); + }; + + interval.every = function (step) { + step = Math.floor(step); + return !isFinite(step) || !(step > 0) + ? null + : !(step > 1) + ? interval + : interval.filter( + field + ? function (d) { + return field(d) % step === 0; + } + : function (d) { + return ( + interval.count(0, d) % step === + 0 + ); + } + ); + }; + } + + return interval; + } + + /***/ + }, + + /***/ "./node_modules/d3-time/src/millisecond.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-time/src/millisecond.js ***! + \*************************************************/ + /* ! exports provided: default, milliseconds */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "milliseconds", + function () { + return milliseconds; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + + var millisecond = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function () { + // Noop + }, + function (date, step) { + date.setTime(Number(date) + step); + }, + function (start, end) { + return end - start; + } + ); // An optimized implementation for this simple case. + + millisecond.every = function (k) { + k = Math.floor(k); + if (!isFinite(k) || !(k > 0)) return null; + if (!(k > 1)) return millisecond; + return Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setTime(Math.floor(date / k) * k); + }, + function (date, step) { + date.setTime(Number(date) + step * k); + }, + function (start, end) { + return (end - start) / k; + } + ); + }; + + /* Harmony default export */ __webpack_exports__.default = millisecond; + var milliseconds = millisecond.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/minute.js": + /* !********************************************!*\ + !*** ./node_modules/d3-time/src/minute.js ***! + \********************************************/ + /* ! exports provided: default, minutes */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "minutes", + function () { + return minutes; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + var minute = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setTime( + date - + date.getMilliseconds() - + date.getSeconds() * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationSecond + ); + }, + function (date, step) { + date.setTime( + Number(date) + + step * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationMinute + ); + }, + function (start, end) { + return ( + (end - start) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationMinute + ); + }, + function (date) { + return date.getMinutes(); + } + ); + /* Harmony default export */ __webpack_exports__.default = minute; + var minutes = minute.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/month.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-time/src/month.js ***! + \*******************************************/ + /* ! exports provided: default, months */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "months", + function () { + return months; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + + var month = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setDate(1); + date.setHours(0, 0, 0, 0); + }, + function (date, step) { + date.setMonth(date.getMonth() + step); + }, + function (start, end) { + return ( + end.getMonth() - + start.getMonth() + + (end.getFullYear() - start.getFullYear()) * 12 + ); + }, + function (date) { + return date.getMonth(); + } + ); + /* Harmony default export */ __webpack_exports__.default = month; + var months = month.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/second.js": + /* !********************************************!*\ + !*** ./node_modules/d3-time/src/second.js ***! + \********************************************/ + /* ! exports provided: default, seconds */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "seconds", + function () { + return seconds; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + var second = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setTime(date - date.getMilliseconds()); + }, + function (date, step) { + date.setTime( + Number(date) + + step * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationSecond + ); + }, + function (start, end) { + return ( + (end - start) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationSecond + ); + }, + function (date) { + return date.getUTCSeconds(); + } + ); + /* Harmony default export */ __webpack_exports__.default = second; + var seconds = second.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/utcDay.js": + /* !********************************************!*\ + !*** ./node_modules/d3-time/src/utcDay.js ***! + \********************************************/ + /* ! exports provided: default, utcDays */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcDays", + function () { + return utcDays; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + var utcDay = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setUTCHours(0, 0, 0, 0); + }, + function (date, step) { + date.setUTCDate(date.getUTCDate() + step); + }, + function (start, end) { + return ( + (end - start) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationDay + ); + }, + function (date) { + return date.getUTCDate() - 1; + } + ); + /* Harmony default export */ __webpack_exports__.default = utcDay; + var utcDays = utcDay.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/utcHour.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-time/src/utcHour.js ***! + \*********************************************/ + /* ! exports provided: default, utcHours */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcHours", + function () { + return utcHours; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + var utcHour = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setUTCMinutes(0, 0, 0); + }, + function (date, step) { + date.setTime( + Number(date) + + step * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationHour + ); + }, + function (start, end) { + return ( + (end - start) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationHour + ); + }, + function (date) { + return date.getUTCHours(); + } + ); + /* Harmony default export */ __webpack_exports__.default = utcHour; + var utcHours = utcHour.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/utcMinute.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-time/src/utcMinute.js ***! + \***********************************************/ + /* ! exports provided: default, utcMinutes */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcMinutes", + function () { + return utcMinutes; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + var utcMinute = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setUTCSeconds(0, 0); + }, + function (date, step) { + date.setTime( + Number(date) + + step * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationMinute + ); + }, + function (start, end) { + return ( + (end - start) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationMinute + ); + }, + function (date) { + return date.getUTCMinutes(); + } + ); + /* Harmony default export */ __webpack_exports__.default = utcMinute; + var utcMinutes = utcMinute.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/utcMonth.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-time/src/utcMonth.js ***! + \**********************************************/ + /* ! exports provided: default, utcMonths */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcMonths", + function () { + return utcMonths; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + + var utcMonth = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setUTCDate(1); + date.setUTCHours(0, 0, 0, 0); + }, + function (date, step) { + date.setUTCMonth(date.getUTCMonth() + step); + }, + function (start, end) { + return ( + end.getUTCMonth() - + start.getUTCMonth() + + (end.getUTCFullYear() - start.getUTCFullYear()) * 12 + ); + }, + function (date) { + return date.getUTCMonth(); + } + ); + /* Harmony default export */ __webpack_exports__.default = utcMonth; + var utcMonths = utcMonth.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/utcWeek.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-time/src/utcWeek.js ***! + \*********************************************/ + /* ! exports provided: utcSunday, utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSundays, utcMondays, utcTuesdays, utcWednesdays, utcThursdays, utcFridays, utcSaturdays */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcSunday", + function () { + return utcSunday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcMonday", + function () { + return utcMonday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcTuesday", + function () { + return utcTuesday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcWednesday", + function () { + return utcWednesday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcThursday", + function () { + return utcThursday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcFriday", + function () { + return utcFriday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcSaturday", + function () { + return utcSaturday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcSundays", + function () { + return utcSundays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcMondays", + function () { + return utcMondays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcTuesdays", + function () { + return utcTuesdays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcWednesdays", + function () { + return utcWednesdays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcThursdays", + function () { + return utcThursdays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcFridays", + function () { + return utcFridays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcSaturdays", + function () { + return utcSaturdays; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + function utcWeekday(i) { + return Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setUTCDate( + date.getUTCDate() - ((date.getUTCDay() + 7 - i) % 7) + ); + date.setUTCHours(0, 0, 0, 0); + }, + function (date, step) { + date.setUTCDate(date.getUTCDate() + step * 7); + }, + function (start, end) { + return ( + (end - start) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationWeek + ); + } + ); + } + + var utcSunday = utcWeekday(0); + var utcMonday = utcWeekday(1); + var utcTuesday = utcWeekday(2); + var utcWednesday = utcWeekday(3); + var utcThursday = utcWeekday(4); + var utcFriday = utcWeekday(5); + var utcSaturday = utcWeekday(6); + var utcSundays = utcSunday.range; + var utcMondays = utcMonday.range; + var utcTuesdays = utcTuesday.range; + var utcWednesdays = utcWednesday.range; + var utcThursdays = utcThursday.range; + var utcFridays = utcFriday.range; + var utcSaturdays = utcSaturday.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/utcYear.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-time/src/utcYear.js ***! + \*********************************************/ + /* ! exports provided: default, utcYears */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "utcYears", + function () { + return utcYears; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + + var utcYear = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setUTCMonth(0, 1); + date.setUTCHours(0, 0, 0, 0); + }, + function (date, step) { + date.setUTCFullYear(date.getUTCFullYear() + step); + }, + function (start, end) { + return end.getUTCFullYear() - start.getUTCFullYear(); + }, + function (date) { + return date.getUTCFullYear(); + } + ); // An optimized implementation for this simple case. + + utcYear.every = function (k) { + return !isFinite((k = Math.floor(k))) || !(k > 0) + ? null + : Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setUTCFullYear( + Math.floor(date.getUTCFullYear() / k) * k + ); + date.setUTCMonth(0, 1); + date.setUTCHours(0, 0, 0, 0); + }, + function (date, step) { + date.setUTCFullYear( + date.getUTCFullYear() + step * k + ); + } + ); + }; + + /* Harmony default export */ __webpack_exports__.default = utcYear; + var utcYears = utcYear.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/week.js": + /* !******************************************!*\ + !*** ./node_modules/d3-time/src/week.js ***! + \******************************************/ + /* ! exports provided: sunday, monday, tuesday, wednesday, thursday, friday, saturday, sundays, mondays, tuesdays, wednesdays, thursdays, fridays, saturdays */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sunday", + function () { + return sunday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "monday", + function () { + return monday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tuesday", + function () { + return tuesday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "wednesday", + function () { + return wednesday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "thursday", + function () { + return thursday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "friday", + function () { + return friday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "saturday", + function () { + return saturday; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sundays", + function () { + return sundays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "mondays", + function () { + return mondays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tuesdays", + function () { + return tuesdays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "wednesdays", + function () { + return wednesdays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "thursdays", + function () { + return thursdays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "fridays", + function () { + return fridays; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "saturdays", + function () { + return saturdays; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + /* Harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./duration.js */ "./node_modules/d3-time/src/duration.js" + ); + + function weekday(i) { + return Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setDate( + date.getDate() - ((date.getDay() + 7 - i) % 7) + ); + date.setHours(0, 0, 0, 0); + }, + function (date, step) { + date.setDate(date.getDate() + step * 7); + }, + function (start, end) { + return ( + (end - + start - + (end.getTimezoneOffset() - + start.getTimezoneOffset()) * + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationMinute) / + _duration_js__WEBPACK_IMPORTED_MODULE_1__.durationWeek + ); + } + ); + } + + var sunday = weekday(0); + var monday = weekday(1); + var tuesday = weekday(2); + var wednesday = weekday(3); + var thursday = weekday(4); + var friday = weekday(5); + var saturday = weekday(6); + var sundays = sunday.range; + var mondays = monday.range; + var tuesdays = tuesday.range; + var wednesdays = wednesday.range; + var thursdays = thursday.range; + var fridays = friday.range; + var saturdays = saturday.range; + + /***/ + }, + + /***/ "./node_modules/d3-time/src/year.js": + /* !******************************************!*\ + !*** ./node_modules/d3-time/src/year.js ***! + \******************************************/ + /* ! exports provided: default, years */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "years", + function () { + return years; + } + ); + /* Harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./interval.js */ "./node_modules/d3-time/src/interval.js" + ); + + var year = Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setMonth(0, 1); + date.setHours(0, 0, 0, 0); + }, + function (date, step) { + date.setFullYear(date.getFullYear() + step); + }, + function (start, end) { + return end.getFullYear() - start.getFullYear(); + }, + function (date) { + return date.getFullYear(); + } + ); // An optimized implementation for this simple case. + + year.every = function (k) { + return !isFinite((k = Math.floor(k))) || !(k > 0) + ? null + : Object( + _interval_js__WEBPACK_IMPORTED_MODULE_0__.default + )( + function (date) { + date.setFullYear( + Math.floor(date.getFullYear() / k) * k + ); + date.setMonth(0, 1); + date.setHours(0, 0, 0, 0); + }, + function (date, step) { + date.setFullYear(date.getFullYear() + step * k); + } + ); + }; + + /* Harmony default export */ __webpack_exports__.default = year; + var years = year.range; + + /***/ + }, + + /***/ "./node_modules/d3-timer/src/index.js": + /* !********************************************!*\ + !*** ./node_modules/d3-timer/src/index.js ***! + \********************************************/ + /* ! exports provided: now, timer, timerFlush, timeout, interval */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _timer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./timer */ "./node_modules/d3-timer/src/timer.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "now", + function () { + return _timer__WEBPACK_IMPORTED_MODULE_0__.now; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timer", + function () { + return _timer__WEBPACK_IMPORTED_MODULE_0__.timer; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timerFlush", + function () { + return _timer__WEBPACK_IMPORTED_MODULE_0__.timerFlush; + } + ); + + /* Harmony import */ var _timeout__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./timeout */ "./node_modules/d3-timer/src/timeout.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeout", + function () { + return _timeout__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./interval */ "./node_modules/d3-timer/src/interval.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interval", + function () { + return _interval__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-timer/src/interval.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-timer/src/interval.js ***! + \***********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _timer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./timer */ "./node_modules/d3-timer/src/timer.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (callback, delay, time) { + var t = new _timer__WEBPACK_IMPORTED_MODULE_0__.Timer(), + total = delay; + if (delay == null) return t.restart(callback, delay, time), t; + (delay = Number(delay)), + (time = + time == null + ? Object( + _timer__WEBPACK_IMPORTED_MODULE_0__.now + )() + : Number(time)); + t.restart( + function tick(elapsed) { + elapsed += total; + t.restart(tick, (total += delay), time); + callback(elapsed); + }, + delay, + time + ); + return t; + }; + + /***/ + }, + + /***/ "./node_modules/d3-timer/src/timeout.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-timer/src/timeout.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _timer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./timer */ "./node_modules/d3-timer/src/timer.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (callback, delay, time) { + var t = new _timer__WEBPACK_IMPORTED_MODULE_0__.Timer(); + delay = delay == null ? 0 : Number(delay); + t.restart( + function (elapsed) { + t.stop(); + callback(elapsed + delay); + }, + delay, + time + ); + return t; + }; + + /***/ + }, + + /***/ "./node_modules/d3-timer/src/timer.js": + /* !********************************************!*\ + !*** ./node_modules/d3-timer/src/timer.js ***! + \********************************************/ + /* ! exports provided: now, Timer, timer, timerFlush */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "now", + function () { + return now; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Timer", + function () { + return Timer; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "timer", + function () { + return timer; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "timerFlush", + function () { + return timerFlush; + } + ); + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + var frame = 0, + // Is an animation frame pending? + timeout = 0, + // Is a timeout pending? + interval = 0, + // Are any timers active? + pokeDelay = 1000, + // How frequently we check for clock skew + taskHead, + taskTail, + clockLast = 0, + clockNow = 0, + clockSkew = 0, + clock = + (typeof performance === "undefined" + ? "undefined" + : _typeof(performance)) === "object" && performance.now + ? performance + : Date, + setFrame = + (typeof window === "undefined" + ? "undefined" + : _typeof(window)) === "object" && + window.requestAnimationFrame + ? window.requestAnimationFrame.bind(window) + : function (f) { + setTimeout(f, 17); + }; + function now() { + return ( + clockNow || + (setFrame(clearNow), (clockNow = clock.now() + clockSkew)) + ); + } + + function clearNow() { + clockNow = 0; + } + + function Timer() { + this._call = this._time = this._next = null; + } + Timer.prototype = timer.prototype = { + constructor: Timer, + restart: function restart(callback, delay, time) { + if (typeof callback !== "function") + throw new TypeError("callback is not a function"); + time = + (time == null ? now() : Number(time)) + + (delay == null ? 0 : Number(delay)); + + if (!this._next && taskTail !== this) { + if (taskTail) taskTail._next = this; + else taskHead = this; + taskTail = this; + } + + this._call = callback; + this._time = time; + sleep(); + }, + stop: function stop() { + if (this._call) { + this._call = null; + this._time = Infinity; + sleep(); + } + }, + }; + function timer(callback, delay, time) { + var t = new Timer(); + t.restart(callback, delay, time); + return t; + } + function timerFlush() { + now(); // Get the current time, if not already set. + + ++frame; // Pretend we’ve set an alarm, if we haven’t already. + + var t = taskHead, + e; + + while (t) { + if ((e = clockNow - t._time) >= 0) t._call.call(null, e); + t = t._next; + } + + --frame; + } + + function wake() { + clockNow = (clockLast = clock.now()) + clockSkew; + frame = timeout = 0; + + try { + timerFlush(); + } finally { + frame = 0; + nap(); + clockNow = 0; + } + } + + function poke() { + var now = clock.now(), + delay = now - clockLast; + if (delay > pokeDelay) (clockSkew -= delay), (clockLast = now); + } + + function nap() { + var t0, + t1 = taskHead, + t2, + time = Infinity; + + while (t1) { + if (t1._call) { + if (time > t1._time) time = t1._time; + (t0 = t1), (t1 = t1._next); + } else { + (t2 = t1._next), (t1._next = null); + t1 = t0 ? (t0._next = t2) : (taskHead = t2); + } + } + + taskTail = t0; + sleep(time); + } + + function sleep(time) { + if (frame) return; // Soonest alarm already set, or will be. + + if (timeout) timeout = clearTimeout(timeout); + var delay = time - clockNow; // Strictly less than if we recomputed clockNow. + + if (delay > 24) { + if (time < Infinity) + timeout = setTimeout( + wake, + time - clock.now() - clockSkew + ); + if (interval) interval = clearInterval(interval); + } else { + if (!interval) + (clockLast = clock.now()), + (interval = setInterval(poke, pokeDelay)); + (frame = 1), setFrame(wake); + } + } + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/active.js": + /* !**************************************************!*\ + !*** ./node_modules/d3-transition/src/active.js ***! + \**************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _transition_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./transition/index */ "./node_modules/d3-transition/src/transition/index.js" + ); + /* Harmony import */ var _transition_schedule__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./transition/schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + var root = [null]; + /* Harmony default export */ __webpack_exports__.default = function (node, name) { + var schedules = node.__transition, + schedule, + i; + + if (schedules) { + name = name == null ? null : String(name); + + for (i in schedules) { + if ( + (schedule = schedules[i]).state > + _transition_schedule__WEBPACK_IMPORTED_MODULE_1__.SCHEDULED && + schedule.name === name + ) { + return new _transition_index__WEBPACK_IMPORTED_MODULE_0__.Transition([[node]], root, name, Number(i)); + } + } + } + + return null; + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/index.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-transition/src/index.js ***! + \*************************************************/ + /* ! exports provided: transition, active, interrupt */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _selection_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./selection/index */ "./node_modules/d3-transition/src/selection/index.js" + ); + /* Harmony import */ var _transition_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./transition/index */ "./node_modules/d3-transition/src/transition/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "transition", + function () { + return _transition_index__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony import */ var _active__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./active */ "./node_modules/d3-transition/src/active.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "active", + function () { + return _active__WEBPACK_IMPORTED_MODULE_2__.default; + } + ); + + /* Harmony import */ var _interrupt__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./interrupt */ "./node_modules/d3-transition/src/interrupt.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interrupt", + function () { + return _interrupt__WEBPACK_IMPORTED_MODULE_3__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/interrupt.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-transition/src/interrupt.js ***! + \*****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _transition_schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./transition/schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (node, name) { + var schedules = node.__transition, + schedule, + active, + empty = true, + i; + if (!schedules) return; + name = name == null ? null : String(name); + + for (i in schedules) { + if ((schedule = schedules[i]).name !== name) { + empty = false; + continue; + } + + active = + schedule.state > + _transition_schedule__WEBPACK_IMPORTED_MODULE_0__.STARTING && + schedule.state < + _transition_schedule__WEBPACK_IMPORTED_MODULE_0__.ENDING; + schedule.state = + _transition_schedule__WEBPACK_IMPORTED_MODULE_0__.ENDED; + schedule.timer.stop(); + schedule.on.call( + active ? "interrupt" : "cancel", + node, + node.__data__, + schedule.index, + schedule.group + ); + delete schedules[i]; + } + + if (empty) delete node.__transition; + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/selection/index.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-transition/src/selection/index.js ***! + \***********************************************************/ + /* ! no exports provided */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _interrupt__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./interrupt */ "./node_modules/d3-transition/src/selection/interrupt.js" + ); + /* Harmony import */ var _transition__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./transition */ "./node_modules/d3-transition/src/selection/transition.js" + ); + + d3_selection__WEBPACK_IMPORTED_MODULE_0__.selection.prototype.interrupt = + _interrupt__WEBPACK_IMPORTED_MODULE_1__.default; + d3_selection__WEBPACK_IMPORTED_MODULE_0__.selection.prototype.transition = + _transition__WEBPACK_IMPORTED_MODULE_2__.default; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/selection/interrupt.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-transition/src/selection/interrupt.js ***! + \***************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _interrupt__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../interrupt */ "./node_modules/d3-transition/src/interrupt.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (name) { + return this.each(function () { + Object(_interrupt__WEBPACK_IMPORTED_MODULE_0__.default)( + this, + name + ); + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/selection/transition.js": + /* !****************************************************************!*\ + !*** ./node_modules/d3-transition/src/selection/transition.js ***! + \****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _transition_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../transition/index */ "./node_modules/d3-transition/src/transition/index.js" + ); + /* Harmony import */ var _transition_schedule__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ../transition/schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + /* Harmony import */ var d3_ease__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-ease */ "./node_modules/d3-ease/src/index.js" + ); + /* Harmony import */ var d3_timer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! d3-timer */ "./node_modules/d3-timer/src/index.js" + ); + + var defaultTiming = { + time: null, + // Set on use. + delay: 0, + duration: 250, + ease: d3_ease__WEBPACK_IMPORTED_MODULE_2__.easeCubicInOut, + }; + + function inherit(node, id) { + var timing; + + while ( + !(timing = node.__transition) || + !(timing = timing[id]) + ) { + if (!(node = node.parentNode)) { + return ( + (defaultTiming.time = Object( + d3_timer__WEBPACK_IMPORTED_MODULE_3__.now + )()), + defaultTiming + ); + } + } + + return timing; + } + + /* Harmony default export */ __webpack_exports__.default = function (name) { + var id, timing; + + if ( + name instanceof + _transition_index__WEBPACK_IMPORTED_MODULE_0__.Transition + ) { + (id = name._id), (name = name._name); + } else { + (id = Object( + _transition_index__WEBPACK_IMPORTED_MODULE_0__.newId + )()), + ((timing = defaultTiming).time = Object( + d3_timer__WEBPACK_IMPORTED_MODULE_3__.now + )()), + (name = name == null ? null : String(name)); + } + + for ( + var groups = this._groups, m = groups.length, j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], n = group.length, node, i = 0; + i < n; + ++i + ) { + if ((node = group[i])) { + Object( + _transition_schedule__WEBPACK_IMPORTED_MODULE_1__.default + )( + node, + name, + id, + i, + group, + timing || inherit(node, id) + ); + } + } + } + + return new _transition_index__WEBPACK_IMPORTED_MODULE_0__.Transition(groups, this._parents, name, id); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/attr.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/attr.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _tween__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./tween */ "./node_modules/d3-transition/src/transition/tween.js" + ); + /* Harmony import */ var _interpolate__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./interpolate */ "./node_modules/d3-transition/src/transition/interpolate.js" + ); + + function attrRemove(name) { + return function () { + this.removeAttribute(name); + }; + } + + function attrRemoveNS(fullname) { + return function () { + this.removeAttributeNS(fullname.space, fullname.local); + }; + } + + function attrConstant(name, interpolate, value1) { + var string00, + string1 = String(value1), + interpolate0; + return function () { + var string0 = this.getAttribute(name); + return string0 === string1 + ? null + : string0 === string00 + ? interpolate0 + : (interpolate0 = interpolate( + (string00 = string0), + value1 + )); + }; + } + + function attrConstantNS(fullname, interpolate, value1) { + var string00, + string1 = String(value1), + interpolate0; + return function () { + var string0 = this.getAttributeNS( + fullname.space, + fullname.local + ); + return string0 === string1 + ? null + : string0 === string00 + ? interpolate0 + : (interpolate0 = interpolate( + (string00 = string0), + value1 + )); + }; + } + + function attrFunction(name, interpolate, value) { + var string00, string10, interpolate0; + return function () { + var string0, + value1 = value(this), + string1; + if (value1 == null) return void this.removeAttribute(name); + string0 = this.getAttribute(name); + string1 = String(value1); + return string0 === string1 + ? null + : string0 === string00 && string1 === string10 + ? interpolate0 + : ((string10 = string1), + (interpolate0 = interpolate( + (string00 = string0), + value1 + ))); + }; + } + + function attrFunctionNS(fullname, interpolate, value) { + var string00, string10, interpolate0; + return function () { + var string0, + value1 = value(this), + string1; + if (value1 == null) + return void this.removeAttributeNS( + fullname.space, + fullname.local + ); + string0 = this.getAttributeNS( + fullname.space, + fullname.local + ); + string1 = String(value1); + return string0 === string1 + ? null + : string0 === string00 && string1 === string10 + ? interpolate0 + : ((string10 = string1), + (interpolate0 = interpolate( + (string00 = string0), + value1 + ))); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value) { + var fullname = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.namespace + )(name), + i = + fullname === "transform" + ? d3_interpolate__WEBPACK_IMPORTED_MODULE_0__.interpolateTransformSvg + : _interpolate__WEBPACK_IMPORTED_MODULE_3__.default; + return this.attrTween( + name, + typeof value === "function" + ? (fullname.local ? attrFunctionNS : attrFunction)( + fullname, + i, + Object( + _tween__WEBPACK_IMPORTED_MODULE_2__.tweenValue + )(this, "attr." + name, value) + ) + : value == null + ? (fullname.local ? attrRemoveNS : attrRemove)(fullname) + : (fullname.local ? attrConstantNS : attrConstant)( + fullname, + i, + value + ) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/attrTween.js": + /* !****************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/attrTween.js ***! + \****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + + function attrInterpolate(name, i) { + return function (t) { + this.setAttribute(name, i(t)); + }; + } + + function attrInterpolateNS(fullname, i) { + return function (t) { + this.setAttributeNS(fullname.space, fullname.local, i(t)); + }; + } + + function attrTweenNS(fullname, value) { + var t0, i0; + + function tween() { + var i = value.apply(this, arguments); + if (i !== i0) + t0 = (i0 = i) && attrInterpolateNS(fullname, i); + return t0; + } + + tween._value = value; + return tween; + } + + function attrTween(name, value) { + var t0, i0; + + function tween() { + var i = value.apply(this, arguments); + if (i !== i0) t0 = (i0 = i) && attrInterpolate(name, i); + return t0; + } + + tween._value = value; + return tween; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value) { + var key = "attr." + name; + if (arguments.length < 2) + return (key = this.tween(key)) && key._value; + if (value == null) return this.tween(key, null); + if (typeof value !== "function") throw new Error(); + var fullname = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_0__.namespace + )(name); + return this.tween( + key, + (fullname.local ? attrTweenNS : attrTween)(fullname, value) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/delay.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/delay.js ***! + \************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + function delayFunction(id, value) { + return function () { + Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.init)( + this, + id + ).delay = Number(value.apply(this, arguments)); + }; + } + + function delayConstant(id, value) { + return ( + (value = Number(value)), + function () { + Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.init)( + this, + id + ).delay = value; + } + ); + } + + /* Harmony default export */ __webpack_exports__.default = function (value) { + var id = this._id; + return arguments.length + ? this.each( + (typeof value === "function" + ? delayFunction + : delayConstant)(id, value) + ) + : Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.get)( + this.node(), + id + ).delay; + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/duration.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/duration.js ***! + \***************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + function durationFunction(id, value) { + return function () { + Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.set)( + this, + id + ).duration = Number(value.apply(this, arguments)); + }; + } + + function durationConstant(id, value) { + return ( + (value = Number(value)), + function () { + Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.set)( + this, + id + ).duration = value; + } + ); + } + + /* Harmony default export */ __webpack_exports__.default = function (value) { + var id = this._id; + return arguments.length + ? this.each( + (typeof value === "function" + ? durationFunction + : durationConstant)(id, value) + ) + : Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.get)( + this.node(), + id + ).duration; + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/ease.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/ease.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + function easeConstant(id, value) { + if (typeof value !== "function") throw new Error(); + return function () { + Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.set)( + this, + id + ).ease = value; + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (value) { + var id = this._id; + return arguments.length + ? this.each(easeConstant(id, value)) + : Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.get)( + this.node(), + id + ).ease; + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/end.js": + /* !**********************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/end.js ***! + \**********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var on0, + on1, + that = this, + id = that._id, + size = that.size(); + return new Promise(function (resolve, reject) { + var cancel = { + value: reject, + }, + end = { + value: function value() { + if (--size === 0) resolve(); + }, + }; + that.each(function () { + var schedule = Object( + _schedule__WEBPACK_IMPORTED_MODULE_0__.set + )(this, id), + on = schedule.on; // If this node shared a dispatch with the previous node, + // just assign the updated shared dispatch and we’re done! + // Otherwise, copy-on-write. + + if (on !== on0) { + on1 = (on0 = on).copy(); + + on1._.cancel.push(cancel); + + on1._.interrupt.push(cancel); + + on1._.end.push(end); + } + + schedule.on = on1; + }); + }); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/filter.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/filter.js ***! + \*************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-transition/src/transition/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (match) { + if (typeof match !== "function") + match = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_0__.matcher + )(match); + + for ( + var groups = this._groups, + m = groups.length, + subgroups = new Array(m), + j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], + n = group.length, + subgroup = (subgroups[j] = []), + node, + i = 0; + i < n; + ++i + ) { + if ( + (node = group[i]) && + match.call(node, node.__data__, i, group) + ) { + subgroup.push(node); + } + } + } + + return new _index__WEBPACK_IMPORTED_MODULE_1__.Transition( + subgroups, + this._parents, + this._name, + this._id + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/index.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/index.js ***! + \************************************************************/ + /* ! exports provided: Transition, default, newId */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Transition", + function () { + return Transition; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return transition; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "newId", + function () { + return newId; + } + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _attr__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./attr */ "./node_modules/d3-transition/src/transition/attr.js" + ); + /* Harmony import */ var _attrTween__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./attrTween */ "./node_modules/d3-transition/src/transition/attrTween.js" + ); + /* Harmony import */ var _delay__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./delay */ "./node_modules/d3-transition/src/transition/delay.js" + ); + /* Harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./duration */ "./node_modules/d3-transition/src/transition/duration.js" + ); + /* Harmony import */ var _ease__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./ease */ "./node_modules/d3-transition/src/transition/ease.js" + ); + /* Harmony import */ var _filter__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./filter */ "./node_modules/d3-transition/src/transition/filter.js" + ); + /* Harmony import */ var _merge__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./merge */ "./node_modules/d3-transition/src/transition/merge.js" + ); + /* Harmony import */ var _on__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./on */ "./node_modules/d3-transition/src/transition/on.js" + ); + /* Harmony import */ var _remove__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! ./remove */ "./node_modules/d3-transition/src/transition/remove.js" + ); + /* Harmony import */ var _select__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! ./select */ "./node_modules/d3-transition/src/transition/select.js" + ); + /* Harmony import */ var _selectAll__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! ./selectAll */ "./node_modules/d3-transition/src/transition/selectAll.js" + ); + /* Harmony import */ var _selection__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! ./selection */ "./node_modules/d3-transition/src/transition/selection.js" + ); + /* Harmony import */ var _style__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! ./style */ "./node_modules/d3-transition/src/transition/style.js" + ); + /* Harmony import */ var _styleTween__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! ./styleTween */ "./node_modules/d3-transition/src/transition/styleTween.js" + ); + /* Harmony import */ var _text__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! ./text */ "./node_modules/d3-transition/src/transition/text.js" + ); + /* Harmony import */ var _transition__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! ./transition */ "./node_modules/d3-transition/src/transition/transition.js" + ); + /* Harmony import */ var _tween__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! ./tween */ "./node_modules/d3-transition/src/transition/tween.js" + ); + /* Harmony import */ var _end__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__( + /* ! ./end */ "./node_modules/d3-transition/src/transition/end.js" + ); + + var id = 0; + function Transition(groups, parents, name, id) { + this._groups = groups; + this._parents = parents; + this._name = name; + this._id = id; + } + function transition(name) { + return Object( + d3_selection__WEBPACK_IMPORTED_MODULE_0__.selection + )().transition(name); + } + function newId() { + return ++id; + } + var selection_prototype = + d3_selection__WEBPACK_IMPORTED_MODULE_0__.selection + .prototype; + Transition.prototype = transition.prototype = { + constructor: Transition, + select: _select__WEBPACK_IMPORTED_MODULE_10__.default, + selectAll: _selectAll__WEBPACK_IMPORTED_MODULE_11__.default, + filter: _filter__WEBPACK_IMPORTED_MODULE_6__.default, + merge: _merge__WEBPACK_IMPORTED_MODULE_7__.default, + selection: _selection__WEBPACK_IMPORTED_MODULE_12__.default, + transition: + _transition__WEBPACK_IMPORTED_MODULE_16__.default, + call: selection_prototype.call, + nodes: selection_prototype.nodes, + node: selection_prototype.node, + size: selection_prototype.size, + empty: selection_prototype.empty, + each: selection_prototype.each, + on: _on__WEBPACK_IMPORTED_MODULE_8__.default, + attr: _attr__WEBPACK_IMPORTED_MODULE_1__.default, + attrTween: _attrTween__WEBPACK_IMPORTED_MODULE_2__.default, + style: _style__WEBPACK_IMPORTED_MODULE_13__.default, + styleTween: + _styleTween__WEBPACK_IMPORTED_MODULE_14__.default, + text: _text__WEBPACK_IMPORTED_MODULE_15__.default, + remove: _remove__WEBPACK_IMPORTED_MODULE_9__.default, + tween: _tween__WEBPACK_IMPORTED_MODULE_17__.default, + delay: _delay__WEBPACK_IMPORTED_MODULE_3__.default, + duration: _duration__WEBPACK_IMPORTED_MODULE_4__.default, + ease: _ease__WEBPACK_IMPORTED_MODULE_5__.default, + end: _end__WEBPACK_IMPORTED_MODULE_18__.default, + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/interpolate.js": + /* !******************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/interpolate.js ***! + \******************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (a, b) { + var c; + return (typeof b === "number" + ? d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateNumber + : b instanceof + d3_color__WEBPACK_IMPORTED_MODULE_0__.color + ? d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateRgb + : (c = Object( + d3_color__WEBPACK_IMPORTED_MODULE_0__.color + )(b)) + ? ((b = c), + d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateRgb) + : d3_interpolate__WEBPACK_IMPORTED_MODULE_1__.interpolateString)(a, b); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/merge.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/merge.js ***! + \************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-transition/src/transition/index.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (transition) { + if (transition._id !== this._id) throw new Error(); + + for ( + var groups0 = this._groups, + groups1 = transition._groups, + m0 = groups0.length, + m1 = groups1.length, + m = Math.min(m0, m1), + merges = new Array(m0), + j = 0; + j < m; + ++j + ) { + for ( + var group0 = groups0[j], + group1 = groups1[j], + n = group0.length, + merge = (merges[j] = new Array(n)), + node, + i = 0; + i < n; + ++i + ) { + if ((node = group0[i] || group1[i])) { + merge[i] = node; + } + } + } + + for (; j < m0; ++j) { + merges[j] = groups0[j]; + } + + return new _index__WEBPACK_IMPORTED_MODULE_0__.Transition( + merges, + this._parents, + this._name, + this._id + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/on.js": + /* !*********************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/on.js ***! + \*********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + function start(name) { + return (String(name)) + .trim() + .split(/^|\s+/) + .every(function (t) { + var i = t.indexOf("."); + if (i >= 0) t = t.slice(0, i); + return !t || t === "start"; + }); + } + + function onFunction(id, name, listener) { + var on0, + on1, + sit = start(name) + ? _schedule__WEBPACK_IMPORTED_MODULE_0__.init + : _schedule__WEBPACK_IMPORTED_MODULE_0__.set; + return function () { + var schedule = sit(this, id), + on = schedule.on; // If this node shared a dispatch with the previous node, + // just assign the updated shared dispatch and we’re done! + // Otherwise, copy-on-write. + + if (on !== on0) + (on1 = (on0 = on).copy()).on(name, listener); + schedule.on = on1; + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, listener) { + var id = this._id; + return arguments.length < 2 + ? Object(_schedule__WEBPACK_IMPORTED_MODULE_0__.get)( + this.node(), + id + ).on.on(name) + : this.each(onFunction(id, name, listener)); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/remove.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/remove.js ***! + \*************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function removeFunction(id) { + return function () { + var parent = this.parentNode; + + for (var i in this.__transition) { + if (Number(i) !== id) return; + } + + if (parent) parent.removeChild(this); + }; + } + + /* Harmony default export */ __webpack_exports__.default = function () { + return this.on("end.remove", removeFunction(this._id)); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/schedule.js": + /* !***************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/schedule.js ***! + \***************************************************************/ + /* ! exports provided: CREATED, SCHEDULED, STARTING, STARTED, RUNNING, ENDING, ENDED, default, init, set, get */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "CREATED", + function () { + return CREATED; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "SCHEDULED", + function () { + return SCHEDULED; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "STARTING", + function () { + return STARTING; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "STARTED", + function () { + return STARTED; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "RUNNING", + function () { + return RUNNING; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "ENDING", + function () { + return ENDING; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "ENDED", + function () { + return ENDED; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "init", + function () { + return init; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "set", + function () { + return set; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "get", + function () { + return get; + } + ); + /* Harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js" + ); + /* Harmony import */ var d3_timer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-timer */ "./node_modules/d3-timer/src/index.js" + ); + + var emptyOn = Object( + d3_dispatch__WEBPACK_IMPORTED_MODULE_0__.dispatch + )("start", "end", "cancel", "interrupt"); + var emptyTween = []; + var CREATED = 0; + var SCHEDULED = 1; + var STARTING = 2; + var STARTED = 3; + var RUNNING = 4; + var ENDING = 5; + var ENDED = 6; + /* Harmony default export */ __webpack_exports__.default = function (node, name, id, index, group, timing) { + var schedules = node.__transition; + if (!schedules) node.__transition = {}; + else if (id in schedules) return; + create(node, id, { + name: name, + index: index, + // For context during callback. + group: group, + // For context during callback. + on: emptyOn, + tween: emptyTween, + time: timing.time, + delay: timing.delay, + duration: timing.duration, + ease: timing.ease, + timer: null, + state: CREATED, + }); + }; + function init(node, id) { + var schedule = get(node, id); + if (schedule.state > CREATED) + throw new Error("too late; already scheduled"); + return schedule; + } + function set(node, id) { + var schedule = get(node, id); + if (schedule.state > STARTED) + throw new Error("too late; already running"); + return schedule; + } + function get(node, id) { + var schedule = node.__transition; + if (!schedule || !(schedule = schedule[id])) + throw new Error("transition not found"); + return schedule; + } + + function create(node, id, self) { + var schedules = node.__transition, + tween; // Initialize the self timer when the transition is created. + // Note the actual delay is not known until the first callback! + + schedules[id] = self; + self.timer = Object( + d3_timer__WEBPACK_IMPORTED_MODULE_1__.timer + )(schedule, 0, self.time); + + function schedule(elapsed) { + self.state = SCHEDULED; + self.timer.restart(start, self.delay, self.time); // If the elapsed delay is less than our first sleep, start immediately. + + if (self.delay <= elapsed) start(elapsed - self.delay); + } + + function start(elapsed) { + var i, j, n, o; // If the state is not SCHEDULED, then we previously errored on start. + + if (self.state !== SCHEDULED) return stop(); + + for (i in schedules) { + o = schedules[i]; + if (o.name !== self.name) continue; // While this element already has a starting transition during this frame, + // defer starting an interrupting transition until that transition has a + // chance to tick (and possibly end); see d3/d3-transition#54! + + if (o.state === STARTED) + return Object( + d3_timer__WEBPACK_IMPORTED_MODULE_1__.timeout + )(start); // Interrupt the active transition, if any. + + if (o.state === RUNNING) { + o.state = ENDED; + o.timer.stop(); + o.on.call( + "interrupt", + node, + node.__data__, + o.index, + o.group + ); + delete schedules[i]; + } // Cancel any pre-empted transitions. + else if (Number(i) < id) { + o.state = ENDED; + o.timer.stop(); + o.on.call( + "cancel", + node, + node.__data__, + o.index, + o.group + ); + delete schedules[i]; + } + } // Defer the first tick to end of the current frame; see d3/d3#1576. + // Note the transition may be canceled after start and before the first tick! + // Note this must be scheduled before the start event; see d3/d3-transition#16! + // Assuming this is successful, subsequent callbacks go straight to tick. + + Object(d3_timer__WEBPACK_IMPORTED_MODULE_1__.timeout)( + function () { + if (self.state === STARTED) { + self.state = RUNNING; + self.timer.restart(tick, self.delay, self.time); + tick(elapsed); + } + } + ); // Dispatch the start event. + // Note this must be done before the tween are initialized. + + self.state = STARTING; + self.on.call( + "start", + node, + node.__data__, + self.index, + self.group + ); + if (self.state !== STARTING) return; // Interrupted + + self.state = STARTED; // Initialize the tween, deleting null tween. + + tween = new Array((n = self.tween.length)); + + for (i = 0, j = -1; i < n; ++i) { + if ( + (o = self.tween[i].value.call( + node, + node.__data__, + self.index, + self.group + )) + ) { + tween[++j] = o; + } + } + + tween.length = j + 1; + } + + function tick(elapsed) { + var t = + elapsed < self.duration + ? self.ease.call(null, elapsed / self.duration) + : (self.timer.restart(stop), + (self.state = ENDING), + 1), + i = -1, + n = tween.length; + + while (++i < n) { + tween[i].call(node, t); + } // Dispatch the end event. + + if (self.state === ENDING) { + self.on.call( + "end", + node, + node.__data__, + self.index, + self.group + ); + stop(); + } + } + + function stop() { + self.state = ENDED; + self.timer.stop(); + delete schedules[id]; + + for (var i in schedules) { + return; + } // eslint-disable-line no-unused-vars + + delete node.__transition; + } + } + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/select.js": + /* !*************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/select.js ***! + \*************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-transition/src/transition/index.js" + ); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (select) { + var name = this._name, + id = this._id; + if (typeof select !== "function") + select = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_0__.selector + )(select); + + for ( + var groups = this._groups, + m = groups.length, + subgroups = new Array(m), + j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], + n = group.length, + subgroup = (subgroups[j] = new Array(n)), + node, + subnode, + i = 0; + i < n; + ++i + ) { + if ( + (node = group[i]) && + (subnode = select.call( + node, + node.__data__, + i, + group + )) + ) { + if ("__data__" in node) + subnode.__data__ = node.__data__; + subgroup[i] = subnode; + Object( + _schedule__WEBPACK_IMPORTED_MODULE_2__.default + )( + subgroup[i], + name, + id, + i, + subgroup, + Object( + _schedule__WEBPACK_IMPORTED_MODULE_2__.get + )(node, id) + ); + } + } + } + + return new _index__WEBPACK_IMPORTED_MODULE_1__.Transition( + subgroups, + this._parents, + name, + id + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/selectAll.js": + /* !****************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/selectAll.js ***! + \****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-transition/src/transition/index.js" + ); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function (select) { + var name = this._name, + id = this._id; + if (typeof select !== "function") + select = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_0__.selectorAll + )(select); + + for ( + var groups = this._groups, + m = groups.length, + subgroups = [], + parents = [], + j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], n = group.length, node, i = 0; + i < n; + ++i + ) { + if ((node = group[i])) { + for ( + var children = select.call( + node, + node.__data__, + i, + group + ), + child, + inherit = Object( + _schedule__WEBPACK_IMPORTED_MODULE_2__.get + )(node, id), + k = 0, + l = children.length; + k < l; + ++k + ) { + if ((child = children[k])) { + Object( + _schedule__WEBPACK_IMPORTED_MODULE_2__.default + )(child, name, id, k, children, inherit); + } + } + + subgroups.push(children); + parents.push(node); + } + } + } + + return new _index__WEBPACK_IMPORTED_MODULE_1__.Transition( + subgroups, + parents, + name, + id + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/selection.js": + /* !****************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/selection.js ***! + \****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + + var Selection = + d3_selection__WEBPACK_IMPORTED_MODULE_0__.selection.prototype + .constructor; + /* Harmony default export */ __webpack_exports__.default = function () { + return new Selection(this._groups, this._parents); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/style.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/style.js ***! + \************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + /* Harmony import */ var _tween__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./tween */ "./node_modules/d3-transition/src/transition/tween.js" + ); + /* Harmony import */ var _interpolate__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./interpolate */ "./node_modules/d3-transition/src/transition/interpolate.js" + ); + + function styleNull(name, interpolate) { + var string00, string10, interpolate0; + return function () { + var string0 = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.style + )(this, name), + string1 = + (this.style.removeProperty(name), + Object( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.style + )(this, name)); + return string0 === string1 + ? null + : string0 === string00 && string1 === string10 + ? interpolate0 + : (interpolate0 = interpolate( + (string00 = string0), + (string10 = string1) + )); + }; + } + + function styleRemove(name) { + return function () { + this.style.removeProperty(name); + }; + } + + function styleConstant(name, interpolate, value1) { + var string00, + string1 = String(value1), + interpolate0; + return function () { + var string0 = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.style + )(this, name); + return string0 === string1 + ? null + : string0 === string00 + ? interpolate0 + : (interpolate0 = interpolate( + (string00 = string0), + value1 + )); + }; + } + + function styleFunction(name, interpolate, value) { + var string00, string10, interpolate0; + return function () { + var string0 = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.style + )(this, name), + value1 = value(this), + string1 = String(value1); + if (value1 == null) + string1 = value1 = + (this.style.removeProperty(name), + Object( + d3_selection__WEBPACK_IMPORTED_MODULE_1__.style + )(this, name)); + return string0 === string1 + ? null + : string0 === string00 && string1 === string10 + ? interpolate0 + : ((string10 = string1), + (interpolate0 = interpolate( + (string00 = string0), + value1 + ))); + }; + } + + function styleMaybeRemove(id, name) { + var on0, + on1, + listener0, + key = "style." + name, + event = "end." + key, + remove; + return function () { + var schedule = Object( + _schedule__WEBPACK_IMPORTED_MODULE_2__.set + )(this, id), + on = schedule.on, + listener = + schedule.value[key] == null + ? remove || (remove = styleRemove(name)) + : undefined; // If this node shared a dispatch with the previous node, + // just assign the updated shared dispatch and we’re done! + // Otherwise, copy-on-write. + + if (on !== on0 || listener0 !== listener) + (on1 = (on0 = on).copy()).on( + event, + (listener0 = listener) + ); + schedule.on = on1; + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value, priority) { + var i = + (name = String(name)) === "transform" + ? d3_interpolate__WEBPACK_IMPORTED_MODULE_0__.interpolateTransformCss + : _interpolate__WEBPACK_IMPORTED_MODULE_4__.default; + return value == null + ? this.styleTween(name, styleNull(name, i)).on( + "end.style." + name, + styleRemove(name) + ) + : typeof value === "function" + ? this.styleTween( + name, + styleFunction( + name, + i, + Object( + _tween__WEBPACK_IMPORTED_MODULE_3__.tweenValue + )(this, "style." + name, value) + ) + ).each(styleMaybeRemove(this._id, name)) + : this.styleTween( + name, + styleConstant(name, i, value), + priority + ).on("end.style." + name, null); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/styleTween.js": + /* !*****************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/styleTween.js ***! + \*****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + function styleInterpolate(name, i, priority) { + return function (t) { + this.style.setProperty(name, i(t), priority); + }; + } + + function styleTween(name, value, priority) { + var t, i0; + + function tween() { + var i = value.apply(this, arguments); + if (i !== i0) + t = (i0 = i) && styleInterpolate(name, i, priority); + return t; + } + + tween._value = value; + return tween; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value, priority) { + var key = "style." + (name = String(name)); + if (arguments.length < 2) + return (key = this.tween(key)) && key._value; + if (value == null) return this.tween(key, null); + if (typeof value !== "function") throw new Error(); + return this.tween( + key, + styleTween(name, value, priority == null ? "" : priority) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/text.js": + /* !***********************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/text.js ***! + \***********************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _tween__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./tween */ "./node_modules/d3-transition/src/transition/tween.js" + ); + + function textConstant(value) { + return function () { + this.textContent = value; + }; + } + + function textFunction(value) { + return function () { + var value1 = value(this); + this.textContent = value1 == null ? "" : value1; + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (value) { + return this.tween( + "text", + typeof value === "function" + ? textFunction( + Object( + _tween__WEBPACK_IMPORTED_MODULE_0__.tweenValue + )(this, "text", value) + ) + : textConstant(value == null ? "" : String(value)) + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/transition.js": + /* !*****************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/transition.js ***! + \*****************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./index */ "./node_modules/d3-transition/src/transition/index.js" + ); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var name = this._name, + id0 = this._id, + id1 = Object( + _index__WEBPACK_IMPORTED_MODULE_0__.newId + )(); + + for ( + var groups = this._groups, m = groups.length, j = 0; + j < m; + ++j + ) { + for ( + var group = groups[j], n = group.length, node, i = 0; + i < n; + ++i + ) { + if ((node = group[i])) { + var inherit = Object( + _schedule__WEBPACK_IMPORTED_MODULE_1__.get + )(node, id0); + Object( + _schedule__WEBPACK_IMPORTED_MODULE_1__.default + )(node, name, id1, i, group, { + time: + inherit.time + + inherit.delay + + inherit.duration, + delay: 0, + duration: inherit.duration, + ease: inherit.ease, + }); + } + } + } + + return new _index__WEBPACK_IMPORTED_MODULE_0__.Transition( + groups, + this._parents, + name, + id1 + ); + }; + + /***/ + }, + + /***/ "./node_modules/d3-transition/src/transition/tween.js": + /* !************************************************************!*\ + !*** ./node_modules/d3-transition/src/transition/tween.js ***! + \************************************************************/ + /* ! exports provided: default, tweenValue */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "tweenValue", + function () { + return tweenValue; + } + ); + /* Harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js" + ); + + function tweenRemove(id, name) { + var tween0, tween1; + return function () { + var schedule = Object( + _schedule__WEBPACK_IMPORTED_MODULE_0__.set + )(this, id), + tween = schedule.tween; // If this node shared tween with the previous node, + // just assign the updated shared tween and we’re done! + // Otherwise, copy-on-write. + + if (tween !== tween0) { + tween1 = tween0 = tween; + + for (var i = 0, n = tween1.length; i < n; ++i) { + if (tween1[i].name === name) { + tween1 = tween1.slice(); + tween1.splice(i, 1); + break; + } + } + } + + schedule.tween = tween1; + }; + } + + function tweenFunction(id, name, value) { + var tween0, tween1; + if (typeof value !== "function") throw new Error(); + return function () { + var schedule = Object( + _schedule__WEBPACK_IMPORTED_MODULE_0__.set + )(this, id), + tween = schedule.tween; // If this node shared tween with the previous node, + // just assign the updated shared tween and we’re done! + // Otherwise, copy-on-write. + + if (tween !== tween0) { + tween1 = (tween0 = tween).slice(); + + for ( + var t = { + name: name, + value: value, + }, + i = 0, + n = tween1.length; + i < n; + ++i + ) { + if (tween1[i].name === name) { + tween1[i] = t; + break; + } + } + + if (i === n) tween1.push(t); + } + + schedule.tween = tween1; + }; + } + + /* Harmony default export */ __webpack_exports__.default = function (name, value) { + var id = this._id; + name = String(name); + + if (arguments.length < 2) { + var tween = Object( + _schedule__WEBPACK_IMPORTED_MODULE_0__.get + )(this.node(), id).tween; + + for (var i = 0, n = tween.length, t; i < n; ++i) { + if ((t = tween[i]).name === name) { + return t.value; + } + } + + return null; + } + + return this.each( + (value == null ? tweenRemove : tweenFunction)( + id, + name, + value + ) + ); + }; + function tweenValue(transition, name, value) { + var id = transition._id; + transition.each(function () { + var schedule = Object( + _schedule__WEBPACK_IMPORTED_MODULE_0__.set + )(this, id); + (schedule.value || (schedule.value = {}))[ + name + ] = value.apply(this, arguments); + }); + return function (node) { + return Object( + _schedule__WEBPACK_IMPORTED_MODULE_0__.get + )(node, id).value[name]; + }; + } + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/Beach.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-voronoi/src/Beach.js ***! + \**********************************************/ + /* ! exports provided: removeBeach, addBeach */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "removeBeach", + function () { + return removeBeach; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "addBeach", + function () { + return addBeach; + } + ); + /* Harmony import */ var _RedBlackTree__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./RedBlackTree */ "./node_modules/d3-voronoi/src/RedBlackTree.js" + ); + /* Harmony import */ var _Cell__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./Cell */ "./node_modules/d3-voronoi/src/Cell.js" + ); + /* Harmony import */ var _Circle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./Circle */ "./node_modules/d3-voronoi/src/Circle.js" + ); + /* Harmony import */ var _Edge__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./Edge */ "./node_modules/d3-voronoi/src/Edge.js" + ); + /* Harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js" + ); + + var beachPool = []; + + function Beach() { + Object( + _RedBlackTree__WEBPACK_IMPORTED_MODULE_0__.RedBlackNode + )(this); + this.edge = this.site = this.circle = null; + } + + function createBeach(site) { + var beach = beachPool.pop() || new Beach(); + beach.site = site; + return beach; + } + + function detachBeach(beach) { + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.detachCircle)( + beach + ); + _Diagram__WEBPACK_IMPORTED_MODULE_4__.beaches.remove(beach); + beachPool.push(beach); + Object( + _RedBlackTree__WEBPACK_IMPORTED_MODULE_0__.RedBlackNode + )(beach); + } + + function removeBeach(beach) { + var circle = beach.circle, + x = circle.x, + y = circle.cy, + vertex = [x, y], + previous = beach.P, + next = beach.N, + disappearing = [beach]; + detachBeach(beach); + var lArc = previous; + + while ( + lArc.circle && + Math.abs(x - lArc.circle.x) < + _Diagram__WEBPACK_IMPORTED_MODULE_4__.epsilon && + Math.abs(y - lArc.circle.cy) < + _Diagram__WEBPACK_IMPORTED_MODULE_4__.epsilon + ) { + previous = lArc.P; + disappearing.unshift(lArc); + detachBeach(lArc); + lArc = previous; + } + + disappearing.unshift(lArc); + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.detachCircle)( + lArc + ); + var rArc = next; + + while ( + rArc.circle && + Math.abs(x - rArc.circle.x) < + _Diagram__WEBPACK_IMPORTED_MODULE_4__.epsilon && + Math.abs(y - rArc.circle.cy) < + _Diagram__WEBPACK_IMPORTED_MODULE_4__.epsilon + ) { + next = rArc.N; + disappearing.push(rArc); + detachBeach(rArc); + rArc = next; + } + + disappearing.push(rArc); + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.detachCircle)( + rArc + ); + var nArcs = disappearing.length, + iArc; + + for (iArc = 1; iArc < nArcs; ++iArc) { + rArc = disappearing[iArc]; + lArc = disappearing[iArc - 1]; + Object(_Edge__WEBPACK_IMPORTED_MODULE_3__.setEdgeEnd)( + rArc.edge, + lArc.site, + rArc.site, + vertex + ); + } + + lArc = disappearing[0]; + rArc = disappearing[nArcs - 1]; + rArc.edge = Object( + _Edge__WEBPACK_IMPORTED_MODULE_3__.createEdge + )(lArc.site, rArc.site, null, vertex); + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.attachCircle)( + lArc + ); + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.attachCircle)( + rArc + ); + } + function addBeach(site) { + var x = site[0], + directrix = site[1], + lArc, + rArc, + dxl, + dxr, + node = _Diagram__WEBPACK_IMPORTED_MODULE_4__.beaches._; + + while (node) { + dxl = leftBreakPoint(node, directrix) - x; + if (dxl > _Diagram__WEBPACK_IMPORTED_MODULE_4__.epsilon) + node = node.L; + else { + dxr = x - rightBreakPoint(node, directrix); + + if ( + dxr > + _Diagram__WEBPACK_IMPORTED_MODULE_4__.epsilon + ) { + if (!node.R) { + lArc = node; + break; + } + + node = node.R; + } else { + if ( + dxl > + -_Diagram__WEBPACK_IMPORTED_MODULE_4__.epsilon + ) { + lArc = node.P; + rArc = node; + } else if ( + dxr > + -_Diagram__WEBPACK_IMPORTED_MODULE_4__.epsilon + ) { + lArc = node; + rArc = node.N; + } else { + lArc = rArc = node; + } + + break; + } + } + } + + Object(_Cell__WEBPACK_IMPORTED_MODULE_1__.createCell)(site); + var newArc = createBeach(site); + _Diagram__WEBPACK_IMPORTED_MODULE_4__.beaches.insert( + lArc, + newArc + ); + if (!lArc && !rArc) return; + + if (lArc === rArc) { + Object( + _Circle__WEBPACK_IMPORTED_MODULE_2__.detachCircle + )(lArc); + rArc = createBeach(lArc.site); + _Diagram__WEBPACK_IMPORTED_MODULE_4__.beaches.insert( + newArc, + rArc + ); + newArc.edge = rArc.edge = Object( + _Edge__WEBPACK_IMPORTED_MODULE_3__.createEdge + )(lArc.site, newArc.site); + Object( + _Circle__WEBPACK_IMPORTED_MODULE_2__.attachCircle + )(lArc); + Object( + _Circle__WEBPACK_IMPORTED_MODULE_2__.attachCircle + )(rArc); + return; + } + + if (!rArc) { + // && lArc + newArc.edge = Object( + _Edge__WEBPACK_IMPORTED_MODULE_3__.createEdge + )(lArc.site, newArc.site); + return; + } // Else lArc !== rArc + + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.detachCircle)( + lArc + ); + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.detachCircle)( + rArc + ); + var lSite = lArc.site, + ax = lSite[0], + ay = lSite[1], + bx = site[0] - ax, + by = site[1] - ay, + rSite = rArc.site, + cx = rSite[0] - ax, + cy = rSite[1] - ay, + d = 2 * (bx * cy - by * cx), + hb = bx * bx + by * by, + hc = cx * cx + cy * cy, + vertex = [ + (cy * hb - by * hc) / d + ax, + (bx * hc - cx * hb) / d + ay, + ]; + Object(_Edge__WEBPACK_IMPORTED_MODULE_3__.setEdgeEnd)( + rArc.edge, + lSite, + rSite, + vertex + ); + newArc.edge = Object( + _Edge__WEBPACK_IMPORTED_MODULE_3__.createEdge + )(lSite, site, null, vertex); + rArc.edge = Object( + _Edge__WEBPACK_IMPORTED_MODULE_3__.createEdge + )(site, rSite, null, vertex); + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.attachCircle)( + lArc + ); + Object(_Circle__WEBPACK_IMPORTED_MODULE_2__.attachCircle)( + rArc + ); + } + + function leftBreakPoint(arc, directrix) { + var site = arc.site, + rfocx = site[0], + rfocy = site[1], + pby2 = rfocy - directrix; + if (!pby2) return rfocx; + var lArc = arc.P; + if (!lArc) return -Infinity; + site = lArc.site; + var lfocx = site[0], + lfocy = site[1], + plby2 = lfocy - directrix; + if (!plby2) return lfocx; + var hl = lfocx - rfocx, + aby2 = 1 / pby2 - 1 / plby2, + b = hl / plby2; + if (aby2) + return ( + (-b + + Math.sqrt( + b * b - + 2 * + aby2 * + ((hl * hl) / (-2 * plby2) - + lfocy + + plby2 / 2 + + rfocy - + pby2 / 2) + )) / + aby2 + + rfocx + ); + return (rfocx + lfocx) / 2; + } + + function rightBreakPoint(arc, directrix) { + var rArc = arc.N; + if (rArc) return leftBreakPoint(rArc, directrix); + var site = arc.site; + return site[1] === directrix ? site[0] : Infinity; + } + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/Cell.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-voronoi/src/Cell.js ***! + \*********************************************/ + /* ! exports provided: createCell, cellHalfedgeStart, cellHalfedgeEnd, sortCellHalfedges, clipCells */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "createCell", + function () { + return createCell; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cellHalfedgeStart", + function () { + return cellHalfedgeStart; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cellHalfedgeEnd", + function () { + return cellHalfedgeEnd; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "sortCellHalfedges", + function () { + return sortCellHalfedges; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "clipCells", + function () { + return clipCells; + } + ); + /* Harmony import */ var _Edge__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./Edge */ "./node_modules/d3-voronoi/src/Edge.js" + ); + /* Harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js" + ); + + function createCell(site) { + return (_Diagram__WEBPACK_IMPORTED_MODULE_1__.cells[ + site.index + ] = { + site: site, + halfedges: [], + }); + } + + function cellHalfedgeAngle(cell, edge) { + var site = cell.site, + va = edge.left, + vb = edge.right; + if (site === vb) (vb = va), (va = site); + if (vb) return Math.atan2(vb[1] - va[1], vb[0] - va[0]); + if (site === va) (va = edge[1]), (vb = edge[0]); + else (va = edge[0]), (vb = edge[1]); + return Math.atan2(va[0] - vb[0], vb[1] - va[1]); + } + + function cellHalfedgeStart(cell, edge) { + return edge[Number(edge.left !== cell.site)]; + } + function cellHalfedgeEnd(cell, edge) { + return edge[Number(edge.left === cell.site)]; + } + function sortCellHalfedges() { + for ( + var i = 0, + n = + _Diagram__WEBPACK_IMPORTED_MODULE_1__.cells + .length, + cell, + halfedges, + j, + m; + i < n; + ++i + ) { + if ( + (cell = + _Diagram__WEBPACK_IMPORTED_MODULE_1__.cells[ + i + ]) && + (m = (halfedges = cell.halfedges).length) + ) { + var index = new Array(m), + array = new Array(m); + + for (j = 0; j < m; ++j) { + (index[j] = j), + (array[j] = cellHalfedgeAngle( + cell, + _Diagram__WEBPACK_IMPORTED_MODULE_1__.edges[halfedges[j]] + )); + } + + index.sort(function (i, j) { + return array[j] - array[i]; + }); + + for (j = 0; j < m; ++j) { + array[j] = halfedges[index[j]]; + } + + for (j = 0; j < m; ++j) { + halfedges[j] = array[j]; + } + } + } + } + function clipCells(x0, y0, x1, y1) { + var nCells = + _Diagram__WEBPACK_IMPORTED_MODULE_1__.cells.length, + iCell, + cell, + site, + iHalfedge, + halfedges, + nHalfedges, + start, + startX, + startY, + end, + endX, + endY, + cover = true; + + for (iCell = 0; iCell < nCells; ++iCell) { + if ( + (cell = + _Diagram__WEBPACK_IMPORTED_MODULE_1__.cells[ + iCell + ]) + ) { + site = cell.site; + halfedges = cell.halfedges; + iHalfedge = halfedges.length; // Remove any dangling clipped edges. + + while (iHalfedge--) { + if ( + !_Diagram__WEBPACK_IMPORTED_MODULE_1__.edges[ + halfedges[iHalfedge] + ] + ) { + halfedges.splice(iHalfedge, 1); + } + } // Insert any border edges as necessary. + + (iHalfedge = 0), (nHalfedges = halfedges.length); + + while (iHalfedge < nHalfedges) { + (end = cellHalfedgeEnd( + cell, + _Diagram__WEBPACK_IMPORTED_MODULE_1__.edges[ + halfedges[iHalfedge] + ] + )), + (endX = end[0]), + (endY = end[1]); + (start = cellHalfedgeStart( + cell, + _Diagram__WEBPACK_IMPORTED_MODULE_1__.edges[ + halfedges[++iHalfedge % nHalfedges] + ] + )), + (startX = start[0]), + (startY = start[1]); + + if ( + Math.abs(endX - startX) > + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon || + Math.abs(endY - startY) > + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ) { + halfedges.splice( + iHalfedge, + 0, + _Diagram__WEBPACK_IMPORTED_MODULE_1__.edges.push( + Object( + _Edge__WEBPACK_IMPORTED_MODULE_0__.createBorderEdge + )( + site, + end, + Math.abs(endX - x0) < + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon && + y1 - endY > + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? [ + x0, + Math.abs(startX - x0) < + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? startY + : y1, + ] + : Math.abs(endY - y1) < + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon && + x1 - endX > + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? [ + Math.abs(startY - y1) < + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? startX + : x1, + y1, + ] + : Math.abs(endX - x1) < + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon && + endY - y0 > + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? [ + x1, + Math.abs(startX - x1) < + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? startY + : y0, + ] + : Math.abs(endY - y0) < + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon && + endX - x0 > + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? [ + Math.abs(startY - y0) < + _Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon + ? startX + : x0, + y0, + ] + : null + ) + ) - 1 + ); + ++nHalfedges; + } + } + + if (nHalfedges) cover = false; + } + } // If there weren’t any edges, have the closest site cover the extent. + // It doesn’t matter which corner of the extent we measure! + + if (cover) { + var dx, + dy, + d2, + dc = Infinity; + + for (iCell = 0, cover = null; iCell < nCells; ++iCell) { + if ( + (cell = + _Diagram__WEBPACK_IMPORTED_MODULE_1__.cells[ + iCell + ]) + ) { + site = cell.site; + dx = site[0] - x0; + dy = site[1] - y0; + d2 = dx * dx + dy * dy; + if (d2 < dc) (dc = d2), (cover = cell); + } + } + + if (cover) { + var v00 = [x0, y0], + v01 = [x0, y1], + v11 = [x1, y1], + v10 = [x1, y0]; + cover.halfedges.push( + _Diagram__WEBPACK_IMPORTED_MODULE_1__.edges.push( + Object( + _Edge__WEBPACK_IMPORTED_MODULE_0__.createBorderEdge + )((site = cover.site), v00, v01) + ) - 1, + _Diagram__WEBPACK_IMPORTED_MODULE_1__.edges.push( + Object( + _Edge__WEBPACK_IMPORTED_MODULE_0__.createBorderEdge + )(site, v01, v11) + ) - 1, + _Diagram__WEBPACK_IMPORTED_MODULE_1__.edges.push( + Object( + _Edge__WEBPACK_IMPORTED_MODULE_0__.createBorderEdge + )(site, v11, v10) + ) - 1, + _Diagram__WEBPACK_IMPORTED_MODULE_1__.edges.push( + Object( + _Edge__WEBPACK_IMPORTED_MODULE_0__.createBorderEdge + )(site, v10, v00) + ) - 1 + ); + } + } // Lastly delete any cells with no edges; these were entirely clipped. + + for (iCell = 0; iCell < nCells; ++iCell) { + if ( + (cell = + _Diagram__WEBPACK_IMPORTED_MODULE_1__.cells[ + iCell + ]) + ) { + if (!cell.halfedges.length) { + delete _Diagram__WEBPACK_IMPORTED_MODULE_1__.cells[iCell]; + } + } + } + } + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/Circle.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-voronoi/src/Circle.js ***! + \***********************************************/ + /* ! exports provided: firstCircle, attachCircle, detachCircle */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "firstCircle", + function () { + return firstCircle; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "attachCircle", + function () { + return attachCircle; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "detachCircle", + function () { + return detachCircle; + } + ); + /* Harmony import */ var _RedBlackTree__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./RedBlackTree */ "./node_modules/d3-voronoi/src/RedBlackTree.js" + ); + /* Harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js" + ); + + var circlePool = []; + var firstCircle; + + function Circle() { + Object( + _RedBlackTree__WEBPACK_IMPORTED_MODULE_0__.RedBlackNode + )(this); + this.x = this.y = this.arc = this.site = this.cy = null; + } + + function attachCircle(arc) { + var lArc = arc.P, + rArc = arc.N; + if (!lArc || !rArc) return; + var lSite = lArc.site, + cSite = arc.site, + rSite = rArc.site; + if (lSite === rSite) return; + var bx = cSite[0], + by = cSite[1], + ax = lSite[0] - bx, + ay = lSite[1] - by, + cx = rSite[0] - bx, + cy = rSite[1] - by; + var d = 2 * (ax * cy - ay * cx); + if (d >= -_Diagram__WEBPACK_IMPORTED_MODULE_1__.epsilon2) + return; + var ha = ax * ax + ay * ay, + hc = cx * cx + cy * cy, + x = (cy * ha - ay * hc) / d, + y = (ax * hc - cx * ha) / d; + var circle = circlePool.pop() || new Circle(); + circle.arc = arc; + circle.site = cSite; + circle.x = x + bx; + circle.y = (circle.cy = y + by) + Math.sqrt(x * x + y * y); // Y bottom + + arc.circle = circle; + var before = null, + node = _Diagram__WEBPACK_IMPORTED_MODULE_1__.circles._; + + while (node) { + if ( + circle.y < node.y || + (circle.y === node.y && circle.x <= node.x) + ) { + if (node.L) node = node.L; + else { + before = node.P; + break; + } + } else if (node.R) node = node.R; + else { + before = node; + break; + } + } + + _Diagram__WEBPACK_IMPORTED_MODULE_1__.circles.insert( + before, + circle + ); + if (!before) firstCircle = circle; + } + function detachCircle(arc) { + var circle = arc.circle; + + if (circle) { + if (!circle.P) firstCircle = circle.N; + _Diagram__WEBPACK_IMPORTED_MODULE_1__.circles.remove( + circle + ); + circlePool.push(circle); + Object( + _RedBlackTree__WEBPACK_IMPORTED_MODULE_0__.RedBlackNode + )(circle); + arc.circle = null; + } + } + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/Diagram.js": + /* !************************************************!*\ + !*** ./node_modules/d3-voronoi/src/Diagram.js ***! + \************************************************/ + /* ! exports provided: epsilon, epsilon2, beaches, cells, circles, edges, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "epsilon", + function () { + return epsilon; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "epsilon2", + function () { + return epsilon2; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "beaches", + function () { + return beaches; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "cells", + function () { + return cells; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "circles", + function () { + return circles; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "edges", + function () { + return edges; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return Diagram; + } + ); + /* Harmony import */ var _Beach__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./Beach */ "./node_modules/d3-voronoi/src/Beach.js" + ); + /* Harmony import */ var _Cell__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./Cell */ "./node_modules/d3-voronoi/src/Cell.js" + ); + /* Harmony import */ var _Circle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./Circle */ "./node_modules/d3-voronoi/src/Circle.js" + ); + /* Harmony import */ var _Edge__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! ./Edge */ "./node_modules/d3-voronoi/src/Edge.js" + ); + /* Harmony import */ var _RedBlackTree__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! ./RedBlackTree */ "./node_modules/d3-voronoi/src/RedBlackTree.js" + ); + + var epsilon = 1e-6; + var epsilon2 = 1e-12; + var beaches; + var cells; + var circles; + var edges; + + function triangleArea(a, b, c) { + return ( + (a[0] - c[0]) * (b[1] - a[1]) - + (a[0] - b[0]) * (c[1] - a[1]) + ); + } + + function lexicographic(a, b) { + return b[1] - a[1] || b[0] - a[0]; + } + + function Diagram(sites, extent) { + var site = sites.sort(lexicographic).pop(), + x, + y, + circle; + edges = []; + cells = new Array(sites.length); + beaches = new _RedBlackTree__WEBPACK_IMPORTED_MODULE_4__.default(); + circles = new _RedBlackTree__WEBPACK_IMPORTED_MODULE_4__.default(); + + while (true) { + circle = + _Circle__WEBPACK_IMPORTED_MODULE_2__.firstCircle; + + if ( + site && + (!circle || + site[1] < circle.y || + (site[1] === circle.y && site[0] < circle.x)) + ) { + if (site[0] !== x || site[1] !== y) { + Object( + _Beach__WEBPACK_IMPORTED_MODULE_0__.addBeach + )(site); + (x = site[0]), (y = site[1]); + } + + site = sites.pop(); + } else if (circle) { + Object( + _Beach__WEBPACK_IMPORTED_MODULE_0__.removeBeach + )(circle.arc); + } else { + break; + } + } + + Object( + _Cell__WEBPACK_IMPORTED_MODULE_1__.sortCellHalfedges + )(); + + if (extent) { + var x0 = Number(extent[0][0]), + y0 = Number(extent[0][1]), + x1 = Number(extent[1][0]), + y1 = Number(extent[1][1]); + Object(_Edge__WEBPACK_IMPORTED_MODULE_3__.clipEdges)( + x0, + y0, + x1, + y1 + ); + Object(_Cell__WEBPACK_IMPORTED_MODULE_1__.clipCells)( + x0, + y0, + x1, + y1 + ); + } + + this.edges = edges; + this.cells = cells; + beaches = circles = edges = cells = null; + } + Diagram.prototype = { + constructor: Diagram, + polygons: function polygons() { + var edges = this.edges; + return this.cells.map(function (cell) { + var polygon = cell.halfedges.map(function (i) { + return Object( + _Cell__WEBPACK_IMPORTED_MODULE_1__.cellHalfedgeStart + )(cell, edges[i]); + }); + polygon.data = cell.site.data; + return polygon; + }); + }, + triangles: function triangles() { + var triangles = [], + edges = this.edges; + this.cells.forEach(function (cell, i) { + if (!(m = (halfedges = cell.halfedges).length)) return; + var site = cell.site, + halfedges, + j = -1, + m, + s0, + e1 = edges[halfedges[m - 1]], + s1 = e1.left === site ? e1.right : e1.left; + + while (++j < m) { + s0 = s1; + e1 = edges[halfedges[j]]; + s1 = e1.left === site ? e1.right : e1.left; + + if ( + s0 && + s1 && + i < s0.index && + i < s1.index && + triangleArea(site, s0, s1) < 0 + ) { + triangles.push([site.data, s0.data, s1.data]); + } + } + }); + return triangles; + }, + links: function links() { + return this.edges + .filter(function (edge) { + return edge.right; + }) + .map(function (edge) { + return { + source: edge.left.data, + target: edge.right.data, + }; + }); + }, + find: function find(x, y, radius) { + var that = this, + i0, + i1 = that._found || 0, + n = that.cells.length, + cell; // Use the previously-found cell, or start with an arbitrary one. + + while (!(cell = that.cells[i1])) { + if (++i1 >= n) return null; + } + + var dx = x - cell.site[0], + dy = y - cell.site[1], + d2 = dx * dx + dy * dy; // Traverse the half-edges to find a closer cell, if any. + + do { + (cell = that.cells[(i0 = i1)]), (i1 = null); + cell.halfedges.forEach(function (e) { + var edge = that.edges[e], + v = edge.left; + if ((v === cell.site || !v) && !(v = edge.right)) + return; + var vx = x - v[0], + vy = y - v[1], + v2 = vx * vx + vy * vy; + if (v2 < d2) (d2 = v2), (i1 = v.index); + }); + } while (i1 !== null); + + that._found = i0; + return radius == null || d2 <= radius * radius + ? cell.site + : null; + }, + }; + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/Edge.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-voronoi/src/Edge.js ***! + \*********************************************/ + /* ! exports provided: createEdge, createBorderEdge, setEdgeEnd, clipEdges */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "createEdge", + function () { + return createEdge; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "createBorderEdge", + function () { + return createBorderEdge; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "setEdgeEnd", + function () { + return setEdgeEnd; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "clipEdges", + function () { + return clipEdges; + } + ); + /* Harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js" + ); + + function createEdge(left, right, v0, v1) { + var edge = [null, null], + index = + _Diagram__WEBPACK_IMPORTED_MODULE_0__.edges.push( + edge + ) - 1; + edge.left = left; + edge.right = right; + if (v0) setEdgeEnd(edge, left, right, v0); + if (v1) setEdgeEnd(edge, right, left, v1); + _Diagram__WEBPACK_IMPORTED_MODULE_0__.cells[ + left.index + ].halfedges.push(index); + _Diagram__WEBPACK_IMPORTED_MODULE_0__.cells[ + right.index + ].halfedges.push(index); + return edge; + } + function createBorderEdge(left, v0, v1) { + var edge = [v0, v1]; + edge.left = left; + return edge; + } + function setEdgeEnd(edge, left, right, vertex) { + if (!edge[0] && !edge[1]) { + edge[0] = vertex; + edge.left = left; + edge.right = right; + } else if (edge.left === right) { + edge[1] = vertex; + } else { + edge[0] = vertex; + } + } // Liang–Barsky line clipping. + + function clipEdge(edge, x0, y0, x1, y1) { + var a = edge[0], + b = edge[1], + ax = a[0], + ay = a[1], + bx = b[0], + by = b[1], + t0 = 0, + t1 = 1, + dx = bx - ax, + dy = by - ay, + r; + r = x0 - ax; + if (!dx && r > 0) return; + r /= dx; + + if (dx < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dx > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + + r = x1 - ax; + if (!dx && r < 0) return; + r /= dx; + + if (dx < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dx > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + + r = y0 - ay; + if (!dy && r > 0) return; + r /= dy; + + if (dy < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dy > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + + r = y1 - ay; + if (!dy && r < 0) return; + r /= dy; + + if (dy < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dy > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + + if (!(t0 > 0) && !(t1 < 1)) return true; // TODO Better check? + + if (t0 > 0) edge[0] = [ax + t0 * dx, ay + t0 * dy]; + if (t1 < 1) edge[1] = [ax + t1 * dx, ay + t1 * dy]; + return true; + } + + function connectEdge(edge, x0, y0, x1, y1) { + var v1 = edge[1]; + if (v1) return true; + var v0 = edge[0], + left = edge.left, + right = edge.right, + lx = left[0], + ly = left[1], + rx = right[0], + ry = right[1], + fx = (lx + rx) / 2, + fy = (ly + ry) / 2, + fm, + fb; + + if (ry === ly) { + if (fx < x0 || fx >= x1) return; + + if (lx > rx) { + if (!v0) v0 = [fx, y0]; + else if (v0[1] >= y1) return; + v1 = [fx, y1]; + } else { + if (!v0) v0 = [fx, y1]; + else if (v0[1] < y0) return; + v1 = [fx, y0]; + } + } else { + fm = (lx - rx) / (ry - ly); + fb = fy - fm * fx; + + if (fm < -1 || fm > 1) { + if (lx > rx) { + if (!v0) v0 = [(y0 - fb) / fm, y0]; + else if (v0[1] >= y1) return; + v1 = [(y1 - fb) / fm, y1]; + } else { + if (!v0) v0 = [(y1 - fb) / fm, y1]; + else if (v0[1] < y0) return; + v1 = [(y0 - fb) / fm, y0]; + } + } else if (ly < ry) { + if (!v0) v0 = [x0, fm * x0 + fb]; + else if (v0[0] >= x1) return; + v1 = [x1, fm * x1 + fb]; + } else { + if (!v0) v0 = [x1, fm * x1 + fb]; + else if (v0[0] < x0) return; + v1 = [x0, fm * x0 + fb]; + } + } + + edge[0] = v0; + edge[1] = v1; + return true; + } + + function clipEdges(x0, y0, x1, y1) { + var i = _Diagram__WEBPACK_IMPORTED_MODULE_0__.edges.length, + edge; + + while (i--) { + if ( + !connectEdge( + (edge = + _Diagram__WEBPACK_IMPORTED_MODULE_0__.edges[ + i + ]), + x0, + y0, + x1, + y1 + ) || + !clipEdge(edge, x0, y0, x1, y1) || + !( + Math.abs(edge[0][0] - edge[1][0]) > + _Diagram__WEBPACK_IMPORTED_MODULE_0__.epsilon || + Math.abs(edge[0][1] - edge[1][1]) > + _Diagram__WEBPACK_IMPORTED_MODULE_0__.epsilon + ) + ) { + delete _Diagram__WEBPACK_IMPORTED_MODULE_0__.edges[ + i + ]; + } + } + } + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/RedBlackTree.js": + /* !*****************************************************!*\ + !*** ./node_modules/d3-voronoi/src/RedBlackTree.js ***! + \*****************************************************/ + /* ! exports provided: RedBlackNode, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "RedBlackNode", + function () { + return RedBlackNode; + } + ); + function RedBlackTree() { + this._ = null; // Root node + } + + function RedBlackNode(node) { + node.U = node.C = node.L = node.R = node.P = node.N = null; // Parent node // color - true for red, false for black // left node // right node // previous node // next node + } + RedBlackTree.prototype = { + constructor: RedBlackTree, + insert: function insert(after, node) { + var parent, grandpa, uncle; + + if (after) { + node.P = after; + node.N = after.N; + if (after.N) after.N.P = node; + after.N = node; + + if (after.R) { + after = after.R; + + while (after.L) { + after = after.L; + } + + after.L = node; + } else { + after.R = node; + } + + parent = after; + } else if (this._) { + after = RedBlackFirst(this._); + node.P = null; + node.N = after; + after.P = after.L = node; + parent = after; + } else { + node.P = node.N = null; + this._ = node; + parent = null; + } + + node.L = node.R = null; + node.U = parent; + node.C = true; + after = node; + + while (parent && parent.C) { + grandpa = parent.U; + + if (parent === grandpa.L) { + uncle = grandpa.R; + + if (uncle && uncle.C) { + parent.C = uncle.C = false; + grandpa.C = true; + after = grandpa; + } else { + if (after === parent.R) { + RedBlackRotateLeft(this, parent); + after = parent; + parent = after.U; + } + + parent.C = false; + grandpa.C = true; + RedBlackRotateRight(this, grandpa); + } + } else { + uncle = grandpa.L; + + if (uncle && uncle.C) { + parent.C = uncle.C = false; + grandpa.C = true; + after = grandpa; + } else { + if (after === parent.L) { + RedBlackRotateRight(this, parent); + after = parent; + parent = after.U; + } + + parent.C = false; + grandpa.C = true; + RedBlackRotateLeft(this, grandpa); + } + } + + parent = after.U; + } + + this._.C = false; + }, + remove: function remove(node) { + if (node.N) node.N.P = node.P; + if (node.P) node.P.N = node.N; + node.N = node.P = null; + var parent = node.U, + sibling, + left = node.L, + right = node.R, + next, + red; + if (!left) next = right; + else if (!right) next = left; + else next = RedBlackFirst(right); + + if (parent) { + if (parent.L === node) parent.L = next; + else parent.R = next; + } else { + this._ = next; + } + + if (left && right) { + red = next.C; + next.C = node.C; + next.L = left; + left.U = next; + + if (next !== right) { + parent = next.U; + next.U = node.U; + node = next.R; + parent.L = node; + next.R = right; + right.U = next; + } else { + next.U = parent; + parent = next; + node = next.R; + } + } else { + red = node.C; + node = next; + } + + if (node) node.U = parent; + if (red) return; + + if (node && node.C) { + node.C = false; + return; + } + + do { + if (node === this._) break; + + if (node === parent.L) { + sibling = parent.R; + + if (sibling.C) { + sibling.C = false; + parent.C = true; + RedBlackRotateLeft(this, parent); + sibling = parent.R; + } + + if ( + (sibling.L && sibling.L.C) || + (sibling.R && sibling.R.C) + ) { + if (!sibling.R || !sibling.R.C) { + sibling.L.C = false; + sibling.C = true; + RedBlackRotateRight(this, sibling); + sibling = parent.R; + } + + sibling.C = parent.C; + parent.C = sibling.R.C = false; + RedBlackRotateLeft(this, parent); + node = this._; + break; + } + } else { + sibling = parent.L; + + if (sibling.C) { + sibling.C = false; + parent.C = true; + RedBlackRotateRight(this, parent); + sibling = parent.L; + } + + if ( + (sibling.L && sibling.L.C) || + (sibling.R && sibling.R.C) + ) { + if (!sibling.L || !sibling.L.C) { + sibling.R.C = false; + sibling.C = true; + RedBlackRotateLeft(this, sibling); + sibling = parent.L; + } + + sibling.C = parent.C; + parent.C = sibling.L.C = false; + RedBlackRotateRight(this, parent); + node = this._; + break; + } + } + + sibling.C = true; + node = parent; + parent = parent.U; + } while (!node.C); + + if (node) node.C = false; + }, + }; + + function RedBlackRotateLeft(tree, node) { + var p = node, + q = node.R, + parent = p.U; + + if (parent) { + if (parent.L === p) parent.L = q; + else parent.R = q; + } else { + tree._ = q; + } + + q.U = parent; + p.U = q; + p.R = q.L; + if (p.R) p.R.U = p; + q.L = p; + } + + function RedBlackRotateRight(tree, node) { + var p = node, + q = node.L, + parent = p.U; + + if (parent) { + if (parent.L === p) parent.L = q; + else parent.R = q; + } else { + tree._ = q; + } + + q.U = parent; + p.U = q; + p.L = q.R; + if (p.L) p.L.U = p; + q.R = p; + } + + function RedBlackFirst(node) { + while (node.L) { + node = node.L; + } + + return node; + } + + /* Harmony default export */ __webpack_exports__.default = RedBlackTree; + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/constant.js": + /* !*************************************************!*\ + !*** ./node_modules/d3-voronoi/src/constant.js ***! + \*************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/index.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-voronoi/src/index.js ***! + \**********************************************/ + /* ! exports provided: voronoi */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _voronoi__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./voronoi */ "./node_modules/d3-voronoi/src/voronoi.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "voronoi", + function () { + return _voronoi__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/point.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-voronoi/src/point.js ***! + \**********************************************/ + /* ! exports provided: x, y */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "x", + function () { + return x; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "y", + function () { + return y; + } + ); + function x(d) { + return d[0]; + } + function y(d) { + return d[1]; + } + + /***/ + }, + + /***/ "./node_modules/d3-voronoi/src/voronoi.js": + /* !************************************************!*\ + !*** ./node_modules/d3-voronoi/src/voronoi.js ***! + \************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./constant */ "./node_modules/d3-voronoi/src/constant.js" + ); + /* Harmony import */ var _point__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./point */ "./node_modules/d3-voronoi/src/point.js" + ); + /* Harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js" + ); + + /* Harmony default export */ __webpack_exports__.default = function () { + var x = _point__WEBPACK_IMPORTED_MODULE_1__.x, + y = _point__WEBPACK_IMPORTED_MODULE_1__.y, + extent = null; + + function voronoi(data) { + return new _Diagram__WEBPACK_IMPORTED_MODULE_2__.default( + data.map(function (d, i) { + var s = [ + Math.round( + x(d, i, data) / + _Diagram__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) * + _Diagram__WEBPACK_IMPORTED_MODULE_2__.epsilon, + Math.round( + y(d, i, data) / + _Diagram__WEBPACK_IMPORTED_MODULE_2__.epsilon + ) * + _Diagram__WEBPACK_IMPORTED_MODULE_2__.epsilon, + ]; + s.index = i; + s.data = d; + return s; + }), + extent + ); + } + + voronoi.polygons = function (data) { + return voronoi(data).polygons(); + }; + + voronoi.links = function (data) { + return voronoi(data).links(); + }; + + voronoi.triangles = function (data) { + return voronoi(data).triangles(); + }; + + voronoi.x = function (_) { + return arguments.length + ? ((x = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + voronoi) + : x; + }; + + voronoi.y = function (_) { + return arguments.length + ? ((y = + typeof _ === "function" + ? _ + : Object( + _constant__WEBPACK_IMPORTED_MODULE_0__.default + )(Number(_))), + voronoi) + : y; + }; + + voronoi.extent = function (_) { + return arguments.length + ? ((extent = + _ == null + ? null + : [ + [Number(_[0][0]), Number(_[0][1])], + [Number(_[1][0]), Number(_[1][1])], + ]), + voronoi) + : extent && [ + [extent[0][0], extent[0][1]], + [extent[1][0], extent[1][1]], + ]; + }; + + voronoi.size = function (_) { + return arguments.length + ? ((extent = + _ == null + ? null + : [ + [0, 0], + [Number(_[0]), Number(_[1])], + ]), + voronoi) + : extent && [ + extent[1][0] - extent[0][0], + extent[1][1] - extent[0][1], + ]; + }; + + return voronoi; + }; + + /***/ + }, + + /***/ "./node_modules/d3-zoom/src/constant.js": + /* !**********************************************!*\ + !*** ./node_modules/d3-zoom/src/constant.js ***! + \**********************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony default export */ __webpack_exports__.default = function (x) { + return function () { + return x; + }; + }; + + /***/ + }, + + /***/ "./node_modules/d3-zoom/src/event.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-zoom/src/event.js ***! + \*******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return ZoomEvent; + } + ); + function ZoomEvent(target, type, transform) { + this.target = target; + this.type = type; + this.transform = transform; + } + + /***/ + }, + + /***/ "./node_modules/d3-zoom/src/index.js": + /* !*******************************************!*\ + !*** ./node_modules/d3-zoom/src/index.js ***! + \*******************************************/ + /* ! exports provided: zoom, zoomTransform, zoomIdentity */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _zoom_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./zoom.js */ "./node_modules/d3-zoom/src/zoom.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "zoom", + function () { + return _zoom_js__WEBPACK_IMPORTED_MODULE_0__.default; + } + ); + + /* Harmony import */ var _transform_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./transform.js */ "./node_modules/d3-zoom/src/transform.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "zoomTransform", + function () { + return _transform_js__WEBPACK_IMPORTED_MODULE_1__.default; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "zoomIdentity", + function () { + return _transform_js__WEBPACK_IMPORTED_MODULE_1__.identity; + } + ); + + /***/ + }, + + /***/ "./node_modules/d3-zoom/src/noevent.js": + /* !*********************************************!*\ + !*** ./node_modules/d3-zoom/src/noevent.js ***! + \*********************************************/ + /* ! exports provided: nopropagation, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "nopropagation", + function () { + return nopropagation; + } + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + + function nopropagation() { + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.stopImmediatePropagation(); + } + /* Harmony default export */ __webpack_exports__.default = function () { + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.preventDefault(); + d3_selection__WEBPACK_IMPORTED_MODULE_0__.event.stopImmediatePropagation(); + }; + + /***/ + }, + + /***/ "./node_modules/d3-zoom/src/transform.js": + /* !***********************************************!*\ + !*** ./node_modules/d3-zoom/src/transform.js ***! + \***********************************************/ + /* ! exports provided: Transform, identity, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "Transform", + function () { + return Transform; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "identity", + function () { + return identity; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "default", + function () { + return transform; + } + ); + function Transform(k, x, y) { + this.k = k; + this.x = x; + this.y = y; + } + Transform.prototype = { + constructor: Transform, + scale: function scale(k) { + return k === 1 + ? this + : new Transform(this.k * k, this.x, this.y); + }, + translate: function translate(x, y) { + return (x === 0) & (y === 0) + ? this + : new Transform( + this.k, + this.x + this.k * x, + this.y + this.k * y + ); + }, + apply: function apply(point) { + return [ + point[0] * this.k + this.x, + point[1] * this.k + this.y, + ]; + }, + applyX: function applyX(x) { + return x * this.k + this.x; + }, + applyY: function applyY(y) { + return y * this.k + this.y; + }, + invert: function invert(location) { + return [ + (location[0] - this.x) / this.k, + (location[1] - this.y) / this.k, + ]; + }, + invertX: function invertX(x) { + return (x - this.x) / this.k; + }, + invertY: function invertY(y) { + return (y - this.y) / this.k; + }, + rescaleX: function rescaleX(x) { + return x + .copy() + .domain( + x.range().map(this.invertX, this).map(x.invert, x) + ); + }, + rescaleY: function rescaleY(y) { + return y + .copy() + .domain( + y.range().map(this.invertY, this).map(y.invert, y) + ); + }, + toString: function toString() { + return ( + "translate(" + + this.x + + "," + + this.y + + ") scale(" + + this.k + + ")" + ); + }, + }; + var identity = new Transform(1, 0, 0); + transform.prototype = Transform.prototype; + function transform(node) { + while (!node.__zoom) { + if (!(node = node.parentNode)) return identity; + } + + return node.__zoom; + } + + /***/ + }, + + /***/ "./node_modules/d3-zoom/src/zoom.js": + /* !******************************************!*\ + !*** ./node_modules/d3-zoom/src/zoom.js ***! + \******************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js" + ); + /* Harmony import */ var d3_drag__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-drag */ "./node_modules/d3-drag/src/index.js" + ); + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony import */ var d3_transition__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! d3-transition */ "./node_modules/d3-transition/src/index.js" + ); + /* Harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! ./constant.js */ "./node_modules/d3-zoom/src/constant.js" + ); + /* Harmony import */ var _event_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! ./event.js */ "./node_modules/d3-zoom/src/event.js" + ); + /* Harmony import */ var _transform_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! ./transform.js */ "./node_modules/d3-zoom/src/transform.js" + ); + /* Harmony import */ var _noevent_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! ./noevent.js */ "./node_modules/d3-zoom/src/noevent.js" + ); + + // Ignore right-click, since that should open the context menu. + + function defaultFilter() { + return ( + !d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .ctrlKey && + !d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.button + ); + } + + function defaultExtent() { + var e = this; + + if (e instanceof SVGElement) { + e = e.ownerSVGElement || e; + + if (e.hasAttribute("viewBox")) { + e = e.viewBox.baseVal; + return [ + [e.x, e.y], + [e.x + e.width, e.y + e.height], + ]; + } + + return [ + [0, 0], + [e.width.baseVal.value, e.height.baseVal.value], + ]; + } + + return [ + [0, 0], + [e.clientWidth, e.clientHeight], + ]; + } + + function defaultTransform() { + return ( + this.__zoom || + _transform_js__WEBPACK_IMPORTED_MODULE_7__.identity + ); + } + + function defaultWheelDelta() { + return ( + -d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.deltaY * + (d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .deltaMode === 1 + ? 0.05 + : d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .deltaMode + ? 1 + : 0.002) + ); + } + + function defaultTouchable() { + return navigator.maxTouchPoints || "ontouchstart" in this; + } + + function defaultConstrain(transform, extent, translateExtent) { + var dx0 = + transform.invertX(extent[0][0]) - translateExtent[0][0], + dx1 = + transform.invertX(extent[1][0]) - translateExtent[1][0], + dy0 = + transform.invertY(extent[0][1]) - translateExtent[0][1], + dy1 = + transform.invertY(extent[1][1]) - translateExtent[1][1]; + return transform.translate( + dx1 > dx0 + ? (dx0 + dx1) / 2 + : Math.min(0, dx0) || Math.max(0, dx1), + dy1 > dy0 + ? (dy0 + dy1) / 2 + : Math.min(0, dy0) || Math.max(0, dy1) + ); + } + + /* Harmony default export */ __webpack_exports__.default = function () { + var filter = defaultFilter, + extent = defaultExtent, + constrain = defaultConstrain, + wheelDelta = defaultWheelDelta, + touchable = defaultTouchable, + scaleExtent = [0, Infinity], + translateExtent = [ + [-Infinity, -Infinity], + [Infinity, Infinity], + ], + duration = 250, + interpolate = + d3_interpolate__WEBPACK_IMPORTED_MODULE_2__.interpolateZoom, + listeners = Object( + d3_dispatch__WEBPACK_IMPORTED_MODULE_0__.dispatch + )("start", "zoom", "end"), + touchstarting, + touchending, + touchDelay = 500, + wheelDelay = 150, + clickDistance2 = 0; + + function zoom(selection) { + selection + .property("__zoom", defaultTransform) + .on("wheel.zoom", wheeled) + .on("mousedown.zoom", mousedowned) + .on("dblclick.zoom", dblclicked) + .filter(touchable) + .on("touchstart.zoom", touchstarted) + .on("touchmove.zoom", touchmoved) + .on("touchend.zoom touchcancel.zoom", touchended) + .style("touch-action", "none") + .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); + } + + zoom.transform = function (collection, transform, point) { + var selection = collection.selection + ? collection.selection() + : collection; + selection.property("__zoom", defaultTransform); + + if (collection !== selection) { + schedule(collection, transform, point); + } else { + selection.interrupt().each(function () { + gesture(this, arguments) + .start() + .zoom( + null, + typeof transform === "function" + ? transform.apply(this, arguments) + : transform + ) + .end(); + }); + } + }; + + zoom.scaleBy = function (selection, k, p) { + zoom.scaleTo( + selection, + function () { + var k0 = this.__zoom.k, + k1 = + typeof k === "function" + ? k.apply(this, arguments) + : k; + return k0 * k1; + }, + p + ); + }; + + zoom.scaleTo = function (selection, k, p) { + zoom.transform( + selection, + function () { + var e = extent.apply(this, arguments), + t0 = this.__zoom, + p0 = + p == null + ? centroid(e) + : typeof p === "function" + ? p.apply(this, arguments) + : p, + p1 = t0.invert(p0), + k1 = + typeof k === "function" + ? k.apply(this, arguments) + : k; + return constrain( + translate(scale(t0, k1), p0, p1), + e, + translateExtent + ); + }, + p + ); + }; + + zoom.translateBy = function (selection, x, y) { + zoom.transform(selection, function () { + return constrain( + this.__zoom.translate( + typeof x === "function" + ? x.apply(this, arguments) + : x, + typeof y === "function" + ? y.apply(this, arguments) + : y + ), + extent.apply(this, arguments), + translateExtent + ); + }); + }; + + zoom.translateTo = function (selection, x, y, p) { + zoom.transform( + selection, + function () { + var e = extent.apply(this, arguments), + t = this.__zoom, + p0 = + p == null + ? centroid(e) + : typeof p === "function" + ? p.apply(this, arguments) + : p; + return constrain( + _transform_js__WEBPACK_IMPORTED_MODULE_7__.identity + .translate(p0[0], p0[1]) + .scale(t.k) + .translate( + typeof x === "function" + ? -x.apply(this, arguments) + : -x, + typeof y === "function" + ? -y.apply(this, arguments) + : -y + ), + e, + translateExtent + ); + }, + p + ); + }; + + function scale(transform, k) { + k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], k)); + return k === transform.k + ? transform + : new _transform_js__WEBPACK_IMPORTED_MODULE_7__.Transform(k, transform.x, transform.y); + } + + function translate(transform, p0, p1) { + var x = p0[0] - p1[0] * transform.k, + y = p0[1] - p1[1] * transform.k; + return x === transform.x && y === transform.y + ? transform + : new _transform_js__WEBPACK_IMPORTED_MODULE_7__.Transform(transform.k, x, y); + } + + function centroid(extent) { + return [ + (Number(extent[0][0]) + Number(extent[1][0])) / 2, + (Number(extent[0][1]) + Number(extent[1][1])) / 2, + ]; + } + + function schedule(transition, transform, point) { + transition + .on("start.zoom", function () { + gesture(this, arguments).start(); + }) + .on("interrupt.zoom end.zoom", function () { + gesture(this, arguments).end(); + }) + .tween("zoom", function () { + var that = this, + args = arguments, + g = gesture(that, args), + e = extent.apply(that, args), + p = + point == null + ? centroid(e) + : typeof point === "function" + ? point.apply(that, args) + : point, + w = Math.max( + e[1][0] - e[0][0], + e[1][1] - e[0][1] + ), + a = that.__zoom, + b = + typeof transform === "function" + ? transform.apply(that, args) + : transform, + i = interpolate( + a.invert(p).concat(w / a.k), + b.invert(p).concat(w / b.k) + ); + return function (t) { + if (t === 1) t = b; + // Avoid rounding error on end. + else { + var l = i(t), + k = w / l[2]; + t = new _transform_js__WEBPACK_IMPORTED_MODULE_7__.Transform(k, p[0] - l[0] * k, p[1] - l[1] * k); + } + g.zoom(null, t); + }; + }); + } + + function gesture(that, args, clean) { + return ( + (!clean && that.__zooming) || new Gesture(that, args) + ); + } + + function Gesture(that, args) { + this.that = that; + this.args = args; + this.active = 0; + this.extent = extent.apply(that, args); + this.taps = 0; + } + + Gesture.prototype = { + start: function start() { + if (++this.active === 1) { + this.that.__zooming = this; + this.emit("start"); + } + + return this; + }, + zoom: function zoom(key, transform) { + if (this.mouse && key !== "mouse") + this.mouse[1] = transform.invert(this.mouse[0]); + if (this.touch0 && key !== "touch") + this.touch0[1] = transform.invert(this.touch0[0]); + if (this.touch1 && key !== "touch") + this.touch1[1] = transform.invert(this.touch1[0]); + this.that.__zoom = transform; + this.emit("zoom"); + return this; + }, + end: function end() { + if (--this.active === 0) { + delete this.that.__zooming; + this.emit("end"); + } + + return this; + }, + emit: function emit(type) { + Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.customEvent + )( + new _event_js__WEBPACK_IMPORTED_MODULE_6__.default(zoom, type, this.that.__zoom), + listeners.apply, + listeners, + [type, this.that, this.args] + ); + }, + }; + + function wheeled() { + if (!filter.apply(this, arguments)) return; + var g = gesture(this, arguments), + t = this.__zoom, + k = Math.max( + scaleExtent[0], + Math.min( + scaleExtent[1], + t.k * + Math.pow( + 2, + wheelDelta.apply(this, arguments) + ) + ) + ), + p = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.mouse + )(this); // If the mouse is in the same location as before, reuse it. + // If there were recent wheel events, reset the wheel idle timeout. + + if (g.wheel) { + if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) { + g.mouse[1] = t.invert((g.mouse[0] = p)); + } + + clearTimeout(g.wheel); + } // If this wheel event won’t trigger a transform change, ignore it. + else if (t.k === k) return; + // Otherwise, capture the mouse point and location at the start. + else { + g.mouse = [p, t.invert(p)]; + Object( + d3_transition__WEBPACK_IMPORTED_MODULE_4__.interrupt + )(this); + g.start(); + } + + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_8__.default + )(); + g.wheel = setTimeout(wheelidled, wheelDelay); + g.zoom( + "mouse", + constrain( + translate(scale(t, k), g.mouse[0], g.mouse[1]), + g.extent, + translateExtent + ) + ); + + function wheelidled() { + g.wheel = null; + g.end(); + } + } + + function mousedowned() { + if (touchending || !filter.apply(this, arguments)) return; + var g = gesture(this, arguments, true), + v = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.select + )( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .view + ) + .on("mousemove.zoom", mousemoved, true) + .on("mouseup.zoom", mouseupped, true), + p = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.mouse + )(this), + x0 = + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .clientX, + y0 = + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .clientY; + Object(d3_drag__WEBPACK_IMPORTED_MODULE_1__.dragDisable)( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.view + ); + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_8__.nopropagation + )(); + g.mouse = [p, this.__zoom.invert(p)]; + Object( + d3_transition__WEBPACK_IMPORTED_MODULE_4__.interrupt + )(this); + g.start(); + + function mousemoved() { + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_8__.default + )(); + + if (!g.moved) { + var dx = + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.clientX - x0, + dy = + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event.clientY - y0; + g.moved = dx * dx + dy * dy > clickDistance2; + } + + g.zoom( + "mouse", + constrain( + translate( + g.that.__zoom, + (g.mouse[0] = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.mouse + )(g.that)), + g.mouse[1] + ), + g.extent, + translateExtent + ) + ); + } + + function mouseupped() { + v.on("mousemove.zoom mouseup.zoom", null); + Object( + d3_drag__WEBPACK_IMPORTED_MODULE_1__.dragEnable + )( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .view, + g.moved + ); + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_8__.default + )(); + g.end(); + } + } + + function dblclicked() { + if (!filter.apply(this, arguments)) return; + var t0 = this.__zoom, + p0 = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.mouse + )(this), + p1 = t0.invert(p0), + k1 = + t0.k * + (d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .shiftKey + ? 0.5 + : 2), + t1 = constrain( + translate(scale(t0, k1), p0, p1), + extent.apply(this, arguments), + translateExtent + ); + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_8__.default + )(); + if (duration > 0) + Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.select + )(this) + .transition() + .duration(duration) + .call(schedule, t1, p0); + else + Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.select + )(this).call(zoom.transform, t1); + } + + function touchstarted() { + if (!filter.apply(this, arguments)) return; + var touches = + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .touches, + n = touches.length, + g = gesture( + this, + arguments, + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .changedTouches.length === n + ), + started, + i, + t, + p; + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_8__.nopropagation + )(); + + for (i = 0; i < n; ++i) { + (t = touches[i]), + (p = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.touch + )(this, touches, t.identifier)); + p = [p, this.__zoom.invert(p), t.identifier]; + if (!g.touch0) + (g.touch0 = p), + (started = true), + (g.taps = 1 + Boolean(touchstarting)); + else if (!g.touch1 && g.touch0[2] !== p[2]) + (g.touch1 = p), (g.taps = 0); + } + + if (touchstarting) + touchstarting = clearTimeout(touchstarting); + + if (started) { + if (g.taps < 2) + touchstarting = setTimeout(function () { + touchstarting = null; + }, touchDelay); + Object( + d3_transition__WEBPACK_IMPORTED_MODULE_4__.interrupt + )(this); + g.start(); + } + } + + function touchmoved() { + if (!this.__zooming) return; + var g = gesture(this, arguments), + touches = + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .changedTouches, + n = touches.length, + i, + t, + p, + l; + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_8__.default + )(); + if (touchstarting) + touchstarting = clearTimeout(touchstarting); + g.taps = 0; + + for (i = 0; i < n; ++i) { + (t = touches[i]), + (p = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.touch + )(this, touches, t.identifier)); + if (g.touch0 && g.touch0[2] === t.identifier) + g.touch0[0] = p; + else if (g.touch1 && g.touch1[2] === t.identifier) + g.touch1[0] = p; + } + + t = g.that.__zoom; + + if (g.touch1) { + var p0 = g.touch0[0], + l0 = g.touch0[1], + p1 = g.touch1[0], + l1 = g.touch1[1], + dp = + (dp = p1[0] - p0[0]) * dp + + (dp = p1[1] - p0[1]) * dp, + dl = + (dl = l1[0] - l0[0]) * dl + + (dl = l1[1] - l0[1]) * dl; + t = scale(t, Math.sqrt(dp / dl)); + p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2]; + l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2]; + } else if (g.touch0) (p = g.touch0[0]), (l = g.touch0[1]); + else return; + + g.zoom( + "touch", + constrain(translate(t, p, l), g.extent, translateExtent) + ); + } + + function touchended() { + if (!this.__zooming) return; + var g = gesture(this, arguments), + touches = + d3_selection__WEBPACK_IMPORTED_MODULE_3__.event + .changedTouches, + n = touches.length, + i, + t; + Object( + _noevent_js__WEBPACK_IMPORTED_MODULE_8__.nopropagation + )(); + if (touchending) clearTimeout(touchending); + touchending = setTimeout(function () { + touchending = null; + }, touchDelay); + + for (i = 0; i < n; ++i) { + t = touches[i]; + if (g.touch0 && g.touch0[2] === t.identifier) + delete g.touch0; + else if (g.touch1 && g.touch1[2] === t.identifier) + delete g.touch1; + } + + if (g.touch1 && !g.touch0) + (g.touch0 = g.touch1), delete g.touch1; + if (g.touch0) g.touch0[1] = this.__zoom.invert(g.touch0[0]); + else { + g.end(); // If this was a dbltap, reroute to the (optional) dblclick.zoom handler. + + if (g.taps === 2) { + var p = Object( + d3_selection__WEBPACK_IMPORTED_MODULE_3__.select + )(this).on("dblclick.zoom"); + if (p) p.apply(this, arguments); + } + } + } + + zoom.wheelDelta = function (_) { + return arguments.length + ? ((wheelDelta = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_5__.default + )(Number(_))), + zoom) + : wheelDelta; + }; + + zoom.filter = function (_) { + return arguments.length + ? ((filter = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_5__.default + )(Boolean(_))), + zoom) + : filter; + }; + + zoom.touchable = function (_) { + return arguments.length + ? ((touchable = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_5__.default + )(Boolean(_))), + zoom) + : touchable; + }; + + zoom.extent = function (_) { + return arguments.length + ? ((extent = + typeof _ === "function" + ? _ + : Object( + _constant_js__WEBPACK_IMPORTED_MODULE_5__.default + )([ + [Number(_[0][0]), Number(_[0][1])], + [Number(_[1][0]), Number(_[1][1])], + ])), + zoom) + : extent; + }; + + zoom.scaleExtent = function (_) { + return arguments.length + ? ((scaleExtent[0] = Number(_[0])), + (scaleExtent[1] = Number(_[1])), + zoom) + : [scaleExtent[0], scaleExtent[1]]; + }; + + zoom.translateExtent = function (_) { + return arguments.length + ? ((translateExtent[0][0] = Number(_[0][0])), + (translateExtent[1][0] = Number(_[1][0])), + (translateExtent[0][1] = Number(_[0][1])), + (translateExtent[1][1] = Number(_[1][1])), + zoom) + : [ + [translateExtent[0][0], translateExtent[0][1]], + [translateExtent[1][0], translateExtent[1][1]], + ]; + }; + + zoom.constrain = function (_) { + return arguments.length + ? ((constrain = _), zoom) + : constrain; + }; + + zoom.duration = function (_) { + return arguments.length + ? ((duration = Number(_)), zoom) + : duration; + }; + + zoom.interpolate = function (_) { + return arguments.length + ? ((interpolate = _), zoom) + : interpolate; + }; + + zoom.on = function () { + var value = listeners.on.apply(listeners, arguments); + return value === listeners ? zoom : value; + }; + + zoom.clickDistance = function (_) { + return arguments.length + ? ((clickDistance2 = (_ = Number(_)) * _), zoom) + : Math.sqrt(clickDistance2); + }; + + return zoom; + }; + + /***/ + }, + + /***/ "./node_modules/d3/dist/package.js": + /* !*****************************************!*\ + !*** ./node_modules/d3/dist/package.js ***! + \*****************************************/ + /* ! exports provided: name, version, description, keywords, homepage, license, author, main, unpkg, jsdelivr, module, repository, files, scripts, devDependencies, dependencies */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "name", + function () { + return name; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "version", + function () { + return version; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "description", + function () { + return description; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "keywords", + function () { + return keywords; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "homepage", + function () { + return homepage; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "license", + function () { + return license; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "author", + function () { + return author; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "main", + function () { + return main; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "unpkg", + function () { + return unpkg; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "jsdelivr", + function () { + return jsdelivr; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "module", + function () { + return module; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "repository", + function () { + return repository; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "files", + function () { + return files; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "scripts", + function () { + return scripts; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "devDependencies", + function () { + return devDependencies; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "dependencies", + function () { + return dependencies; + } + ); + var name = "d3"; + var version = "5.12.0"; + var description = "Data-Driven Documents"; + var keywords = [ + "dom", + "visualization", + "svg", + "animation", + "canvas", + ]; + var homepage = "https://d3js.org"; + var license = "BSD-3-Clause"; + var author = { + name: "Mike Bostock", + url: "https://bost.ocks.org/mike", + }; + var main = "dist/d3.node.js"; + var unpkg = "dist/d3.min.js"; + var jsdelivr = "dist/d3.min.js"; + var module = "index.js"; + var repository = { + type: "git", + url: "https://github.com/d3/d3.git", + }; + var files = ["dist/**/*.js", "index.js"]; + var scripts = { + pretest: + "rimraf dist && mkdir dist && json2module package.json > dist/package.js && rollup -c", + test: "tape 'test/**/*-test.js'", + prepublishOnly: "yarn test", + postpublish: + 'git push && git push --tags && cd ../d3.github.com && git pull && cp ../d3/dist/d3.js d3.v5.js && cp ../d3/dist/d3.min.js d3.v5.min.js && git add d3.v5.js d3.v5.min.js && git commit -m "d3 ${npm_package_version}" && git push && cd - && cd ../d3-bower && git pull && cp ../d3/LICENSE ../d3/README.md ../d3/dist/d3.js ../d3/dist/d3.min.js . && git add -- LICENSE README.md d3.js d3.min.js && git commit -m "${npm_package_version}" && git tag -am "${npm_package_version}" v${npm_package_version} && git push && git push --tags && cd - && zip -j dist/d3.zip -- LICENSE README.md API.md CHANGES.md dist/d3.js dist/d3.min.js', + }; + var devDependencies = { + json2module: "0.0", + rimraf: "2", + rollup: "1", + "rollup-plugin-ascii": "0.0", + "rollup-plugin-node-resolve": "3", + "rollup-plugin-terser": "5", + tape: "4", + }; + var dependencies = { + "d3-array": "1", + "d3-axis": "1", + "d3-brush": "1", + "d3-chord": "1", + "d3-collection": "1", + "d3-color": "1", + "d3-contour": "1", + "d3-dispatch": "1", + "d3-drag": "1", + "d3-dsv": "1", + "d3-ease": "1", + "d3-fetch": "1", + "d3-force": "1", + "d3-format": "1", + "d3-geo": "1", + "d3-hierarchy": "1", + "d3-interpolate": "1", + "d3-path": "1", + "d3-polygon": "1", + "d3-quadtree": "1", + "d3-random": "1", + "d3-scale": "2", + "d3-scale-chromatic": "1", + "d3-selection": "1", + "d3-shape": "1", + "d3-time": "1", + "d3-time-format": "2", + "d3-timer": "1", + "d3-transition": "1", + "d3-voronoi": "1", + "d3-zoom": "1", + }; + + /***/ + }, + + /***/ "./node_modules/d3/index.js": + /* !**********************************!*\ + !*** ./node_modules/d3/index.js ***! + \**********************************/ + /* ! exports provided: version, bisect, bisectRight, bisectLeft, ascending, bisector, cross, descending, deviation, extent, histogram, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges, max, mean, median, merge, min, pairs, permute, quantile, range, scan, shuffle, sum, ticks, tickIncrement, tickStep, transpose, variance, zip, axisTop, axisRight, axisBottom, axisLeft, brush, brushX, brushY, brushSelection, chord, ribbon, nest, set, map, keys, values, entries, color, rgb, hsl, lab, hcl, lch, gray, cubehelix, contours, contourDensity, dispatch, drag, dragDisable, dragEnable, dsvFormat, csvParse, csvParseRows, csvFormat, csvFormatBody, csvFormatRows, tsvParse, tsvParseRows, tsvFormat, tsvFormatBody, tsvFormatRows, autoType, easeLinear, easeQuad, easeQuadIn, easeQuadOut, easeQuadInOut, easeCubic, easeCubicIn, easeCubicOut, easeCubicInOut, easePoly, easePolyIn, easePolyOut, easePolyInOut, easeSin, easeSinIn, easeSinOut, easeSinInOut, easeExp, easeExpIn, easeExpOut, easeExpInOut, easeCircle, easeCircleIn, easeCircleOut, easeCircleInOut, easeBounce, easeBounceIn, easeBounceOut, easeBounceInOut, easeBack, easeBackIn, easeBackOut, easeBackInOut, easeElastic, easeElasticIn, easeElasticOut, easeElasticInOut, blob, buffer, dsv, csv, tsv, image, json, text, xml, html, svg, forceCenter, forceCollide, forceLink, forceManyBody, forceRadial, forceSimulation, forceX, forceY, formatDefaultLocale, format, formatPrefix, formatLocale, formatSpecifier, FormatSpecifier, precisionFixed, precisionPrefix, precisionRound, geoArea, geoBounds, geoCentroid, geoCircle, geoClipAntimeridian, geoClipCircle, geoClipExtent, geoClipRectangle, geoContains, geoDistance, geoGraticule, geoGraticule10, geoInterpolate, geoLength, geoPath, geoAlbers, geoAlbersUsa, geoAzimuthalEqualArea, geoAzimuthalEqualAreaRaw, geoAzimuthalEquidistant, geoAzimuthalEquidistantRaw, geoConicConformal, geoConicConformalRaw, geoConicEqualArea, geoConicEqualAreaRaw, geoConicEquidistant, geoConicEquidistantRaw, geoEqualEarth, geoEqualEarthRaw, geoEquirectangular, geoEquirectangularRaw, geoGnomonic, geoGnomonicRaw, geoIdentity, geoProjection, geoProjectionMutator, geoMercator, geoMercatorRaw, geoNaturalEarth1, geoNaturalEarth1Raw, geoOrthographic, geoOrthographicRaw, geoStereographic, geoStereographicRaw, geoTransverseMercator, geoTransverseMercatorRaw, geoRotation, geoStream, geoTransform, cluster, hierarchy, pack, packSiblings, packEnclose, partition, stratify, tree, treemap, treemapBinary, treemapDice, treemapSlice, treemapSliceDice, treemapSquarify, treemapResquarify, interpolate, interpolateArray, interpolateBasis, interpolateBasisClosed, interpolateDate, interpolateDiscrete, interpolateHue, interpolateNumber, interpolateObject, interpolateRound, interpolateString, interpolateTransformCss, interpolateTransformSvg, interpolateZoom, interpolateRgb, interpolateRgbBasis, interpolateRgbBasisClosed, interpolateHsl, interpolateHslLong, interpolateLab, interpolateHcl, interpolateHclLong, interpolateCubehelix, interpolateCubehelixLong, piecewise, quantize, path, polygonArea, polygonCentroid, polygonHull, polygonContains, polygonLength, quadtree, randomUniform, randomNormal, randomLogNormal, randomBates, randomIrwinHall, randomExponential, scaleBand, scalePoint, scaleIdentity, scaleLinear, scaleLog, scaleSymlog, scaleOrdinal, scaleImplicit, scalePow, scaleSqrt, scaleQuantile, scaleQuantize, scaleThreshold, scaleTime, scaleUtc, scaleSequential, scaleSequentialLog, scaleSequentialPow, scaleSequentialSqrt, scaleSequentialSymlog, scaleSequentialQuantile, scaleDiverging, scaleDivergingLog, scaleDivergingPow, scaleDivergingSqrt, scaleDivergingSymlog, tickFormat, schemeCategory10, schemeAccent, schemeDark2, schemePaired, schemePastel1, schemePastel2, schemeSet1, schemeSet2, schemeSet3, schemeTableau10, interpolateBrBG, schemeBrBG, interpolatePRGn, schemePRGn, interpolatePiYG, schemePiYG, interpolatePuOr, schemePuOr, interpolateRdBu, schemeRdBu, interpolateRdGy, schemeRdGy, interpolateRdYlBu, schemeRdYlBu, interpolateRdYlGn, schemeRdYlGn, interpolateSpectral, schemeSpectral, interpolateBuGn, schemeBuGn, interpolateBuPu, schemeBuPu, interpolateGnBu, schemeGnBu, interpolateOrRd, schemeOrRd, interpolatePuBuGn, schemePuBuGn, interpolatePuBu, schemePuBu, interpolatePuRd, schemePuRd, interpolateRdPu, schemeRdPu, interpolateYlGnBu, schemeYlGnBu, interpolateYlGn, schemeYlGn, interpolateYlOrBr, schemeYlOrBr, interpolateYlOrRd, schemeYlOrRd, interpolateBlues, schemeBlues, interpolateGreens, schemeGreens, interpolateGreys, schemeGreys, interpolatePurples, schemePurples, interpolateReds, schemeReds, interpolateOranges, schemeOranges, interpolateCividis, interpolateCubehelixDefault, interpolateRainbow, interpolateWarm, interpolateCool, interpolateSinebow, interpolateTurbo, interpolateViridis, interpolateMagma, interpolateInferno, interpolatePlasma, create, creator, local, matcher, mouse, namespace, namespaces, clientPoint, select, selectAll, selection, selector, selectorAll, style, touch, touches, window, event, customEvent, arc, area, line, pie, areaRadial, radialArea, lineRadial, radialLine, pointRadial, linkHorizontal, linkVertical, linkRadial, symbol, symbols, symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye, curveBasisClosed, curveBasisOpen, curveBasis, curveBundle, curveCardinalClosed, curveCardinalOpen, curveCardinal, curveCatmullRomClosed, curveCatmullRomOpen, curveCatmullRom, curveLinearClosed, curveLinear, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, stack, stackOffsetExpand, stackOffsetDiverging, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAppearance, stackOrderAscending, stackOrderDescending, stackOrderInsideOut, stackOrderNone, stackOrderReverse, timeInterval, timeMillisecond, timeMilliseconds, utcMillisecond, utcMilliseconds, timeSecond, timeSeconds, utcSecond, utcSeconds, timeMinute, timeMinutes, timeHour, timeHours, timeDay, timeDays, timeWeek, timeWeeks, timeSunday, timeSundays, timeMonday, timeMondays, timeTuesday, timeTuesdays, timeWednesday, timeWednesdays, timeThursday, timeThursdays, timeFriday, timeFridays, timeSaturday, timeSaturdays, timeMonth, timeMonths, timeYear, timeYears, utcMinute, utcMinutes, utcHour, utcHours, utcDay, utcDays, utcWeek, utcWeeks, utcSunday, utcSundays, utcMonday, utcMondays, utcTuesday, utcTuesdays, utcWednesday, utcWednesdays, utcThursday, utcThursdays, utcFriday, utcFridays, utcSaturday, utcSaturdays, utcMonth, utcMonths, utcYear, utcYears, timeFormatDefaultLocale, timeFormat, timeParse, utcFormat, utcParse, timeFormatLocale, isoFormat, isoParse, now, timer, timerFlush, timeout, interval, transition, active, interrupt, voronoi, zoom, zoomTransform, zoomIdentity */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _dist_package_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ./dist/package.js */ "./node_modules/d3/dist/package.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "version", + function () { + return _dist_package_js__WEBPACK_IMPORTED_MODULE_0__.version; + } + ); + + /* Harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! d3-array */ "./node_modules/d3-array/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "bisect", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.bisect; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "bisectRight", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.bisectRight; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "bisectLeft", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.bisectLeft; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "ascending", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.ascending; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "bisector", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.bisector; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "cross", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.cross; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "descending", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.descending; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "deviation", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.deviation; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "extent", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.extent; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "histogram", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.histogram; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "thresholdFreedmanDiaconis", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.thresholdFreedmanDiaconis; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "thresholdScott", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.thresholdScott; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "thresholdSturges", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.thresholdSturges; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "max", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.max; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "mean", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.mean; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "median", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.median; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "merge", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.merge; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "min", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.min; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "pairs", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.pairs; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "permute", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.permute; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "quantile", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.quantile; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "range", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.range; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scan", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.scan; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "shuffle", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.shuffle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "sum", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.sum; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "ticks", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.ticks; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tickIncrement", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.tickIncrement; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tickStep", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.tickStep; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "transpose", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.transpose; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "variance", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.variance; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "zip", + function () { + return d3_array__WEBPACK_IMPORTED_MODULE_1__.zip; + } + ); + + /* Harmony import */ var d3_axis__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__( + /* ! d3-axis */ "./node_modules/d3-axis/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "axisTop", + function () { + return d3_axis__WEBPACK_IMPORTED_MODULE_2__.axisTop; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "axisRight", + function () { + return d3_axis__WEBPACK_IMPORTED_MODULE_2__.axisRight; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "axisBottom", + function () { + return d3_axis__WEBPACK_IMPORTED_MODULE_2__.axisBottom; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "axisLeft", + function () { + return d3_axis__WEBPACK_IMPORTED_MODULE_2__.axisLeft; + } + ); + + /* Harmony import */ var d3_brush__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__( + /* ! d3-brush */ "./node_modules/d3-brush/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "brush", + function () { + return d3_brush__WEBPACK_IMPORTED_MODULE_3__.brush; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "brushX", + function () { + return d3_brush__WEBPACK_IMPORTED_MODULE_3__.brushX; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "brushY", + function () { + return d3_brush__WEBPACK_IMPORTED_MODULE_3__.brushY; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "brushSelection", + function () { + return d3_brush__WEBPACK_IMPORTED_MODULE_3__.brushSelection; + } + ); + + /* Harmony import */ var d3_chord__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__( + /* ! d3-chord */ "./node_modules/d3-chord/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "chord", + function () { + return d3_chord__WEBPACK_IMPORTED_MODULE_4__.chord; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "ribbon", + function () { + return d3_chord__WEBPACK_IMPORTED_MODULE_4__.ribbon; + } + ); + + /* Harmony import */ var d3_collection__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__( + /* ! d3-collection */ "./node_modules/d3-collection/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "nest", + function () { + return d3_collection__WEBPACK_IMPORTED_MODULE_5__.nest; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "set", + function () { + return d3_collection__WEBPACK_IMPORTED_MODULE_5__.set; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "map", + function () { + return d3_collection__WEBPACK_IMPORTED_MODULE_5__.map; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "keys", + function () { + return d3_collection__WEBPACK_IMPORTED_MODULE_5__.keys; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "values", + function () { + return d3_collection__WEBPACK_IMPORTED_MODULE_5__.values; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "entries", + function () { + return d3_collection__WEBPACK_IMPORTED_MODULE_5__.entries; + } + ); + + /* Harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__( + /* ! d3-color */ "./node_modules/d3-color/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "color", + function () { + return d3_color__WEBPACK_IMPORTED_MODULE_6__.color; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "rgb", + function () { + return d3_color__WEBPACK_IMPORTED_MODULE_6__.rgb; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "hsl", + function () { + return d3_color__WEBPACK_IMPORTED_MODULE_6__.hsl; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "lab", + function () { + return d3_color__WEBPACK_IMPORTED_MODULE_6__.lab; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "hcl", + function () { + return d3_color__WEBPACK_IMPORTED_MODULE_6__.hcl; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "lch", + function () { + return d3_color__WEBPACK_IMPORTED_MODULE_6__.lch; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "gray", + function () { + return d3_color__WEBPACK_IMPORTED_MODULE_6__.gray; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "cubehelix", + function () { + return d3_color__WEBPACK_IMPORTED_MODULE_6__.cubehelix; + } + ); + + /* Harmony import */ var d3_contour__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__( + /* ! d3-contour */ "./node_modules/d3-contour/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "contours", + function () { + return d3_contour__WEBPACK_IMPORTED_MODULE_7__.contours; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "contourDensity", + function () { + return d3_contour__WEBPACK_IMPORTED_MODULE_7__.contourDensity; + } + ); + + /* Harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__( + /* ! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dispatch", + function () { + return d3_dispatch__WEBPACK_IMPORTED_MODULE_8__.dispatch; + } + ); + + /* Harmony import */ var d3_drag__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__( + /* ! d3-drag */ "./node_modules/d3-drag/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "drag", + function () { + return d3_drag__WEBPACK_IMPORTED_MODULE_9__.drag; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dragDisable", + function () { + return d3_drag__WEBPACK_IMPORTED_MODULE_9__.dragDisable; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dragEnable", + function () { + return d3_drag__WEBPACK_IMPORTED_MODULE_9__.dragEnable; + } + ); + + /* Harmony import */ var d3_dsv__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__( + /* ! d3-dsv */ "./node_modules/d3-dsv/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dsvFormat", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.dsvFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvParse", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.csvParse; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvParseRows", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.csvParseRows; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvFormat", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.csvFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvFormatBody", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.csvFormatBody; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csvFormatRows", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.csvFormatRows; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvParse", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.tsvParse; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvParseRows", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.tsvParseRows; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormat", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.tsvFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormatBody", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.tsvFormatBody; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsvFormatRows", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.tsvFormatRows; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "autoType", + function () { + return d3_dsv__WEBPACK_IMPORTED_MODULE_10__.autoType; + } + ); + + /* Harmony import */ var d3_ease__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__( + /* ! d3-ease */ "./node_modules/d3-ease/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeLinear", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeLinear; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeQuad", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeQuad; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeQuadIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeQuadIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeQuadOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeQuadOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeQuadInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeQuadInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCubic", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeCubic; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCubicIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeCubicIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCubicOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeCubicOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCubicInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeCubicInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easePoly", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easePoly; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easePolyIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easePolyIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easePolyOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easePolyOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easePolyInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easePolyInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeSin", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeSin; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeSinIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeSinIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeSinOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeSinOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeSinInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeSinInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeExp", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeExp; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeExpIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeExpIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeExpOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeExpOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeExpInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeExpInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCircle", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeCircle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCircleIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeCircleIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCircleOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeCircleOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeCircleInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeCircleInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBounce", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeBounce; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBounceIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeBounceIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBounceOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeBounceOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBounceInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeBounceInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBack", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeBack; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBackIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeBackIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBackOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeBackOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeBackInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeBackInOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeElastic", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeElastic; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeElasticIn", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeElasticIn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeElasticOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeElasticOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "easeElasticInOut", + function () { + return d3_ease__WEBPACK_IMPORTED_MODULE_11__.easeElasticInOut; + } + ); + + /* Harmony import */ var d3_fetch__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__( + /* ! d3-fetch */ "./node_modules/d3-fetch/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "blob", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.blob; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "buffer", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.buffer; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "dsv", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.dsv; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "csv", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.csv; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tsv", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.tsv; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "image", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.image; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "json", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.json; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "text", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.text; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "xml", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.xml; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "html", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.html; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "svg", + function () { + return d3_fetch__WEBPACK_IMPORTED_MODULE_12__.svg; + } + ); + + /* Harmony import */ var d3_force__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__( + /* ! d3-force */ "./node_modules/d3-force/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceCenter", + function () { + return d3_force__WEBPACK_IMPORTED_MODULE_13__.forceCenter; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceCollide", + function () { + return d3_force__WEBPACK_IMPORTED_MODULE_13__.forceCollide; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceLink", + function () { + return d3_force__WEBPACK_IMPORTED_MODULE_13__.forceLink; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceManyBody", + function () { + return d3_force__WEBPACK_IMPORTED_MODULE_13__.forceManyBody; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceRadial", + function () { + return d3_force__WEBPACK_IMPORTED_MODULE_13__.forceRadial; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceSimulation", + function () { + return d3_force__WEBPACK_IMPORTED_MODULE_13__.forceSimulation; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceX", + function () { + return d3_force__WEBPACK_IMPORTED_MODULE_13__.forceX; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "forceY", + function () { + return d3_force__WEBPACK_IMPORTED_MODULE_13__.forceY; + } + ); + + /* Harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__( + /* ! d3-format */ "./node_modules/d3-format/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "formatDefaultLocale", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.formatDefaultLocale; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "format", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.format; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "formatPrefix", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.formatPrefix; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "formatLocale", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.formatLocale; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "formatSpecifier", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.formatSpecifier; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "FormatSpecifier", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.FormatSpecifier; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "precisionFixed", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.precisionFixed; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "precisionPrefix", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.precisionPrefix; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "precisionRound", + function () { + return d3_format__WEBPACK_IMPORTED_MODULE_14__.precisionRound; + } + ); + + /* Harmony import */ var d3_geo__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__( + /* ! d3-geo */ "./node_modules/d3-geo/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoArea", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoArea; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoBounds", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoBounds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoCentroid", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoCentroid; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoCircle", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoCircle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoClipAntimeridian", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoClipAntimeridian; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoClipCircle", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoClipCircle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoClipExtent", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoClipExtent; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoClipRectangle", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoClipRectangle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoContains", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoContains; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoDistance", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoDistance; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoGraticule", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoGraticule; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoGraticule10", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoGraticule10; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoInterpolate", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoInterpolate; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoLength", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoLength; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoPath", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoPath; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAlbers", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoAlbers; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAlbersUsa", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoAlbersUsa; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAzimuthalEqualArea", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoAzimuthalEqualArea; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAzimuthalEqualAreaRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoAzimuthalEqualAreaRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAzimuthalEquidistant", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoAzimuthalEquidistant; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoAzimuthalEquidistantRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoAzimuthalEquidistantRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicConformal", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoConicConformal; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicConformalRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoConicConformalRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicEqualArea", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoConicEqualArea; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicEqualAreaRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoConicEqualAreaRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicEquidistant", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoConicEquidistant; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoConicEquidistantRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoConicEquidistantRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoEqualEarth", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoEqualEarth; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoEqualEarthRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoEqualEarthRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoEquirectangular", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoEquirectangular; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoEquirectangularRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoEquirectangularRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoGnomonic", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoGnomonic; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoGnomonicRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoGnomonicRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoIdentity", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoIdentity; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoProjection", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoProjection; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoProjectionMutator", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoProjectionMutator; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoMercator", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoMercator; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoMercatorRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoMercatorRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoNaturalEarth1", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoNaturalEarth1; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoNaturalEarth1Raw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoNaturalEarth1Raw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoOrthographic", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoOrthographic; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoOrthographicRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoOrthographicRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoStereographic", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoStereographic; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoStereographicRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoStereographicRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoTransverseMercator", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoTransverseMercator; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoTransverseMercatorRaw", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoTransverseMercatorRaw; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoRotation", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoRotation; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoStream", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoStream; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "geoTransform", + function () { + return d3_geo__WEBPACK_IMPORTED_MODULE_15__.geoTransform; + } + ); + + /* Harmony import */ var d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__( + /* ! d3-hierarchy */ "./node_modules/d3-hierarchy/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "cluster", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.cluster; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "hierarchy", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.hierarchy; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "pack", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.pack; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "packSiblings", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.packSiblings; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "packEnclose", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.packEnclose; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "partition", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.partition; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stratify", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.stratify; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tree", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.tree; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemap", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.treemap; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapBinary", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.treemapBinary; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapDice", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.treemapDice; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapSlice", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.treemapSlice; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapSliceDice", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.treemapSliceDice; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapSquarify", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.treemapSquarify; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "treemapResquarify", + function () { + return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__.treemapResquarify; + } + ); + + /* Harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__( + /* ! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolate", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolate; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateArray", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateArray; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBasis", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateBasis; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBasisClosed", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateBasisClosed; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateDate", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateDate; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateDiscrete", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateDiscrete; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHue", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateHue; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateNumber", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateNumber; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateObject", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateObject; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRound", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateRound; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateString", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateString; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateTransformCss", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateTransformCss; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateTransformSvg", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateTransformSvg; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateZoom", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateZoom; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRgb", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateRgb; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRgbBasis", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateRgbBasis; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRgbBasisClosed", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateRgbBasisClosed; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHsl", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateHsl; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHslLong", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateHslLong; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateLab", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateLab; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHcl", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateHcl; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateHclLong", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateHclLong; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCubehelix", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateCubehelix; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCubehelixLong", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.interpolateCubehelixLong; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "piecewise", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.piecewise; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "quantize", + function () { + return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__.quantize; + } + ); + + /* Harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__( + /* ! d3-path */ "./node_modules/d3-path/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "path", + function () { + return d3_path__WEBPACK_IMPORTED_MODULE_18__.path; + } + ); + + /* Harmony import */ var d3_polygon__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__( + /* ! d3-polygon */ "./node_modules/d3-polygon/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonArea", + function () { + return d3_polygon__WEBPACK_IMPORTED_MODULE_19__.polygonArea; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonCentroid", + function () { + return d3_polygon__WEBPACK_IMPORTED_MODULE_19__.polygonCentroid; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonHull", + function () { + return d3_polygon__WEBPACK_IMPORTED_MODULE_19__.polygonHull; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonContains", + function () { + return d3_polygon__WEBPACK_IMPORTED_MODULE_19__.polygonContains; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "polygonLength", + function () { + return d3_polygon__WEBPACK_IMPORTED_MODULE_19__.polygonLength; + } + ); + + /* Harmony import */ var d3_quadtree__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__( + /* ! d3-quadtree */ "./node_modules/d3-quadtree/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "quadtree", + function () { + return d3_quadtree__WEBPACK_IMPORTED_MODULE_20__.quadtree; + } + ); + + /* Harmony import */ var d3_random__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__( + /* ! d3-random */ "./node_modules/d3-random/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomUniform", + function () { + return d3_random__WEBPACK_IMPORTED_MODULE_21__.randomUniform; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomNormal", + function () { + return d3_random__WEBPACK_IMPORTED_MODULE_21__.randomNormal; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomLogNormal", + function () { + return d3_random__WEBPACK_IMPORTED_MODULE_21__.randomLogNormal; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomBates", + function () { + return d3_random__WEBPACK_IMPORTED_MODULE_21__.randomBates; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomIrwinHall", + function () { + return d3_random__WEBPACK_IMPORTED_MODULE_21__.randomIrwinHall; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "randomExponential", + function () { + return d3_random__WEBPACK_IMPORTED_MODULE_21__.randomExponential; + } + ); + + /* Harmony import */ var d3_scale__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__( + /* ! d3-scale */ "./node_modules/d3-scale/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleBand", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleBand; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scalePoint", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scalePoint; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleIdentity", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleIdentity; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleLinear", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleLinear; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleLog", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleLog; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSymlog", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleSymlog; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleOrdinal", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleOrdinal; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleImplicit", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleImplicit; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scalePow", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scalePow; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSqrt", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleSqrt; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleQuantile", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleQuantile; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleQuantize", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleQuantize; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleThreshold", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleThreshold; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleTime", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleTime; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleUtc", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleUtc; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequential", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleSequential; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialLog", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleSequentialLog; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialPow", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleSequentialPow; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialSqrt", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleSequentialSqrt; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialSymlog", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleSequentialSymlog; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleSequentialQuantile", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleSequentialQuantile; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDiverging", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleDiverging; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDivergingLog", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleDivergingLog; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDivergingPow", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleDivergingPow; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDivergingSqrt", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleDivergingSqrt; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "scaleDivergingSymlog", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.scaleDivergingSymlog; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "tickFormat", + function () { + return d3_scale__WEBPACK_IMPORTED_MODULE_22__.tickFormat; + } + ); + + /* Harmony import */ var d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__( + /* ! d3-scale-chromatic */ "./node_modules/d3-scale-chromatic/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeCategory10", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeCategory10; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeAccent", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeAccent; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeDark2", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeDark2; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePaired", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePaired; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePastel1", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePastel1; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePastel2", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePastel2; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeSet1", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeSet1; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeSet2", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeSet2; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeSet3", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeSet3; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeTableau10", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeTableau10; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBrBG", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateBrBG; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeBrBG", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeBrBG; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePRGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolatePRGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePRGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePRGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePiYG", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolatePiYG; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePiYG", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePiYG; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePuOr", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolatePuOr; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePuOr", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePuOr; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateRdBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeRdBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdGy", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateRdGy; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdGy", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeRdGy; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdYlBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateRdYlBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdYlBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeRdYlBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdYlGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateRdYlGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdYlGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeRdYlGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateSpectral", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateSpectral; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeSpectral", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeSpectral; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBuGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateBuGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeBuGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeBuGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBuPu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateBuPu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeBuPu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeBuPu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateGnBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateGnBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeGnBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeGnBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateOrRd", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateOrRd; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeOrRd", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeOrRd; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePuBuGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolatePuBuGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePuBuGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePuBuGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePuBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolatePuBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePuBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePuBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePuRd", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolatePuRd; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePuRd", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePuRd; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRdPu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateRdPu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeRdPu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeRdPu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateYlGnBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateYlGnBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeYlGnBu", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeYlGnBu; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateYlGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateYlGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeYlGn", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeYlGn; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateYlOrBr", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateYlOrBr; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeYlOrBr", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeYlOrBr; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateYlOrRd", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateYlOrRd; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeYlOrRd", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeYlOrRd; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateBlues", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateBlues; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeBlues", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeBlues; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateGreens", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateGreens; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeGreens", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeGreens; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateGreys", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateGreys; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeGreys", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeGreys; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePurples", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolatePurples; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemePurples", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemePurples; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateReds", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateReds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeReds", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeReds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateOranges", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateOranges; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "schemeOranges", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.schemeOranges; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCividis", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateCividis; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCubehelixDefault", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateCubehelixDefault; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateRainbow", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateRainbow; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateWarm", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateWarm; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateCool", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateCool; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateSinebow", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateSinebow; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateTurbo", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateTurbo; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateViridis", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateViridis; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateMagma", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateMagma; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolateInferno", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolateInferno; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interpolatePlasma", + function () { + return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__.interpolatePlasma; + } + ); + + /* Harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__( + /* ! d3-selection */ "./node_modules/d3-selection/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "create", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.create; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "creator", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.creator; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "local", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.local; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "matcher", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.matcher; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "mouse", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.mouse; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "namespace", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.namespace; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "namespaces", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.namespaces; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "clientPoint", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.clientPoint; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "select", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.select; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "selectAll", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.selectAll; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "selection", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.selection; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "selector", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.selector; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "selectorAll", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.selectorAll; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "style", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.style; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "touch", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.touch; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "touches", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.touches; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "window", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.window; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "event", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.event; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "customEvent", + function () { + return d3_selection__WEBPACK_IMPORTED_MODULE_24__.customEvent; + } + ); + + /* Harmony import */ var d3_shape__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__( + /* ! d3-shape */ "./node_modules/d3-shape/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "arc", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.arc; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "area", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.area; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "line", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.line; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "pie", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.pie; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "areaRadial", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.areaRadial; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "radialArea", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.radialArea; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "lineRadial", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.lineRadial; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "radialLine", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.radialLine; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "pointRadial", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.pointRadial; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "linkHorizontal", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.linkHorizontal; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "linkVertical", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.linkVertical; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "linkRadial", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.linkRadial; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbol", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbol; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbols", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbols; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolCircle", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbolCircle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolCross", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbolCross; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolDiamond", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbolDiamond; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolSquare", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbolSquare; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolStar", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbolStar; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolTriangle", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbolTriangle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "symbolWye", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.symbolWye; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveBasisClosed", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveBasisClosed; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveBasisOpen", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveBasisOpen; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveBasis", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveBasis; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveBundle", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveBundle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCardinalClosed", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveCardinalClosed; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCardinalOpen", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveCardinalOpen; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCardinal", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveCardinal; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCatmullRomClosed", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveCatmullRomClosed; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCatmullRomOpen", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveCatmullRomOpen; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveCatmullRom", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveCatmullRom; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveLinearClosed", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveLinearClosed; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveLinear", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveLinear; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveMonotoneX", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveMonotoneX; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveMonotoneY", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveMonotoneY; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveNatural", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveNatural; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveStep", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveStep; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveStepAfter", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveStepAfter; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "curveStepBefore", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.curveStepBefore; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stack", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stack; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetExpand", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOffsetExpand; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetDiverging", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOffsetDiverging; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetNone", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOffsetNone; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetSilhouette", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOffsetSilhouette; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOffsetWiggle", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOffsetWiggle; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderAppearance", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOrderAppearance; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderAscending", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOrderAscending; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderDescending", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOrderDescending; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderInsideOut", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOrderInsideOut; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderNone", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOrderNone; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "stackOrderReverse", + function () { + return d3_shape__WEBPACK_IMPORTED_MODULE_25__.stackOrderReverse; + } + ); + + /* Harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__( + /* ! d3-time */ "./node_modules/d3-time/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeInterval", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeInterval; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMillisecond", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeMillisecond; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMilliseconds", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeMilliseconds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMillisecond", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcMillisecond; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMilliseconds", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcMilliseconds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSecond", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeSecond; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSeconds", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeSeconds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSecond", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcSecond; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSeconds", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcSeconds; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMinute", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeMinute; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMinutes", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeMinutes; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeHour", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeHour; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeHours", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeHours; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeDay", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeDay; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeDays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeDays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeWeek", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeWeek; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeWeeks", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeWeeks; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSunday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeSunday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSundays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeSundays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMonday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeMonday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMondays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeMondays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeTuesday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeTuesday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeTuesdays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeTuesdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeWednesday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeWednesday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeWednesdays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeWednesdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeThursday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeThursday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeThursdays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeThursdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFriday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeFriday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFridays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeFridays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSaturday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeSaturday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeSaturdays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeSaturdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMonth", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeMonth; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeMonths", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeMonths; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeYear", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeYear; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeYears", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.timeYears; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMinute", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcMinute; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMinutes", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcMinutes; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcHour", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcHour; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcHours", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcHours; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcDay", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcDay; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcDays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcDays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcWeek", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcWeek; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcWeeks", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcWeeks; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSunday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcSunday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSundays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcSundays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMonday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcMonday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMondays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcMondays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcTuesday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcTuesday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcTuesdays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcTuesdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcWednesday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcWednesday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcWednesdays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcWednesdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcThursday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcThursday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcThursdays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcThursdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcFriday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcFriday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcFridays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcFridays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSaturday", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcSaturday; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcSaturdays", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcSaturdays; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMonth", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcMonth; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcMonths", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcMonths; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcYear", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcYear; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcYears", + function () { + return d3_time__WEBPACK_IMPORTED_MODULE_26__.utcYears; + } + ); + + /* Harmony import */ var d3_time_format__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__( + /* ! d3-time-format */ "./node_modules/d3-time-format/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFormatDefaultLocale", + function () { + return d3_time_format__WEBPACK_IMPORTED_MODULE_27__.timeFormatDefaultLocale; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFormat", + function () { + return d3_time_format__WEBPACK_IMPORTED_MODULE_27__.timeFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeParse", + function () { + return d3_time_format__WEBPACK_IMPORTED_MODULE_27__.timeParse; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcFormat", + function () { + return d3_time_format__WEBPACK_IMPORTED_MODULE_27__.utcFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "utcParse", + function () { + return d3_time_format__WEBPACK_IMPORTED_MODULE_27__.utcParse; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeFormatLocale", + function () { + return d3_time_format__WEBPACK_IMPORTED_MODULE_27__.timeFormatLocale; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "isoFormat", + function () { + return d3_time_format__WEBPACK_IMPORTED_MODULE_27__.isoFormat; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "isoParse", + function () { + return d3_time_format__WEBPACK_IMPORTED_MODULE_27__.isoParse; + } + ); + + /* Harmony import */ var d3_timer__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__( + /* ! d3-timer */ "./node_modules/d3-timer/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "now", + function () { + return d3_timer__WEBPACK_IMPORTED_MODULE_28__.now; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timer", + function () { + return d3_timer__WEBPACK_IMPORTED_MODULE_28__.timer; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timerFlush", + function () { + return d3_timer__WEBPACK_IMPORTED_MODULE_28__.timerFlush; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "timeout", + function () { + return d3_timer__WEBPACK_IMPORTED_MODULE_28__.timeout; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interval", + function () { + return d3_timer__WEBPACK_IMPORTED_MODULE_28__.interval; + } + ); + + /* Harmony import */ var d3_transition__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__( + /* ! d3-transition */ "./node_modules/d3-transition/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "transition", + function () { + return d3_transition__WEBPACK_IMPORTED_MODULE_29__.transition; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "active", + function () { + return d3_transition__WEBPACK_IMPORTED_MODULE_29__.active; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "interrupt", + function () { + return d3_transition__WEBPACK_IMPORTED_MODULE_29__.interrupt; + } + ); + + /* Harmony import */ var d3_voronoi__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__( + /* ! d3-voronoi */ "./node_modules/d3-voronoi/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "voronoi", + function () { + return d3_voronoi__WEBPACK_IMPORTED_MODULE_30__.voronoi; + } + ); + + /* Harmony import */ var d3_zoom__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__( + /* ! d3-zoom */ "./node_modules/d3-zoom/src/index.js" + ); + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "zoom", + function () { + return d3_zoom__WEBPACK_IMPORTED_MODULE_31__.zoom; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "zoomTransform", + function () { + return d3_zoom__WEBPACK_IMPORTED_MODULE_31__.zoomTransform; + } + ); + + /* Harmony reexport (safe) */ __webpack_require__.d( + __webpack_exports__, + "zoomIdentity", + function () { + return d3_zoom__WEBPACK_IMPORTED_MODULE_31__.zoomIdentity; + } + ); + + /***/ + }, + + /***/ "./node_modules/dagre-d3-renderer/dist/dagre-d3.core.js": + /* !**************************************************************!*\ + !*** ./node_modules/dagre-d3-renderer/dist/dagre-d3.core.js ***! + \**************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + module.exports = (function (t) { + var e = {}; + + function a(r) { + if (e[r]) return e[r].exports; + var n = (e[r] = { + i: r, + l: !1, + exports: {}, + }); + return ( + t[r].call(n.exports, n, n.exports, a), + (n.l = !0), + n.exports + ); + } + + return ( + (a.m = t), + (a.c = e), + (a.d = function (t, e, r) { + a.o(t, e) || + Object.defineProperty(t, e, { + configurable: !1, + enumerable: !0, + get: r, + }); + }), + (a.r = function (t) { + Object.defineProperty(t, "__esModule", { + value: !0, + }); + }), + (a.n = function (t) { + var e = + t && t.__esModule + ? function () { + return t.default; + } + : function () { + return t; + }; + return a.d(e, "a", e), e; + }), + (a.o = function (t, e) { + return Object.prototype.hasOwnProperty.call(t, e); + }), + (a.p = ""), + (a.w = {}), + a((a.s = 25)) + ); + })([ + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r, + n = a(2), + l = + (r = n) && r.__esModule + ? r + : { + default: r, + }; + var u = /:/g; + + function i(t) { + return t ? String(t).replace(u, "\\:") : ""; + } + + e.default = { + isSubgraph: function isSubgraph(t, e) { + return Boolean(t.children(e).length); + }, + edgeToId: function edgeToId(t) { + return i(t.v) + ":" + i(t.w) + ":" + i(t.name); + }, + applyStyle: function applyStyle(t, e) { + e && t.attr("style", e); + }, + applyClass: function applyClass(t, e, a) { + e && + t + .attr("class", e) + .attr("class", a + " " + t.attr("class")); + }, + applyTransition: function applyTransition(t, e) { + var a = e.graph(); + + if (l.default.isPlainObject(a)) { + var r = a.transition; + if (l.default.isFunction(r)) return r(t); + } + + return t; + }, + }; + }, + function (t, e) { + t.exports = __webpack_require__( + /* ! d3 */ "./node_modules/d3/index.js" + ); + }, + function (t, e) { + t.exports = __webpack_require__( + /* ! lodash */ "./node_modules/lodash/lodash.js" + ); + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r = u(a(16)), + n = u(a(15)), + l = u(a(14)); + + function u(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + e.default = function (t, e, a) { + var u = e.label, + i = t.append("g"); + e.labelType === "svg" + ? (0, l.default)(i, e) + : typeof u !== "string" || e.labelType === "html" + ? (0, n.default)(i, e) + : (0, r.default)(i, e); + var d = i.node().getBBox(), + o = void 0; + + switch (a) { + case "top": + o = -e.height / 2; + break; + + case "bottom": + o = e.height / 2 - d.height; + break; + + default: + o = -d.height / 2; + } + + return ( + i.attr( + "transform", + "translate(" + -d.width / 2 + "," + o + ")" + ), + i + ); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }), + (e.default = function (t, e, a, r) { + var n = t.x, + l = t.y, + u = n - r.x, + i = l - r.y, + d = Math.sqrt(e * e * i * i + a * a * u * u), + o = Math.abs((e * a * u) / d); + r.x < n && (o = -o); + var s = Math.abs((e * a * i) / d); + return ( + r.y < l && (s = -s), + { + x: n + o, + y: l + s, + } + ); + }); + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }), + (e.default = function (t, e) { + var a = t.x, + r = t.y, + n = e.x - a, + l = e.y - r, + u = t.width / 2, + i = t.height / 2, + d = void 0, + o = void 0; + return ( + Math.abs(l) * u > Math.abs(n) * i + ? (l < 0 && (i = -i), + (d = l === 0 ? 0 : (i * n) / l), + (o = i)) + : (n < 0 && (u = -u), + (d = u), + (o = n === 0 ? 0 : (u * l) / n)), + { + x: a + d, + y: r + o, + } + ); + }); + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r, + n = a(23), + l = + (r = n) && r.__esModule + ? r + : { + default: r, + }; + + e.default = function (t, e, a) { + var r = t.x, + n = t.y, + u = [], + i = Number.POSITIVE_INFINITY, + d = Number.POSITIVE_INFINITY; + e.forEach(function (t) { + (i = Math.min(i, t.x)), (d = Math.min(d, t.y)); + }); + + for ( + var o = r - t.width / 2 - i, + s = n - t.height / 2 - d, + f = 0; + f < e.length; + f += 1 + ) { + var c = e[f], + h = e[f < e.length - 1 ? f + 1 : 0], + p = (0, l.default)( + t, + a, + { + x: o + c.x, + y: s + c.y, + }, + { + x: o + h.x, + y: s + h.y, + } + ); + p && u.push(p); + } + + return u.length + ? (u.length > 1 && + u.sort(function (t, e) { + var r = t.x - a.x, + n = t.y - a.y, + l = Math.sqrt(r * r + n * n), + u = e.x - a.x, + i = e.y - a.y, + d = Math.sqrt(u * u + i * i); + return l < d ? -1 : l === d ? 0 : 1; + }), + u[0]) + : (console.log( + "NO INTERSECTION FOUND, RETURN NODE CENTER", + t + ), + t); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r, + n = a(4), + l = + (r = n) && r.__esModule + ? r + : { + default: r, + }; + + e.default = function (t, e, a) { + return (0, l.default)(t, e, e, a); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }), + (e.default = function (t, e) { + return t.intersect(e); + }); + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r, + n = a(0), + l = + (r = n) && r.__esModule + ? r + : { + default: r, + }; + + function u(t, e, a, r) { + var n = t + .append("marker") + .attr("id", e) + .attr("viewBox", "0 0 10 10") + .attr("refX", 9) + .attr("refY", 5) + .attr("markerUnits", "strokeWidth") + .attr("markerWidth", 8) + .attr("markerHeight", 6) + .attr("orient", "auto") + .append("path") + .attr("d", "M 0 0 L 10 5 L 0 10 z") + .style("stroke-width", 1) + .style("stroke-dasharray", "1,0"); + l.default.applyStyle(n, a[r + "Style"]), + a[r + "Class"] && n.attr("class", a[r + "Class"]); + } + + e.default = { + normal: u, + vee: function vee(t, e, a, r) { + var n = t + .append("marker") + .attr("id", e) + .attr("viewBox", "0 0 10 10") + .attr("refX", 9) + .attr("refY", 5) + .attr("markerUnits", "strokeWidth") + .attr("markerWidth", 8) + .attr("markerHeight", 6) + .attr("orient", "auto") + .append("path") + .attr("d", "M 0 0 L 10 5 L 0 10 L 4 5 z") + .style("stroke-width", 1) + .style("stroke-dasharray", "1,0"); + l.default.applyStyle(n, a[r + "Style"]), + a[r + "Class"] && + n.attr("class", a[r + "Class"]); + }, + undirected: function undirected(t, e, a, r) { + var n = t + .append("marker") + .attr("id", e) + .attr("viewBox", "0 0 10 10") + .attr("refX", 9) + .attr("refY", 5) + .attr("markerUnits", "strokeWidth") + .attr("markerWidth", 8) + .attr("markerHeight", 6) + .attr("orient", "auto") + .append("path") + .attr("d", "M 0 5 L 10 5") + .style("stroke-width", 1) + .style("stroke-dasharray", "1,0"); + l.default.applyStyle(n, a[r + "Style"]), + a[r + "Class"] && + n.attr("class", a[r + "Class"]); + }, + default: u, + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r = i(a(5)), + n = i(a(4)), + l = i(a(7)), + u = i(a(6)); + + function i(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + e.default = { + rect: function rect(t, e, a) { + var n = t + .insert("rect", ":first-child") + .attr("rx", a.rx) + .attr("ry", a.ry) + .attr("x", -e.width / 2) + .attr("y", -e.height / 2) + .attr("width", e.width) + .attr("height", e.height); + return ( + (a.intersect = function (t) { + return (0, r.default)(a, t); + }), + n + ); + }, + ellipse: function ellipse(t, e, a) { + var r = e.width / 2, + l = e.height / 2, + u = t + .insert("ellipse", ":first-child") + .attr("x", -e.width / 2) + .attr("y", -e.height / 2) + .attr("rx", r) + .attr("ry", l); + return ( + (a.intersect = function (t) { + return (0, n.default)(a, r, l, t); + }), + u + ); + }, + circle: function circle(t, e, a) { + var r = Math.max(e.width, e.height) / 2, + n = t + .insert("circle", ":first-child") + .attr("x", -e.width / 2) + .attr("y", -e.height / 2) + .attr("r", r); + return ( + (a.intersect = function (t) { + return (0, l.default)(a, r, t); + }), + n + ); + }, + diamond: function diamond(t, e, a) { + var r = (e.width * Math.SQRT2) / 2, + n = (e.height * Math.SQRT2) / 2, + l = [ + { + x: 0, + y: -n, + }, + { + x: -r, + y: 0, + }, + { + x: 0, + y: n, + }, + { + x: r, + y: 0, + }, + ], + i = t.insert("polygon", ":first-child").attr( + "points", + l + .map(function (t) { + return t.x + "," + t.y; + }) + .join(" ") + ); + return ( + (a.intersect = function (t) { + return (0, u.default)(a, l, t); + }), + i + ); + }, + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + + var r = (function (t) { + if (t && t.__esModule) return t; + var e = {}; + if (t != null) + for (var a in t) { + Object.prototype.hasOwnProperty.call( + t, + a + ) && (e[a] = t[a]); + } + return (e.default = t), e; + })(a(1)), + n = i(a(2)), + l = i(a(8)), + u = i(a(0)); + + function i(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + function d(t, e) { + var a = r + .line() + .x(function (t) { + return t.x; + }) + .y(function (t) { + return t.y; + }); + return a.curve(t.curve), a(e); + } + + e.default = function (t, e, a) { + var i = t + .selectAll("g.edgePath") + .data(e.edges(), function (t) { + return u.default.edgeToId(t); + }) + .classed("update", !0); + return ( + (function (t, e) { + var a = t + .enter() + .append("g") + .attr("class", "edgePath") + .style("opacity", 0); + a + .append("path") + .attr("class", "path") + .attr("d", function (t) { + var a = e.edge(t), + r = e.node(t.v).elem, + l = n.default + .range(a.points.length) + .map(function () { + return ( + (e = (t = r).getBBox()), + { + x: (a = t.ownerSVGElement + .getScreenCTM() + .inverse() + .multiply( + t.getScreenCTM() + ) + .translate( + e.width / 2, + e.height / 2 + )).e, + y: a.f, + } + ); + var t, e, a; + }); + return d(a, l); + }), + a.append("defs"); + })(i, e), + (function (t, e) { + var a = t.exit(); + u.default + .applyTransition(a, e) + .style("opacity", 0) + .remove(), + u.default + .applyTransition( + a.select("path.path"), + e + ) + .attr("d", function (t) { + var a = e.node(t.v); + + if (a) { + var l = n.default + .range( + this.getTotalLength() + ) + .map(function () { + return a; + }); + return d({}, l); + } + + return r.select(this).attr("d"); + }); + })(i, e), + (i = t.selectAll("g.edgePath")), + u.default.applyTransition(i, e).style("opacity", 1), + i.each(function (t) { + var a = r.select(this), + n = e.edge(t); + (n.elem = this), + n.id && a.attr("id", n.id), + u.default.applyClass( + a, + n.class, + (a.classed("update") ? "update " : "") + + "edgePath" + ); + }), + i.selectAll("path.path").each(function (t) { + var a = e.edge(t); + a.arrowheadId = n.default.uniqueId("arrowhead"); + var i = r + .select(this) + .attr("marker-end", function () { + return "url(#" + a.arrowheadId + ")"; + }) + .style("fill", "none"); + u.default + .applyTransition(i, e) + .attr("d", function (t) { + return (function (t, e) { + var a = t.edge(e), + r = t.node(e.v), + n = t.node(e.w), + u = a.points.slice( + 1, + a.points.length - 1 + ); + return ( + u.unshift( + (0, l.default)(r, u[0]) + ), + u.push( + (0, l.default)( + n, + u[u.length - 1] + ) + ), + d(a, u) + ); + })(e, t); + }), + u.default.applyStyle(i, a.style); + }), + i.selectAll("defs *").remove(), + i.selectAll("defs").each(function (t) { + var n = e.edge(t); + (0, + a[ + n.arrowhead + ])(r.select(this), n.arrowheadId, n, "arrowhead"); + }), + i + ); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + + var r = (function (t) { + if (t && t.__esModule) return t; + var e = {}; + if (t != null) + for (var a in t) { + Object.prototype.hasOwnProperty.call( + t, + a + ) && (e[a] = t[a]); + } + return (e.default = t), e; + })(a(1)), + n = i(a(2)), + l = i(a(3)), + u = i(a(0)); + + function i(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + e.default = function (t, e) { + var a = t + .selectAll("g.edgeLabel") + .data(e.edges(), function (t) { + return u.default.edgeToId(t); + }) + .classed("update", !0); + return ( + a.selectAll("*").remove(), + a + .enter() + .append("g") + .classed("edgeLabel", !0) + .style("opacity", 0), + (a = t.selectAll("g.edgeLabel")).each(function (t) { + var a = e.edge(t), + u = (0, l.default)( + r.select(this), + e.edge(t), + 0, + 0 + ).classed("label", !0), + i = u.node().getBBox(); + a.labelId && u.attr("id", a.labelId), + n.default.has(a, "width") || + (a.width = i.width), + n.default.has(a, "height") || + (a.height = i.height); + }), + u.default + .applyTransition(a.exit(), e) + .style("opacity", 0) + .remove(), + a + ); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + + var r = (function (t) { + if (t && t.__esModule) return t; + var e = {}; + if (t != null) + for (var a in t) { + Object.prototype.hasOwnProperty.call( + t, + a + ) && (e[a] = t[a]); + } + return (e.default = t), e; + })(a(1)), + n = u(a(0)), + l = u(a(3)); + + function u(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + e.default = function (t, e) { + var a = e.nodes().filter(function (t) { + return n.default.isSubgraph(e, t); + }), + u = t.selectAll("g.cluster").data(a, function (t) { + return t; + }); + return ( + u.selectAll("*").remove(), + u + .enter() + .append("g") + .attr("class", "cluster") + .attr("id", function (t) { + return e.node(t).id; + }) + .style("opacity", 0), + (u = t.selectAll("g.cluster")), + n.default.applyTransition(u, e).style("opacity", 1), + u.each(function (t) { + var a = e.node(t), + n = r.select(this); + r.select(this).append("rect"); + var u = n.append("g").attr("class", "label"); + (0, l.default)(u, a, a.clusterLabelPos); + }), + u.selectAll("rect").each(function (t) { + var a = e.node(t), + l = r.select(this); + n.default.applyStyle(l, a.style); + }), + n.default + .applyTransition(u.exit(), e) + .style("opacity", 0) + .remove(), + u + ); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r, + n = a(0), + l = + (r = n) && r.__esModule + ? r + : { + default: r, + }; + + e.default = function (t, e) { + var a = t; + return ( + a.node().appendChild(e.label), + l.default.applyStyle(a, e.labelStyle), + a + ); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r, + n = + typeof Symbol === "function" && + _typeof(Symbol.iterator) == "symbol" + ? function (t) { + return _typeof(t); + } + : function (t) { + return t && + typeof Symbol === "function" && + t.constructor === Symbol && + t !== Symbol.prototype + ? "symbol" + : _typeof(t); + }, + l = a(0), + u = + (r = l) && r.__esModule + ? r + : { + default: r, + }; + + e.default = function (t, e) { + var a = t + .append("foreignObject") + .attr("width", "100000"), + r = a.append("xhtml:div"); + r.attr("xmlns", "http://www.w3.org/1999/xhtml"); + var l = e.label; + + switch (void 0 === l ? "undefined" : n(l)) { + case "function": + r.insert(l); + break; + + case "object": + r.insert(function () { + return l; + }); + break; + + default: + r.html(l); + } + + u.default.applyStyle(r, e.labelStyle), + r.style("display", "inline-block"), + r.style("white-space", "nowrap"); + var i = r.node().getBoundingClientRect(); + return ( + a.attr("width", i.width).attr("height", i.height), a + ); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r, + n = a(0), + l = + (r = n) && r.__esModule + ? r + : { + default: r, + }; + + e.default = function (t, e) { + for ( + var a = t.append("text"), + r = (function (t) { + for ( + var e = "", a = !1, r = null, n = 0; + n < t.length; + n += 1 + ) { + if (((r = t[n]), a)) { + switch (r) { + case "n": + e += "\n"; + break; + + default: + e += r; + } + + a = !1; + } else r === "\\" ? (a = !0) : (e += r); + } + + return e; + })(e.label).split("\n"), + n = 0; + n < r.length; + n += 1 + ) { + a.append("tspan") + .attr("xml:space", "preserve") + .attr("dy", "1em") + .attr("x", "1") + .text(r[n]); + } + + return l.default.applyStyle(a, e.labelStyle), a; + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + + var r = i(a(2)), + n = (function (t) { + if (t && t.__esModule) return t; + var e = {}; + if (t != null) + for (var a in t) { + Object.prototype.hasOwnProperty.call( + t, + a + ) && (e[a] = t[a]); + } + return (e.default = t), e; + })(a(1)), + l = i(a(3)), + u = i(a(0)); + + function i(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + e.default = function (t, e, a) { + var i = e.nodes().filter(function (t) { + return !u.default.isSubgraph(e, t); + }), + d = t + .selectAll("g.node") + .data(i, function (t) { + return t; + }) + .classed("update", !0); + return ( + d.selectAll("*").remove(), + d + .enter() + .append("g") + .attr("class", "node") + .style("opacity", 0), + (d = t.selectAll("g.node")).each(function (t) { + var i = e.node(t), + d = n.select(this); + u.default.applyClass( + d, + i.class, + (d.classed("update") ? "update " : "") + + "node" + ); + var o = d.append("g").attr("class", "label"), + s = (0, l.default)(o, i), + f = a[i.shape], + c = r.default.pick( + s.node().getBBox(), + "width", + "height" + ); + (i.elem = this), + i.id && d.attr("id", i.id), + i.labelId && o.attr("id", i.labelId), + r.default.has(i, "width") && + (c.width = i.width), + r.default.has(i, "height") && + (c.height = i.height), + (c.width += i.paddingLeft + i.paddingRight), + (c.height += + i.paddingTop + i.paddingBottom), + o.attr( + "transform", + "translate(" + + (i.paddingLeft - i.paddingRight) / + 2 + + "," + + (i.paddingTop - i.paddingBottom) / + 2 + + ")" + ); + var h = f(n.select(this), c, i); + u.default.applyStyle(h, i.style); + var p = h.node().getBBox(); + (i.width = p.width), (i.height = p.height); + }), + u.default + .applyTransition(d.exit(), e) + .style("opacity", 0) + .remove(), + d + ); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + + var r, + n = (function (t) { + if (t && t.__esModule) return t; + var e = {}; + if (t != null) + for (var a in t) { + Object.prototype.hasOwnProperty.call( + t, + a + ) && (e[a] = t[a]); + } + return (e.default = t), e; + })(a(1)), + l = a(0), + u = + (r = l) && r.__esModule + ? r + : { + default: r, + }; + + e.default = function (t, e) { + var a = t.filter(function () { + return !n.select(this).classed("update"); + }); + + function r(t) { + var a = e.node(t); + return "translate(" + a.x + "," + a.y + ")"; + } + + a.attr("transform", r), + u.default + .applyTransition(t, e) + .style("opacity", 1) + .attr("transform", r), + u.default + .applyTransition(a.selectAll("rect"), e) + .attr("width", function (t) { + return e.node(t).width; + }) + .attr("height", function (t) { + return e.node(t).height; + }) + .attr("x", function (t) { + return -e.node(t).width / 2; + }) + .attr("y", function (t) { + return -e.node(t).height / 2; + }); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + + var r = (function (t) { + if (t && t.__esModule) return t; + var e = {}; + if (t != null) + for (var a in t) { + Object.prototype.hasOwnProperty.call( + t, + a + ) && (e[a] = t[a]); + } + return (e.default = t), e; + })(a(1)), + n = u(a(2)), + l = u(a(0)); + + function u(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + e.default = function (t, e) { + function a(t) { + var a = e.edge(t); + return n.default.has(a, "x") + ? "translate(" + a.x + "," + a.y + ")" + : ""; + } + + t + .filter(function () { + return !r.select(this).classed("update"); + }) + .attr("transform", a), + l.default + .applyTransition(t, e) + .style("opacity", 1) + .attr("transform", a); + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + + var r, + n = (function (t) { + if (t && t.__esModule) return t; + var e = {}; + if (t != null) + for (var a in t) { + Object.prototype.hasOwnProperty.call( + t, + a + ) && (e[a] = t[a]); + } + return (e.default = t), e; + })(a(1)), + l = a(0), + u = + (r = l) && r.__esModule + ? r + : { + default: r, + }; + + e.default = function (t, e) { + function a(t) { + var a = e.node(t); + return "translate(" + a.x + "," + a.y + ")"; + } + + t + .filter(function () { + return !n.select(this).classed("update"); + }) + .attr("transform", a), + u.default + .applyTransition(t, e) + .style("opacity", 1) + .attr("transform", a); + }; + }, + function (t, e) { + t.exports = __webpack_require__( + /* ! dagre-layout */ "./node_modules/dagre-layout/dist/dagre-layout.core.js" + ); + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + + var r = y(a(2)), + n = y(a(21)), + l = (function (t) { + if (t && t.__esModule) return t; + var e = {}; + if (t != null) + for (var a in t) { + Object.prototype.hasOwnProperty.call( + t, + a + ) && (e[a] = t[a]); + } + return (e.default = t), e; + })(a(1)), + u = y(a(20)), + i = y(a(19)), + d = y(a(18)), + o = y(a(17)), + s = y(a(13)), + f = y(a(12)), + c = y(a(11)), + h = y(a(10)), + p = y(a(9)); + + function y(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + var g = { + paddingLeft: 10, + paddingRight: 10, + paddingTop: 10, + paddingBottom: 10, + rx: 0, + ry: 0, + shape: "rect", + }, + v = { + arrowhead: "normal", + curve: l.curveLinear, + }; + + function _(t, e) { + var a = t.select("g." + e); + return ( + a.empty() && (a = t.append("g").attr("class", e)), a + ); + } + + e.default = function () { + var t = o.default, + e = s.default, + a = f.default, + l = c.default, + y = h.default, + x = p.default, + b = function b(o, s) { + !(function (t) { + t.nodes().forEach(function (e) { + var a = t.node(e); + r.default.has(a, "label") || + t.children(e).length || + (a.label = e), + r.default.has(a, "paddingX") && + r.default.defaults(a, { + paddingLeft: a.paddingX, + paddingRight: a.paddingX, + }), + r.default.has(a, "paddingY") && + r.default.defaults(a, { + paddingTop: a.paddingY, + paddingBottom: a.paddingY, + }), + r.default.has(a, "padding") && + r.default.defaults(a, { + paddingLeft: a.padding, + paddingRight: a.padding, + paddingTop: a.padding, + paddingBottom: a.padding, + }), + r.default.defaults(a, g), + r.default.each( + [ + "paddingLeft", + "paddingRight", + "paddingTop", + "paddingBottom", + ], + function (t) { + a[t] = Number(a[t]); + } + ), + r.default.has(a, "width") && + (a._prevWidth = a.width), + r.default.has(a, "height") && + (a._prevHeight = a.height); + }), + t.edges().forEach(function (e) { + var a = t.edge(e); + r.default.has(a, "label") || + (a.label = ""), + r.default.defaults(a, v); + }); + })(s), + o.selectAll("*").remove(); + + var f = _(o, "output"), + c = _(f, "clusters"), + h = _(f, "edgePaths"), + p = a(_(f, "edgeLabels"), s), + b = t(_(f, "nodes"), s, y); + + n.default.layout(s); + var m = 1e3, + M = 1e3, + w = -1e3, + O = -1e3, + P = s; + P.nodes() + .map(function (t) { + return P.node(t); + }) + .forEach(function (t) { + (m = Math.min(m, t.x - t.width / 2)), + (M = Math.min( + M, + t.y - t.height / 2 + )), + (w = Math.max( + w, + t.x + t.width / 2 + )), + (O = Math.max( + O, + t.y + t.height / 2 + )); + }), + P.edges().forEach(function (t) { + var e = P.edge(t); + void 0 !== e.label && + void 0 !== e.x && + void 0 !== e.y && + ((m = Math.min( + m, + e.x - e.width / 2 + )), + (M = Math.min( + M, + e.y - e.height / 2 + )), + (w = Math.max( + w, + e.x + e.width / 2 + )), + (O = Math.max( + O, + e.y + e.height / 2 + ))); + + for ( + var a = e.points.slice( + 1, + e.points.length - 1 + ), + r = 0; + r < a.length; + r++ + ) { + var n = a[r]; + (m = Math.min(m, n.x)), + (M = Math.min(M, n.y)), + (w = Math.max(w, n.x)), + (O = Math.max(O, n.y)); + } + }), + (P.minX = m), + (P.minY = M), + (P.maxX = w), + (P.maxY = O), + (0, u.default)(b, s), + (0, i.default)(p, s), + l(h, s, x); + var j = e(c, s); + (0, d.default)(j, s), + (function (t) { + r.default.each(t.nodes(), function (e) { + var a = t.node(e); + r.default.has(a, "_prevWidth") + ? (a.width = a._prevWidth) + : delete a.width, + r.default.has(a, "_prevHeight") + ? (a.height = a._prevHeight) + : delete a.height, + delete a._prevWidth, + delete a._prevHeight; + }); + })(s); + }; + + return ( + (b.createNodes = function (e) { + return arguments.length ? ((t = e), b) : t; + }), + (b.createClusters = function (t) { + return arguments.length ? ((e = t), b) : e; + }), + (b.createEdgeLabels = function (t) { + return arguments.length ? ((a = t), b) : a; + }), + (b.createEdgePaths = function (t) { + return arguments.length ? ((l = t), b) : l; + }), + (b.shapes = function (t) { + return arguments.length ? ((y = t), b) : y; + }), + (b.arrows = function (t) { + return arguments.length ? ((x = t), b) : x; + }), + b + ); + }; + }, + function (t, e, a) { + "use strict"; + + function r(t, e) { + return t * e > 0; + } + + Object.defineProperty(e, "__esModule", { + value: !0, + }), + (e.default = function (t, e, a, n) { + var l = e.y - t.y, + u = t.x - e.x, + i = e.x * t.y - t.x * e.y, + d = l * a.x + u * a.y + i, + o = l * n.x + u * n.y + i; + + if (d === 0 || o === 0 || !r(d, o)) { + var s = n.y - a.y, + f = a.x - n.x, + c = n.x * a.y - a.x * n.y, + h = s * t.x + f * t.y + c, + p = s * e.x + f * e.y + c; + + if (h === 0 || p === 0 || !r(h, p)) { + var y = l * f - s * u; + + if (y !== 0) { + var g = Math.abs(y / 2), + v = u * c - f * i; + return { + x: + v < 0 + ? (v - g) / y + : (v + g) / y, + y: + (v = s * i - l * c) < 0 + ? (v - g) / y + : (v + g) / y, + }; + } + } + } + }); + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r = d(a(8)), + n = d(a(7)), + l = d(a(4)), + u = d(a(6)), + i = d(a(5)); + + function d(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + e.default = { + node: r.default, + circle: n.default, + ellipse: l.default, + polygon: u.default, + rect: i.default, + }; + }, + function (t, e, a) { + "use strict"; + + Object.defineProperty(e, "__esModule", { + value: !0, + }); + var r = u(a(24)), + n = u(a(22)), + l = u(a(0)); + + function u(t) { + return t && t.__esModule + ? t + : { + default: t, + }; + } + + e.default = { + intersect: r.default, + render: n.default, + util: l.default, + }; + }, + ]); + + /***/ + }, + + /***/ "./node_modules/dagre-d3-renderer/lib/label/add-html-label.js": + /* !********************************************************************!*\ + !*** ./node_modules/dagre-d3-renderer/lib/label/add-html-label.js ***! + \********************************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var _util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! ../util */ "./node_modules/dagre-d3-renderer/lib/util.js" + ); + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + function addHtmlLabel(root, node) { + var fo = root.append("foreignObject").attr("width", "100000"); + var div = fo.append("xhtml:div"); + div.attr("xmlns", "http://www.w3.org/1999/xhtml"); + var label = node.label; + + switch (_typeof(label)) { + case "function": + div.insert(label); + break; + + case "object": + // Currently we assume this is a DOM object. + div.insert(function () { + return label; + }); + break; + + default: + div.html(label); + } + + _util__WEBPACK_IMPORTED_MODULE_0__.default.applyStyle( + div, + node.labelStyle + ); + div.style("display", "inline-block"); // Fix for firefox + + div.style("white-space", "nowrap"); + var client = div.node().getBoundingClientRect(); + fo.attr("width", client.width).attr("height", client.height); + return fo; + } + + /* Harmony default export */ __webpack_exports__.default = addHtmlLabel; + + /***/ + }, + + /***/ "./node_modules/dagre-d3-renderer/lib/util.js": + /* !****************************************************!*\ + !*** ./node_modules/dagre-d3-renderer/lib/util.js ***! + \****************************************************/ + /* ! exports provided: default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony import */ var lodash__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! lodash */ "./node_modules/lodash/lodash.js" + ); + /* Harmony import */ var lodash__WEBPACK_IMPORTED_MODULE_0___default = /* #__PURE__*/ __webpack_require__.n( + lodash__WEBPACK_IMPORTED_MODULE_0__ + ); + + /* + * Returns true if the specified node in the graph is a subgraph node. A + * subgraph node is one that contains other nodes. + */ + + function isSubgraph(g, v) { + return Boolean(g.children(v).length); + } + + function edgeToId(e) { + return ( + escapeId(e.v) + ":" + escapeId(e.w) + ":" + escapeId(e.name) + ); + } + + var ID_DELIM = /:/g; + + function escapeId(str) { + return str ? String(str).replace(ID_DELIM, "\\:") : ""; + } + + function applyStyle(dom, styleFn) { + if (styleFn) { + dom.attr("style", styleFn); + } + } + + function applyClass(dom, classFn, otherClasses) { + if (classFn) { + dom.attr("class", classFn).attr( + "class", + otherClasses + " " + dom.attr("class") + ); + } + } + + function applyTransition(selection, g) { + var graph = g.graph(); + + if ( + lodash__WEBPACK_IMPORTED_MODULE_0___default.a.isPlainObject( + graph + ) + ) { + var transition = graph.transition; + + if ( + lodash__WEBPACK_IMPORTED_MODULE_0___default.a.isFunction( + transition + ) + ) { + return transition(selection); + } + } + + return selection; + } // Public utility functions + + /* harmony default export */ __webpack_exports__.default = { + isSubgraph: isSubgraph, + edgeToId: edgeToId, + applyStyle: applyStyle, + applyClass: applyClass, + applyTransition: applyTransition, + }; + + /***/ + }, + + /***/ "./node_modules/dagre-layout/dist/dagre-layout.core.js": + /* !*************************************************************!*\ + !*** ./node_modules/dagre-layout/dist/dagre-layout.core.js ***! + \*************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + module.exports = (function (e) { + var t = {}; + + function n(r) { + if (t[r]) return t[r].exports; + var a = (t[r] = { + i: r, + l: !1, + exports: {}, + }); + return ( + e[r].call(a.exports, a, a.exports, n), + (a.l = !0), + a.exports + ); + } + + return ( + (n.m = e), + (n.c = t), + (n.d = function (e, t, r) { + n.o(e, t) || + Object.defineProperty(e, t, { + configurable: !1, + enumerable: !0, + get: r, + }); + }), + (n.r = function (e) { + Object.defineProperty(e, "__esModule", { + value: !0, + }); + }), + (n.n = function (e) { + var t = + e && e.__esModule + ? function () { + return e.default; + } + : function () { + return e; + }; + return n.d(t, "a", t), t; + }), + (n.o = function (e, t) { + return Object.prototype.hasOwnProperty.call(e, t); + }), + (n.p = ""), + (n.w = {}), + n((n.s = 27)) + ); + })([ + function (e, t) { + e.exports = __webpack_require__( + /* ! lodash */ "./node_modules/lodash/lodash.js" + ); + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }), + (t.addDummyNode = d), + (t.simplify = f), + (t.asNonCompoundGraph = i), + (t.successorWeights = l), + (t.predecessorWeights = c), + (t.intersectRect = s), + (t.buildLayerMatrix = h), + (t.normalizeRanks = v), + (t.removeEmptyRanks = g), + (t.addBorderNode = p), + (t.maxRank = m), + (t.partition = E), + (t.time = b), + (t.notime = w); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }, + o = n(2); + + function d(e, t, n, r) { + var a = void 0; + + do { + a = u.default.uniqueId(r); + } while (e.hasNode(a)); + + return (n.dummy = t), e.setNode(a, n), a; + } + + function f(e) { + var t = new o.Graph().setGraph(e.graph()); + return ( + u.default.forEach(e.nodes(), function (n) { + t.setNode(n, e.node(n)); + }), + u.default.forEach(e.edges(), function (n) { + var r = t.edge(n.v, n.w) || { + weight: 0, + minlen: 1, + }, + a = e.edge(n); + t.setEdge(n.v, n.w, { + weight: r.weight + a.weight, + minlen: Math.max(r.minlen, a.minlen), + }); + }), + t + ); + } + + function i(e) { + var t = new o.Graph({ + multigraph: e.isMultigraph(), + }).setGraph(e.graph()); + return ( + u.default.forEach(e.nodes(), function (n) { + e.children(n).length || t.setNode(n, e.node(n)); + }), + u.default.forEach(e.edges(), function (n) { + t.setEdge(n, e.edge(n)); + }), + t + ); + } + + function l(e) { + var t = u.default.map(e.nodes(), function (t) { + var n = {}; + return ( + u.default.forEach(e.outEdges(t), function (t) { + n[t.w] = (n[t.w] || 0) + e.edge(t).weight; + }), + n + ); + }); + return u.default.zipObject(e.nodes(), t); + } + + function c(e) { + var t = u.default.map(e.nodes(), function (t) { + var n = {}; + return ( + u.default.forEach(e.inEdges(t), function (t) { + n[t.v] = (n[t.v] || 0) + e.edge(t).weight; + }), + n + ); + }); + return u.default.zipObject(e.nodes(), t); + } + + function s(e, t) { + var n = e.x, + r = e.y, + a = t.x - n, + u = t.y - r, + o = e.width / 2, + d = e.height / 2; + if (!a && !u) + throw new Error( + "Not possible to find intersection inside of the rectangle" + ); + var f = void 0, + i = void 0; + return ( + Math.abs(u) * o > Math.abs(a) * d + ? (u < 0 && (d = -d), + (f = (d * a) / u), + (i = d)) + : (a < 0 && (o = -o), + (f = o), + (i = (o * u) / a)), + { + x: n + f, + y: r + i, + } + ); + } + + function h(e) { + var t = u.default.map( + u.default.range(m(e) + 1), + function () { + return []; + } + ); + return ( + u.default.forEach(e.nodes(), function (n) { + var r = e.node(n), + a = r.rank; + u.default.isUndefined(a) || (t[a][r.order] = n); + }), + t + ); + } + + function v(e) { + var t = u.default.min( + u.default.map(e.nodes(), function (t) { + return e.node(t).rank; + }) + ); + u.default.forEach(e.nodes(), function (n) { + var r = e.node(n); + u.default.has(r, "rank") && (r.rank -= t); + }); + } + + function g(e) { + var t = u.default.min( + u.default.map(e.nodes(), function (t) { + return e.node(t).rank; + }) + ), + n = []; + u.default.forEach(e.nodes(), function (r) { + var a = e.node(r).rank - t; + n[a] || (n[a] = []), n[a].push(r); + }); + var r = 0, + a = e.graph().nodeRankFactor; + u.default.forEach(n, function (t, n) { + u.default.isUndefined(t) && n % a != 0 + ? --r + : r && + u.default.forEach(t, function (t) { + e.node(t).rank += r; + }); + }); + } + + function p(e, t, n, r) { + var a = { + width: 0, + height: 0, + }; + return ( + arguments.length >= 4 && + ((a.rank = n), (a.order = r)), + d(e, "border", a, t) + ); + } + + function m(e) { + return u.default.max( + u.default.map(e.nodes(), function (t) { + var n = e.node(t).rank; + if (!u.default.isUndefined(n)) return n; + }) + ); + } + + function E(e, t) { + var n = { + lhs: [], + rhs: [], + }; + return ( + u.default.forEach(e, function (e) { + t(e) ? n.lhs.push(e) : n.rhs.push(e); + }), + n + ); + } + + function b(e, t) { + var n = u.default.now(); + + try { + return t(); + } finally { + console.log( + e + " time: " + (u.default.now() - n) + "ms" + ); + } + } + + function w(e, t) { + return t(); + } + + t.default = { + addDummyNode: d, + simplify: f, + asNonCompoundGraph: i, + successorWeights: l, + predecessorWeights: c, + intersectRect: s, + buildLayerMatrix: h, + normalizeRanks: v, + removeEmptyRanks: g, + addBorderNode: p, + maxRank: m, + partition: E, + time: b, + notime: w, + }; + }, + function (e, t) { + e.exports = __webpack_require__( + /* ! graphlibrary */ "./node_modules/graphlibrary/index.js" + ); + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }), + (t.longestPath = o), + (t.slack = d); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + + function o(e) { + var t = {}; + u.default.forEach(e.sources(), function n(r) { + var a = e.node(r); + if (u.default.has(t, r)) return a.rank; + t[r] = !0; + var o = + u.default.min( + u.default.map(e.outEdges(r), function (t) { + return n(t.w) - e.edge(t).minlen; + }) + ) || 0; + return (a.rank = o); + }); + } + + function d(e, t) { + return ( + e.node(t.w).rank - + e.node(t.v).rank - + e.edge(t).minlen + ); + } + + t.default = { + longestPath: o, + slack: d, + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }, + o = n(2), + d = n(3); + + function f(e, t) { + return ( + u.default.forEach(e.nodes(), function n(r) { + u.default.forEach(t.nodeEdges(r), function (a) { + var u = a.v, + o = r === u ? a.w : u; + e.hasNode(o) || + (0, d.slack)(t, a) || + (e.setNode(o, {}), + e.setEdge(r, o, {}), + n(o)); + }); + }), + e.nodeCount() + ); + } + + function i(e, t) { + return u.default.minBy(t.edges(), function (n) { + if (e.hasNode(n.v) !== e.hasNode(n.w)) + return (0, d.slack)(t, n); + }); + } + + function l(e, t, n) { + u.default.forEach(e.nodes(), function (e) { + t.node(e).rank += n; + }); + } + + t.default = function (e) { + var t = new o.Graph({ + directed: !1, + }), + n = e.nodes()[0], + r = e.nodeCount(); + t.setNode(n, {}); + + for (var a = void 0; f(t, e) < r; ) { + (a = i(t, e)), + l( + t, + e, + t.hasNode(a.v) + ? (0, d.slack)(e, a) + : -(0, d.slack)(e, a) + ); + } + + return t; + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }), + (t.positionX = p); + var r = o(n(0)), + a = n(2), + u = o(n(1)); + + function o(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + function d(e, t) { + var n = {}; + return ( + r.default.reduce(t, function (t, a) { + var u = 0, + o = 0, + d = t.length, + f = r.default.last(a); + return ( + r.default.forEach(a, function (t, l) { + var c = (function (e, t) { + if (e.node(t).dummy) + return r.default.find( + e.predecessors(t), + function (t) { + return e.node(t) + .dummy; + } + ); + })(e, t), + s = c ? e.node(c).order : d; + + (c || t === f) && + (r.default.forEach( + a.slice(o, l + 1), + function (t) { + r.default.forEach( + e.predecessors(t), + function (r) { + var a = e.node(r), + o = a.order; + !(o < u || s < o) || + (a.dummy && + e.node(t) + .dummy) || + i(n, r, t); + } + ); + } + ), + (o = l + 1), + (u = s)); + }), + a + ); + }), + n + ); + } + + function f(e, t) { + var n = {}; + + function a(t, a, u, o, d) { + var f = void 0; + r.default.forEach(r.default.range(a, u), function ( + a + ) { + (f = t[a]), + e.node(f).dummy && + r.default.forEach( + e.predecessors(f), + function (t) { + var r = e.node(t); + r.dummy && + (r.order < o || + r.order > d) && + i(n, t, f); + } + ); + }); + } + + return ( + r.default.reduce(t, function (t, n) { + var u = -1, + o = void 0, + d = 0; + return ( + r.default.forEach(n, function (r, f) { + if (e.node(r).dummy === "border") { + var i = e.predecessors(r); + i.length && + ((o = e.node(i[0]).order), + a(n, d, f, u, o), + (d = f), + (u = o)); + } + + a(n, d, n.length, o, t.length); + }), + n + ); + }), + n + ); + } + + function i(e, t, n) { + if (t > n) { + var r = t; + (t = n), (n = r); + } + + var a = e[t]; + a || (e[t] = a = {}), (a[n] = !0); + } + + function l(e, t, n) { + if (t > n) { + var a = t; + (t = n), (n = a); + } + + return r.default.has(e[t], n); + } + + function c(e, t, n, a) { + var u = {}, + o = {}, + d = {}; + return ( + r.default.forEach(t, function (e) { + r.default.forEach(e, function (e, t) { + (u[e] = e), (o[e] = e), (d[e] = t); + }); + }), + r.default.forEach(t, function (e) { + var t = -1; + r.default.forEach(e, function (e) { + var f = a(e); + if (f.length) + for ( + var i = + ((f = r.default.sortBy( + f, + function (e) { + return d[e]; + } + )).length - + 1) / + 2, + c = Math.floor(i), + s = Math.ceil(i); + c <= s; + ++c + ) { + var h = f[c]; + o[e] === e && + t < d[h] && + !l(n, e, h) && + ((o[h] = e), + (o[e] = u[e] = u[h]), + (t = d[h])); + } + }); + }), + { + root: u, + align: o, + } + ); + } + + function s(e, t, n, u, o) { + var d = {}, + f = (function (e, t, n, u) { + var o = new a.Graph(), + d = e.graph(), + f = (function (e, t, n) { + return function (a, u, o) { + var d = a.node(u), + f = a.node(o), + i = 0, + l = void 0; + if ( + ((i += d.width / 2), + r.default.has(d, "labelpos")) + ) + switch ( + d.labelpos.toLowerCase() + ) { + case "l": + l = -d.width / 2; + break; + + case "r": + l = d.width / 2; + } + if ( + (l && (i += n ? l : -l), + (l = 0), + (i += (d.dummy ? t : e) / 2), + (i += (f.dummy ? t : e) / 2), + (i += f.width / 2), + r.default.has(f, "labelpos")) + ) + switch ( + f.labelpos.toLowerCase() + ) { + case "l": + l = f.width / 2; + break; + + case "r": + l = -f.width / 2; + } + return ( + l && (i += n ? l : -l), + (l = 0), + i + ); + }; + })(d.nodesep, d.edgesep, u); + + return ( + r.default.forEach(t, function (t) { + var a = void 0; + r.default.forEach(t, function (t) { + var r = n[t]; + + if ((o.setNode(r), a)) { + var u = n[a], + d = o.edge(u, r); + o.setEdge( + u, + r, + Math.max(f(e, t, a), d || 0) + ); + } + + a = t; + }); + }), + o + ); + })(e, t, n, o), + i = {}; + + r.default.forEach(f.nodes(), function e(t) { + r.default.has(i, t) || + ((i[t] = !0), + (d[t] = r.default.reduce( + f.inEdges(t), + function (t, n) { + return ( + e(n.v), + Math.max(t, d[n.v] + f.edge(n)) + ); + }, + 0 + ))); + }); + var l = o ? "borderLeft" : "borderRight"; + return ( + r.default.forEach(f.nodes(), function t(n) { + if (i[n] !== 2) { + i[n]++; + var a = e.node(n), + u = r.default.reduce( + f.outEdges(n), + function (e, n) { + return ( + t(n.w), + Math.min( + e, + d[n.w] - f.edge(n) + ) + ); + }, + Number.POSITIVE_INFINITY + ); + u !== Number.POSITIVE_INFINITY && + a.borderType !== l && + (d[n] = Math.max(d[n], u)); + } + }), + r.default.forEach(u, function (e) { + d[e] = d[n[e]]; + }), + d + ); + } + + function h(e, t) { + return r.default.minBy(r.default.values(t), function ( + t + ) { + var n = (r.default.minBy( + r.default.toPairs(t), + function (t) { + return t[1] - m(e, t[0]) / 2; + } + ) || ["k", 0])[1]; + return ( + (r.default.maxBy( + r.default.toPairs(t), + function (t) { + return t[1] + m(e, t[0]) / 2; + } + ) || ["k", 0])[1] - n + ); + }); + } + + function v(e, t) { + var n = r.default.values(t), + a = r.default.min(n), + u = r.default.max(n); + r.default.forEach(["u", "d"], function (n) { + r.default.forEach(["l", "r"], function (o) { + var d = n + o, + f = e[d]; + + if (f !== t) { + var i = r.default.values(f), + l = + o === "l" + ? a - r.default.min(i) + : u - r.default.max(i); + l && + (e[d] = r.default.mapValues( + f, + function (e) { + return e + l; + } + )); + } + }); + }); + } + + function g(e, t) { + return r.default.mapValues(e.ul, function (n, a) { + if (t) return e[t.toLowerCase()][a]; + var u = r.default.sortBy(r.default.map(e, a)); + return (u[1] + u[2]) / 2; + }); + } + + function p(e) { + var t = u.default.buildLayerMatrix(e), + n = r.default.merge(d(e, t), f(e, t)), + a = {}, + o = void 0; + r.default.forEach(["u", "d"], function (u) { + (o = u === "u" ? t : r.default.values(t).reverse()), + r.default.forEach(["l", "r"], function (t) { + t === "r" && + (o = r.default.map(o, function (e) { + return r.default + .values(e) + .reverse(); + })); + var d = r.default.bind( + u === "u" + ? e.predecessors + : e.successors, + e + ), + f = c(0, o, n, d), + i = s(e, o, f.root, f.align, t === "r"); + t === "r" && + (i = r.default.mapValues(i, function ( + e + ) { + return -e; + })), + (a[u + t] = i); + }); + }); + var i = h(e, a); + return v(a, i), g(a, e.graph().align); + } + + function m(e, t) { + return e.node(t).width; + } + + t.default = { + positionX: p, + findType1Conflicts: d, + findType2Conflicts: f, + addConflict: i, + hasConflict: l, + verticalAlignment: c, + horizontalCompaction: s, + alignCoordinates: v, + findSmallestWidthAlignment: h, + balance: g, + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = o(n(0)), + a = o(n(1)), + u = n(5); + + function o(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + t.default = function (e) { + (function (e) { + var t = a.default.buildLayerMatrix(e), + n = e.graph().ranksep, + u = 0; + r.default.forEach(t, function (t) { + var a = r.default.max( + r.default.map(t, function (t) { + return e.node(t).height; + }) + ); + r.default.forEach(t, function (t) { + e.node(t).y = u + a / 2; + }), + (u += a + n); + }); + })((e = a.default.asNonCompoundGraph(e))), + r.default.forEach((0, u.positionX)(e), function ( + t, + n + ) { + e.node(n).x = t; + }); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + + t.default = function (e, t, n) { + var r = {}, + a = void 0; + u.default.forEach(n, function (n) { + for ( + var u = e.parent(n), o = void 0, d = void 0; + u; + + ) { + if ( + ((o = e.parent(u)) + ? ((d = r[o]), (r[o] = u)) + : ((d = a), (a = u)), + d && d !== u) + ) + return void t.setEdge(d, u); + u = o; + } + }); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }, + o = n(2); + + t.default = function (e, t, n) { + var r = (function (e) { + for ( + var t = void 0; + e.hasNode( + (t = u.default.uniqueId("_root")) + ); + + ) {} + + return t; + })(e), + a = new o.Graph({ + compound: !0, + }) + .setGraph({ + root: r, + }) + .setDefaultNodeLabel(function (t) { + return e.node(t); + }); + + return ( + u.default.forEach(e.nodes(), function (o) { + var d = e.node(o), + f = e.parent(o); + (d.rank === t || + (d.minRank <= t && t <= d.maxRank)) && + (a.setNode(o), + a.setParent(o, f || r), + u.default.forEach(e[n](o), function (t) { + var n = t.v === o ? t.w : t.v, + r = a.edge(n, o), + d = u.default.isUndefined(r) + ? 0 + : r.weight; + a.setEdge(n, o, { + weight: e.edge(t).weight + d, + }); + }), + u.default.has(d, "minRank") && + a.setNode(o, { + borderLeft: d.borderLeft[t], + borderRight: d.borderRight[t], + })); + }), + a + ); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = u(n(0)), + a = u(n(1)); + + function u(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + function o(e, t, n) { + for ( + var a = void 0; + t.length && (a = r.default.last(t)).i <= n; + + ) { + t.pop(), e.push(a.vs), n++; + } + + return n; + } + + t.default = function (e, t) { + var n, + u = a.default.partition(e, function (e) { + return r.default.has(e, "barycenter"); + }), + d = u.lhs, + f = r.default.sortBy(u.rhs, function (e) { + return -e.i; + }), + i = [], + l = 0, + c = 0, + s = 0; + d.sort( + ((n = Boolean(t)), + function (e, t) { + return e.barycenter < t.barycenter + ? -1 + : e.barycenter > t.barycenter + ? 1 + : n + ? t.i - e.i + : e.i - t.i; + }) + ), + (s = o(i, f, s)), + r.default.forEach(d, function (e) { + (s += e.vs.length), + i.push(e.vs), + (l += e.barycenter * e.weight), + (c += e.weight), + (s = o(i, f, s)); + }); + var h = { + vs: r.default.flatten(i, !0), + }; + return c && ((h.barycenter = l / c), (h.weight = c)), h; + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + + t.default = function (e, t) { + var n = {}; + return ( + u.default.forEach(e, function (e, t) { + var r = (n[e.v] = { + indegree: 0, + in: [], + out: [], + vs: [e.v], + i: t, + }); + u.default.isUndefined(e.barycenter) || + ((r.barycenter = e.barycenter), + (r.weight = e.weight)); + }), + u.default.forEach(t.edges(), function (e) { + var t = n[e.v], + r = n[e.w]; + u.default.isUndefined(t) || + u.default.isUndefined(r) || + (r.indegree++, t.out.push(n[e.w])); + }), + (function (e) { + var t = []; + + function n(e) { + return function (t) { + var n, r, a, o; + t.merged || + ((u.default.isUndefined( + t.barycenter + ) || + u.default.isUndefined( + e.barycenter + ) || + t.barycenter >= e.barycenter) && + ((r = t), + (a = 0), + (o = 0), + (n = e).weight && + ((a += + n.barycenter * + n.weight), + (o += n.weight)), + r.weight && + ((a += + r.barycenter * + r.weight), + (o += r.weight)), + (n.vs = r.vs.concat(n.vs)), + (n.barycenter = a / o), + (n.weight = o), + (n.i = Math.min(r.i, n.i)), + (r.merged = !0))); + }; + } + + function r(t) { + return function (n) { + n.in.push(t), + --n.indegree == 0 && e.push(n); + }; + } + + for (; e.length; ) { + var a = e.pop(); + t.push(a), + u.default.forEach(a.in.reverse(), n(a)), + u.default.forEach(a.out, r(a)); + } + + return u.default + .chain(t) + .filter(function (e) { + return !e.merged; + }) + .map(function (e) { + return u.default.pick(e, [ + "vs", + "i", + "barycenter", + "weight", + ]); + }) + .value(); + })( + u.default.filter(n, function (e) { + return !e.indegree; + }) + ) + ); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + + t.default = function (e, t) { + return u.default.map(t, function (t) { + var n = e.inEdges(t); + + if (n.length) { + var r = u.default.reduce( + n, + function (t, n) { + var r = e.edge(n), + a = e.node(n.v); + return { + sum: t.sum + r.weight * a.order, + weight: t.weight + r.weight, + }; + }, + { + sum: 0, + weight: 0, + } + ); + return { + v: t, + barycenter: r.sum / r.weight, + weight: r.weight, + }; + } + + return { + v: t, + }; + }); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = d(n(0)), + a = d(n(11)), + u = d(n(10)), + o = d(n(9)); + + function d(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + t.default = function e(t, n, d, f) { + var i = t.children(n), + l = t.node(n), + c = l ? l.borderLeft : void 0, + s = l ? l.borderRight : void 0, + h = {}; + c && + (i = r.default.filter(i, function (e) { + return e !== c && e !== s; + })); + var v = (0, a.default)(t, i); + r.default.forEach(v, function (n) { + if (t.children(n.v).length) { + var a = e(t, n.v, d, f); + (h[n.v] = a), + r.default.has(a, "barycenter") && + ((u = n), + (o = a), + r.default.isUndefined(u.barycenter) + ? ((u.barycenter = o.barycenter), + (u.weight = o.weight)) + : ((u.barycenter = + (u.barycenter * u.weight + + o.barycenter * o.weight) / + (u.weight + o.weight)), + (u.weight += o.weight))); + } + + var u, o; + }); + var g = (0, u.default)(v, d); + !(function (e, t) { + r.default.forEach(e, function (e) { + e.vs = r.default.flatten( + e.vs.map(function (e) { + return t[e] ? t[e].vs : e; + }), + !0 + ); + }); + })(g, h); + var p = (0, o.default)(g, f); + + if ( + c && + ((p.vs = r.default.flatten([c, p.vs, s], !0)), + t.predecessors(c).length) + ) { + var m = t.node(t.predecessors(c)[0]), + E = t.node(t.predecessors(s)[0]); + r.default.has(p, "barycenter") || + ((p.barycenter = 0), (p.weight = 0)), + (p.barycenter = + (p.barycenter * p.weight + + m.order + + E.order) / + (p.weight + 2)), + (p.weight += 2); + } + + return p; + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + + function o(e, t, n) { + for ( + var r = u.default.zipObject( + n, + u.default.map(n, function (e, t) { + return t; + }) + ), + a = u.default.flatten( + u.default.map(t, function (t) { + return u.default + .chain(e.outEdges(t)) + .map(function (t) { + return { + pos: r[t.w], + weight: e.edge(t).weight, + }; + }) + .sortBy("pos") + .value(); + }), + !0 + ), + o = 1; + o < n.length; + + ) { + o <<= 1; + } + + var d = 2 * o - 1; + o -= 1; + var f = u.default.map(new Array(d), function () { + return 0; + }), + i = 0; + return ( + u.default.forEach( + a.forEach(function (e) { + var t = e.pos + o; + f[t] += e.weight; + + for (var n = 0; t > 0; ) { + t % 2 && (n += f[t + 1]), + (f[(t = (t - 1) >> 1)] += e.weight); + } + + i += e.weight * n; + }) + ), + i + ); + } + + t.default = function (e, t) { + for (var n = 0, r = 1; r < t.length; ++r) { + n += o(e, t[r - 1], t[r]); + } + + return n; + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + + t.default = function (e) { + var t = {}, + n = u.default.filter(e.nodes(), function (t) { + return !e.children(t).length; + }), + r = u.default.max( + u.default.map(n, function (t) { + return e.node(t).rank; + }) + ), + a = u.default.map( + u.default.range(r + 1), + function () { + return []; + } + ), + o = u.default.sortBy(n, function (t) { + return e.node(t).rank; + }); + return ( + u.default.forEach(o, function n(r) { + if (!u.default.has(t, r)) { + t[r] = !0; + var o = e.node(r); + a[o.rank].push(r), + u.default.forEach(e.successors(r), n); + } + }), + a + ); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = c(n(0)), + a = n(2), + u = c(n(14)), + o = c(n(13)), + d = c(n(12)), + f = c(n(8)), + i = c(n(7)), + l = c(n(1)); + + function c(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + function s(e, t, n) { + return r.default.map(t, function (t) { + return (0, f.default)(e, t, n); + }); + } + + function h(e, t) { + var n = new a.Graph(); + r.default.forEach(e, function (e) { + var a = e.graph().root, + u = (0, d.default)(e, a, n, t); + r.default.forEach(u.vs, function (t, n) { + e.node(t).order = n; + }), + (0, i.default)(e, n, u.vs); + }); + } + + function v(e, t) { + r.default.forEach(t, function (t) { + r.default.forEach(t, function (t, n) { + e.node(t).order = n; + }); + }); + } + + t.default = function (e) { + var t = l.default.maxRank(e), + n = s(e, r.default.range(1, t + 1), "inEdges"), + a = s( + e, + r.default.range(t - 1, -1, -1), + "outEdges" + ), + d = (0, u.default)(e); + v(e, d); + + for ( + var f = Number.POSITIVE_INFINITY, + i = void 0, + c = 0, + g = 0; + g < 4; + ++c, ++g + ) { + h(c % 2 ? n : a, c % 4 >= 2), + (d = l.default.buildLayerMatrix(e)); + var p = (0, o.default)(e, d); + p < f && + ((g = 0), + (i = r.default.cloneDeep(d)), + (f = p)); + } + + v(e, i); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + + function o(e) { + u.default.forEach(e.nodes(), function (t) { + d(e.node(t)); + }), + u.default.forEach(e.edges(), function (t) { + d(e.edge(t)); + }); + } + + function d(e) { + var t = e.width; + (e.width = e.height), (e.height = t); + } + + function f(e) { + e.y = -e.y; + } + + function i(e) { + var t = e.x; + (e.x = e.y), (e.y = t); + } + + t.default = { + adjust: function adjust(e) { + var t = e.graph().rankdir.toLowerCase(); + (t !== "lr" && t !== "rl") || o(e); + }, + undo: function undo(e) { + var t = e.graph().rankdir.toLowerCase(); + (t !== "bt" && t !== "rl") || + (function (e) { + u.default.forEach(e.nodes(), function (t) { + f(e.node(t)); + }), + u.default.forEach(e.edges(), function ( + t + ) { + var n = e.edge(t); + u.default.forEach(n.points, f), + u.default.has(n, "y") && f(n); + }); + })(e), + (t !== "lr" && t !== "rl") || + ((function (e) { + u.default.forEach(e.nodes(), function ( + t + ) { + i(e.node(t)); + }), + u.default.forEach( + e.edges(), + function (t) { + var n = e.edge(t); + u.default.forEach( + n.points, + i + ), + u.default.has(n, "x") && + i(n); + } + ); + })(e), + o(e)); + }, + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = u(n(0)), + a = u(n(1)); + + function u(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + function o(e, t, n, r, u, o) { + var d = { + width: 0, + height: 0, + rank: o, + borderType: t, + }, + f = u[t][o - 1], + i = a.default.addDummyNode(e, "border", d, n); + (u[t][o] = i), + e.setParent(i, r), + f && + e.setEdge(f, i, { + weight: 1, + }); + } + + t.default = function (e) { + r.default.forEach(e.children(), function t(n) { + var a = e.children(n), + u = e.node(n); + + if ( + (a.length && r.default.forEach(a, t), + r.default.has(u, "minRank")) + ) { + (u.borderLeft = []), (u.borderRight = []); + + for ( + var d = u.minRank, f = u.maxRank + 1; + d < f; + ++d + ) { + o(e, "borderLeft", "_bl", n, u, d), + o(e, "borderRight", "_br", n, u, d); + } + } + }); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = u(n(0)), + a = u(n(1)); + + function u(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + t.default = { + run: function run(e) { + var t = a.default.addDummyNode( + e, + "root", + {}, + "_root" + ), + n = (function (e) { + var t = {}; + return ( + r.default.forEach( + e.children(), + function (n) { + !(function n(a, u) { + var o = e.children(a); + o && + o.length && + r.default.forEach( + o, + function (e) { + n(e, u + 1); + } + ), + (t[a] = u); + })(n, 1); + } + ), + t + ); + })(e), + u = r.default.max(r.default.values(n)) - 1, + o = 2 * u + 1; + + (e.graph().nestingRoot = t), + r.default.forEach(e.edges(), function (t) { + e.edge(t).minlen *= o; + }); + + var d = + (function (e) { + return r.default.reduce( + e.edges(), + function (t, n) { + return t + e.edge(n).weight; + }, + 0 + ); + })(e) + 1; + + r.default.forEach(e.children(), function (f) { + !(function e(t, n, u, o, d, f, i) { + var l = t.children(i); + + if (l.length) { + var c = a.default.addBorderNode( + t, + "_bt" + ), + s = a.default.addBorderNode( + t, + "_bb" + ), + h = t.node(i); + t.setParent(c, i), + (h.borderTop = c), + t.setParent(s, i), + (h.borderBottom = s), + r.default.forEach(l, function (r) { + e(t, n, u, o, d, f, r); + var a = t.node(r), + l = a.borderTop + ? a.borderTop + : r, + h = a.borderBottom + ? a.borderBottom + : r, + v = a.borderTop ? o : 2 * o, + g = + l !== h + ? 1 + : d - f[i] + 1; + t.setEdge(c, l, { + weight: v, + minlen: g, + nestingEdge: !0, + }), + t.setEdge(h, s, { + weight: v, + minlen: g, + nestingEdge: !0, + }); + }), + t.parent(i) || + t.setEdge(n, c, { + weight: 0, + minlen: d + f[i], + }); + } else + i !== n && + t.setEdge(n, i, { + weight: 0, + minlen: u, + }); + })(e, t, o, d, u, n, f); + }), + (e.graph().nodeRankFactor = o); + }, + cleanup: function cleanup(e) { + var t = e.graph(); + e.removeNode(t.nestingRoot), + delete t.nestingRoot, + r.default.forEach(e.edges(), function (t) { + e.edge(t).nestingEdge && e.removeEdge(t); + }); + }, + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(0), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + + t.default = function (e) { + var t = (function (e) { + var t = {}, + n = 0; + return ( + u.default.forEach(e.children(), function r(a) { + var o = n; + u.default.forEach(e.children(a), r), + (t[a] = { + low: o, + lim: n++, + }); + }), + t + ); + })(e); + + u.default.forEach(e.graph().dummyChains, function (n) { + for ( + var r = e.node(n), + a = r.edgeObj, + u = (function (e, t, n, r) { + var a = [], + u = [], + o = Math.min(t[n].low, t[r].low), + d = Math.max(t[n].lim, t[r].lim), + f = void 0, + i = void 0; + f = n; + + do { + (f = e.parent(f)), a.push(f); + } while ( + f && + (t[f].low > o || d > t[f].lim) + ); + + for ( + i = f, f = r; + (f = e.parent(f)) !== i; + + ) { + u.push(f); + } + + return { + path: a.concat(u.reverse()), + lca: i, + }; + })(e, t, a.v, a.w), + o = u.path, + d = u.lca, + f = 0, + i = o[f], + l = !0; + n !== a.w; + + ) { + if (((r = e.node(n)), l)) { + for ( + ; + (i = o[f]) !== d && + e.node(i).maxRank < r.rank; + + ) { + f++; + } + + i === d && (l = !1); + } + + if (!l) { + for ( + ; + f < o.length - 1 && + e.node((i = o[f + 1])).minRank <= + r.rank; + + ) { + f++; + } + + i = o[f]; + } + + e.setParent(n, i), (n = e.successors(n)[0]); + } + }); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = f(n(0)), + a = n(2), + u = f(n(4)), + o = n(3), + d = n(1); + + function f(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + var i = a.alg.preorder, + l = a.alg.postorder; + + function c(e) { + (e = (0, d.simplify)(e)), (0, o.longestPath)(e); + var t = (0, u.default)(e); + v(t), s(t, e); + + for (var n = void 0; (n = g(t)); ) { + m(t, e, n, p(t, e, n)); + } + } + + function s(e, t) { + var n = l(e, e.nodes()); + (n = n.slice(0, n.length - 1)), + r.default.forEach(n, function (n) { + !(function (e, t, n) { + var r = e.node(n).parent; + e.edge(n, r).cutvalue = h(e, t, n); + })(e, t, n); + }); + } + + function h(e, t, n) { + var a = e.node(n).parent, + u = !0, + o = t.edge(n, a), + d = 0; + return ( + o || ((u = !1), (o = t.edge(a, n))), + (d = o.weight), + r.default.forEach(t.nodeEdges(n), function (r) { + var o, + f, + i = r.v === n, + l = i ? r.w : r.v; + + if (l !== a) { + var c = i === u, + s = t.edge(r).weight; + + if ( + ((d += c ? s : -s), + (o = n), + (f = l), + e.hasEdge(o, f)) + ) { + var h = e.edge(n, l).cutvalue; + d += c ? -h : h; + } + } + }), + d + ); + } + + function v(e, t) { + arguments.length < 2 && (t = e.nodes()[0]), + (function e(t, n, a, u, o) { + var d = a; + var f = t.node(u); + n[u] = !0; + r.default.forEach(t.neighbors(u), function (o) { + r.default.has(n, o) || + (a = e(t, n, a, o, u)); + }); + f.low = d; + f.lim = a++; + o ? (f.parent = o) : delete f.parent; + return a; + })(e, {}, 1, t); + } + + function g(e) { + return r.default.find(e.edges(), function (t) { + return e.edge(t).cutvalue < 0; + }); + } + + function p(e, t, n) { + var a = n.v, + u = n.w; + t.hasEdge(a, u) || ((a = n.w), (u = n.v)); + var d = e.node(a), + f = e.node(u), + i = d, + l = !1; + d.lim > f.lim && ((i = f), (l = !0)); + var c = r.default.filter(t.edges(), function (t) { + return ( + l === E(e, e.node(t.v), i) && + l !== E(e, e.node(t.w), i) + ); + }); + return r.default.minBy(c, function (e) { + return (0, o.slack)(t, e); + }); + } + + function m(e, t, n, a) { + var u = n.v, + o = n.w; + e.removeEdge(u, o), + e.setEdge(a.v, a.w, {}), + v(e), + s(e, t), + (function (e, t) { + var n = r.default.find(e.nodes(), function (e) { + return !t.node(e).parent; + }), + a = i(e, n); + (a = a.slice(1)), + r.default.forEach(a, function (n) { + var r = e.node(n).parent, + a = t.edge(n, r), + u = !1; + a || ((a = t.edge(r, n)), (u = !0)), + (t.node(n).rank = + t.node(r).rank + + (u ? a.minlen : -a.minlen)); + }); + })(e, t); + } + + function E(e, t, n) { + return n.low <= t.lim && t.lim <= n.lim; + } + + (c.initLowLimValues = v), + (c.initCutValues = s), + (c.calcCutValue = h), + (c.leaveEdge = g), + (c.enterEdge = p), + (c.exchangeEdges = m), + (t.default = c); + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = n(3), + a = o(n(4)), + u = o(n(20)); + + function o(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + var d = r.longestPath; + + function f(e) { + (0, u.default)(e); + } + + t.default = function (e) { + switch (e.graph().ranker) { + case "network-simplex": + f(e); + break; + + case "tight-tree": + !(function (e) { + (0, r.longestPath)(e), (0, a.default)(e); + })(e); + break; + + case "longest-path": + d(e); + break; + + default: + f(e); + } + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = u(n(0)), + a = u(n(1)); + + function u(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + t.default = { + run: function run(e) { + (e.graph().dummyChains = []), + r.default.forEach(e.edges(), function (t) { + !(function (e, t) { + var n = t.v, + r = e.node(n).rank, + u = t.w, + o = e.node(u).rank, + d = t.name, + f = e.edge(t), + i = f.labelRank; + + if (o !== r + 1) { + e.removeEdge(t); + var l = void 0, + c = void 0, + s = void 0; + + for (s = 0, ++r; r < o; ++s, ++r) { + (f.points = []), + (c = { + width: 0, + height: 0, + edgeLabel: f, + edgeObj: t, + rank: r, + }), + (l = a.default.addDummyNode( + e, + "edge", + c, + "_d" + )), + r === i && + ((c.width = f.width), + (c.height = f.height), + (c.dummy = + "edge-label"), + (c.labelpos = + f.labelpos)), + e.setEdge( + n, + l, + { + weight: f.weight, + }, + d + ), + s === 0 && + e + .graph() + .dummyChains.push( + l + ), + (n = l); + } + + e.setEdge( + n, + u, + { + weight: f.weight, + }, + d + ); + } + })(e, t); + }); + }, + undo: function undo(e) { + r.default.forEach(e.graph().dummyChains, function ( + t + ) { + var n = e.node(t), + r = n.edgeLabel, + a = null; + + for (e.setEdge(n.edgeObj, r); n.dummy; ) { + (a = e.successors(t)[0]), + e.removeNode(t), + r.points.push({ + x: n.x, + y: n.y, + }), + n.dummy === "edge-label" && + ((r.x = n.x), + (r.y = n.y), + (r.width = n.width), + (r.height = n.height)), + (t = a), + (n = e.node(t)); + } + }); + }, + }; + }, + function (e, t, n) { + "use strict"; + + function r() { + var e = {}; + (e._next = e._prev = e), (this._sentinel = e); + } + + function a(e) { + (e._prev._next = e._next), + (e._next._prev = e._prev), + delete e._next, + delete e._prev; + } + + function u(e, t) { + if (e !== "_next" && e !== "_prev") return t; + } + + Object.defineProperty(t, "__esModule", { + value: !0, + }), + (r.prototype.dequeue = function () { + var e = this._sentinel, + t = e._prev; + if (t !== e) return a(t), t; + }), + (r.prototype.enqueue = function (e) { + var t = this._sentinel; + e._prev && e._next && a(e), + (e._next = t._next), + (t._next._prev = e), + (t._next = e), + (e._prev = t); + }), + (r.prototype.toString = function () { + for ( + var e = [], t = this._sentinel, n = t._prev; + n !== t; + + ) { + e.push(JSON.stringify(n, u)), (n = n._prev); + } + + return "[" + e.join(", ") + "]"; + }), + (t.default = r); + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = o(n(0)), + a = n(2), + u = o(n(23)); + + function o(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + var d = r.default.constant(1); + + function f(e, t, n, a, u) { + var o = u ? [] : void 0; + return ( + r.default.forEach(e.inEdges(a.v), function (r) { + var a = e.edge(r), + d = e.node(r.v); + u && + o.push({ + v: r.v, + w: r.w, + }), + (d.out -= a), + i(t, n, d); + }), + r.default.forEach(e.outEdges(a.v), function (r) { + var a = e.edge(r), + u = r.w, + o = e.node(u); + (o.in -= a), i(t, n, o); + }), + e.removeNode(a.v), + o + ); + } + + function i(e, t, n) { + n.out + ? n.in + ? e[n.out - n.in + t].enqueue(n) + : e[e.length - 1].enqueue(n) + : e[0].enqueue(n); + } + + t.default = function (e, t) { + if (e.nodeCount() <= 1) return []; + + var n = (function (e, t) { + var n = new a.Graph(), + o = 0, + d = 0; + r.default.forEach(e.nodes(), function (e) { + n.setNode(e, { + v: e, + in: 0, + out: 0, + }); + }), + r.default.forEach(e.edges(), function (e) { + var r = n.edge(e.v, e.w) || 0, + a = t(e), + u = r + a; + n.setEdge(e.v, e.w, u), + (d = Math.max( + d, + (n.node(e.v).out += a) + )), + (o = Math.max( + o, + (n.node(e.w).in += a) + )); + }); + var f = r.default + .range(d + o + 3) + .map(function () { + return new u.default(); + }), + l = o + 1; + return ( + r.default.forEach(n.nodes(), function (e) { + i(f, l, n.node(e)); + }), + { + graph: n, + buckets: f, + zeroIdx: l, + } + ); + })(e, t || d), + o = (function (e, t, n) { + for ( + var r = [], + a = t[t.length - 1], + u = t[0], + o = void 0; + e.nodeCount(); + + ) { + for (; (o = u.dequeue()); ) { + f(e, t, n, o); + } + + for (; (o = a.dequeue()); ) { + f(e, t, n, o); + } + + if (e.nodeCount()) + for (var d = t.length - 2; d > 0; --d) { + if ((o = t[d].dequeue())) { + r = r.concat(f(e, t, n, o, !0)); + break; + } + } + } + + return r; + })(n.graph, n.buckets, n.zeroIdx); + + return r.default.flatten( + r.default.map(o, function (t) { + return e.outEdges(t.v, t.w); + }), + !0 + ); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = u(n(0)), + a = u(n(24)); + + function u(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + t.default = { + run: function run(e) { + var t = + e.graph().acyclicer === "greedy" + ? (0, a.default)( + e, + (function (e) { + return function (t) { + return e.edge(t).weight; + }; + })(e) + ) + : (function (e) { + var t = [], + n = {}, + a = {}; + return ( + r.default.forEach( + e.nodes(), + function u(o) { + r.default.has(a, o) || + ((a[o] = !0), + (n[o] = !0), + r.default.forEach( + e.outEdges(o), + function (e) { + r.default.has( + n, + e.w + ) + ? t.push( + e + ) + : u(e.w); + } + ), + delete n[o]); + } + ), + t + ); + })(e); + r.default.forEach(t, function (t) { + var n = e.edge(t); + e.removeEdge(t), + (n.forwardName = t.name), + (n.reversed = !0), + e.setEdge( + t.w, + t.v, + n, + r.default.uniqueId("rev") + ); + }); + }, + undo: function undo(e) { + r.default.forEach(e.edges(), function (t) { + var n = e.edge(t); + + if (n.reversed) { + e.removeEdge(t); + var r = n.forwardName; + delete n.reversed, + delete n.forwardName, + e.setEdge(t.w, t.v, n, r); + } + }); + }, + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r = p(n(0)), + a = n(2), + u = p(n(25)), + o = p(n(22)), + d = p(n(21)), + f = n(1), + i = p(f), + l = p(n(19)), + c = p(n(18)), + s = p(n(17)), + h = p(n(16)), + v = p(n(15)), + g = p(n(6)); + + function p(e) { + return e && e.__esModule + ? e + : { + default: e, + }; + } + + var m = [ + "nodesep", + "edgesep", + "ranksep", + "marginx", + "marginy", + ], + E = { + ranksep: 50, + edgesep: 20, + nodesep: 50, + rankdir: "tb", + }, + b = ["acyclicer", "ranker", "rankdir", "align"], + w = ["width", "height"], + y = { + width: 0, + height: 0, + }, + _ = [ + "minlen", + "weight", + "width", + "height", + "labeloffset", + ], + x = { + minlen: 1, + weight: 1, + width: 0, + height: 0, + labeloffset: 10, + labelpos: "r", + }, + k = ["labelpos"]; + + function M(e, t) { + return r.default.mapValues( + r.default.pick(e, t), + Number + ); + } + + function N(e) { + var t = {}; + return ( + r.default.forEach(e, function (e, n) { + t[n.toLowerCase()] = e; + }), + t + ); + } + + t.default = function (e, t) { + var n = + t && t.debugTiming + ? i.default.time + : i.default.notime; + n("layout", function () { + var t = n(" buildLayoutGraph", function () { + return (function (e) { + var t = new a.Graph({ + multigraph: !0, + compound: !0, + }), + n = N(e.graph()); + return ( + t.setGraph( + r.default.merge( + {}, + E, + M(n, m), + r.default.pick(n, b) + ) + ), + r.default.forEach(e.nodes(), function ( + n + ) { + var a = N(e.node(n)); + t.setNode( + n, + r.default.defaults(M(a, w), y) + ), + t.setParent(n, e.parent(n)); + }), + r.default.forEach(e.edges(), function ( + n + ) { + var a = N(e.edge(n)); + t.setEdge( + n, + r.default.merge( + {}, + x, + M(a, _), + r.default.pick(a, k) + ) + ); + }), + t + ); + })(e); + }); + n(" runLayout", function () { + !(function (e, t) { + t( + " makeSpaceForEdgeLabels", + function () { + !(function (e) { + var t = e.graph(); + (t.ranksep /= 2), + r.default.forEach( + e.edges(), + function (n) { + var r = e.edge(n); + (r.minlen *= 2), + r.labelpos.toLowerCase() !== + "c" && + (t.rankdir === + "TB" || + t.rankdir === + "BT" + ? (r.width += + r.labeloffset) + : (r.height += + r.labeloffset)); + } + ); + })(e); + } + ), + t(" removeSelfEdges", function () { + !(function (e) { + r.default.forEach( + e.edges(), + function (t) { + if (t.v === t.w) { + var n = e.node(t.v); + n.selfEdges || + (n.selfEdges = []), + n.selfEdges.push( + { + e: t, + label: e.edge( + t + ), + } + ), + e.removeEdge(t); + } + } + ); + })(e); + }), + t(" acyclic", function () { + u.default.run(e); + }), + t(" nestingGraph.run", function () { + c.default.run(e); + }), + t(" rank", function () { + (0, + d.default)(i.default.asNonCompoundGraph(e)); + }), + t( + " injectEdgeLabelProxies", + function () { + !(function (e) { + r.default.forEach( + e.edges(), + function (t) { + var n = e.edge(t); + + if ( + n.width && + n.height + ) { + var r = e.node( + t.v + ), + a = e.node( + t.w + ), + u = { + rank: + (a.rank - + r.rank) / + 2 + + r.rank, + e: t, + }; + i.default.addDummyNode( + e, + "edge-proxy", + u, + "_ep" + ); + } + } + ); + })(e); + } + ), + t(" removeEmptyRanks", function () { + (0, f.removeEmptyRanks)(e); + }), + t( + " nestingGraph.cleanup", + function () { + c.default.cleanup(e); + } + ), + t(" normalizeRanks", function () { + (0, f.normalizeRanks)(e); + }), + t(" assignRankMinMax", function () { + !(function (e) { + var t = 0; + r.default.forEach( + e.nodes(), + function (n) { + var r = e.node(n); + r.borderTop && + ((r.minRank = e.node( + r.borderTop + ).rank), + (r.maxRank = e.node( + r.borderBottom + ).rank), + (t = Math.max( + t, + r.maxRank + ))); + } + ), + (e.graph().maxRank = t); + })(e); + }), + t( + " removeEdgeLabelProxies", + function () { + !(function (e) { + r.default.forEach( + e.nodes(), + function (t) { + var n = e.node(t); + n.dummy === + "edge-proxy" && + ((e.edge( + n.e + ).labelRank = + n.rank), + e.removeNode( + t + )); + } + ); + })(e); + } + ), + t(" normalize.run", function () { + o.default.run(e); + }), + t(" parentDummyChains", function () { + (0, l.default)(e); + }), + t(" addBorderSegments", function () { + (0, s.default)(e); + }), + t(" order", function () { + (0, v.default)(e); + }), + t(" insertSelfEdges", function () { + !(function (e) { + var t = i.default.buildLayerMatrix( + e + ); + r.default.forEach(t, function ( + t + ) { + var n = 0; + r.default.forEach( + t, + function (t, a) { + var u = e.node(t); + (u.order = a + n), + r.default.forEach( + u.selfEdges, + function ( + t + ) { + i.default.addDummyNode( + e, + "selfedge", + { + width: + t + .label + .width, + height: + t + .label + .height, + rank: + u.rank, + order: + a + + ++n, + e: + t.e, + label: + t.label, + }, + "_se" + ); + } + ), + delete u.selfEdges; + } + ); + }); + })(e); + }), + t( + " adjustCoordinateSystem", + function () { + h.default.adjust(e); + } + ), + t(" position", function () { + (0, g.default)(e); + }), + t(" positionSelfEdges", function () { + !(function (e) { + r.default.forEach( + e.nodes(), + function (t) { + var n = e.node(t); + + if ( + n.dummy === + "selfedge" + ) { + var r = e.node( + n.e.v + ), + a = + r.x + + r.width / 2, + u = r.y, + o = n.x - a, + d = + r.height / + 2; + e.setEdge( + n.e, + n.label + ), + e.removeNode(t), + (n.label.points = [ + { + x: + a + + (2 * + o) / + 3, + y: + u - + d, + }, + { + x: + a + + (5 * + o) / + 6, + y: + u - + d, + }, + { + x: + a + + o, + y: u, + }, + { + x: + a + + (5 * + o) / + 6, + y: + u + + d, + }, + { + x: + a + + (2 * + o) / + 3, + y: + u + + d, + }, + ]), + (n.label.x = + n.x), + (n.label.y = + n.y); + } + } + ); + })(e); + }), + t(" removeBorderNodes", function () { + !(function (e) { + r.default.forEach( + e.nodes(), + function (t) { + if ( + e.children(t).length + ) { + var n = e.node(t), + a = e.node( + n.borderTop + ), + u = e.node( + n.borderBottom + ), + o = e.node( + r.default.last( + n.borderLeft + ) + ), + d = e.node( + r.default.last( + n.borderRight + ) + ); + (n.width = Math.abs( + d.x - o.x + )), + (n.height = Math.abs( + u.y - a.y + )), + (n.x = + o.x + + n.width / + 2), + (n.y = + a.y + + n.height / + 2); + } + } + ), + r.default.forEach( + e.nodes(), + function (t) { + e.node(t) + .dummy === + "border" && + e.removeNode(t); + } + ); + })(e); + }), + t(" normalize.undo", function () { + o.default.undo(e); + }), + t( + " fixupEdgeLabelCoords", + function () { + !(function (e) { + r.default.forEach( + e.edges(), + function (t) { + var n = e.edge(t); + if ( + r.default.has( + n, + "x" + ) + ) + switch ( + ((n.labelpos !== + "l" && + n.labelpos !== + "r") || + (n.width -= + n.labeloffset), + n.labelpos) + ) { + case "l": + n.x -= + n.width / + 2 + + n.labeloffset; + break; + + case "r": + n.x += + n.width / + 2 + + n.labeloffset; + } + } + ); + })(e); + } + ), + t( + " undoCoordinateSystem", + function () { + h.default.undo(e); + } + ), + t(" translateGraph", function () { + !(function (e) { + var t = + Number.POSITIVE_INFINITY, + n = 0, + a = + Number.POSITIVE_INFINITY, + u = 0, + o = e.graph(), + d = o.marginx || 0, + f = o.marginy || 0; + + function i(e) { + var r = e.x, + o = e.y, + d = e.width, + f = e.height; + (t = Math.min( + t, + r - d / 2 + )), + (n = Math.max( + n, + r + d / 2 + )), + (a = Math.min( + a, + o - f / 2 + )), + (u = Math.max( + u, + o + f / 2 + )); + } + + r.default.forEach( + e.nodes(), + function (t) { + i(e.node(t)); + } + ), + r.default.forEach( + e.edges(), + function (t) { + var n = e.edge(t); + r.default.has( + n, + "x" + ) && i(n); + } + ), + (t -= d), + (a -= f), + r.default.forEach( + e.nodes(), + function (n) { + var r = e.node(n); + (r.x -= t), + (r.y -= a); + } + ), + r.default.forEach( + e.edges(), + function (n) { + var u = e.edge(n); + r.default.forEach( + u.points, + function (e) { + (e.x -= t), + (e.y -= a); + } + ), + r.default.has( + u, + "x" + ) && (u.x -= t), + r.default.has( + u, + "y" + ) && (u.y -= a); + } + ), + (o.width = n - t + d), + (o.height = u - a + f); + })(e); + }), + t( + " assignNodeIntersects", + function () { + !(function (e) { + r.default.forEach( + e.edges(), + function (t) { + var n = e.edge(t), + r = e.node(t.v), + a = e.node(t.w), + u = null, + o = null; + n.points + ? ((u = + n + .points[0]), + (o = + n.points[ + n + .points + .length - + 1 + ])) + : ((n.points = []), + (u = a), + (o = r)), + n.points.unshift( + i.default.intersectRect( + r, + u + ) + ), + n.points.push( + i.default.intersectRect( + a, + o + ) + ); + } + ); + })(e); + } + ), + t(" reversePoints", function () { + !(function (e) { + r.default.forEach( + e.edges(), + function (t) { + var n = e.edge(t); + n.reversed && + n.points.reverse(); + } + ); + })(e); + }), + t(" acyclic.undo", function () { + u.default.undo(e); + }); + })(t, n); + }), + n(" updateInputGraph", function () { + !(function (e, t) { + r.default.forEach(e.nodes(), function ( + n + ) { + var r = e.node(n), + a = t.node(n); + r && + ((r.x = a.x), + (r.y = a.y), + t.children(n).length && + ((r.width = a.width), + (r.height = a.height))); + }), + r.default.forEach( + e.edges(), + function (n) { + var a = e.edge(n), + u = t.edge(n); + (a.points = u.points), + r.default.has(u, "x") && + ((a.x = u.x), + (a.y = u.y)); + } + ), + (e.graph().width = t.graph().width), + (e.graph().height = t.graph().height); + })(e, t); + }); + }); + }; + }, + function (e, t, n) { + "use strict"; + + Object.defineProperty(t, "__esModule", { + value: !0, + }); + var r, + a = n(26), + u = + (r = a) && r.__esModule + ? r + : { + default: r, + }; + t.default = { + layout: u.default, + }; + }, + ]); + + /***/ + }, + + /***/ "./node_modules/des.js/lib/des.js": + /* !****************************************!*\ + !*** ./node_modules/des.js/lib/des.js ***! + \****************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + exports.utils = __webpack_require__( + /* ! ./des/utils */ "./node_modules/des.js/lib/des/utils.js" + ); + exports.Cipher = __webpack_require__( + /* ! ./des/cipher */ "./node_modules/des.js/lib/des/cipher.js" + ); + exports.DES = __webpack_require__( + /* ! ./des/des */ "./node_modules/des.js/lib/des/des.js" + ); + exports.CBC = __webpack_require__( + /* ! ./des/cbc */ "./node_modules/des.js/lib/des/cbc.js" + ); + exports.EDE = __webpack_require__( + /* ! ./des/ede */ "./node_modules/des.js/lib/des/ede.js" + ); + + /***/ + }, + + /***/ "./node_modules/des.js/lib/des/cbc.js": + /* !********************************************!*\ + !*** ./node_modules/des.js/lib/des/cbc.js ***! + \********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var proto = {}; + + function CBCState(iv) { + assert.equal(iv.length, 8, "Invalid IV length"); + this.iv = new Array(8); + + for (var i = 0; i < this.iv.length; i++) { + this.iv[i] = iv[i]; + } + } + + function instantiate(Base) { + function CBC(options) { + Base.call(this, options); + + this._cbcInit(); + } + + inherits(CBC, Base); + var keys = Object.keys(proto); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + CBC.prototype[key] = proto[key]; + } + + CBC.create = function create(options) { + return new CBC(options); + }; + + return CBC; + } + + exports.instantiate = instantiate; + + proto._cbcInit = function _cbcInit() { + var state = new CBCState(this.options.iv); + this._cbcState = state; + }; + + proto._update = function _update(inp, inOff, out, outOff) { + var state = this._cbcState; + var superProto = this.constructor.super_.prototype; + var iv = state.iv; + + if (this.type === "encrypt") { + for (var i = 0; i < this.blockSize; i++) { + iv[i] ^= inp[inOff + i]; + } + + superProto._update.call(this, iv, 0, out, outOff); + + for (var i = 0; i < this.blockSize; i++) { + iv[i] = out[outOff + i]; + } + } else { + superProto._update.call(this, inp, inOff, out, outOff); + + for (var i = 0; i < this.blockSize; i++) { + out[outOff + i] ^= iv[i]; + } + + for (var i = 0; i < this.blockSize; i++) { + iv[i] = inp[inOff + i]; + } + } + }; + + /***/ + }, + + /***/ "./node_modules/des.js/lib/des/cipher.js": + /* !***********************************************!*\ + !*** ./node_modules/des.js/lib/des/cipher.js ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + function Cipher(options) { + this.options = options; + this.type = this.options.type; + this.blockSize = 8; + + this._init(); + + this.buffer = new Array(this.blockSize); + this.bufferOff = 0; + } + + module.exports = Cipher; + + Cipher.prototype._init = function _init() { + // Might be overrided + }; + + Cipher.prototype.update = function update(data) { + if (data.length === 0) return []; + if (this.type === "decrypt") return this._updateDecrypt(data); + return this._updateEncrypt(data); + }; + + Cipher.prototype._buffer = function _buffer(data, off) { + // Append data to buffer + var min = Math.min( + this.buffer.length - this.bufferOff, + data.length - off + ); + + for (var i = 0; i < min; i++) { + this.buffer[this.bufferOff + i] = data[off + i]; + } + + this.bufferOff += min; // Shift next + + return min; + }; + + Cipher.prototype._flushBuffer = function _flushBuffer(out, off) { + this._update(this.buffer, 0, out, off); + + this.bufferOff = 0; + return this.blockSize; + }; + + Cipher.prototype._updateEncrypt = function _updateEncrypt(data) { + var inputOff = 0; + var outputOff = 0; + var count = + ((this.bufferOff + data.length) / this.blockSize) | 0; + var out = new Array(count * this.blockSize); + + if (this.bufferOff !== 0) { + inputOff += this._buffer(data, inputOff); + if (this.bufferOff === this.buffer.length) + outputOff += this._flushBuffer(out, outputOff); + } // Write blocks + + var max = + data.length - ((data.length - inputOff) % this.blockSize); + + for (; inputOff < max; inputOff += this.blockSize) { + this._update(data, inputOff, out, outputOff); + + outputOff += this.blockSize; + } // Queue rest + + for (; inputOff < data.length; inputOff++, this.bufferOff++) { + this.buffer[this.bufferOff] = data[inputOff]; + } + + return out; + }; + + Cipher.prototype._updateDecrypt = function _updateDecrypt(data) { + var inputOff = 0; + var outputOff = 0; + var count = + Math.ceil((this.bufferOff + data.length) / this.blockSize) - + 1; + var out = new Array(count * this.blockSize); // TODO(indutny): optimize it, this is far from optimal + + for (; count > 0; count--) { + inputOff += this._buffer(data, inputOff); + outputOff += this._flushBuffer(out, outputOff); + } // Buffer rest of the input + + inputOff += this._buffer(data, inputOff); + return out; + }; + + Cipher.prototype.final = function final(buffer) { + var first; + if (buffer) first = this.update(buffer); + var last; + if (this.type === "encrypt") last = this._finalEncrypt(); + else last = this._finalDecrypt(); + if (first) return first.concat(last); + return last; + }; + + Cipher.prototype._pad = function _pad(buffer, off) { + if (off === 0) return false; + + while (off < buffer.length) { + buffer[off++] = 0; + } + + return true; + }; + + Cipher.prototype._finalEncrypt = function _finalEncrypt() { + if (!this._pad(this.buffer, this.bufferOff)) return []; + var out = new Array(this.blockSize); + + this._update(this.buffer, 0, out, 0); + + return out; + }; + + Cipher.prototype._unpad = function _unpad(buffer) { + return buffer; + }; + + Cipher.prototype._finalDecrypt = function _finalDecrypt() { + assert.equal( + this.bufferOff, + this.blockSize, + "Not enough data to decrypt" + ); + var out = new Array(this.blockSize); + + this._flushBuffer(out, 0); + + return this._unpad(out); + }; + + /***/ + }, + + /***/ "./node_modules/des.js/lib/des/des.js": + /* !********************************************!*\ + !*** ./node_modules/des.js/lib/des/des.js ***! + \********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var des = __webpack_require__( + /* ! ../des */ "./node_modules/des.js/lib/des.js" + ); + + var utils = des.utils; + var Cipher = des.Cipher; + + function DESState() { + this.tmp = new Array(2); + this.keys = null; + } + + function DES(options) { + Cipher.call(this, options); + var state = new DESState(); + this._desState = state; + this.deriveKeys(state, options.key); + } + + inherits(DES, Cipher); + module.exports = DES; + + DES.create = function create(options) { + return new DES(options); + }; + + var shiftTable = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]; + + DES.prototype.deriveKeys = function deriveKeys(state, key) { + state.keys = new Array(16 * 2); + assert.equal(key.length, this.blockSize, "Invalid key length"); + var kL = utils.readUInt32BE(key, 0); + var kR = utils.readUInt32BE(key, 4); + utils.pc1(kL, kR, state.tmp, 0); + kL = state.tmp[0]; + kR = state.tmp[1]; + + for (var i = 0; i < state.keys.length; i += 2) { + var shift = shiftTable[i >>> 1]; + kL = utils.r28shl(kL, shift); + kR = utils.r28shl(kR, shift); + utils.pc2(kL, kR, state.keys, i); + } + }; + + DES.prototype._update = function _update(inp, inOff, out, outOff) { + var state = this._desState; + var l = utils.readUInt32BE(inp, inOff); + var r = utils.readUInt32BE(inp, inOff + 4); // Initial Permutation + + utils.ip(l, r, state.tmp, 0); + l = state.tmp[0]; + r = state.tmp[1]; + if (this.type === "encrypt") + this._encrypt(state, l, r, state.tmp, 0); + else this._decrypt(state, l, r, state.tmp, 0); + l = state.tmp[0]; + r = state.tmp[1]; + utils.writeUInt32BE(out, l, outOff); + utils.writeUInt32BE(out, r, outOff + 4); + }; + + DES.prototype._pad = function _pad(buffer, off) { + var value = buffer.length - off; + + for (var i = off; i < buffer.length; i++) { + buffer[i] = value; + } + + return true; + }; + + DES.prototype._unpad = function _unpad(buffer) { + var pad = buffer[buffer.length - 1]; + + for (var i = buffer.length - pad; i < buffer.length; i++) { + assert.equal(buffer[i], pad); + } + + return buffer.slice(0, buffer.length - pad); + }; + + DES.prototype._encrypt = function _encrypt( + state, + lStart, + rStart, + out, + off + ) { + var l = lStart; + var r = rStart; // Apply f() x16 times + + for (var i = 0; i < state.keys.length; i += 2) { + var keyL = state.keys[i]; + var keyR = state.keys[i + 1]; // F(r, k) + + utils.expand(r, state.tmp, 0); + keyL ^= state.tmp[0]; + keyR ^= state.tmp[1]; + var s = utils.substitute(keyL, keyR); + var f = utils.permute(s); + var t = r; + r = (l ^ f) >>> 0; + l = t; + } // Reverse Initial Permutation + + utils.rip(r, l, out, off); + }; + + DES.prototype._decrypt = function _decrypt( + state, + lStart, + rStart, + out, + off + ) { + var l = rStart; + var r = lStart; // Apply f() x16 times + + for (var i = state.keys.length - 2; i >= 0; i -= 2) { + var keyL = state.keys[i]; + var keyR = state.keys[i + 1]; // F(r, k) + + utils.expand(l, state.tmp, 0); + keyL ^= state.tmp[0]; + keyR ^= state.tmp[1]; + var s = utils.substitute(keyL, keyR); + var f = utils.permute(s); + var t = l; + l = (r ^ f) >>> 0; + r = t; + } // Reverse Initial Permutation + + utils.rip(l, r, out, off); + }; + + /***/ + }, + + /***/ "./node_modules/des.js/lib/des/ede.js": + /* !********************************************!*\ + !*** ./node_modules/des.js/lib/des/ede.js ***! + \********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var des = __webpack_require__( + /* ! ../des */ "./node_modules/des.js/lib/des.js" + ); + + var Cipher = des.Cipher; + var DES = des.DES; + + function EDEState(type, key) { + assert.equal(key.length, 24, "Invalid key length"); + var k1 = key.slice(0, 8); + var k2 = key.slice(8, 16); + var k3 = key.slice(16, 24); + + if (type === "encrypt") { + this.ciphers = [ + DES.create({ + type: "encrypt", + key: k1, + }), + DES.create({ + type: "decrypt", + key: k2, + }), + DES.create({ + type: "encrypt", + key: k3, + }), + ]; + } else { + this.ciphers = [ + DES.create({ + type: "decrypt", + key: k3, + }), + DES.create({ + type: "encrypt", + key: k2, + }), + DES.create({ + type: "decrypt", + key: k1, + }), + ]; + } + } + + function EDE(options) { + Cipher.call(this, options); + var state = new EDEState(this.type, this.options.key); + this._edeState = state; + } + + inherits(EDE, Cipher); + module.exports = EDE; + + EDE.create = function create(options) { + return new EDE(options); + }; + + EDE.prototype._update = function _update(inp, inOff, out, outOff) { + var state = this._edeState; + + state.ciphers[0]._update(inp, inOff, out, outOff); + + state.ciphers[1]._update(out, outOff, out, outOff); + + state.ciphers[2]._update(out, outOff, out, outOff); + }; + + EDE.prototype._pad = DES.prototype._pad; + EDE.prototype._unpad = DES.prototype._unpad; + + /***/ + }, + + /***/ "./node_modules/des.js/lib/des/utils.js": + /* !**********************************************!*\ + !*** ./node_modules/des.js/lib/des/utils.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + exports.readUInt32BE = function readUInt32BE(bytes, off) { + var res = + (bytes[0 + off] << 24) | + (bytes[1 + off] << 16) | + (bytes[2 + off] << 8) | + bytes[3 + off]; + return res >>> 0; + }; + + exports.writeUInt32BE = function writeUInt32BE(bytes, value, off) { + bytes[0 + off] = value >>> 24; + bytes[1 + off] = (value >>> 16) & 0xff; + bytes[2 + off] = (value >>> 8) & 0xff; + bytes[3 + off] = value & 0xff; + }; + + exports.ip = function ip(inL, inR, out, off) { + var outL = 0; + var outR = 0; + + for (var i = 6; i >= 0; i -= 2) { + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= (inR >>> (j + i)) & 1; + } + + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= (inL >>> (j + i)) & 1; + } + } + + for (var i = 6; i >= 0; i -= 2) { + for (var j = 1; j <= 25; j += 8) { + outR <<= 1; + outR |= (inR >>> (j + i)) & 1; + } + + for (var j = 1; j <= 25; j += 8) { + outR <<= 1; + outR |= (inL >>> (j + i)) & 1; + } + } + + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + + exports.rip = function rip(inL, inR, out, off) { + var outL = 0; + var outR = 0; + + for (var i = 0; i < 4; i++) { + for (var j = 24; j >= 0; j -= 8) { + outL <<= 1; + outL |= (inR >>> (j + i)) & 1; + outL <<= 1; + outL |= (inL >>> (j + i)) & 1; + } + } + + for (var i = 4; i < 8; i++) { + for (var j = 24; j >= 0; j -= 8) { + outR <<= 1; + outR |= (inR >>> (j + i)) & 1; + outR <<= 1; + outR |= (inL >>> (j + i)) & 1; + } + } + + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + + exports.pc1 = function pc1(inL, inR, out, off) { + var outL = 0; + var outR = 0; // 7, 15, 23, 31, 39, 47, 55, 63 + // 6, 14, 22, 30, 39, 47, 55, 63 + // 5, 13, 21, 29, 39, 47, 55, 63 + // 4, 12, 20, 28 + + for (var i = 7; i >= 5; i--) { + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= (inR >> (j + i)) & 1; + } + + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= (inL >> (j + i)) & 1; + } + } + + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= (inR >> (j + i)) & 1; + } // 1, 9, 17, 25, 33, 41, 49, 57 + // 2, 10, 18, 26, 34, 42, 50, 58 + // 3, 11, 19, 27, 35, 43, 51, 59 + // 36, 44, 52, 60 + + for (var i = 1; i <= 3; i++) { + for (var j = 0; j <= 24; j += 8) { + outR <<= 1; + outR |= (inR >> (j + i)) & 1; + } + + for (var j = 0; j <= 24; j += 8) { + outR <<= 1; + outR |= (inL >> (j + i)) & 1; + } + } + + for (var j = 0; j <= 24; j += 8) { + outR <<= 1; + outR |= (inL >> (j + i)) & 1; + } + + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + + exports.r28shl = function r28shl(num, shift) { + return ((num << shift) & 0xfffffff) | (num >>> (28 - shift)); + }; + + var pc2table = [ + // InL => outL + 14, + 11, + 17, + 4, + 27, + 23, + 25, + 0, + 13, + 22, + 7, + 18, + 5, + 9, + 16, + 24, + 2, + 20, + 12, + 21, + 1, + 8, + 15, + 26, // InR => outR + 15, + 4, + 25, + 19, + 9, + 1, + 26, + 16, + 5, + 11, + 23, + 8, + 12, + 7, + 17, + 0, + 22, + 3, + 10, + 14, + 6, + 20, + 27, + 24, + ]; + + exports.pc2 = function pc2(inL, inR, out, off) { + var outL = 0; + var outR = 0; + var len = pc2table.length >>> 1; + + for (var i = 0; i < len; i++) { + outL <<= 1; + outL |= (inL >>> pc2table[i]) & 0x1; + } + + for (var i = len; i < pc2table.length; i++) { + outR <<= 1; + outR |= (inR >>> pc2table[i]) & 0x1; + } + + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + + exports.expand = function expand(r, out, off) { + var outL = 0; + var outR = 0; + outL = ((r & 1) << 5) | (r >>> 27); + + for (var i = 23; i >= 15; i -= 4) { + outL <<= 6; + outL |= (r >>> i) & 0x3f; + } + + for (var i = 11; i >= 3; i -= 4) { + outR |= (r >>> i) & 0x3f; + outR <<= 6; + } + + outR |= ((r & 0x1f) << 1) | (r >>> 31); + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + + var sTable = [ + 14, + 0, + 4, + 15, + 13, + 7, + 1, + 4, + 2, + 14, + 15, + 2, + 11, + 13, + 8, + 1, + 3, + 10, + 10, + 6, + 6, + 12, + 12, + 11, + 5, + 9, + 9, + 5, + 0, + 3, + 7, + 8, + 4, + 15, + 1, + 12, + 14, + 8, + 8, + 2, + 13, + 4, + 6, + 9, + 2, + 1, + 11, + 7, + 15, + 5, + 12, + 11, + 9, + 3, + 7, + 14, + 3, + 10, + 10, + 0, + 5, + 6, + 0, + 13, + 15, + 3, + 1, + 13, + 8, + 4, + 14, + 7, + 6, + 15, + 11, + 2, + 3, + 8, + 4, + 14, + 9, + 12, + 7, + 0, + 2, + 1, + 13, + 10, + 12, + 6, + 0, + 9, + 5, + 11, + 10, + 5, + 0, + 13, + 14, + 8, + 7, + 10, + 11, + 1, + 10, + 3, + 4, + 15, + 13, + 4, + 1, + 2, + 5, + 11, + 8, + 6, + 12, + 7, + 6, + 12, + 9, + 0, + 3, + 5, + 2, + 14, + 15, + 9, + 10, + 13, + 0, + 7, + 9, + 0, + 14, + 9, + 6, + 3, + 3, + 4, + 15, + 6, + 5, + 10, + 1, + 2, + 13, + 8, + 12, + 5, + 7, + 14, + 11, + 12, + 4, + 11, + 2, + 15, + 8, + 1, + 13, + 1, + 6, + 10, + 4, + 13, + 9, + 0, + 8, + 6, + 15, + 9, + 3, + 8, + 0, + 7, + 11, + 4, + 1, + 15, + 2, + 14, + 12, + 3, + 5, + 11, + 10, + 5, + 14, + 2, + 7, + 12, + 7, + 13, + 13, + 8, + 14, + 11, + 3, + 5, + 0, + 6, + 6, + 15, + 9, + 0, + 10, + 3, + 1, + 4, + 2, + 7, + 8, + 2, + 5, + 12, + 11, + 1, + 12, + 10, + 4, + 14, + 15, + 9, + 10, + 3, + 6, + 15, + 9, + 0, + 0, + 6, + 12, + 10, + 11, + 1, + 7, + 13, + 13, + 8, + 15, + 9, + 1, + 4, + 3, + 5, + 14, + 11, + 5, + 12, + 2, + 7, + 8, + 2, + 4, + 14, + 2, + 14, + 12, + 11, + 4, + 2, + 1, + 12, + 7, + 4, + 10, + 7, + 11, + 13, + 6, + 1, + 8, + 5, + 5, + 0, + 3, + 15, + 15, + 10, + 13, + 3, + 0, + 9, + 14, + 8, + 9, + 6, + 4, + 11, + 2, + 8, + 1, + 12, + 11, + 7, + 10, + 1, + 13, + 14, + 7, + 2, + 8, + 13, + 15, + 6, + 9, + 15, + 12, + 0, + 5, + 9, + 6, + 10, + 3, + 4, + 0, + 5, + 14, + 3, + 12, + 10, + 1, + 15, + 10, + 4, + 15, + 2, + 9, + 7, + 2, + 12, + 6, + 9, + 8, + 5, + 0, + 6, + 13, + 1, + 3, + 13, + 4, + 14, + 14, + 0, + 7, + 11, + 5, + 3, + 11, + 8, + 9, + 4, + 14, + 3, + 15, + 2, + 5, + 12, + 2, + 9, + 8, + 5, + 12, + 15, + 3, + 10, + 7, + 11, + 0, + 14, + 4, + 1, + 10, + 7, + 1, + 6, + 13, + 0, + 11, + 8, + 6, + 13, + 4, + 13, + 11, + 0, + 2, + 11, + 14, + 7, + 15, + 4, + 0, + 9, + 8, + 1, + 13, + 10, + 3, + 14, + 12, + 3, + 9, + 5, + 7, + 12, + 5, + 2, + 10, + 15, + 6, + 8, + 1, + 6, + 1, + 6, + 4, + 11, + 11, + 13, + 13, + 8, + 12, + 1, + 3, + 4, + 7, + 10, + 14, + 7, + 10, + 9, + 15, + 5, + 6, + 0, + 8, + 15, + 0, + 14, + 5, + 2, + 9, + 3, + 2, + 12, + 13, + 1, + 2, + 15, + 8, + 13, + 4, + 8, + 6, + 10, + 15, + 3, + 11, + 7, + 1, + 4, + 10, + 12, + 9, + 5, + 3, + 6, + 14, + 11, + 5, + 0, + 0, + 14, + 12, + 9, + 7, + 2, + 7, + 2, + 11, + 1, + 4, + 14, + 1, + 7, + 9, + 4, + 12, + 10, + 14, + 8, + 2, + 13, + 0, + 15, + 6, + 12, + 10, + 9, + 13, + 0, + 15, + 3, + 3, + 5, + 5, + 6, + 8, + 11, + ]; + + exports.substitute = function substitute(inL, inR) { + var out = 0; + + for (var i = 0; i < 4; i++) { + var b = (inL >>> (18 - i * 6)) & 0x3f; + var sb = sTable[i * 0x40 + b]; + out <<= 4; + out |= sb; + } + + for (var i = 0; i < 4; i++) { + var b = (inR >>> (18 - i * 6)) & 0x3f; + var sb = sTable[4 * 0x40 + i * 0x40 + b]; + out <<= 4; + out |= sb; + } + + return out >>> 0; + }; + + var permuteTable = [ + 16, + 25, + 12, + 11, + 3, + 20, + 4, + 15, + 31, + 17, + 9, + 6, + 27, + 14, + 1, + 22, + 30, + 24, + 8, + 18, + 0, + 5, + 29, + 23, + 13, + 19, + 2, + 26, + 10, + 21, + 28, + 7, + ]; + + exports.permute = function permute(num) { + var out = 0; + + for (var i = 0; i < permuteTable.length; i++) { + out <<= 1; + out |= (num >>> permuteTable[i]) & 0x1; + } + + return out >>> 0; + }; + + exports.padSplit = function padSplit(num, size, group) { + var str = num.toString(2); + + while (str.length < size) { + str = "0" + str; + } + + var out = []; + + for (var i = 0; i < size; i += group) { + out.push(str.slice(i, i + group)); + } + + return out.join(" "); + }; + + /***/ + }, + + /***/ "./node_modules/diffie-hellman/browser.js": + /* !************************************************!*\ + !*** ./node_modules/diffie-hellman/browser.js ***! + \************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + var generatePrime = __webpack_require__( + /* ! ./lib/generatePrime */ "./node_modules/diffie-hellman/lib/generatePrime.js" + ); + + var primes = __webpack_require__( + /* ! ./lib/primes.json */ "./node_modules/diffie-hellman/lib/primes.json" + ); + + var DH = __webpack_require__( + /* ! ./lib/dh */ "./node_modules/diffie-hellman/lib/dh.js" + ); + + function getDiffieHellman(mod) { + var prime = new Buffer(primes[mod].prime, "hex"); + var gen = new Buffer(primes[mod].gen, "hex"); + return new DH(prime, gen); + } + + var ENCODINGS = { + binary: true, + hex: true, + base64: true, + }; + + function createDiffieHellman(prime, enc, generator, genc) { + if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) { + return createDiffieHellman( + prime, + "binary", + enc, + generator + ); + } + + enc = enc || "binary"; + genc = genc || "binary"; + generator = generator || new Buffer([2]); + + if (!Buffer.isBuffer(generator)) { + generator = new Buffer(generator, genc); + } + + if (typeof prime === "number") { + return new DH( + generatePrime(prime, generator), + generator, + true + ); + } + + if (!Buffer.isBuffer(prime)) { + prime = new Buffer(prime, enc); + } + + return new DH(prime, generator, true); + } + + exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman; + exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman; + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/diffie-hellman/lib/dh.js": + /* !***********************************************!*\ + !*** ./node_modules/diffie-hellman/lib/dh.js ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (Buffer) { + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var MillerRabin = __webpack_require__( + /* ! miller-rabin */ "./node_modules/miller-rabin/lib/mr.js" + ); + + var millerRabin = new MillerRabin(); + var TWENTYFOUR = new BN(24); + var ELEVEN = new BN(11); + var TEN = new BN(10); + var THREE = new BN(3); + var SEVEN = new BN(7); + + var primes = __webpack_require__( + /* ! ./generatePrime */ "./node_modules/diffie-hellman/lib/generatePrime.js" + ); + + var randomBytes = __webpack_require__( + /* ! randombytes */ "./node_modules/randombytes/browser.js" + ); + + module.exports = DH; + + function setPublicKey(pub, enc) { + enc = enc || "utf8"; + + if (!Buffer.isBuffer(pub)) { + pub = new Buffer(pub, enc); + } + + this._pub = new BN(pub); + return this; + } + + function setPrivateKey(priv, enc) { + enc = enc || "utf8"; + + if (!Buffer.isBuffer(priv)) { + priv = new Buffer(priv, enc); + } + + this._priv = new BN(priv); + return this; + } + + var primeCache = {}; + + function checkPrime(prime, generator) { + var gen = generator.toString("hex"); + var hex = [gen, prime.toString(16)].join("_"); + + if (hex in primeCache) { + return primeCache[hex]; + } + + var error = 0; + + if ( + prime.isEven() || + !primes.simpleSieve || + !primes.fermatTest(prime) || + !millerRabin.test(prime) + ) { + // Not a prime so +1 + error += 1; + + if (gen === "02" || gen === "05") { + // We'd be able to check the generator + // it would fail so +8 + error += 8; + } else { + // We wouldn't be able to test the generator + // so +4 + error += 4; + } + + primeCache[hex] = error; + return error; + } + + if (!millerRabin.test(prime.shrn(1))) { + // Not a safe prime + error += 2; + } + + var rem; + + switch (gen) { + case "02": + if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) { + // Unsuidable generator + error += 8; + } + + break; + + case "05": + rem = prime.mod(TEN); + + if (rem.cmp(THREE) && rem.cmp(SEVEN)) { + // Prime mod 10 needs to equal 3 or 7 + error += 8; + } + + break; + + default: + error += 4; + } + + primeCache[hex] = error; + return error; + } + + function DH(prime, generator, malleable) { + this.setGenerator(generator); + this.__prime = new BN(prime); + this._prime = BN.mont(this.__prime); + this._primeLen = prime.length; + this._pub = undefined; + this._priv = undefined; + this._primeCode = undefined; + + if (malleable) { + this.setPublicKey = setPublicKey; + this.setPrivateKey = setPrivateKey; + } else { + this._primeCode = 8; + } + } + + Object.defineProperty(DH.prototype, "verifyError", { + enumerable: true, + get: function get() { + if (typeof this._primeCode !== "number") { + this._primeCode = checkPrime( + this.__prime, + this.__gen + ); + } + + return this._primeCode; + }, + }); + + DH.prototype.generateKeys = function () { + if (!this._priv) { + this._priv = new BN(randomBytes(this._primeLen)); + } + + this._pub = this._gen + .toRed(this._prime) + .redPow(this._priv) + .fromRed(); + return this.getPublicKey(); + }; + + DH.prototype.computeSecret = function (other) { + other = new BN(other); + other = other.toRed(this._prime); + var secret = other.redPow(this._priv).fromRed(); + var out = new Buffer(secret.toArray()); + var prime = this.getPrime(); + + if (out.length < prime.length) { + var front = new Buffer(prime.length - out.length); + front.fill(0); + out = Buffer.concat([front, out]); + } + + return out; + }; + + DH.prototype.getPublicKey = function getPublicKey(enc) { + return formatReturnValue(this._pub, enc); + }; + + DH.prototype.getPrivateKey = function getPrivateKey(enc) { + return formatReturnValue(this._priv, enc); + }; + + DH.prototype.getPrime = function (enc) { + return formatReturnValue(this.__prime, enc); + }; + + DH.prototype.getGenerator = function (enc) { + return formatReturnValue(this._gen, enc); + }; + + DH.prototype.setGenerator = function (gen, enc) { + enc = enc || "utf8"; + + if (!Buffer.isBuffer(gen)) { + gen = new Buffer(gen, enc); + } + + this.__gen = gen; + this._gen = new BN(gen); + return this; + }; + + function formatReturnValue(bn, enc) { + var buf = new Buffer(bn.toArray()); + + if (!enc) { + return buf; + } + return buf.toString(enc); + + } + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../../buffer/index.js */ "./node_modules/buffer/index.js" + ).Buffer + )); + + /***/ + }, + + /***/ "./node_modules/diffie-hellman/lib/generatePrime.js": + /* !**********************************************************!*\ + !*** ./node_modules/diffie-hellman/lib/generatePrime.js ***! + \**********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var randomBytes = __webpack_require__( + /* ! randombytes */ "./node_modules/randombytes/browser.js" + ); + + module.exports = findPrime; + findPrime.simpleSieve = simpleSieve; + findPrime.fermatTest = fermatTest; + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var TWENTYFOUR = new BN(24); + + var MillerRabin = __webpack_require__( + /* ! miller-rabin */ "./node_modules/miller-rabin/lib/mr.js" + ); + + var millerRabin = new MillerRabin(); + var ONE = new BN(1); + var TWO = new BN(2); + var FIVE = new BN(5); + var SIXTEEN = new BN(16); + var EIGHT = new BN(8); + var TEN = new BN(10); + var THREE = new BN(3); + var SEVEN = new BN(7); + var ELEVEN = new BN(11); + var FOUR = new BN(4); + var TWELVE = new BN(12); + var primes = null; + + function _getPrimes() { + if (primes !== null) return primes; + var limit = 0x100000; + var res = []; + res[0] = 2; + + for (var i = 1, k = 3; k < limit; k += 2) { + var sqrt = Math.ceil(Math.sqrt(k)); + + for (var j = 0; j < i && res[j] <= sqrt; j++) { + if (k % res[j] === 0) break; + } + + if (i !== j && res[j] <= sqrt) continue; + res[i++] = k; + } + + primes = res; + return res; + } + + function simpleSieve(p) { + var primes = _getPrimes(); + + for (var i = 0; i < primes.length; i++) { + if (p.modn(primes[i]) === 0) { + if (p.cmpn(primes[i]) === 0) { + return true; + } + return false; + + } + } + + return true; + } + + function fermatTest(p) { + var red = BN.mont(p); + return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0; + } + + function findPrime(bits, gen) { + if (bits < 16) { + // This is what openssl does + if (gen === 2 || gen === 5) { + return new BN([0x8c, 0x7b]); + } + return new BN([0x8c, 0x27]); + + } + + gen = new BN(gen); + var num, n2; + + while (true) { + num = new BN(randomBytes(Math.ceil(bits / 8))); + + while (num.bitLength() > bits) { + num.ishrn(1); + } + + if (num.isEven()) { + num.iadd(ONE); + } + + if (!num.testn(1)) { + num.iadd(TWO); + } + + if (!gen.cmp(TWO)) { + while (num.mod(TWENTYFOUR).cmp(ELEVEN)) { + num.iadd(FOUR); + } + } else if (!gen.cmp(FIVE)) { + while (num.mod(TEN).cmp(THREE)) { + num.iadd(FOUR); + } + } + + n2 = num.shrn(1); + + if ( + simpleSieve(n2) && + simpleSieve(num) && + fermatTest(n2) && + fermatTest(num) && + millerRabin.test(n2) && + millerRabin.test(num) + ) { + return num; + } + } + } + + /***/ + }, + + /***/ "./node_modules/diffie-hellman/lib/primes.json": + /* !*****************************************************!*\ + !*** ./node_modules/diffie-hellman/lib/primes.json ***! + \*****************************************************/ + /* ! exports provided: modp1, modp2, modp5, modp14, modp15, modp16, modp17, modp18, default */ + /***/ function (module) { + module.exports = JSON.parse( + '{"modp1":{"gen":"02","prime":"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff"},"modp2":{"gen":"02","prime":"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff"},"modp5":{"gen":"02","prime":"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff"},"modp14":{"gen":"02","prime":"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff"},"modp15":{"gen":"02","prime":"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff"},"modp16":{"gen":"02","prime":"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff"},"modp17":{"gen":"02","prime":"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff"},"modp18":{"gen":"02","prime":"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dbe115974a3926f12fee5e438777cb6a932df8cd8bec4d073b931ba3bc832b68d9dd300741fa7bf8afc47ed2576f6936ba424663aab639c5ae4f5683423b4742bf1c978238f16cbe39d652de3fdb8befc848ad922222e04a4037c0713eb57a81a23f0c73473fc646cea306b4bcbc8862f8385ddfa9d4b7fa2c087e879683303ed5bdd3a062b3cf5b3a278a66d2a13f83f44f82ddf310ee074ab6a364597e899a0255dc164f31cc50846851df9ab48195ded7ea1b1d510bd7ee74d73faf36bc31ecfa268359046f4eb879f924009438b481c6cd7889a002ed5ee382bc9190da6fc026e479558e4475677e9aa9e3050e2765694dfc81f56e880b96e7160c980dd98edd3dfffffffffffffffff"}}' + ); + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic.js": + /* !***********************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic.js ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var elliptic = exports; + elliptic.version = __webpack_require__( + /* ! ../package.json */ "./node_modules/elliptic/package.json" + ).version; + elliptic.utils = __webpack_require__( + /* ! ./elliptic/utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + elliptic.rand = __webpack_require__( + /* ! brorand */ "./node_modules/brorand/index.js" + ); + elliptic.curve = __webpack_require__( + /* ! ./elliptic/curve */ "./node_modules/elliptic/lib/elliptic/curve/index.js" + ); + elliptic.curves = __webpack_require__( + /* ! ./elliptic/curves */ "./node_modules/elliptic/lib/elliptic/curves.js" + ); // Protocols + + elliptic.ec = __webpack_require__( + /* ! ./elliptic/ec */ "./node_modules/elliptic/lib/elliptic/ec/index.js" + ); + elliptic.eddsa = __webpack_require__( + /* ! ./elliptic/eddsa */ "./node_modules/elliptic/lib/elliptic/eddsa/index.js" + ); + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/curve/base.js": + /* !**********************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/curve/base.js ***! + \**********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var getNAF = utils.getNAF; + var getJSF = utils.getJSF; + var assert = utils.assert; + + function BaseCurve(type, conf) { + this.type = type; + this.p = new BN(conf.p, 16); // Use Montgomery, when there is no fast reduction for the prime + + this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p); // Useful for many curves + + this.zero = new BN(0).toRed(this.red); + this.one = new BN(1).toRed(this.red); + this.two = new BN(2).toRed(this.red); // Curve configuration, optional + + this.n = conf.n && new BN(conf.n, 16); + this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed); // Temporary arrays + + this._wnafT1 = new Array(4); + this._wnafT2 = new Array(4); + this._wnafT3 = new Array(4); + this._wnafT4 = new Array(4); // Generalized Greg Maxwell's trick + + var adjustCount = this.n && this.p.div(this.n); + + if (!adjustCount || adjustCount.cmpn(100) > 0) { + this.redN = null; + } else { + this._maxwellTrick = true; + this.redN = this.n.toRed(this.red); + } + } + + module.exports = BaseCurve; + + BaseCurve.prototype.point = function point() { + throw new Error("Not implemented"); + }; + + BaseCurve.prototype.validate = function validate() { + throw new Error("Not implemented"); + }; + + BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) { + assert(p.precomputed); + + var doubles = p._getDoubles(); + + var naf = getNAF(k, 1); + var I = + (1 << (doubles.step + 1)) - + (doubles.step % 2 === 0 ? 2 : 1); + I /= 3; // Translate into more windowed form + + var repr = []; + + for (var j = 0; j < naf.length; j += doubles.step) { + var nafW = 0; + + for (var k = j + doubles.step - 1; k >= j; k--) { + nafW = (nafW << 1) + naf[k]; + } + + repr.push(nafW); + } + + var a = this.jpoint(null, null, null); + var b = this.jpoint(null, null, null); + + for (var i = I; i > 0; i--) { + for (var j = 0; j < repr.length; j++) { + var nafW = repr[j]; + if (nafW === i) b = b.mixedAdd(doubles.points[j]); + else if (nafW === -i) + b = b.mixedAdd(doubles.points[j].neg()); + } + + a = a.add(b); + } + + return a.toP(); + }; + + BaseCurve.prototype._wnafMul = function _wnafMul(p, k) { + var w = 4; // Precompute window + + var nafPoints = p._getNAFPoints(w); + + w = nafPoints.wnd; + var wnd = nafPoints.points; // Get NAF form + + var naf = getNAF(k, w); // Add `this`*(N+1) for every w-NAF index + + var acc = this.jpoint(null, null, null); + + for (var i = naf.length - 1; i >= 0; i--) { + // Count zeroes + for (var k = 0; i >= 0 && naf[i] === 0; i--) { + k++; + } + + if (i >= 0) k++; + acc = acc.dblp(k); + if (i < 0) break; + var z = naf[i]; + assert(z !== 0); + + if (p.type === "affine") { + // J +- P + if (z > 0) acc = acc.mixedAdd(wnd[(z - 1) >> 1]); + else acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg()); + } else { + // J +- J + if (z > 0) acc = acc.add(wnd[(z - 1) >> 1]); + else acc = acc.add(wnd[(-z - 1) >> 1].neg()); + } + } + + return p.type === "affine" ? acc.toP() : acc; + }; + + BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd( + defW, + points, + coeffs, + len, + jacobianResult + ) { + var wndWidth = this._wnafT1; + var wnd = this._wnafT2; + var naf = this._wnafT3; // Fill all arrays + + var max = 0; + + for (var i = 0; i < len; i++) { + var p = points[i]; + + var nafPoints = p._getNAFPoints(defW); + + wndWidth[i] = nafPoints.wnd; + wnd[i] = nafPoints.points; + } // Comb small window NAFs + + for (var i = len - 1; i >= 1; i -= 2) { + var a = i - 1; + var b = i; + + if (wndWidth[a] !== 1 || wndWidth[b] !== 1) { + naf[a] = getNAF(coeffs[a], wndWidth[a]); + naf[b] = getNAF(coeffs[b], wndWidth[b]); + max = Math.max(naf[a].length, max); + max = Math.max(naf[b].length, max); + continue; + } + + var comb = [ + points[a], + /* 1 */ + null, + /* 3 */ + null, + /* 5 */ + points[b], + /* 7 */ + ]; // Try to avoid Projective points, if possible + + if (points[a].y.cmp(points[b].y) === 0) { + comb[1] = points[a].add(points[b]); + comb[2] = points[a].toJ().mixedAdd(points[b].neg()); + } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) { + comb[1] = points[a].toJ().mixedAdd(points[b]); + comb[2] = points[a].add(points[b].neg()); + } else { + comb[1] = points[a].toJ().mixedAdd(points[b]); + comb[2] = points[a].toJ().mixedAdd(points[b].neg()); + } + + var index = [ + -3, + /* -1 -1 */ + -1, + /* -1 0 */ + -5, + /* -1 1 */ + -7, + /* 0 -1 */ + 0, + /* 0 0 */ + 7, + /* 0 1 */ + 5, + /* 1 -1 */ + 1, + /* 1 0 */ + 3, + /* 1 1 */ + ]; + var jsf = getJSF(coeffs[a], coeffs[b]); + max = Math.max(jsf[0].length, max); + naf[a] = new Array(max); + naf[b] = new Array(max); + + for (var j = 0; j < max; j++) { + var ja = jsf[0][j] | 0; + var jb = jsf[1][j] | 0; + naf[a][j] = index[(ja + 1) * 3 + (jb + 1)]; + naf[b][j] = 0; + wnd[a] = comb; + } + } + + var acc = this.jpoint(null, null, null); + var tmp = this._wnafT4; + + for (var i = max; i >= 0; i--) { + var k = 0; + + while (i >= 0) { + var zero = true; + + for (var j = 0; j < len; j++) { + tmp[j] = naf[j][i] | 0; + if (tmp[j] !== 0) zero = false; + } + + if (!zero) break; + k++; + i--; + } + + if (i >= 0) k++; + acc = acc.dblp(k); + if (i < 0) break; + + for (var j = 0; j < len; j++) { + var z = tmp[j]; + var p; + if (z === 0) continue; + else if (z > 0) p = wnd[j][(z - 1) >> 1]; + else if (z < 0) p = wnd[j][(-z - 1) >> 1].neg(); + if (p.type === "affine") acc = acc.mixedAdd(p); + else acc = acc.add(p); + } + } // Zeroify references + + for (var i = 0; i < len; i++) { + wnd[i] = null; + } + + if (jacobianResult) return acc; + return acc.toP(); + }; + + function BasePoint(curve, type) { + this.curve = curve; + this.type = type; + this.precomputed = null; + } + + BaseCurve.BasePoint = BasePoint; + + BasePoint.prototype.eq = function eq() /* Other*/ + { + throw new Error("Not implemented"); + }; + + BasePoint.prototype.validate = function validate() { + return this.curve.validate(this); + }; + + BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) { + bytes = utils.toArray(bytes, enc); + var len = this.p.byteLength(); // Uncompressed, hybrid-odd, hybrid-even + + if ( + (bytes[0] === 0x04 || + bytes[0] === 0x06 || + bytes[0] === 0x07) && + bytes.length - 1 === 2 * len + ) { + if (bytes[0] === 0x06) + assert(bytes[bytes.length - 1] % 2 === 0); + else if (bytes[0] === 0x07) + assert(bytes[bytes.length - 1] % 2 === 1); + var res = this.point( + bytes.slice(1, 1 + len), + bytes.slice(1 + len, 1 + 2 * len) + ); + return res; + } else if ( + (bytes[0] === 0x02 || bytes[0] === 0x03) && + bytes.length - 1 === len + ) { + return this.pointFromX( + bytes.slice(1, 1 + len), + bytes[0] === 0x03 + ); + } + + throw new Error("Unknown point format"); + }; + + BasePoint.prototype.encodeCompressed = function encodeCompressed( + enc + ) { + return this.encode(enc, true); + }; + + BasePoint.prototype._encode = function _encode(compact) { + var len = this.curve.p.byteLength(); + var x = this.getX().toArray("be", len); + if (compact) + return [this.getY().isEven() ? 0x02 : 0x03].concat(x); + return [0x04].concat(x, this.getY().toArray("be", len)); + }; + + BasePoint.prototype.encode = function encode(enc, compact) { + return utils.encode(this._encode(compact), enc); + }; + + BasePoint.prototype.precompute = function precompute(power) { + if (this.precomputed) return this; + var precomputed = { + doubles: null, + naf: null, + beta: null, + }; + precomputed.naf = this._getNAFPoints(8); + precomputed.doubles = this._getDoubles(4, power); + precomputed.beta = this._getBeta(); + this.precomputed = precomputed; + return this; + }; + + BasePoint.prototype._hasDoubles = function _hasDoubles(k) { + if (!this.precomputed) return false; + var doubles = this.precomputed.doubles; + if (!doubles) return false; + return ( + doubles.points.length >= + Math.ceil((k.bitLength() + 1) / doubles.step) + ); + }; + + BasePoint.prototype._getDoubles = function _getDoubles( + step, + power + ) { + if (this.precomputed && this.precomputed.doubles) + return this.precomputed.doubles; + var doubles = [this]; + var acc = this; + + for (var i = 0; i < power; i += step) { + for (var j = 0; j < step; j++) { + acc = acc.dbl(); + } + + doubles.push(acc); + } + + return { + step: step, + points: doubles, + }; + }; + + BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) { + if (this.precomputed && this.precomputed.naf) + return this.precomputed.naf; + var res = [this]; + var max = (1 << wnd) - 1; + var dbl = max === 1 ? null : this.dbl(); + + for (var i = 1; i < max; i++) { + res[i] = res[i - 1].add(dbl); + } + + return { + wnd: wnd, + points: res, + }; + }; + + BasePoint.prototype._getBeta = function _getBeta() { + return null; + }; + + BasePoint.prototype.dblp = function dblp(k) { + var r = this; + + for (var i = 0; i < k; i++) { + r = r.dbl(); + } + + return r; + }; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/curve/edwards.js": + /* !*************************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/curve/edwards.js ***! + \*************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Base = __webpack_require__( + /* ! ./base */ "./node_modules/elliptic/lib/elliptic/curve/base.js" + ); + + var assert = utils.assert; + + function EdwardsCurve(conf) { + // NOTE: Important as we are creating point in Base.call() + this.twisted = (conf.a | 0) !== 1; + this.mOneA = this.twisted && (conf.a | 0) === -1; + this.extended = this.mOneA; + Base.call(this, "edwards", conf); + this.a = new BN(conf.a, 16).umod(this.red.m); + this.a = this.a.toRed(this.red); + this.c = new BN(conf.c, 16).toRed(this.red); + this.c2 = this.c.redSqr(); + this.d = new BN(conf.d, 16).toRed(this.red); + this.dd = this.d.redAdd(this.d); + assert(!this.twisted || this.c.fromRed().cmpn(1) === 0); + this.oneC = (conf.c | 0) === 1; + } + + inherits(EdwardsCurve, Base); + module.exports = EdwardsCurve; + + EdwardsCurve.prototype._mulA = function _mulA(num) { + if (this.mOneA) return num.redNeg(); + return this.a.redMul(num); + }; + + EdwardsCurve.prototype._mulC = function _mulC(num) { + if (this.oneC) return num; + return this.c.redMul(num); + }; // Just for compatibility with Short curve + + EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) { + return this.point(x, y, z, t); + }; + + EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) { + x = new BN(x, 16); + if (!x.red) x = x.toRed(this.red); + var x2 = x.redSqr(); + var rhs = this.c2.redSub(this.a.redMul(x2)); + var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2)); + var y2 = rhs.redMul(lhs.redInvm()); + var y = y2.redSqrt(); + if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) + throw new Error("invalid point"); + var isOdd = y.fromRed().isOdd(); + if ((odd && !isOdd) || (!odd && isOdd)) y = y.redNeg(); + return this.point(x, y); + }; + + EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) { + y = new BN(y, 16); + if (!y.red) y = y.toRed(this.red); // X^2 = (y^2 - c^2) / (c^2 d y^2 - a) + + var y2 = y.redSqr(); + var lhs = y2.redSub(this.c2); + var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a); + var x2 = lhs.redMul(rhs.redInvm()); + + if (x2.cmp(this.zero) === 0) { + if (odd) throw new Error("invalid point"); + else return this.point(this.zero, y); + } + + var x = x2.redSqrt(); + if (x.redSqr().redSub(x2).cmp(this.zero) !== 0) + throw new Error("invalid point"); + if (x.fromRed().isOdd() !== odd) x = x.redNeg(); + return this.point(x, y); + }; + + EdwardsCurve.prototype.validate = function validate(point) { + if (point.isInfinity()) return true; // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2) + + point.normalize(); + var x2 = point.x.redSqr(); + var y2 = point.y.redSqr(); + var lhs = x2.redMul(this.a).redAdd(y2); + var rhs = this.c2.redMul( + this.one.redAdd(this.d.redMul(x2).redMul(y2)) + ); + return lhs.cmp(rhs) === 0; + }; + + function Point(curve, x, y, z, t) { + Base.BasePoint.call(this, curve, "projective"); + + if (x === null && y === null && z === null) { + this.x = this.curve.zero; + this.y = this.curve.one; + this.z = this.curve.one; + this.t = this.curve.zero; + this.zOne = true; + } else { + this.x = new BN(x, 16); + this.y = new BN(y, 16); + this.z = z ? new BN(z, 16) : this.curve.one; + this.t = t && new BN(t, 16); + if (!this.x.red) this.x = this.x.toRed(this.curve.red); + if (!this.y.red) this.y = this.y.toRed(this.curve.red); + if (!this.z.red) this.z = this.z.toRed(this.curve.red); + if (this.t && !this.t.red) + this.t = this.t.toRed(this.curve.red); + this.zOne = this.z === this.curve.one; // Use extended coordinates + + if (this.curve.extended && !this.t) { + this.t = this.x.redMul(this.y); + if (!this.zOne) + this.t = this.t.redMul(this.z.redInvm()); + } + } + } + + inherits(Point, Base.BasePoint); + + EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) { + return Point.fromJSON(this, obj); + }; + + EdwardsCurve.prototype.point = function point(x, y, z, t) { + return new Point(this, x, y, z, t); + }; + + Point.fromJSON = function fromJSON(curve, obj) { + return new Point(curve, obj[0], obj[1], obj[2]); + }; + + Point.prototype.inspect = function inspect() { + if (this.isInfinity()) return ""; + return ( + "" + ); + }; + + Point.prototype.isInfinity = function isInfinity() { + // XXX This code assumes that zero is always zero in red + return ( + this.x.cmpn(0) === 0 && + (this.y.cmp(this.z) === 0 || + (this.zOne && this.y.cmp(this.curve.c) === 0)) + ); + }; + + Point.prototype._extDbl = function _extDbl() { + // Hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html + // #doubling-dbl-2008-hwcd + // 4M + 4S + // A = X1^2 + var a = this.x.redSqr(); // B = Y1^2 + + var b = this.y.redSqr(); // C = 2 * Z1^2 + + var c = this.z.redSqr(); + c = c.redIAdd(c); // D = a * A + + var d = this.curve._mulA(a); // E = (X1 + Y1)^2 - A - B + + var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b); // G = D + B + + var g = d.redAdd(b); // F = G - C + + var f = g.redSub(c); // H = D - B + + var h = d.redSub(b); // X3 = E * F + + var nx = e.redMul(f); // Y3 = G * H + + var ny = g.redMul(h); // T3 = E * H + + var nt = e.redMul(h); // Z3 = F * G + + var nz = f.redMul(g); + return this.curve.point(nx, ny, nz, nt); + }; + + Point.prototype._projDbl = function _projDbl() { + // Hyperelliptic.org/EFD/g1p/auto-twisted-projective.html + // #doubling-dbl-2008-bbjlp + // #doubling-dbl-2007-bl + // and others + // Generally 3M + 4S or 2M + 4S + // B = (X1 + Y1)^2 + var b = this.x.redAdd(this.y).redSqr(); // C = X1^2 + + var c = this.x.redSqr(); // D = Y1^2 + + var d = this.y.redSqr(); + var nx; + var ny; + var nz; + + if (this.curve.twisted) { + // E = a * C + var e = this.curve._mulA(c); // F = E + D + + var f = e.redAdd(d); + + if (this.zOne) { + // X3 = (B - C - D) * (F - 2) + nx = b + .redSub(c) + .redSub(d) + .redMul(f.redSub(this.curve.two)); // Y3 = F * (E - D) + + ny = f.redMul(e.redSub(d)); // Z3 = F^2 - 2 * F + + nz = f.redSqr().redSub(f).redSub(f); + } else { + // H = Z1^2 + var h = this.z.redSqr(); // J = F - 2 * H + + var j = f.redSub(h).redISub(h); // X3 = (B-C-D)*J + + nx = b.redSub(c).redISub(d).redMul(j); // Y3 = F * (E - D) + + ny = f.redMul(e.redSub(d)); // Z3 = F * J + + nz = f.redMul(j); + } + } else { + // E = C + D + var e = c.redAdd(d); // H = (c * Z1)^2 + + var h = this.curve._mulC(this.z).redSqr(); // J = E - 2 * H + + var j = e.redSub(h).redSub(h); // X3 = c * (B - E) * J + + nx = this.curve._mulC(b.redISub(e)).redMul(j); // Y3 = c * E * (C - D) + + ny = this.curve._mulC(e).redMul(c.redISub(d)); // Z3 = E * J + + nz = e.redMul(j); + } + + return this.curve.point(nx, ny, nz); + }; + + Point.prototype.dbl = function dbl() { + if (this.isInfinity()) return this; // Double in extended coordinates + + if (this.curve.extended) return this._extDbl(); + return this._projDbl(); + }; + + Point.prototype._extAdd = function _extAdd(p) { + // Hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html + // #addition-add-2008-hwcd-3 + // 8M + // A = (Y1 - X1) * (Y2 - X2) + var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x)); // B = (Y1 + X1) * (Y2 + X2) + + var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x)); // C = T1 * k * T2 + + var c = this.t.redMul(this.curve.dd).redMul(p.t); // D = Z1 * 2 * Z2 + + var d = this.z.redMul(p.z.redAdd(p.z)); // E = B - A + + var e = b.redSub(a); // F = D - C + + var f = d.redSub(c); // G = D + C + + var g = d.redAdd(c); // H = B + A + + var h = b.redAdd(a); // X3 = E * F + + var nx = e.redMul(f); // Y3 = G * H + + var ny = g.redMul(h); // T3 = E * H + + var nt = e.redMul(h); // Z3 = F * G + + var nz = f.redMul(g); + return this.curve.point(nx, ny, nz, nt); + }; + + Point.prototype._projAdd = function _projAdd(p) { + // Hyperelliptic.org/EFD/g1p/auto-twisted-projective.html + // #addition-add-2008-bbjlp + // #addition-add-2007-bl + // 10M + 1S + // A = Z1 * Z2 + var a = this.z.redMul(p.z); // B = A^2 + + var b = a.redSqr(); // C = X1 * X2 + + var c = this.x.redMul(p.x); // D = Y1 * Y2 + + var d = this.y.redMul(p.y); // E = d * C * D + + var e = this.curve.d.redMul(c).redMul(d); // F = B - E + + var f = b.redSub(e); // G = B + E + + var g = b.redAdd(e); // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D) + + var tmp = this.x + .redAdd(this.y) + .redMul(p.x.redAdd(p.y)) + .redISub(c) + .redISub(d); + var nx = a.redMul(f).redMul(tmp); + var ny; + var nz; + + if (this.curve.twisted) { + // Y3 = A * G * (D - a * C) + ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c))); // Z3 = F * G + + nz = f.redMul(g); + } else { + // Y3 = A * G * (D - C) + ny = a.redMul(g).redMul(d.redSub(c)); // Z3 = c * F * G + + nz = this.curve._mulC(f).redMul(g); + } + + return this.curve.point(nx, ny, nz); + }; + + Point.prototype.add = function add(p) { + if (this.isInfinity()) return p; + if (p.isInfinity()) return this; + if (this.curve.extended) return this._extAdd(p); + return this._projAdd(p); + }; + + Point.prototype.mul = function mul(k) { + if (this._hasDoubles(k)) + return this.curve._fixedNafMul(this, k); + return this.curve._wnafMul(this, k); + }; + + Point.prototype.mulAdd = function mulAdd(k1, p, k2) { + return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false); + }; + + Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) { + return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true); + }; + + Point.prototype.normalize = function normalize() { + if (this.zOne) return this; // Normalize coordinates + + var zi = this.z.redInvm(); + this.x = this.x.redMul(zi); + this.y = this.y.redMul(zi); + if (this.t) this.t = this.t.redMul(zi); + this.z = this.curve.one; + this.zOne = true; + return this; + }; + + Point.prototype.neg = function neg() { + return this.curve.point( + this.x.redNeg(), + this.y, + this.z, + this.t && this.t.redNeg() + ); + }; + + Point.prototype.getX = function getX() { + this.normalize(); + return this.x.fromRed(); + }; + + Point.prototype.getY = function getY() { + this.normalize(); + return this.y.fromRed(); + }; + + Point.prototype.eq = function eq(other) { + return ( + this === other || + (this.getX().cmp(other.getX()) === 0 && + this.getY().cmp(other.getY()) === 0) + ); + }; + + Point.prototype.eqXToP = function eqXToP(x) { + var rx = x.toRed(this.curve.red).redMul(this.z); + if (this.x.cmp(rx) === 0) return true; + var xc = x.clone(); + var t = this.curve.redN.redMul(this.z); + + for (;;) { + xc.iadd(this.curve.n); + if (xc.cmp(this.curve.p) >= 0) return false; + rx.redIAdd(t); + if (this.x.cmp(rx) === 0) return true; + } + }; // Compatibility with BaseCurve + + Point.prototype.toP = Point.prototype.normalize; + Point.prototype.mixedAdd = Point.prototype.add; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/curve/index.js": + /* !***********************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/curve/index.js ***! + \***********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var curve = exports; + curve.base = __webpack_require__( + /* ! ./base */ "./node_modules/elliptic/lib/elliptic/curve/base.js" + ); + curve.short = __webpack_require__( + /* ! ./short */ "./node_modules/elliptic/lib/elliptic/curve/short.js" + ); + curve.mont = __webpack_require__( + /* ! ./mont */ "./node_modules/elliptic/lib/elliptic/curve/mont.js" + ); + curve.edwards = __webpack_require__( + /* ! ./edwards */ "./node_modules/elliptic/lib/elliptic/curve/edwards.js" + ); + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/curve/mont.js": + /* !**********************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/curve/mont.js ***! + \**********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Base = __webpack_require__( + /* ! ./base */ "./node_modules/elliptic/lib/elliptic/curve/base.js" + ); + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + function MontCurve(conf) { + Base.call(this, "mont", conf); + this.a = new BN(conf.a, 16).toRed(this.red); + this.b = new BN(conf.b, 16).toRed(this.red); + this.i4 = new BN(4).toRed(this.red).redInvm(); + this.two = new BN(2).toRed(this.red); + this.a24 = this.i4.redMul(this.a.redAdd(this.two)); + } + + inherits(MontCurve, Base); + module.exports = MontCurve; + + MontCurve.prototype.validate = function validate(point) { + var x = point.normalize().x; + var x2 = x.redSqr(); + var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x); + var y = rhs.redSqrt(); + return y.redSqr().cmp(rhs) === 0; + }; + + function Point(curve, x, z) { + Base.BasePoint.call(this, curve, "projective"); + + if (x === null && z === null) { + this.x = this.curve.one; + this.z = this.curve.zero; + } else { + this.x = new BN(x, 16); + this.z = new BN(z, 16); + if (!this.x.red) this.x = this.x.toRed(this.curve.red); + if (!this.z.red) this.z = this.z.toRed(this.curve.red); + } + } + + inherits(Point, Base.BasePoint); + + MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) { + return this.point(utils.toArray(bytes, enc), 1); + }; + + MontCurve.prototype.point = function point(x, z) { + return new Point(this, x, z); + }; + + MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) { + return Point.fromJSON(this, obj); + }; + + Point.prototype.precompute = function precompute() { + // No-op + }; + + Point.prototype._encode = function _encode() { + return this.getX().toArray("be", this.curve.p.byteLength()); + }; + + Point.fromJSON = function fromJSON(curve, obj) { + return new Point(curve, obj[0], obj[1] || curve.one); + }; + + Point.prototype.inspect = function inspect() { + if (this.isInfinity()) return ""; + return ( + "" + ); + }; + + Point.prototype.isInfinity = function isInfinity() { + // XXX This code assumes that zero is always zero in red + return this.z.cmpn(0) === 0; + }; + + Point.prototype.dbl = function dbl() { + // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3 + // 2M + 2S + 4A + // A = X1 + Z1 + var a = this.x.redAdd(this.z); // AA = A^2 + + var aa = a.redSqr(); // B = X1 - Z1 + + var b = this.x.redSub(this.z); // BB = B^2 + + var bb = b.redSqr(); // C = AA - BB + + var c = aa.redSub(bb); // X3 = AA * BB + + var nx = aa.redMul(bb); // Z3 = C * (BB + A24 * C) + + var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c))); + return this.curve.point(nx, nz); + }; + + Point.prototype.add = function add() { + throw new Error("Not supported on Montgomery curve"); + }; + + Point.prototype.diffAdd = function diffAdd(p, diff) { + // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3 + // 4M + 2S + 6A + // A = X2 + Z2 + var a = this.x.redAdd(this.z); // B = X2 - Z2 + + var b = this.x.redSub(this.z); // C = X3 + Z3 + + var c = p.x.redAdd(p.z); // D = X3 - Z3 + + var d = p.x.redSub(p.z); // DA = D * A + + var da = d.redMul(a); // CB = C * B + + var cb = c.redMul(b); // X5 = Z1 * (DA + CB)^2 + + var nx = diff.z.redMul(da.redAdd(cb).redSqr()); // Z5 = X1 * (DA - CB)^2 + + var nz = diff.x.redMul(da.redISub(cb).redSqr()); + return this.curve.point(nx, nz); + }; + + Point.prototype.mul = function mul(k) { + var t = k.clone(); + var a = this; // (N / 2) * Q + Q + + var b = this.curve.point(null, null); // (N / 2) * Q + + var c = this; // Q + + for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) { + bits.push(t.andln(1)); + } + + for (var i = bits.length - 1; i >= 0; i--) { + if (bits[i] === 0) { + // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q + a = a.diffAdd(b, c); // N * Q = 2 * ((N / 2) * Q + Q)) + + b = b.dbl(); + } else { + // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q) + b = a.diffAdd(b, c); // N * Q + Q = 2 * ((N / 2) * Q + Q) + + a = a.dbl(); + } + } + + return b; + }; + + Point.prototype.mulAdd = function mulAdd() { + throw new Error("Not supported on Montgomery curve"); + }; + + Point.prototype.jumlAdd = function jumlAdd() { + throw new Error("Not supported on Montgomery curve"); + }; + + Point.prototype.eq = function eq(other) { + return this.getX().cmp(other.getX()) === 0; + }; + + Point.prototype.normalize = function normalize() { + this.x = this.x.redMul(this.z.redInvm()); + this.z = this.curve.one; + return this; + }; + + Point.prototype.getX = function getX() { + // Normalize coordinates + this.normalize(); + return this.x.fromRed(); + }; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/curve/short.js": + /* !***********************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/curve/short.js ***! + \***********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + var Base = __webpack_require__( + /* ! ./base */ "./node_modules/elliptic/lib/elliptic/curve/base.js" + ); + + var assert = utils.assert; + + function ShortCurve(conf) { + Base.call(this, "short", conf); + this.a = new BN(conf.a, 16).toRed(this.red); + this.b = new BN(conf.b, 16).toRed(this.red); + this.tinv = this.two.redInvm(); + this.zeroA = this.a.fromRed().cmpn(0) === 0; + this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0; // If the curve is endomorphic, precalculate beta and lambda + + this.endo = this._getEndomorphism(conf); + this._endoWnafT1 = new Array(4); + this._endoWnafT2 = new Array(4); + } + + inherits(ShortCurve, Base); + module.exports = ShortCurve; + + ShortCurve.prototype._getEndomorphism = function _getEndomorphism( + conf + ) { + // No efficient endomorphism + if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1) + return; // Compute beta and lambda, that lambda * P = (beta * Px; Py) + + var beta; + var lambda; + + if (conf.beta) { + beta = new BN(conf.beta, 16).toRed(this.red); + } else { + var betas = this._getEndoRoots(this.p); // Choose the smallest beta + + beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1]; + beta = beta.toRed(this.red); + } + + if (conf.lambda) { + lambda = new BN(conf.lambda, 16); + } else { + // Choose the lambda that is matching selected beta + var lambdas = this._getEndoRoots(this.n); + + if ( + this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === + 0 + ) { + lambda = lambdas[0]; + } else { + lambda = lambdas[1]; + assert( + this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === + 0 + ); + } + } // Get basis vectors, used for balanced length-two representation + + var basis; + + if (conf.basis) { + basis = conf.basis.map(function (vec) { + return { + a: new BN(vec.a, 16), + b: new BN(vec.b, 16), + }; + }); + } else { + basis = this._getEndoBasis(lambda); + } + + return { + beta: beta, + lambda: lambda, + basis: basis, + }; + }; + + ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) { + // Find roots of for x^2 + x + 1 in F + // Root = (-1 +- Sqrt(-3)) / 2 + // + var red = num === this.p ? this.red : BN.mont(num); + var tinv = new BN(2).toRed(red).redInvm(); + var ntinv = tinv.redNeg(); + var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv); + var l1 = ntinv.redAdd(s).fromRed(); + var l2 = ntinv.redSub(s).fromRed(); + return [l1, l2]; + }; + + ShortCurve.prototype._getEndoBasis = function _getEndoBasis( + lambda + ) { + // AprxSqrt >= sqrt(this.n) + var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2)); // 3.74 + // Run EGCD, until r(L + 1) < aprxSqrt + + var u = lambda; + var v = this.n.clone(); + var x1 = new BN(1); + var y1 = new BN(0); + var x2 = new BN(0); + var y2 = new BN(1); // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n) + + var a0; + var b0; // First vector + + var a1; + var b1; // Second vector + + var a2; + var b2; + var prevR; + var i = 0; + var r; + var x; + + while (u.cmpn(0) !== 0) { + var q = v.div(u); + r = v.sub(q.mul(u)); + x = x2.sub(q.mul(x1)); + var y = y2.sub(q.mul(y1)); + + if (!a1 && r.cmp(aprxSqrt) < 0) { + a0 = prevR.neg(); + b0 = x1; + a1 = r.neg(); + b1 = x; + } else if (a1 && ++i === 2) { + break; + } + + prevR = r; + v = u; + u = r; + x2 = x1; + x1 = x; + y2 = y1; + y1 = y; + } + + a2 = r.neg(); + b2 = x; + var len1 = a1.sqr().add(b1.sqr()); + var len2 = a2.sqr().add(b2.sqr()); + + if (len2.cmp(len1) >= 0) { + a2 = a0; + b2 = b0; + } // Normalize signs + + if (a1.negative) { + a1 = a1.neg(); + b1 = b1.neg(); + } + + if (a2.negative) { + a2 = a2.neg(); + b2 = b2.neg(); + } + + return [ + { + a: a1, + b: b1, + }, + { + a: a2, + b: b2, + }, + ]; + }; + + ShortCurve.prototype._endoSplit = function _endoSplit(k) { + var basis = this.endo.basis; + var v1 = basis[0]; + var v2 = basis[1]; + var c1 = v2.b.mul(k).divRound(this.n); + var c2 = v1.b.neg().mul(k).divRound(this.n); + var p1 = c1.mul(v1.a); + var p2 = c2.mul(v2.a); + var q1 = c1.mul(v1.b); + var q2 = c2.mul(v2.b); // Calculate answer + + var k1 = k.sub(p1).sub(p2); + var k2 = q1.add(q2).neg(); + return { + k1: k1, + k2: k2, + }; + }; + + ShortCurve.prototype.pointFromX = function pointFromX(x, odd) { + x = new BN(x, 16); + if (!x.red) x = x.toRed(this.red); + var y2 = x + .redSqr() + .redMul(x) + .redIAdd(x.redMul(this.a)) + .redIAdd(this.b); + var y = y2.redSqrt(); + if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) + throw new Error("invalid point"); // XXX Is there any way to tell if the number is odd without converting it + // to non-red form? + + var isOdd = y.fromRed().isOdd(); + if ((odd && !isOdd) || (!odd && isOdd)) y = y.redNeg(); + return this.point(x, y); + }; + + ShortCurve.prototype.validate = function validate(point) { + if (point.inf) return true; + var x = point.x; + var y = point.y; + var ax = this.a.redMul(x); + var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b); + return y.redSqr().redISub(rhs).cmpn(0) === 0; + }; + + ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd( + points, + coeffs, + jacobianResult + ) { + var npoints = this._endoWnafT1; + var ncoeffs = this._endoWnafT2; + + for (var i = 0; i < points.length; i++) { + var split = this._endoSplit(coeffs[i]); + + var p = points[i]; + + var beta = p._getBeta(); + + if (split.k1.negative) { + split.k1.ineg(); + p = p.neg(true); + } + + if (split.k2.negative) { + split.k2.ineg(); + beta = beta.neg(true); + } + + npoints[i * 2] = p; + npoints[i * 2 + 1] = beta; + ncoeffs[i * 2] = split.k1; + ncoeffs[i * 2 + 1] = split.k2; + } + + var res = this._wnafMulAdd( + 1, + npoints, + ncoeffs, + i * 2, + jacobianResult + ); // Clean-up references to points and coefficients + + for (var j = 0; j < i * 2; j++) { + npoints[j] = null; + ncoeffs[j] = null; + } + + return res; + }; + + function Point(curve, x, y, isRed) { + Base.BasePoint.call(this, curve, "affine"); + + if (x === null && y === null) { + this.x = null; + this.y = null; + this.inf = true; + } else { + this.x = new BN(x, 16); + this.y = new BN(y, 16); // Force redgomery representation when loading from JSON + + if (isRed) { + this.x.forceRed(this.curve.red); + this.y.forceRed(this.curve.red); + } + + if (!this.x.red) this.x = this.x.toRed(this.curve.red); + if (!this.y.red) this.y = this.y.toRed(this.curve.red); + this.inf = false; + } + } + + inherits(Point, Base.BasePoint); + + ShortCurve.prototype.point = function point(x, y, isRed) { + return new Point(this, x, y, isRed); + }; + + ShortCurve.prototype.pointFromJSON = function pointFromJSON( + obj, + red + ) { + return Point.fromJSON(this, obj, red); + }; + + Point.prototype._getBeta = function _getBeta() { + if (!this.curve.endo) return; + var pre = this.precomputed; + if (pre && pre.beta) return pre.beta; + var beta = this.curve.point( + this.x.redMul(this.curve.endo.beta), + this.y + ); + + if (pre) { + var curve = this.curve; + + var endoMul = function endoMul(p) { + return curve.point(p.x.redMul(curve.endo.beta), p.y); + }; + + pre.beta = beta; + beta.precomputed = { + beta: null, + naf: pre.naf && { + wnd: pre.naf.wnd, + points: pre.naf.points.map(endoMul), + }, + doubles: pre.doubles && { + step: pre.doubles.step, + points: pre.doubles.points.map(endoMul), + }, + }; + } + + return beta; + }; + + Point.prototype.toJSON = function toJSON() { + if (!this.precomputed) return [this.x, this.y]; + return [ + this.x, + this.y, + this.precomputed && { + doubles: this.precomputed.doubles && { + step: this.precomputed.doubles.step, + points: this.precomputed.doubles.points.slice(1), + }, + naf: this.precomputed.naf && { + wnd: this.precomputed.naf.wnd, + points: this.precomputed.naf.points.slice(1), + }, + }, + ]; + }; + + Point.fromJSON = function fromJSON(curve, obj, red) { + if (typeof obj === "string") obj = JSON.parse(obj); + var res = curve.point(obj[0], obj[1], red); + if (!obj[2]) return res; + + function obj2point(obj) { + return curve.point(obj[0], obj[1], red); + } + + var pre = obj[2]; + res.precomputed = { + beta: null, + doubles: pre.doubles && { + step: pre.doubles.step, + points: [res].concat(pre.doubles.points.map(obj2point)), + }, + naf: pre.naf && { + wnd: pre.naf.wnd, + points: [res].concat(pre.naf.points.map(obj2point)), + }, + }; + return res; + }; + + Point.prototype.inspect = function inspect() { + if (this.isInfinity()) return ""; + return ( + "" + ); + }; + + Point.prototype.isInfinity = function isInfinity() { + return this.inf; + }; + + Point.prototype.add = function add(p) { + // O + P = P + if (this.inf) return p; // P + O = P + + if (p.inf) return this; // P + P = 2P + + if (this.eq(p)) return this.dbl(); // P + (-P) = O + + if (this.neg().eq(p)) return this.curve.point(null, null); // P + Q = O + + if (this.x.cmp(p.x) === 0) return this.curve.point(null, null); + var c = this.y.redSub(p.y); + if (c.cmpn(0) !== 0) c = c.redMul(this.x.redSub(p.x).redInvm()); + var nx = c.redSqr().redISub(this.x).redISub(p.x); + var ny = c.redMul(this.x.redSub(nx)).redISub(this.y); + return this.curve.point(nx, ny); + }; + + Point.prototype.dbl = function dbl() { + if (this.inf) return this; // 2P = O + + var ys1 = this.y.redAdd(this.y); + if (ys1.cmpn(0) === 0) return this.curve.point(null, null); + var a = this.curve.a; + var x2 = this.x.redSqr(); + var dyinv = ys1.redInvm(); + var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv); + var nx = c.redSqr().redISub(this.x.redAdd(this.x)); + var ny = c.redMul(this.x.redSub(nx)).redISub(this.y); + return this.curve.point(nx, ny); + }; + + Point.prototype.getX = function getX() { + return this.x.fromRed(); + }; + + Point.prototype.getY = function getY() { + return this.y.fromRed(); + }; + + Point.prototype.mul = function mul(k) { + k = new BN(k, 16); + if (this.isInfinity()) return this; + else if (this._hasDoubles(k)) + return this.curve._fixedNafMul(this, k); + else if (this.curve.endo) + return this.curve._endoWnafMulAdd([this], [k]); + return this.curve._wnafMul(this, k); + }; + + Point.prototype.mulAdd = function mulAdd(k1, p2, k2) { + var points = [this, p2]; + var coeffs = [k1, k2]; + if (this.curve.endo) + return this.curve._endoWnafMulAdd(points, coeffs); + return this.curve._wnafMulAdd(1, points, coeffs, 2); + }; + + Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) { + var points = [this, p2]; + var coeffs = [k1, k2]; + if (this.curve.endo) + return this.curve._endoWnafMulAdd(points, coeffs, true); + return this.curve._wnafMulAdd(1, points, coeffs, 2, true); + }; + + Point.prototype.eq = function eq(p) { + return ( + this === p || + (this.inf === p.inf && + (this.inf || + (this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0))) + ); + }; + + Point.prototype.neg = function neg(_precompute) { + if (this.inf) return this; + var res = this.curve.point(this.x, this.y.redNeg()); + + if (_precompute && this.precomputed) { + var pre = this.precomputed; + + var negate = function negate(p) { + return p.neg(); + }; + + res.precomputed = { + naf: pre.naf && { + wnd: pre.naf.wnd, + points: pre.naf.points.map(negate), + }, + doubles: pre.doubles && { + step: pre.doubles.step, + points: pre.doubles.points.map(negate), + }, + }; + } + + return res; + }; + + Point.prototype.toJ = function toJ() { + if (this.inf) return this.curve.jpoint(null, null, null); + var res = this.curve.jpoint(this.x, this.y, this.curve.one); + return res; + }; + + function JPoint(curve, x, y, z) { + Base.BasePoint.call(this, curve, "jacobian"); + + if (x === null && y === null && z === null) { + this.x = this.curve.one; + this.y = this.curve.one; + this.z = new BN(0); + } else { + this.x = new BN(x, 16); + this.y = new BN(y, 16); + this.z = new BN(z, 16); + } + + if (!this.x.red) this.x = this.x.toRed(this.curve.red); + if (!this.y.red) this.y = this.y.toRed(this.curve.red); + if (!this.z.red) this.z = this.z.toRed(this.curve.red); + this.zOne = this.z === this.curve.one; + } + + inherits(JPoint, Base.BasePoint); + + ShortCurve.prototype.jpoint = function jpoint(x, y, z) { + return new JPoint(this, x, y, z); + }; + + JPoint.prototype.toP = function toP() { + if (this.isInfinity()) return this.curve.point(null, null); + var zinv = this.z.redInvm(); + var zinv2 = zinv.redSqr(); + var ax = this.x.redMul(zinv2); + var ay = this.y.redMul(zinv2).redMul(zinv); + return this.curve.point(ax, ay); + }; + + JPoint.prototype.neg = function neg() { + return this.curve.jpoint(this.x, this.y.redNeg(), this.z); + }; + + JPoint.prototype.add = function add(p) { + // O + P = P + if (this.isInfinity()) return p; // P + O = P + + if (p.isInfinity()) return this; // 12M + 4S + 7A + + var pz2 = p.z.redSqr(); + var z2 = this.z.redSqr(); + var u1 = this.x.redMul(pz2); + var u2 = p.x.redMul(z2); + var s1 = this.y.redMul(pz2.redMul(p.z)); + var s2 = p.y.redMul(z2.redMul(this.z)); + var h = u1.redSub(u2); + var r = s1.redSub(s2); + + if (h.cmpn(0) === 0) { + if (r.cmpn(0) !== 0) + return this.curve.jpoint(null, null, null); + return this.dbl(); + } + + var h2 = h.redSqr(); + var h3 = h2.redMul(h); + var v = u1.redMul(h2); + var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v); + var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3)); + var nz = this.z.redMul(p.z).redMul(h); + return this.curve.jpoint(nx, ny, nz); + }; + + JPoint.prototype.mixedAdd = function mixedAdd(p) { + // O + P = P + if (this.isInfinity()) return p.toJ(); // P + O = P + + if (p.isInfinity()) return this; // 8M + 3S + 7A + + var z2 = this.z.redSqr(); + var u1 = this.x; + var u2 = p.x.redMul(z2); + var s1 = this.y; + var s2 = p.y.redMul(z2).redMul(this.z); + var h = u1.redSub(u2); + var r = s1.redSub(s2); + + if (h.cmpn(0) === 0) { + if (r.cmpn(0) !== 0) + return this.curve.jpoint(null, null, null); + return this.dbl(); + } + + var h2 = h.redSqr(); + var h3 = h2.redMul(h); + var v = u1.redMul(h2); + var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v); + var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3)); + var nz = this.z.redMul(h); + return this.curve.jpoint(nx, ny, nz); + }; + + JPoint.prototype.dblp = function dblp(pow) { + if (pow === 0) return this; + if (this.isInfinity()) return this; + if (!pow) return this.dbl(); + + if (this.curve.zeroA || this.curve.threeA) { + var r = this; + + for (var i = 0; i < pow; i++) { + r = r.dbl(); + } + + return r; + } // 1M + 2S + 1A + N * (4S + 5M + 8A) + // N = 1 => 6M + 6S + 9A + + var a = this.curve.a; + var tinv = this.curve.tinv; + var jx = this.x; + var jy = this.y; + var jz = this.z; + var jz4 = jz.redSqr().redSqr(); // Reuse results + + var jyd = jy.redAdd(jy); + + for (var i = 0; i < pow; i++) { + var jx2 = jx.redSqr(); + var jyd2 = jyd.redSqr(); + var jyd4 = jyd2.redSqr(); + var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4)); + var t1 = jx.redMul(jyd2); + var nx = c.redSqr().redISub(t1.redAdd(t1)); + var t2 = t1.redISub(nx); + var dny = c.redMul(t2); + dny = dny.redIAdd(dny).redISub(jyd4); + var nz = jyd.redMul(jz); + if (i + 1 < pow) jz4 = jz4.redMul(jyd4); + jx = nx; + jz = nz; + jyd = dny; + } + + return this.curve.jpoint(jx, jyd.redMul(tinv), jz); + }; + + JPoint.prototype.dbl = function dbl() { + if (this.isInfinity()) return this; + if (this.curve.zeroA) return this._zeroDbl(); + else if (this.curve.threeA) return this._threeDbl(); + return this._dbl(); + }; + + JPoint.prototype._zeroDbl = function _zeroDbl() { + var nx; + var ny; + var nz; // Z = 1 + + if (this.zOne) { + // Hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html + // #doubling-mdbl-2007-bl + // 1M + 5S + 14A + // XX = X1^2 + var xx = this.x.redSqr(); // YY = Y1^2 + + var yy = this.y.redSqr(); // YYYY = YY^2 + + var yyyy = yy.redSqr(); // S = 2 * ((X1 + YY)^2 - XX - YYYY) + + var s = this.x + .redAdd(yy) + .redSqr() + .redISub(xx) + .redISub(yyyy); + s = s.redIAdd(s); // M = 3 * XX + a; a = 0 + + var m = xx.redAdd(xx).redIAdd(xx); // T = M ^ 2 - 2*S + + var t = m.redSqr().redISub(s).redISub(s); // 8 * YYYY + + var yyyy8 = yyyy.redIAdd(yyyy); + yyyy8 = yyyy8.redIAdd(yyyy8); + yyyy8 = yyyy8.redIAdd(yyyy8); // X3 = T + + nx = t; // Y3 = M * (S - T) - 8 * YYYY + + ny = m.redMul(s.redISub(t)).redISub(yyyy8); // Z3 = 2*Y1 + + nz = this.y.redAdd(this.y); + } else { + // Hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html + // #doubling-dbl-2009-l + // 2M + 5S + 13A + // A = X1^2 + var a = this.x.redSqr(); // B = Y1^2 + + var b = this.y.redSqr(); // C = B^2 + + var c = b.redSqr(); // D = 2 * ((X1 + B)^2 - A - C) + + var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c); + d = d.redIAdd(d); // E = 3 * A + + var e = a.redAdd(a).redIAdd(a); // F = E^2 + + var f = e.redSqr(); // 8 * C + + var c8 = c.redIAdd(c); + c8 = c8.redIAdd(c8); + c8 = c8.redIAdd(c8); // X3 = F - 2 * D + + nx = f.redISub(d).redISub(d); // Y3 = E * (D - X3) - 8 * C + + ny = e.redMul(d.redISub(nx)).redISub(c8); // Z3 = 2 * Y1 * Z1 + + nz = this.y.redMul(this.z); + nz = nz.redIAdd(nz); + } + + return this.curve.jpoint(nx, ny, nz); + }; + + JPoint.prototype._threeDbl = function _threeDbl() { + var nx; + var ny; + var nz; // Z = 1 + + if (this.zOne) { + // Hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html + // #doubling-mdbl-2007-bl + // 1M + 5S + 15A + // XX = X1^2 + var xx = this.x.redSqr(); // YY = Y1^2 + + var yy = this.y.redSqr(); // YYYY = YY^2 + + var yyyy = yy.redSqr(); // S = 2 * ((X1 + YY)^2 - XX - YYYY) + + var s = this.x + .redAdd(yy) + .redSqr() + .redISub(xx) + .redISub(yyyy); + s = s.redIAdd(s); // M = 3 * XX + a + + var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a); // T = M^2 - 2 * S + + var t = m.redSqr().redISub(s).redISub(s); // X3 = T + + nx = t; // Y3 = M * (S - T) - 8 * YYYY + + var yyyy8 = yyyy.redIAdd(yyyy); + yyyy8 = yyyy8.redIAdd(yyyy8); + yyyy8 = yyyy8.redIAdd(yyyy8); + ny = m.redMul(s.redISub(t)).redISub(yyyy8); // Z3 = 2 * Y1 + + nz = this.y.redAdd(this.y); + } else { + // Hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b + // 3M + 5S + // delta = Z1^2 + var delta = this.z.redSqr(); // Gamma = Y1^2 + + var gamma = this.y.redSqr(); // Beta = X1 * gamma + + var beta = this.x.redMul(gamma); // Alpha = 3 * (X1 - delta) * (X1 + delta) + + var alpha = this.x + .redSub(delta) + .redMul(this.x.redAdd(delta)); + alpha = alpha.redAdd(alpha).redIAdd(alpha); // X3 = alpha^2 - 8 * beta + + var beta4 = beta.redIAdd(beta); + beta4 = beta4.redIAdd(beta4); + var beta8 = beta4.redAdd(beta4); + nx = alpha.redSqr().redISub(beta8); // Z3 = (Y1 + Z1)^2 - gamma - delta + + nz = this.y + .redAdd(this.z) + .redSqr() + .redISub(gamma) + .redISub(delta); // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2 + + var ggamma8 = gamma.redSqr(); + ggamma8 = ggamma8.redIAdd(ggamma8); + ggamma8 = ggamma8.redIAdd(ggamma8); + ggamma8 = ggamma8.redIAdd(ggamma8); + ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8); + } + + return this.curve.jpoint(nx, ny, nz); + }; + + JPoint.prototype._dbl = function _dbl() { + var a = this.curve.a; // 4M + 6S + 10A + + var jx = this.x; + var jy = this.y; + var jz = this.z; + var jz4 = jz.redSqr().redSqr(); + var jx2 = jx.redSqr(); + var jy2 = jy.redSqr(); + var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4)); + var jxd4 = jx.redAdd(jx); + jxd4 = jxd4.redIAdd(jxd4); + var t1 = jxd4.redMul(jy2); + var nx = c.redSqr().redISub(t1.redAdd(t1)); + var t2 = t1.redISub(nx); + var jyd8 = jy2.redSqr(); + jyd8 = jyd8.redIAdd(jyd8); + jyd8 = jyd8.redIAdd(jyd8); + jyd8 = jyd8.redIAdd(jyd8); + var ny = c.redMul(t2).redISub(jyd8); + var nz = jy.redAdd(jy).redMul(jz); + return this.curve.jpoint(nx, ny, nz); + }; + + JPoint.prototype.trpl = function trpl() { + if (!this.curve.zeroA) return this.dbl().add(this); // Hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl + // 5M + 10S + ... + // XX = X1^2 + + var xx = this.x.redSqr(); // YY = Y1^2 + + var yy = this.y.redSqr(); // ZZ = Z1^2 + + var zz = this.z.redSqr(); // YYYY = YY^2 + + var yyyy = yy.redSqr(); // M = 3 * XX + a * ZZ2; a = 0 + + var m = xx.redAdd(xx).redIAdd(xx); // MM = M^2 + + var mm = m.redSqr(); // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM + + var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); + e = e.redIAdd(e); + e = e.redAdd(e).redIAdd(e); + e = e.redISub(mm); // EE = E^2 + + var ee = e.redSqr(); // T = 16*YYYY + + var t = yyyy.redIAdd(yyyy); + t = t.redIAdd(t); + t = t.redIAdd(t); + t = t.redIAdd(t); // U = (M + E)^2 - MM - EE - T + + var u = m + .redIAdd(e) + .redSqr() + .redISub(mm) + .redISub(ee) + .redISub(t); // X3 = 4 * (X1 * EE - 4 * YY * U) + + var yyu4 = yy.redMul(u); + yyu4 = yyu4.redIAdd(yyu4); + yyu4 = yyu4.redIAdd(yyu4); + var nx = this.x.redMul(ee).redISub(yyu4); + nx = nx.redIAdd(nx); + nx = nx.redIAdd(nx); // Y3 = 8 * Y1 * (U * (T - U) - E * EE) + + var ny = this.y.redMul( + u.redMul(t.redISub(u)).redISub(e.redMul(ee)) + ); + ny = ny.redIAdd(ny); + ny = ny.redIAdd(ny); + ny = ny.redIAdd(ny); // Z3 = (Z1 + E)^2 - ZZ - EE + + var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee); + return this.curve.jpoint(nx, ny, nz); + }; + + JPoint.prototype.mul = function mul(k, kbase) { + k = new BN(k, kbase); + return this.curve._wnafMul(this, k); + }; + + JPoint.prototype.eq = function eq(p) { + if (p.type === "affine") return this.eq(p.toJ()); + if (this === p) return true; // X1 * z2^2 == x2 * z1^2 + + var z2 = this.z.redSqr(); + var pz2 = p.z.redSqr(); + if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) + return false; // Y1 * z2^3 == y2 * z1^3 + + var z3 = z2.redMul(this.z); + var pz3 = pz2.redMul(p.z); + return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0; + }; + + JPoint.prototype.eqXToP = function eqXToP(x) { + var zs = this.z.redSqr(); + var rx = x.toRed(this.curve.red).redMul(zs); + if (this.x.cmp(rx) === 0) return true; + var xc = x.clone(); + var t = this.curve.redN.redMul(zs); + + for (;;) { + xc.iadd(this.curve.n); + if (xc.cmp(this.curve.p) >= 0) return false; + rx.redIAdd(t); + if (this.x.cmp(rx) === 0) return true; + } + }; + + JPoint.prototype.inspect = function inspect() { + if (this.isInfinity()) return ""; + return ( + "" + ); + }; + + JPoint.prototype.isInfinity = function isInfinity() { + // XXX This code assumes that zero is always zero in red + return this.z.cmpn(0) === 0; + }; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/curves.js": + /* !******************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/curves.js ***! + \******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var curves = exports; + + var hash = __webpack_require__( + /* ! hash.js */ "./node_modules/hash.js/lib/hash.js" + ); + + var curve = __webpack_require__( + /* ! ./curve */ "./node_modules/elliptic/lib/elliptic/curve/index.js" + ); + + var utils = __webpack_require__( + /* ! ./utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var assert = utils.assert; + + function PresetCurve(options) { + if (options.type === "short") + this.curve = new curve.short(options); + else if (options.type === "edwards") + this.curve = new curve.edwards(options); + else this.curve = new curve.mont(options); + this.g = this.curve.g; + this.n = this.curve.n; + this.hash = options.hash; + assert(this.g.validate(), "Invalid curve"); + assert( + this.g.mul(this.n).isInfinity(), + "Invalid curve, G*N != O" + ); + } + + curves.PresetCurve = PresetCurve; + + function defineCurve(name, options) { + Object.defineProperty(curves, name, { + configurable: true, + enumerable: true, + get: function get() { + var curve = new PresetCurve(options); + Object.defineProperty(curves, name, { + configurable: true, + enumerable: true, + value: curve, + }); + return curve; + }, + }); + } + + defineCurve("p192", { + type: "short", + prime: "p192", + p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff", + a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc", + b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1", + n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831", + hash: hash.sha256, + gRed: false, + g: [ + "188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012", + "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811", + ], + }); + defineCurve("p224", { + type: "short", + prime: "p224", + p: + "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001", + a: + "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe", + b: + "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4", + n: + "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d", + hash: hash.sha256, + gRed: false, + g: [ + "b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21", + "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34", + ], + }); + defineCurve("p256", { + type: "short", + prime: null, + p: + "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff", + a: + "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc", + b: + "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b", + n: + "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551", + hash: hash.sha256, + gRed: false, + g: [ + "6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296", + "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5", + ], + }); + defineCurve("p384", { + type: "short", + prime: null, + p: + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff " + + "fffffffe ffffffff 00000000 00000000 ffffffff", + a: + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff " + + "fffffffe ffffffff 00000000 00000000 fffffffc", + b: + "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f " + + "5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef", + n: + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 " + + "f4372ddf 581a0db2 48b0a77a ecec196a ccc52973", + hash: hash.sha384, + gRed: false, + g: [ + "aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 " + + "5502f25d bf55296c 3a545e38 72760ab7", + "3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 " + + "0a60b1ce 1d7e819d 7a431d7c 90ea0e5f", + ], + }); + defineCurve("p521", { + type: "short", + prime: null, + p: + "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff " + + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff " + + "ffffffff ffffffff ffffffff ffffffff ffffffff", + a: + "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff " + + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff " + + "ffffffff ffffffff ffffffff ffffffff fffffffc", + b: + "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b " + + "99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd " + + "3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00", + n: + "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff " + + "ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 " + + "f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409", + hash: hash.sha512, + gRed: false, + g: [ + "000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 " + + "053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 " + + "a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66", + "00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 " + + "579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 " + + "3fad0761 353c7086 a272c240 88be9476 9fd16650", + ], + }); + defineCurve("curve25519", { + type: "mont", + prime: "p25519", + p: + "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", + a: "76d06", + b: "1", + n: + "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", + hash: hash.sha256, + gRed: false, + g: ["9"], + }); + defineCurve("ed25519", { + type: "edwards", + prime: "p25519", + p: + "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", + a: "-1", + c: "1", + // -121665 * (121666^(-1)) (mod P) + d: + "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3", + n: + "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", + hash: hash.sha256, + gRed: false, + g: [ + "216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a", // 4/5 + "6666666666666666666666666666666666666666666666666666666666666658", + ], + }); + var pre; + + try { + pre = __webpack_require__( + /* ! ./precomputed/secp256k1 */ "./node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js" + ); + } catch (e) { + pre = undefined; + } + + defineCurve("secp256k1", { + type: "short", + prime: "k256", + p: + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f", + a: "0", + b: "7", + n: + "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141", + h: "1", + hash: hash.sha256, + // Precomputed endomorphism + beta: + "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee", + lambda: + "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72", + basis: [ + { + a: "3086d221a7d46bcde86c90e49284eb15", + b: "-e4437ed6010e88286f547fa90abfe4c3", + }, + { + a: "114ca50f7a8e2f3f657c1108d9d44cfd8", + b: "3086d221a7d46bcde86c90e49284eb15", + }, + ], + gRed: false, + g: [ + "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", + "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", + pre, + ], + }); + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/ec/index.js": + /* !********************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/ec/index.js ***! + \********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var HmacDRBG = __webpack_require__( + /* ! hmac-drbg */ "./node_modules/hmac-drbg/lib/hmac-drbg.js" + ); + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var curves = __webpack_require__( + /* ! ../curves */ "./node_modules/elliptic/lib/elliptic/curves.js" + ); + + var rand = __webpack_require__( + /* ! brorand */ "./node_modules/brorand/index.js" + ); + + var assert = utils.assert; + + var KeyPair = __webpack_require__( + /* ! ./key */ "./node_modules/elliptic/lib/elliptic/ec/key.js" + ); + + var Signature = __webpack_require__( + /* ! ./signature */ "./node_modules/elliptic/lib/elliptic/ec/signature.js" + ); + + function EC(options) { + if (!(this instanceof EC)) return new EC(options); // Shortcut `elliptic.ec(curve-name)` + + if (typeof options === "string") { + assert( + curves.hasOwnProperty(options), + "Unknown curve " + options + ); + options = curves[options]; + } // Shortcut for `elliptic.ec(elliptic.curves.curveName)` + + if (options instanceof curves.PresetCurve) + options = { + curve: options, + }; + this.curve = options.curve.curve; + this.n = this.curve.n; + this.nh = this.n.ushrn(1); + this.g = this.curve.g; // Point on curve + + this.g = options.curve.g; + this.g.precompute(options.curve.n.bitLength() + 1); // Hash for function for DRBG + + this.hash = options.hash || options.curve.hash; + } + + module.exports = EC; + + EC.prototype.keyPair = function keyPair(options) { + return new KeyPair(this, options); + }; + + EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) { + return KeyPair.fromPrivate(this, priv, enc); + }; + + EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) { + return KeyPair.fromPublic(this, pub, enc); + }; + + EC.prototype.genKeyPair = function genKeyPair(options) { + if (!options) options = {}; // Instantiate Hmac_DRBG + + var drbg = new HmacDRBG({ + hash: this.hash, + pers: options.pers, + persEnc: options.persEnc || "utf8", + entropy: options.entropy || rand(this.hash.hmacStrength), + entropyEnc: + (options.entropy && options.entropyEnc) || "utf8", + nonce: this.n.toArray(), + }); + var bytes = this.n.byteLength(); + var ns2 = this.n.sub(new BN(2)); + + do { + var priv = new BN(drbg.generate(bytes)); + if (priv.cmp(ns2) > 0) continue; + priv.iaddn(1); + return this.keyFromPrivate(priv); + } while (true); + }; + + EC.prototype._truncateToN = function truncateToN(msg, truncOnly) { + var delta = msg.byteLength() * 8 - this.n.bitLength(); + if (delta > 0) msg = msg.ushrn(delta); + if (!truncOnly && msg.cmp(this.n) >= 0) return msg.sub(this.n); + return msg; + }; + + EC.prototype.sign = function sign(msg, key, enc, options) { + if (_typeof(enc) === "object") { + options = enc; + enc = null; + } + + if (!options) options = {}; + key = this.keyFromPrivate(key, enc); + msg = this._truncateToN(new BN(msg, 16)); // Zero-extend key to provide enough entropy + + var bytes = this.n.byteLength(); + var bkey = key.getPrivate().toArray("be", bytes); // Zero-extend nonce to have the same byte size as N + + var nonce = msg.toArray("be", bytes); // Instantiate Hmac_DRBG + + var drbg = new HmacDRBG({ + hash: this.hash, + entropy: bkey, + nonce: nonce, + pers: options.pers, + persEnc: options.persEnc || "utf8", + }); // Number of bytes to generate + + var ns1 = this.n.sub(new BN(1)); + + for (var iter = 0; true; iter++) { + var k = options.k + ? options.k(iter) + : new BN(drbg.generate(this.n.byteLength())); + k = this._truncateToN(k, true); + if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) continue; + var kp = this.g.mul(k); + if (kp.isInfinity()) continue; + var kpX = kp.getX(); + var r = kpX.umod(this.n); + if (r.cmpn(0) === 0) continue; + var s = k + .invm(this.n) + .mul(r.mul(key.getPrivate()).iadd(msg)); + s = s.umod(this.n); + if (s.cmpn(0) === 0) continue; + var recoveryParam = + (kp.getY().isOdd() ? 1 : 0) | + (kpX.cmp(r) !== 0 ? 2 : 0); // Use complement of `s`, if it is > `n / 2` + + if (options.canonical && s.cmp(this.nh) > 0) { + s = this.n.sub(s); + recoveryParam ^= 1; + } + + return new Signature({ + r: r, + s: s, + recoveryParam: recoveryParam, + }); + } + }; + + EC.prototype.verify = function verify(msg, signature, key, enc) { + msg = this._truncateToN(new BN(msg, 16)); + key = this.keyFromPublic(key, enc); + signature = new Signature(signature, "hex"); // Perform primitive values validation + + var r = signature.r; + var s = signature.s; + if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0) return false; + if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) return false; // Validate signature + + var sinv = s.invm(this.n); + var u1 = sinv.mul(msg).umod(this.n); + var u2 = sinv.mul(r).umod(this.n); + + if (!this.curve._maxwellTrick) { + var p = this.g.mulAdd(u1, key.getPublic(), u2); + if (p.isInfinity()) return false; + return p.getX().umod(this.n).cmp(r) === 0; + } // NOTE: Greg Maxwell's trick, inspired by: + // https://git.io/vad3K + + var p = this.g.jmulAdd(u1, key.getPublic(), u2); + if (p.isInfinity()) return false; // Compare `p.x` of Jacobian point with `r`, + // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the + // inverse of `p.z^2` + + return p.eqXToP(r); + }; + + EC.prototype.recoverPubKey = function (msg, signature, j, enc) { + assert( + (3 & j) === j, + "The recovery param is more than two bits" + ); + signature = new Signature(signature, enc); + var n = this.n; + var e = new BN(msg); + var r = signature.r; + var s = signature.s; // A set LSB signifies that the y-coordinate is odd + + var isYOdd = j & 1; + var isSecondKey = j >> 1; + if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey) + throw new Error("Unable to find sencond key candinate"); // 1.1. Let x = r + jn. + + if (isSecondKey) + r = this.curve.pointFromX(r.add(this.curve.n), isYOdd); + else r = this.curve.pointFromX(r, isYOdd); + var rInv = signature.r.invm(n); + var s1 = n.sub(e).mul(rInv).umod(n); + var s2 = s.mul(rInv).umod(n); // 1.6.1 Compute Q = r^-1 (sR - eG) + // Q = r^-1 (sR + -eG) + + return this.g.mulAdd(s1, r, s2); + }; + + EC.prototype.getKeyRecoveryParam = function (e, signature, Q, enc) { + signature = new Signature(signature, enc); + if (signature.recoveryParam !== null) + return signature.recoveryParam; + + for (var i = 0; i < 4; i++) { + var Qprime; + + try { + Qprime = this.recoverPubKey(e, signature, i); + } catch (e) { + continue; + } + + if (Qprime.eq(Q)) return i; + } + + throw new Error("Unable to find valid recovery factor"); + }; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/ec/key.js": + /* !******************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/ec/key.js ***! + \******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var assert = utils.assert; + + function KeyPair(ec, options) { + this.ec = ec; + this.priv = null; + this.pub = null; // KeyPair(ec, { priv: ..., pub: ... }) + + if (options.priv) + this._importPrivate(options.priv, options.privEnc); + if (options.pub) + this._importPublic(options.pub, options.pubEnc); + } + + module.exports = KeyPair; + + KeyPair.fromPublic = function fromPublic(ec, pub, enc) { + if (pub instanceof KeyPair) return pub; + return new KeyPair(ec, { + pub: pub, + pubEnc: enc, + }); + }; + + KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) { + if (priv instanceof KeyPair) return priv; + return new KeyPair(ec, { + priv: priv, + privEnc: enc, + }); + }; + + KeyPair.prototype.validate = function validate() { + var pub = this.getPublic(); + if (pub.isInfinity()) + return { + result: false, + reason: "Invalid public key", + }; + if (!pub.validate()) + return { + result: false, + reason: "Public key is not a point", + }; + if (!pub.mul(this.ec.curve.n).isInfinity()) + return { + result: false, + reason: "Public key * N != O", + }; + return { + result: true, + reason: null, + }; + }; + + KeyPair.prototype.getPublic = function getPublic(compact, enc) { + // Compact is optional argument + if (typeof compact === "string") { + enc = compact; + compact = null; + } + + if (!this.pub) this.pub = this.ec.g.mul(this.priv); + if (!enc) return this.pub; + return this.pub.encode(enc, compact); + }; + + KeyPair.prototype.getPrivate = function getPrivate(enc) { + if (enc === "hex") return this.priv.toString(16, 2); + return this.priv; + }; + + KeyPair.prototype._importPrivate = function _importPrivate( + key, + enc + ) { + this.priv = new BN(key, enc || 16); // Ensure that the priv won't be bigger than n, otherwise we may fail + // in fixed multiplication method + + this.priv = this.priv.umod(this.ec.curve.n); + }; + + KeyPair.prototype._importPublic = function _importPublic(key, enc) { + if (key.x || key.y) { + // Montgomery points only have an `x` coordinate. + // Weierstrass/Edwards points on the other hand have both `x` and + // `y` coordinates. + if (this.ec.curve.type === "mont") { + assert(key.x, "Need x coordinate"); + } else if ( + this.ec.curve.type === "short" || + this.ec.curve.type === "edwards" + ) { + assert(key.x && key.y, "Need both x and y coordinate"); + } + + this.pub = this.ec.curve.point(key.x, key.y); + return; + } + + this.pub = this.ec.curve.decodePoint(key, enc); + }; // ECDH + + KeyPair.prototype.derive = function derive(pub) { + return pub.mul(this.priv).getX(); + }; // ECDSA + + KeyPair.prototype.sign = function sign(msg, enc, options) { + return this.ec.sign(msg, this, enc, options); + }; + + KeyPair.prototype.verify = function verify(msg, signature) { + return this.ec.verify(msg, signature, this); + }; + + KeyPair.prototype.inspect = function inspect() { + return ( + "" + ); + }; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/ec/signature.js": + /* !************************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/ec/signature.js ***! + \************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var assert = utils.assert; + + function Signature(options, enc) { + if (options instanceof Signature) return options; + if (this._importDER(options, enc)) return; + assert(options.r && options.s, "Signature without r or s"); + this.r = new BN(options.r, 16); + this.s = new BN(options.s, 16); + if (options.recoveryParam === undefined) + this.recoveryParam = null; + else this.recoveryParam = options.recoveryParam; + } + + module.exports = Signature; + + function Position() { + this.place = 0; + } + + function getLength(buf, p) { + var initial = buf[p.place++]; + + if (!(initial & 0x80)) { + return initial; + } + + var octetLen = initial & 0xf; + var val = 0; + + for (var i = 0, off = p.place; i < octetLen; i++, off++) { + val <<= 8; + val |= buf[off]; + } + + p.place = off; + return val; + } + + function rmPadding(buf) { + var i = 0; + var len = buf.length - 1; + + while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) { + i++; + } + + if (i === 0) { + return buf; + } + + return buf.slice(i); + } + + Signature.prototype._importDER = function _importDER(data, enc) { + data = utils.toArray(data, enc); + var p = new Position(); + + if (data[p.place++] !== 0x30) { + return false; + } + + var len = getLength(data, p); + + if (len + p.place !== data.length) { + return false; + } + + if (data[p.place++] !== 0x02) { + return false; + } + + var rlen = getLength(data, p); + var r = data.slice(p.place, rlen + p.place); + p.place += rlen; + + if (data[p.place++] !== 0x02) { + return false; + } + + var slen = getLength(data, p); + + if (data.length !== slen + p.place) { + return false; + } + + var s = data.slice(p.place, slen + p.place); + + if (r[0] === 0 && r[1] & 0x80) { + r = r.slice(1); + } + + if (s[0] === 0 && s[1] & 0x80) { + s = s.slice(1); + } + + this.r = new BN(r); + this.s = new BN(s); + this.recoveryParam = null; + return true; + }; + + function constructLength(arr, len) { + if (len < 0x80) { + arr.push(len); + return; + } + + var octets = 1 + ((Math.log(len) / Math.LN2) >>> 3); + arr.push(octets | 0x80); + + while (--octets) { + arr.push((len >>> (octets << 3)) & 0xff); + } + + arr.push(len); + } + + Signature.prototype.toDER = function toDER(enc) { + var r = this.r.toArray(); + var s = this.s.toArray(); // Pad values + + if (r[0] & 0x80) r = [0].concat(r); // Pad values + + if (s[0] & 0x80) s = [0].concat(s); + r = rmPadding(r); + s = rmPadding(s); + + while (!s[0] && !(s[1] & 0x80)) { + s = s.slice(1); + } + + var arr = [0x02]; + constructLength(arr, r.length); + arr = arr.concat(r); + arr.push(0x02); + constructLength(arr, s.length); + var backHalf = arr.concat(s); + var res = [0x30]; + constructLength(res, backHalf.length); + res = res.concat(backHalf); + return utils.encode(res, enc); + }; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/eddsa/index.js": + /* !***********************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/eddsa/index.js ***! + \***********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var hash = __webpack_require__( + /* ! hash.js */ "./node_modules/hash.js/lib/hash.js" + ); + + var curves = __webpack_require__( + /* ! ../curves */ "./node_modules/elliptic/lib/elliptic/curves.js" + ); + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var assert = utils.assert; + var parseBytes = utils.parseBytes; + + var KeyPair = __webpack_require__( + /* ! ./key */ "./node_modules/elliptic/lib/elliptic/eddsa/key.js" + ); + + var Signature = __webpack_require__( + /* ! ./signature */ "./node_modules/elliptic/lib/elliptic/eddsa/signature.js" + ); + + function EDDSA(curve) { + assert(curve === "ed25519", "only tested with ed25519 so far"); + if (!(this instanceof EDDSA)) return new EDDSA(curve); + var curve = curves[curve].curve; + this.curve = curve; + this.g = curve.g; + this.g.precompute(curve.n.bitLength() + 1); + this.pointClass = curve.point().constructor; + this.encodingLength = Math.ceil(curve.n.bitLength() / 8); + this.hash = hash.sha512; + } + + module.exports = EDDSA; + /** + * @param {Array|String} message - message bytes + * @param {Array|String|KeyPair} secret - secret bytes or a keypair + * @returns {Signature} - signature + */ + + EDDSA.prototype.sign = function sign(message, secret) { + message = parseBytes(message); + var key = this.keyFromSecret(secret); + var r = this.hashInt(key.messagePrefix(), message); + var R = this.g.mul(r); + var Rencoded = this.encodePoint(R); + var s_ = this.hashInt(Rencoded, key.pubBytes(), message).mul( + key.priv() + ); + var S = r.add(s_).umod(this.curve.n); + return this.makeSignature({ + R: R, + S: S, + Rencoded: Rencoded, + }); + }; + /** + * @param {Array} message - message bytes + * @param {Array|String|Signature} sig - sig bytes + * @param {Array|String|Point|KeyPair} pub - public key + * @returns {Boolean} - true if public key matches sig of message + */ + + EDDSA.prototype.verify = function verify(message, sig, pub) { + message = parseBytes(message); + sig = this.makeSignature(sig); + var key = this.keyFromPublic(pub); + var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message); + var SG = this.g.mul(sig.S()); + var RplusAh = sig.R().add(key.pub().mul(h)); + return RplusAh.eq(SG); + }; + + EDDSA.prototype.hashInt = function hashInt() { + var hash = this.hash(); + + for (var i = 0; i < arguments.length; i++) { + hash.update(arguments[i]); + } + + return utils.intFromLE(hash.digest()).umod(this.curve.n); + }; + + EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) { + return KeyPair.fromPublic(this, pub); + }; + + EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) { + return KeyPair.fromSecret(this, secret); + }; + + EDDSA.prototype.makeSignature = function makeSignature(sig) { + if (sig instanceof Signature) return sig; + return new Signature(this, sig); + }; + /** + * * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2 + * + * EDDSA defines methods for encoding and decoding points and integers. These are + * helper convenience methods, that pass along to utility functions implied + * parameters. + * + */ + + EDDSA.prototype.encodePoint = function encodePoint(point) { + var enc = point.getY().toArray("le", this.encodingLength); + enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0; + return enc; + }; + + EDDSA.prototype.decodePoint = function decodePoint(bytes) { + bytes = utils.parseBytes(bytes); + var lastIx = bytes.length - 1; + var normed = bytes + .slice(0, lastIx) + .concat(bytes[lastIx] & ~0x80); + var xIsOdd = (bytes[lastIx] & 0x80) !== 0; + var y = utils.intFromLE(normed); + return this.curve.pointFromY(y, xIsOdd); + }; + + EDDSA.prototype.encodeInt = function encodeInt(num) { + return num.toArray("le", this.encodingLength); + }; + + EDDSA.prototype.decodeInt = function decodeInt(bytes) { + return utils.intFromLE(bytes); + }; + + EDDSA.prototype.isPoint = function isPoint(val) { + return val instanceof this.pointClass; + }; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/eddsa/key.js": + /* !*********************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/eddsa/key.js ***! + \*********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var assert = utils.assert; + var parseBytes = utils.parseBytes; + var cachedProperty = utils.cachedProperty; + /** + * @param {EDDSA} eddsa - instance + * @param {Object} params - public/private key parameters + * + * @param {Array} [params.secret] - secret seed bytes + * @param {Point} [params.pub] - public key point (aka `A` in eddsa terms) + * @param {Array} [params.pub] - public key point encoded as bytes + * + */ + + function KeyPair(eddsa, params) { + this.eddsa = eddsa; + this._secret = parseBytes(params.secret); + if (eddsa.isPoint(params.pub)) this._pub = params.pub; + else this._pubBytes = parseBytes(params.pub); + } + + KeyPair.fromPublic = function fromPublic(eddsa, pub) { + if (pub instanceof KeyPair) return pub; + return new KeyPair(eddsa, { + pub: pub, + }); + }; + + KeyPair.fromSecret = function fromSecret(eddsa, secret) { + if (secret instanceof KeyPair) return secret; + return new KeyPair(eddsa, { + secret: secret, + }); + }; + + KeyPair.prototype.secret = function secret() { + return this._secret; + }; + + cachedProperty(KeyPair, "pubBytes", function pubBytes() { + return this.eddsa.encodePoint(this.pub()); + }); + cachedProperty(KeyPair, "pub", function pub() { + if (this._pubBytes) + return this.eddsa.decodePoint(this._pubBytes); + return this.eddsa.g.mul(this.priv()); + }); + cachedProperty(KeyPair, "privBytes", function privBytes() { + var eddsa = this.eddsa; + var hash = this.hash(); + var lastIx = eddsa.encodingLength - 1; + var a = hash.slice(0, eddsa.encodingLength); + a[0] &= 248; + a[lastIx] &= 127; + a[lastIx] |= 64; + return a; + }); + cachedProperty(KeyPair, "priv", function priv() { + return this.eddsa.decodeInt(this.privBytes()); + }); + cachedProperty(KeyPair, "hash", function hash() { + return this.eddsa.hash().update(this.secret()).digest(); + }); + cachedProperty(KeyPair, "messagePrefix", function messagePrefix() { + return this.hash().slice(this.eddsa.encodingLength); + }); + + KeyPair.prototype.sign = function sign(message) { + assert(this._secret, "KeyPair can only verify"); + return this.eddsa.sign(message, this); + }; + + KeyPair.prototype.verify = function verify(message, sig) { + return this.eddsa.verify(message, sig, this); + }; + + KeyPair.prototype.getSecret = function getSecret(enc) { + assert(this._secret, "KeyPair is public only"); + return utils.encode(this.secret(), enc); + }; + + KeyPair.prototype.getPublic = function getPublic(enc) { + return utils.encode(this.pubBytes(), enc); + }; + + module.exports = KeyPair; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/eddsa/signature.js": + /* !***************************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/eddsa/signature.js ***! + \***************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js" + ); + + var assert = utils.assert; + var cachedProperty = utils.cachedProperty; + var parseBytes = utils.parseBytes; + /** + * @param {EDDSA} eddsa - eddsa instance + * @param {Array|Object} sig - + * @param {Array|Point} [sig.R] - R point as Point or bytes + * @param {Array|bn} [sig.S] - S scalar as bn or bytes + * @param {Array} [sig.Rencoded] - R point encoded + * @param {Array} [sig.Sencoded] - S scalar encoded + */ + + function Signature(eddsa, sig) { + this.eddsa = eddsa; + if (_typeof(sig) !== "object") sig = parseBytes(sig); + + if (Array.isArray(sig)) { + sig = { + R: sig.slice(0, eddsa.encodingLength), + S: sig.slice(eddsa.encodingLength), + }; + } + + assert(sig.R && sig.S, "Signature without R or S"); + if (eddsa.isPoint(sig.R)) this._R = sig.R; + if (sig.S instanceof BN) this._S = sig.S; + this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded; + this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded; + } + + cachedProperty(Signature, "S", function S() { + return this.eddsa.decodeInt(this.Sencoded()); + }); + cachedProperty(Signature, "R", function R() { + return this.eddsa.decodePoint(this.Rencoded()); + }); + cachedProperty(Signature, "Rencoded", function Rencoded() { + return this.eddsa.encodePoint(this.R()); + }); + cachedProperty(Signature, "Sencoded", function Sencoded() { + return this.eddsa.encodeInt(this.S()); + }); + + Signature.prototype.toBytes = function toBytes() { + return this.Rencoded().concat(this.Sencoded()); + }; + + Signature.prototype.toHex = function toHex() { + return utils.encode(this.toBytes(), "hex").toUpperCase(); + }; + + module.exports = Signature; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js": + /* !*********************************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js ***! + \*********************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + module.exports = { + doubles: { + step: 4, + points: [ + [ + "e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a", + "f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821", + ], + [ + "8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508", + "11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf", + ], + [ + "175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739", + "d3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695", + ], + [ + "363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640", + "4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9", + ], + [ + "8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c", + "4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36", + ], + [ + "723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda", + "96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f", + ], + [ + "eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa", + "5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999", + ], + [ + "100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0", + "cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09", + ], + [ + "e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d", + "9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d", + ], + [ + "feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d", + "e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088", + ], + [ + "da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1", + "9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d", + ], + [ + "53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0", + "5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8", + ], + [ + "8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047", + "10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a", + ], + [ + "385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862", + "283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453", + ], + [ + "6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7", + "7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160", + ], + [ + "3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd", + "56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0", + ], + [ + "85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83", + "7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6", + ], + [ + "948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a", + "53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589", + ], + [ + "6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8", + "bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17", + ], + [ + "e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d", + "4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda", + ], + [ + "e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725", + "7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd", + ], + [ + "213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754", + "4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2", + ], + [ + "4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c", + "17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6", + ], + [ + "fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6", + "6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f", + ], + [ + "76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39", + "c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01", + ], + [ + "c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891", + "893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3", + ], + [ + "d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b", + "febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f", + ], + [ + "b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03", + "2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7", + ], + [ + "e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d", + "eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78", + ], + [ + "a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070", + "7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1", + ], + [ + "90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4", + "e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150", + ], + [ + "8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da", + "662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82", + ], + [ + "e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11", + "1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc", + ], + [ + "8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e", + "efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b", + ], + [ + "e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41", + "2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51", + ], + [ + "b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef", + "67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45", + ], + [ + "d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8", + "db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120", + ], + [ + "324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d", + "648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84", + ], + [ + "4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96", + "35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d", + ], + [ + "9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd", + "ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d", + ], + [ + "6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5", + "9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8", + ], + [ + "a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266", + "40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8", + ], + [ + "7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71", + "34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac", + ], + [ + "928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac", + "c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f", + ], + [ + "85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751", + "1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962", + ], + [ + "ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e", + "493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907", + ], + [ + "827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241", + "c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec", + ], + [ + "eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3", + "be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d", + ], + [ + "e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f", + "4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414", + ], + [ + "1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19", + "aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd", + ], + [ + "146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be", + "b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0", + ], + [ + "fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9", + "6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811", + ], + [ + "da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2", + "8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1", + ], + [ + "a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13", + "7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c", + ], + [ + "174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c", + "ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73", + ], + [ + "959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba", + "2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd", + ], + [ + "d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151", + "e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405", + ], + [ + "64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073", + "d99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589", + ], + [ + "8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458", + "38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e", + ], + [ + "13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b", + "69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27", + ], + [ + "bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366", + "d3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1", + ], + [ + "8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa", + "40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482", + ], + [ + "8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0", + "620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945", + ], + [ + "dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787", + "7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573", + ], + [ + "f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e", + "ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82", + ], + ], + }, + naf: { + wnd: 7, + points: [ + [ + "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9", + "388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672", + ], + [ + "2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4", + "d8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6", + ], + [ + "5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc", + "6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da", + ], + [ + "acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe", + "cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37", + ], + [ + "774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb", + "d984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b", + ], + [ + "f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8", + "ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81", + ], + [ + "d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e", + "581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58", + ], + [ + "defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34", + "4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77", + ], + [ + "2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c", + "85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a", + ], + [ + "352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5", + "321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c", + ], + [ + "2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f", + "2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67", + ], + [ + "9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714", + "73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402", + ], + [ + "daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729", + "a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55", + ], + [ + "c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db", + "2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482", + ], + [ + "6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4", + "e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82", + ], + [ + "1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5", + "b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396", + ], + [ + "605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479", + "2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49", + ], + [ + "62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d", + "80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf", + ], + [ + "80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f", + "1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a", + ], + [ + "7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb", + "d0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7", + ], + [ + "d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9", + "eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933", + ], + [ + "49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963", + "758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a", + ], + [ + "77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74", + "958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6", + ], + [ + "f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530", + "e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37", + ], + [ + "463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b", + "5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e", + ], + [ + "f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247", + "cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6", + ], + [ + "caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1", + "cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476", + ], + [ + "2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120", + "4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40", + ], + [ + "7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435", + "91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61", + ], + [ + "754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18", + "673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683", + ], + [ + "e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8", + "59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5", + ], + [ + "186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb", + "3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b", + ], + [ + "df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f", + "55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417", + ], + [ + "5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143", + "efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868", + ], + [ + "290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba", + "e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a", + ], + [ + "af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45", + "f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6", + ], + [ + "766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a", + "744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996", + ], + [ + "59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e", + "c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e", + ], + [ + "f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8", + "e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d", + ], + [ + "7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c", + "30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2", + ], + [ + "948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519", + "e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e", + ], + [ + "7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab", + "100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437", + ], + [ + "3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca", + "ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311", + ], + [ + "d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf", + "8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4", + ], + [ + "1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610", + "68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575", + ], + [ + "733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4", + "f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d", + ], + [ + "15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c", + "d56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d", + ], + [ + "a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940", + "edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629", + ], + [ + "e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980", + "a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06", + ], + [ + "311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3", + "66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374", + ], + [ + "34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf", + "9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee", + ], + [ + "f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63", + "4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1", + ], + [ + "d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448", + "fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b", + ], + [ + "32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf", + "5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661", + ], + [ + "7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5", + "8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6", + ], + [ + "ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6", + "8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e", + ], + [ + "16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5", + "5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d", + ], + [ + "eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99", + "f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc", + ], + [ + "78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51", + "f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4", + ], + [ + "494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5", + "42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c", + ], + [ + "a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5", + "204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b", + ], + [ + "c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997", + "4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913", + ], + [ + "841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881", + "73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154", + ], + [ + "5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5", + "39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865", + ], + [ + "36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66", + "d2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc", + ], + [ + "336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726", + "ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224", + ], + [ + "8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede", + "6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e", + ], + [ + "1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94", + "60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6", + ], + [ + "85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31", + "3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511", + ], + [ + "29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51", + "b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b", + ], + [ + "a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252", + "ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2", + ], + [ + "4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5", + "cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c", + ], + [ + "d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b", + "6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3", + ], + [ + "ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4", + "322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d", + ], + [ + "af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f", + "6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700", + ], + [ + "e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889", + "2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4", + ], + [ + "591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246", + "b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196", + ], + [ + "11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984", + "998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4", + ], + [ + "3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a", + "b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257", + ], + [ + "cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030", + "bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13", + ], + [ + "c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197", + "6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096", + ], + [ + "c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593", + "c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38", + ], + [ + "a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef", + "21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f", + ], + [ + "347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38", + "60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448", + ], + [ + "da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a", + "49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a", + ], + [ + "c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111", + "5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4", + ], + [ + "4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502", + "7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437", + ], + [ + "3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea", + "be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7", + ], + [ + "cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26", + "8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d", + ], + [ + "b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986", + "39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a", + ], + [ + "d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e", + "62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54", + ], + [ + "48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4", + "25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77", + ], + [ + "dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda", + "ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517", + ], + [ + "6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859", + "cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10", + ], + [ + "e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f", + "f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125", + ], + [ + "eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c", + "6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e", + ], + [ + "13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942", + "fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1", + ], + [ + "ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a", + "1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2", + ], + [ + "b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80", + "5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423", + ], + [ + "ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d", + "438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8", + ], + [ + "8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1", + "cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758", + ], + [ + "52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63", + "c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375", + ], + [ + "e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352", + "6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d", + ], + [ + "7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193", + "ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec", + ], + [ + "5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00", + "9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0", + ], + [ + "32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58", + "ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c", + ], + [ + "e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7", + "d3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4", + ], + [ + "8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8", + "c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f", + ], + [ + "4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e", + "67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649", + ], + [ + "3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d", + "cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826", + ], + [ + "674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b", + "299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5", + ], + [ + "d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f", + "f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87", + ], + [ + "30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6", + "462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b", + ], + [ + "be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297", + "62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc", + ], + [ + "93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a", + "7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c", + ], + [ + "b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c", + "ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f", + ], + [ + "d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52", + "4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a", + ], + [ + "d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb", + "bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46", + ], + [ + "463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065", + "bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f", + ], + [ + "7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917", + "603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03", + ], + [ + "74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9", + "cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08", + ], + [ + "30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3", + "553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8", + ], + [ + "9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57", + "712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373", + ], + [ + "176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66", + "ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3", + ], + [ + "75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8", + "9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8", + ], + [ + "809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721", + "9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1", + ], + [ + "1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180", + "4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9", + ], + ], + }, + }; + + /***/ + }, + + /***/ "./node_modules/elliptic/lib/elliptic/utils.js": + /* !*****************************************************!*\ + !*** ./node_modules/elliptic/lib/elliptic/utils.js ***! + \*****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = exports; + + var BN = __webpack_require__( + /* ! bn.js */ "./node_modules/bn.js/lib/bn.js" + ); + + var minAssert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + var minUtils = __webpack_require__( + /* ! minimalistic-crypto-utils */ "./node_modules/minimalistic-crypto-utils/lib/utils.js" + ); + + utils.assert = minAssert; + utils.toArray = minUtils.toArray; + utils.zero2 = minUtils.zero2; + utils.toHex = minUtils.toHex; + utils.encode = minUtils.encode; // Represent num in a w-NAF form + + function getNAF(num, w) { + var naf = []; + var ws = 1 << (w + 1); + var k = num.clone(); + + while (k.cmpn(1) >= 0) { + var z; + + if (k.isOdd()) { + var mod = k.andln(ws - 1); + if (mod > (ws >> 1) - 1) z = (ws >> 1) - mod; + else z = mod; + k.isubn(z); + } else { + z = 0; + } + + naf.push(z); // Optimization, shift by word if possible + + var shift = + k.cmpn(0) !== 0 && k.andln(ws - 1) === 0 ? w + 1 : 1; + + for (var i = 1; i < shift; i++) { + naf.push(0); + } + + k.iushrn(shift); + } + + return naf; + } + + utils.getNAF = getNAF; // Represent k1, k2 in a Joint Sparse Form + + function getJSF(k1, k2) { + var jsf = [[], []]; + k1 = k1.clone(); + k2 = k2.clone(); + var d1 = 0; + var d2 = 0; + + while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) { + // First phase + var m14 = (k1.andln(3) + d1) & 3; + var m24 = (k2.andln(3) + d2) & 3; + if (m14 === 3) m14 = -1; + if (m24 === 3) m24 = -1; + var u1; + + if ((m14 & 1) === 0) { + u1 = 0; + } else { + var m8 = (k1.andln(7) + d1) & 7; + if ((m8 === 3 || m8 === 5) && m24 === 2) u1 = -m14; + else u1 = m14; + } + + jsf[0].push(u1); + var u2; + + if ((m24 & 1) === 0) { + u2 = 0; + } else { + var m8 = (k2.andln(7) + d2) & 7; + if ((m8 === 3 || m8 === 5) && m14 === 2) u2 = -m24; + else u2 = m24; + } + + jsf[1].push(u2); // Second phase + + if (2 * d1 === u1 + 1) d1 = 1 - d1; + if (2 * d2 === u2 + 1) d2 = 1 - d2; + k1.iushrn(1); + k2.iushrn(1); + } + + return jsf; + } + + utils.getJSF = getJSF; + + function cachedProperty(obj, name, computer) { + var key = "_" + name; + + obj.prototype[name] = function cachedProperty() { + return this[key] !== undefined + ? this[key] + : (this[key] = computer.call(this)); + }; + } + + utils.cachedProperty = cachedProperty; + + function parseBytes(bytes) { + return typeof bytes === "string" + ? utils.toArray(bytes, "hex") + : bytes; + } + + utils.parseBytes = parseBytes; + + function intFromLE(bytes) { + return new BN(bytes, "hex", "le"); + } + + utils.intFromLE = intFromLE; + + /***/ + }, + + /***/ "./node_modules/elliptic/package.json": + /* !********************************************!*\ + !*** ./node_modules/elliptic/package.json ***! + \********************************************/ + /* ! exports provided: name, version, description, main, files, scripts, repository, keywords, author, license, bugs, homepage, devDependencies, dependencies, default */ + /***/ function (module) { + module.exports = JSON.parse( + '{"name":"elliptic","version":"6.5.1","description":"EC cryptography","main":"lib/elliptic.js","files":["lib"],"scripts":{"jscs":"jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js","jshint":"jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js","lint":"npm run jscs && npm run jshint","unit":"istanbul test _mocha --reporter=spec test/index.js","test":"npm run lint && npm run unit","version":"grunt dist && git add dist/"},"repository":{"type":"git","url":"git@github.com:indutny/elliptic"},"keywords":["EC","Elliptic","curve","Cryptography"],"author":"Fedor Indutny ","license":"MIT","bugs":{"url":"https://github.com/indutny/elliptic/issues"},"homepage":"https://github.com/indutny/elliptic","devDependencies":{"brfs":"^1.4.3","coveralls":"^3.0.4","grunt":"^1.0.4","grunt-browserify":"^5.0.0","grunt-cli":"^1.2.0","grunt-contrib-connect":"^1.0.0","grunt-contrib-copy":"^1.0.0","grunt-contrib-uglify":"^1.0.1","grunt-mocha-istanbul":"^3.0.1","grunt-saucelabs":"^9.0.1","istanbul":"^0.4.2","jscs":"^3.0.7","jshint":"^2.6.0","mocha":"^6.1.4"},"dependencies":{"bn.js":"^4.4.0","brorand":"^1.0.1","hash.js":"^1.0.0","hmac-drbg":"^1.0.0","inherits":"^2.0.1","minimalistic-assert":"^1.0.0","minimalistic-crypto-utils":"^1.0.0"}}' + ); + + /***/ + }, + + /***/ "./node_modules/escaper/dist/escaper.js": + /* !**********************************************!*\ + !*** ./node_modules/escaper/dist/escaper.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + function _typeof2(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof2 = function _typeof2(obj) { + return typeof obj; + }; + } else { + _typeof2 = function _typeof2(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof2(obj); + } + + /* ! + * Escaper v2.5.3 + * https://github.com/kobezzza/Escaper + * + * Released under the MIT license + * https://github.com/kobezzza/Escaper/blob/master/LICENSE + * + * Date: Tue, 23 Jan 2018 15:58:45 GMT + */ + (function (global, factory) { + (false ? undefined : _typeof2(exports)) === "object" && + typeof module !== "undefined" + ? factory(exports) + : typeof define === "function" && define.amd + ? define("Escaper", ["exports"], factory) + : factory((global.Escaper = {})); + })(this, function (exports) { + "use strict"; + + var _typeof = + typeof Symbol === "function" && + _typeof2(Symbol.iterator) === "symbol" + ? function (obj) { + return _typeof2(obj); + } + : function (obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : _typeof2(obj); + }; + + var Escaper = void 0; + var escaper = (Escaper = { + VERSION: [2, 5, 3], + content: [], + cache: {}, + snakeskinRgxp: null, + symbols: null, + replace: replace, + paste: paste, + }); + var stringLiterals = { + '"': true, + "'": true, + "`": true, + }; + var literals = { + "/": true, + }; + + for (var key in stringLiterals) { + if (!stringLiterals.hasOwnProperty(key)) { + break; + } + + literals[key] = true; + } + + var singleComments = { + "//": true, + "//*": true, + "//!": true, + "//#": true, + "//@": true, + "//$": true, + }; + var multComments = { + "/*": true, + "/**": true, + "/*!": true, + "/*#": true, + "/*@": true, + "/*$": true, + }; + var keyArr = []; + var finalMap = {}; + + for (var _key in literals) { + if (!literals.hasOwnProperty(_key)) { + break; + } + + keyArr.push(_key); + finalMap[_key] = true; + } + + for (var _key2 in singleComments) { + if (!singleComments.hasOwnProperty(_key2)) { + break; + } + + keyArr.push(_key2); + finalMap[_key2] = true; + } + + for (var _key3 in multComments) { + if (!multComments.hasOwnProperty(_key3)) { + break; + } + + keyArr.push(_key3); + finalMap[_key3] = true; + } + + var rgxpFlags = []; + var rgxpFlagsMap = { + g: true, + m: true, + i: true, + y: true, + u: true, + }; + + for (var _key4 in rgxpFlagsMap) { + if (!rgxpFlagsMap.hasOwnProperty(_key4)) { + break; + } + + rgxpFlags.push(_key4); + } + + var escapeEndMap = { + "-": true, + "+": true, + "*": true, + "%": true, + "~": true, + ">": true, + "<": true, + "^": true, + ",": true, + ";": true, + "=": true, + "|": true, + "&": true, + "!": true, + "?": true, + ":": true, + "(": true, + "{": true, + "[": true, + }; + var escapeEndWordMap = { + return: true, + yield: true, + await: true, + typeof: true, + void: true, + instanceof: true, + delete: true, + in: true, + new: true, + of: true, + }; + /** + * @param {!Object} obj + * @param {!Object} p + * @param {(boolean|number)} val + */ + + function mix(obj, p, val) { + for (var _key5 in obj) { + if (!obj.hasOwnProperty(_key5)) { + break; + } + + if (_key5 in p === false) { + p[_key5] = val; + } + } + } + + var symbols = void 0; + var snakeskinRgxp = void 0; + var uSRgxp = /[^\s/]/; + var wRgxp = /[a-z]/; + var sRgxp = /\s/; + var nRgxp = /[\r\n]/; + var posRgxp = /\${pos}/g; + var objMap = { + object: true, + function: true, + }; + /** + * Replaces all found blocks ' ... ', " ... ", ` ... `, / ... /, // ..., /* ... *\/ to + * __ESCAPER_QUOT__number_ in a string and returns a new string + * + * @param {string} str - source string + * @param {(Object|boolean)=} [opt_withCommentsOrParams=false] - parameters: + * + * (if a parameter value is set to -1, then all found matches will be removed from the final string, + * or if the value will be set to true/false they will be included/excluded) + * + * *) @label - template for replacement, e.g. __ESCAPER_QUOT__${pos}_ + * *) @all - replaces all found matches + * *) @comments - replaces all kinds of comments + * *) @strings - replaces all kinds of string literals + * *) @literals - replaces all kinds of string literals and regular expressions + * *) ` + * *) ' + * *) " + * *) / + * *) // + * *) //* + * *) //! + * *) //# + * *) //@ + * *) //$ + * *) /* + * *) /** + * *) /*! + * *) /*# + * *) /*@ + * *) /*$ + * + * OR if the value is boolean, then will be replaced all found comments (true) / literals (false) + * + * @param {Array=} [opt_content=Escaper.content] - array for matches + * @param {?boolean=} [opt_snakeskin] - private parameter for using with Snakeskin + * @return {string} + */ + + function replace( + str, + opt_withCommentsOrParams, + opt_content, + opt_snakeskin + ) { + symbols = symbols || Escaper.symbols || "a-z"; + snakeskinRgxp = + snakeskinRgxp || + Escaper.snakeskinRgxp || + new RegExp("[!$" + symbols + "_]", "i"); + var _Escaper = Escaper, + cache = _Escaper.cache, + content = _Escaper.content; + var isObj = Boolean( + opt_withCommentsOrParams && + objMap[ + typeof opt_withCommentsOrParams === "undefined" + ? "undefined" + : _typeof(opt_withCommentsOrParams) + ] + ); + var p = isObj ? Object(opt_withCommentsOrParams) : {}; + + function mark(pos) { + if (p["@label"]) { + return p["@label"].replace(posRgxp, pos); + } + + return "__ESCAPER_QUOT__" + pos + "_"; + } + + var withComments = false; + + if (typeof opt_withCommentsOrParams === "boolean") { + withComments = Boolean(opt_withCommentsOrParams); + } + + if ("@comments" in p) { + mix(multComments, p, p["@comments"]); + mix(singleComments, p, p["@comments"]); + delete p["@comments"]; + } + + if ("@strings" in p) { + mix(stringLiterals, p, p["@strings"]); + delete p["@strings"]; + } + + if ("@literals" in p) { + mix(literals, p, p["@literals"]); + delete p["@literals"]; + } + + if ("@all" in p) { + mix(finalMap, p, p["@all"]); + delete p["@all"]; + } + + var cacheKey = ""; + + for (var i = -1; ++i < keyArr.length; ) { + var el = keyArr[i]; + + if (multComments[el] || singleComments[el]) { + p[el] = withComments || p[el]; + } else { + p[el] = p[el] || !isObj; + } + + cacheKey += p[el] + ","; + } + + var initStr = str, + stack = opt_content || content; + + if ( + stack === content && + cache[cacheKey] && + cache[cacheKey][initStr] + ) { + return cache[cacheKey][initStr]; + } + + var begin = false, + end = true; + var escape = false, + comment = false; + var selectionStart = 0, + block = false; + var templateVar = 0, + filterStart = false; + var cut = void 0, + label = void 0; + var part = "", + rPart = ""; + + for (var _i = -1; ++_i < str.length; ) { + var _el = str.charAt(_i); + + var next = str.charAt(_i + 1), + word = str.substr(_i, 2), + extWord = str.substr(_i, 3); + + if (!comment) { + if (!begin) { + if (_el === "/") { + if ( + singleComments[word] || + multComments[word] + ) { + if ( + singleComments[extWord] || + multComments[extWord] + ) { + comment = extWord; + } else { + comment = word; + } + } + + if (comment) { + selectionStart = _i; + continue; + } + } + + if ( + escapeEndMap[_el] || + escapeEndWordMap[rPart] + ) { + end = true; + rPart = ""; + } else if (uSRgxp.test(_el)) { + end = false; + } + + if (wRgxp.test(_el)) { + part += _el; + } else { + rPart = part; + part = ""; + } + + var skip = false; + + if (opt_snakeskin) { + if ( + _el === "|" && + snakeskinRgxp.test(next) + ) { + filterStart = true; + end = false; + skip = true; + } else if (filterStart && sRgxp.test(_el)) { + filterStart = false; + end = true; + skip = true; + } + } + + if (!skip) { + if (escapeEndMap[_el]) { + end = true; + } else if (uSRgxp.test(_el)) { + end = false; + } + } + } // [] inside RegExp + + if (begin === "/" && !escape) { + if (_el === "[") { + block = true; + } else if (_el === "]") { + block = false; + } + } + + if (!begin && templateVar) { + if (_el === "}") { + templateVar--; + } else if (_el === "{") { + templateVar++; + } + + if (!templateVar) { + _el = "`"; + } + } + + if (begin === "`" && !escape && word === "${") { + _el = "`"; + _i++; + templateVar++; + } + + if ( + finalMap[_el] && + (_el !== "/" || end) && + !begin + ) { + begin = _el; + selectionStart = _i; + } else if (begin && (_el === "\\" || escape)) { + escape = !escape; + } else if ( + finalMap[_el] && + begin === _el && + !escape && + (begin !== "/" || !block) + ) { + if (_el === "/") { + for (var j = -1; ++j < rgxpFlags.length; ) { + if (rgxpFlagsMap[str.charAt(_i + 1)]) { + _i++; + } + } + } + + begin = false; + end = false; + + if (p[_el]) { + cut = str.substring(selectionStart, _i + 1); + + if (p[_el] === -1) { + label = ""; + } else { + label = mark(stack.length); + stack.push(cut); + } + + str = + str.substring(0, selectionStart) + + label + + str.substring(_i + 1); + _i += label.length - cut.length; + } + } + } else if ( + (nRgxp.test(next) && singleComments[comment]) || + (multComments[_el + str.charAt(_i - 1)] && + _i - selectionStart > 2 && + multComments[comment]) + ) { + if (p[comment]) { + cut = str.substring(selectionStart, _i + 1); + + if (p[comment] === -1) { + label = ""; + } else { + label = mark(stack.length); + stack.push(cut); + } + + str = + str.substring(0, selectionStart) + + label + + str.substring(_i + 1); + _i += label.length - cut.length; + } + + comment = false; + } + } + + if (stack === content) { + cache[cacheKey] = cache[cacheKey] || {}; + cache[cacheKey][initStr] = str; + } + + return str; + } + + var pasteRgxp = /__ESCAPER_QUOT__(\d+)_/g; + /** + * Replaces all found blocks __ESCAPER_QUOT__number_ to real content in a string + * and returns a new string + * + * @param {string} str - source string + * @param {Array=} [opt_content=Escaper.content] - array of matches + * @param {RegExp=} [opt_rgxp] - RegExp for searching, e.g. /__ESCAPER_QUOT__(\d+)_/g + * @return {string} + */ + + function paste(str, opt_content, opt_rgxp) { + return str.replace(opt_rgxp || pasteRgxp, function ( + str, + pos + ) { + return (opt_content || Escaper.content)[pos]; + }); + } + + exports.default = escaper; + exports.replace = replace; + exports.paste = paste; + Object.defineProperty(exports, "__esModule", { + value: true, + }); + }); + + /***/ + }, + + /***/ "./node_modules/events/events.js": + /* !***************************************!*\ + !*** ./node_modules/events/events.js ***! + \***************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + // Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + var R = + (typeof Reflect === "undefined" + ? "undefined" + : _typeof(Reflect)) === "object" + ? Reflect + : null; + var ReflectApply = + R && typeof R.apply === "function" + ? R.apply + : function ReflectApply(target, receiver, args) { + return Function.prototype.apply.call( + target, + receiver, + args + ); + }; + var ReflectOwnKeys; + + if (R && typeof R.ownKeys === "function") { + ReflectOwnKeys = R.ownKeys; + } else if (Object.getOwnPropertySymbols) { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target).concat( + Object.getOwnPropertySymbols(target) + ); + }; + } else { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target); + }; + } + + function ProcessEmitWarning(warning) { + if (console && console.warn) console.warn(warning); + } + + var NumberIsNaN = + Number.isNaN || + function NumberIsNaN(value) { + return value !== value; + }; + + function EventEmitter() { + EventEmitter.init.call(this); + } + + module.exports = EventEmitter; // Backwards-compat with node 0.10.x + + EventEmitter.EventEmitter = EventEmitter; + EventEmitter.prototype._events = undefined; + EventEmitter.prototype._eventsCount = 0; + EventEmitter.prototype._maxListeners = undefined; // By default EventEmitters will print a warning if more than 10 listeners are + // added to it. This is a useful default which helps finding memory leaks. + + var defaultMaxListeners = 10; + Object.defineProperty(EventEmitter, "defaultMaxListeners", { + enumerable: true, + get: function get() { + return defaultMaxListeners; + }, + set: function set(arg) { + if ( + typeof arg !== "number" || + arg < 0 || + NumberIsNaN(arg) + ) { + throw new RangeError( + 'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + + arg + + "." + ); + } + + defaultMaxListeners = arg; + }, + }); + + EventEmitter.init = function () { + if ( + this._events === undefined || + this._events === Object.getPrototypeOf(this)._events + ) { + this._events = Object.create(null); + this._eventsCount = 0; + } + + this._maxListeners = this._maxListeners || undefined; + }; // Obviously not all Emitters should be limited to 10. This function allows + // that to be increased. Set to zero for unlimited. + + EventEmitter.prototype.setMaxListeners = function setMaxListeners( + n + ) { + if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) { + throw new RangeError( + 'The value of "n" is out of range. It must be a non-negative number. Received ' + + n + + "." + ); + } + + this._maxListeners = n; + return this; + }; + + function $getMaxListeners(that) { + if (that._maxListeners === undefined) + return EventEmitter.defaultMaxListeners; + return that._maxListeners; + } + + EventEmitter.prototype.getMaxListeners = function getMaxListeners() { + return $getMaxListeners(this); + }; + + EventEmitter.prototype.emit = function emit(type) { + var args = []; + + for (var i = 1; i < arguments.length; i++) { + args.push(arguments[i]); + } + + var doError = type === "error"; + var events = this._events; + if (events !== undefined) + doError = doError && events.error === undefined; + else if (!doError) return false; // If there is no 'error' event listener then throw. + + if (doError) { + var er; + if (args.length > 0) er = args[0]; + + if (er instanceof Error) { + // Note: The comments on the `throw` lines are intentional, they show + // up in Node's output if this results in an unhandled exception. + throw er; // Unhandled 'error' event + } // At least give some kind of context to the user + + var err = new Error( + "Unhandled error." + (er ? " (" + er.message + ")" : "") + ); + err.context = er; + throw err; // Unhandled 'error' event + } + + var handler = events[type]; + if (handler === undefined) return false; + + if (typeof handler === "function") { + ReflectApply(handler, this, args); + } else { + var len = handler.length; + var listeners = arrayClone(handler, len); + + for (var i = 0; i < len; ++i) { + ReflectApply(listeners[i], this, args); + } + } + + return true; + }; + + function _addListener(target, type, listener, prepend) { + var m; + var events; + var existing; + + if (typeof listener !== "function") { + throw new TypeError( + 'The "listener" argument must be of type Function. Received type ' + + _typeof(listener) + ); + } + + events = target._events; + + if (events === undefined) { + events = target._events = Object.create(null); + target._eventsCount = 0; + } else { + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (events.newListener !== undefined) { + target.emit( + "newListener", + type, + listener.listener ? listener.listener : listener + ); // Re-assign `events` because a newListener handler could have caused the + // this._events to be assigned to a new object + + events = target._events; + } + + existing = events[type]; + } + + if (existing === undefined) { + // Optimize the case of one listener. Don't need the extra array object. + existing = events[type] = listener; + ++target._eventsCount; + } else { + if (typeof existing === "function") { + // Adding the second element, need to change to array. + existing = events[type] = prepend + ? [listener, existing] + : [existing, listener]; // If we've already got an array, just append. + } else if (prepend) { + existing.unshift(listener); + } else { + existing.push(listener); + } // Check for listener leak + + m = $getMaxListeners(target); + + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; // No error code for this since it is a Warning + // eslint-disable-next-line no-restricted-syntax + + var w = new Error( + "Possible EventEmitter memory leak detected. " + + existing.length + + " " + + String(type) + + " listeners " + + "added. Use emitter.setMaxListeners() to " + + "increase limit" + ); + w.name = "MaxListenersExceededWarning"; + w.emitter = target; + w.type = type; + w.count = existing.length; + ProcessEmitWarning(w); + } + } + + return target; + } + + EventEmitter.prototype.addListener = function addListener( + type, + listener + ) { + return _addListener(this, type, listener, false); + }; + + EventEmitter.prototype.on = EventEmitter.prototype.addListener; + + EventEmitter.prototype.prependListener = function prependListener( + type, + listener + ) { + return _addListener(this, type, listener, true); + }; + + function onceWrapper() { + var args = []; + + for (var i = 0; i < arguments.length; i++) { + args.push(arguments[i]); + } + + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + ReflectApply(this.listener, this.target, args); + } + } + + function _onceWrap(target, type, listener) { + var state = { + fired: false, + wrapFn: undefined, + target: target, + type: type, + listener: listener, + }; + var wrapped = onceWrapper.bind(state); + wrapped.listener = listener; + state.wrapFn = wrapped; + return wrapped; + } + + EventEmitter.prototype.once = function once(type, listener) { + if (typeof listener !== "function") { + throw new TypeError( + 'The "listener" argument must be of type Function. Received type ' + + _typeof(listener) + ); + } + + this.on(type, _onceWrap(this, type, listener)); + return this; + }; + + EventEmitter.prototype.prependOnceListener = function prependOnceListener( + type, + listener + ) { + if (typeof listener !== "function") { + throw new TypeError( + 'The "listener" argument must be of type Function. Received type ' + + _typeof(listener) + ); + } + + this.prependListener(type, _onceWrap(this, type, listener)); + return this; + }; // Emits a 'removeListener' event if and only if the listener was removed. + + EventEmitter.prototype.removeListener = function removeListener( + type, + listener + ) { + var list, events, position, i, originalListener; + + if (typeof listener !== "function") { + throw new TypeError( + 'The "listener" argument must be of type Function. Received type ' + + _typeof(listener) + ); + } + + events = this._events; + if (events === undefined) return this; + list = events[type]; + if (list === undefined) return this; + + if (list === listener || list.listener === listener) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else { + delete events[type]; + if (events.removeListener) + this.emit( + "removeListener", + type, + list.listener || listener + ); + } + } else if (typeof list !== "function") { + position = -1; + + for (i = list.length - 1; i >= 0; i--) { + if ( + list[i] === listener || + list[i].listener === listener + ) { + originalListener = list[i].listener; + position = i; + break; + } + } + + if (position < 0) return this; + if (position === 0) list.shift(); + else { + spliceOne(list, position); + } + if (list.length === 1) events[type] = list[0]; + if (events.removeListener !== undefined) + this.emit( + "removeListener", + type, + originalListener || listener + ); + } + + return this; + }; + + EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + + EventEmitter.prototype.removeAllListeners = function removeAllListeners( + type + ) { + var listeners, events, i; + events = this._events; + if (events === undefined) return this; // Not listening for removeListener, no need to emit + + if (events.removeListener === undefined) { + if (arguments.length === 0) { + this._events = Object.create(null); + this._eventsCount = 0; + } else if (events[type] !== undefined) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else delete events[type]; + } + + return this; + } // Emit removeListener for all listeners on all events + + if (arguments.length === 0) { + var keys = Object.keys(events); + var key; + + for (i = 0; i < keys.length; ++i) { + key = keys[i]; + if (key === "removeListener") continue; + this.removeAllListeners(key); + } + + this.removeAllListeners("removeListener"); + this._events = Object.create(null); + this._eventsCount = 0; + return this; + } + + listeners = events[type]; + + if (typeof listeners === "function") { + this.removeListener(type, listeners); + } else if (listeners !== undefined) { + // LIFO order + for (i = listeners.length - 1; i >= 0; i--) { + this.removeListener(type, listeners[i]); + } + } + + return this; + }; + + function _listeners(target, type, unwrap) { + var events = target._events; + if (events === undefined) return []; + var evlistener = events[type]; + if (evlistener === undefined) return []; + if (typeof evlistener === "function") + return unwrap + ? [evlistener.listener || evlistener] + : [evlistener]; + return unwrap + ? unwrapListeners(evlistener) + : arrayClone(evlistener, evlistener.length); + } + + EventEmitter.prototype.listeners = function listeners(type) { + return _listeners(this, type, true); + }; + + EventEmitter.prototype.rawListeners = function rawListeners(type) { + return _listeners(this, type, false); + }; + + EventEmitter.listenerCount = function (emitter, type) { + if (typeof emitter.listenerCount === "function") { + return emitter.listenerCount(type); + } + return listenerCount.call(emitter, type); + + }; + + EventEmitter.prototype.listenerCount = listenerCount; + + function listenerCount(type) { + var events = this._events; + + if (events !== undefined) { + var evlistener = events[type]; + + if (typeof evlistener === "function") { + return 1; + } else if (evlistener !== undefined) { + return evlistener.length; + } + } + + return 0; + } + + EventEmitter.prototype.eventNames = function eventNames() { + return this._eventsCount > 0 + ? ReflectOwnKeys(this._events) + : []; + }; + + function arrayClone(arr, n) { + var copy = new Array(n); + + for (var i = 0; i < n; ++i) { + copy[i] = arr[i]; + } + + return copy; + } + + function spliceOne(list, index) { + for (; index + 1 < list.length; index++) { + list[index] = list[index + 1]; + } + + list.pop(); + } + + function unwrapListeners(arr) { + var ret = new Array(arr.length); + + for (var i = 0; i < ret.length; ++i) { + ret[i] = arr[i].listener || arr[i]; + } + + return ret; + } + + /***/ + }, + + /***/ "./node_modules/evp_bytestokey/index.js": + /* !**********************************************!*\ + !*** ./node_modules/evp_bytestokey/index.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var MD5 = __webpack_require__( + /* ! md5.js */ "./node_modules/md5.js/index.js" + ); + /* eslint-disable camelcase */ + + function EVP_BytesToKey(password, salt, keyBits, ivLen) { + if (!Buffer.isBuffer(password)) + password = Buffer.from(password, "binary"); + + if (salt) { + if (!Buffer.isBuffer(salt)) + salt = Buffer.from(salt, "binary"); + if (salt.length !== 8) + throw new RangeError( + "salt should be Buffer with 8 byte length" + ); + } + + var keyLen = keyBits / 8; + var key = Buffer.alloc(keyLen); + var iv = Buffer.alloc(ivLen || 0); + var tmp = Buffer.alloc(0); + + while (keyLen > 0 || ivLen > 0) { + var hash = new MD5(); + hash.update(tmp); + hash.update(password); + if (salt) hash.update(salt); + tmp = hash.digest(); + var used = 0; + + if (keyLen > 0) { + var keyStart = key.length - keyLen; + used = Math.min(keyLen, tmp.length); + tmp.copy(key, keyStart, 0, used); + keyLen -= used; + } + + if (used < tmp.length && ivLen > 0) { + var ivStart = iv.length - ivLen; + var length = Math.min(ivLen, tmp.length - used); + tmp.copy(iv, ivStart, used, used + length); + ivLen -= length; + } + } + + tmp.fill(0); + return { + key: key, + iv: iv, + }; + } + + module.exports = EVP_BytesToKey; + + /***/ + }, + + /***/ "./node_modules/graphlibrary/index.js": + /* !********************************************!*\ + !*** ./node_modules/graphlibrary/index.js ***! + \********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + module.exports = { + Graph: __webpack_require__( + /* ! ./lib/graph */ "./node_modules/graphlibrary/lib/graph.js" + ), + json: __webpack_require__( + /* ! ./lib/json */ "./node_modules/graphlibrary/lib/json.js" + ), + alg: __webpack_require__( + /* ! ./lib/alg */ "./node_modules/graphlibrary/lib/alg/index.js" + ), + }; + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/components.js": + /* !*********************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/components.js ***! + \*********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + module.exports = components; + + function components(g) { + var visited = {}; + var cmpts = []; + var cmpt; + + function dfs(v) { + if (_.has(visited, v)) return; + visited[v] = true; + cmpt.push(v); + + _.each(g.successors(v), dfs); + + _.each(g.predecessors(v), dfs); + } + + _.each(g.nodes(), function (v) { + cmpt = []; + dfs(v); + + if (cmpt.length) { + cmpts.push(cmpt); + } + }); + + return cmpts; + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/dfs.js": + /* !**************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/dfs.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + module.exports = dfs; + /* + * A helper that preforms a pre- or post-order traversal on the input graph + * and returns the nodes in the order they were visited. If the graph is + * undirected then this algorithm will navigate using neighbors. If the graph + * is directed then this algorithm will navigate using successors. + * + * Order must be one of "pre" or "post". + */ + + function dfs(g, vs, order) { + if (!_.isArray(vs)) { + vs = [vs]; + } + + var navigation = (g.isDirected() + ? g.successors + : g.neighbors + ).bind(g); + var acc = []; + var visited = {}; + + _.each(vs, function (v) { + if (!g.hasNode(v)) { + throw new Error("Graph does not have node: " + v); + } + + doDfs(g, v, order === "post", visited, navigation, acc); + }); + + return acc; + } + + function doDfs(g, v, postorder, visited, navigation, acc) { + if (!_.has(visited, v)) { + visited[v] = true; + + if (!postorder) { + acc.push(v); + } + + _.each(navigation(v), function (w) { + doDfs(g, w, postorder, visited, navigation, acc); + }); + + if (postorder) { + acc.push(v); + } + } + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/dijkstra-all.js": + /* !***********************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/dijkstra-all.js ***! + \***********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var dijkstra = __webpack_require__( + /* ! ./dijkstra */ "./node_modules/graphlibrary/lib/alg/dijkstra.js" + ); + + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + module.exports = dijkstraAll; + + function dijkstraAll(g, weightFunc, edgeFunc) { + return _.transform( + g.nodes(), + function (acc, v) { + acc[v] = dijkstra(g, v, weightFunc, edgeFunc); + }, + {} + ); + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/dijkstra.js": + /* !*******************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/dijkstra.js ***! + \*******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + var PriorityQueue = __webpack_require__( + /* ! ../data/priority-queue */ "./node_modules/graphlibrary/lib/data/priority-queue.js" + ); + + module.exports = dijkstra; + + var DEFAULT_WEIGHT_FUNC = _.constant(1); + + function dijkstra(g, source, weightFn, edgeFn) { + return runDijkstra( + g, + String(source), + weightFn || DEFAULT_WEIGHT_FUNC, + edgeFn || + function (v) { + return g.outEdges(v); + } + ); + } + + function runDijkstra(g, source, weightFn, edgeFn) { + var results = {}; + var pq = new PriorityQueue(); + var v, vEntry; + + var updateNeighbors = function updateNeighbors(edge) { + var w = edge.v !== v ? edge.v : edge.w; + var wEntry = results[w]; + var weight = weightFn(edge); + var distance = vEntry.distance + weight; + + if (weight < 0) { + throw new Error( + "dijkstra does not allow negative edge weights. " + + "Bad edge: " + + edge + + " Weight: " + + weight + ); + } + + if (distance < wEntry.distance) { + wEntry.distance = distance; + wEntry.predecessor = v; + pq.decrease(w, distance); + } + }; + + g.nodes().forEach(function (v) { + var distance = v === source ? 0 : Number.POSITIVE_INFINITY; + results[v] = { + distance: distance, + }; + pq.add(v, distance); + }); + + while (pq.size() > 0) { + v = pq.removeMin(); + vEntry = results[v]; + + if (vEntry.distance === Number.POSITIVE_INFINITY) { + break; + } + + edgeFn(v).forEach(updateNeighbors); + } + + return results; + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/find-cycles.js": + /* !**********************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/find-cycles.js ***! + \**********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + var tarjan = __webpack_require__( + /* ! ./tarjan */ "./node_modules/graphlibrary/lib/alg/tarjan.js" + ); + + module.exports = findCycles; + + function findCycles(g) { + return _.filter(tarjan(g), function (cmpt) { + return ( + cmpt.length > 1 || + (cmpt.length === 1 && g.hasEdge(cmpt[0], cmpt[0])) + ); + }); + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/floyd-warshall.js": + /* !*************************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/floyd-warshall.js ***! + \*************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + module.exports = floydWarshall; + + var DEFAULT_WEIGHT_FUNC = _.constant(1); + + function floydWarshall(g, weightFn, edgeFn) { + return runFloydWarshall( + g, + weightFn || DEFAULT_WEIGHT_FUNC, + edgeFn || + function (v) { + return g.outEdges(v); + } + ); + } + + function runFloydWarshall(g, weightFn, edgeFn) { + var results = {}; + var nodes = g.nodes(); + nodes.forEach(function (v) { + results[v] = {}; + results[v][v] = { + distance: 0, + }; + nodes.forEach(function (w) { + if (v !== w) { + results[v][w] = { + distance: Number.POSITIVE_INFINITY, + }; + } + }); + edgeFn(v).forEach(function (edge) { + var w = edge.v === v ? edge.w : edge.v; + var d = weightFn(edge); + results[v][w] = { + distance: d, + predecessor: v, + }; + }); + }); + nodes.forEach(function (k) { + var rowK = results[k]; + nodes.forEach(function (i) { + var rowI = results[i]; + nodes.forEach(function (j) { + var ik = rowI[k]; + var kj = rowK[j]; + var ij = rowI[j]; + var altDistance = ik.distance + kj.distance; + + if (altDistance < ij.distance) { + ij.distance = altDistance; + ij.predecessor = kj.predecessor; + } + }); + }); + }); + return results; + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/index.js": + /* !****************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/index.js ***! + \****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + module.exports = { + components: __webpack_require__( + /* ! ./components */ "./node_modules/graphlibrary/lib/alg/components.js" + ), + dijkstra: __webpack_require__( + /* ! ./dijkstra */ "./node_modules/graphlibrary/lib/alg/dijkstra.js" + ), + dijkstraAll: __webpack_require__( + /* ! ./dijkstra-all */ "./node_modules/graphlibrary/lib/alg/dijkstra-all.js" + ), + findCycles: __webpack_require__( + /* ! ./find-cycles */ "./node_modules/graphlibrary/lib/alg/find-cycles.js" + ), + floydWarshall: __webpack_require__( + /* ! ./floyd-warshall */ "./node_modules/graphlibrary/lib/alg/floyd-warshall.js" + ), + isAcyclic: __webpack_require__( + /* ! ./is-acyclic */ "./node_modules/graphlibrary/lib/alg/is-acyclic.js" + ), + postorder: __webpack_require__( + /* ! ./postorder */ "./node_modules/graphlibrary/lib/alg/postorder.js" + ), + preorder: __webpack_require__( + /* ! ./preorder */ "./node_modules/graphlibrary/lib/alg/preorder.js" + ), + prim: __webpack_require__( + /* ! ./prim */ "./node_modules/graphlibrary/lib/alg/prim.js" + ), + tarjan: __webpack_require__( + /* ! ./tarjan */ "./node_modules/graphlibrary/lib/alg/tarjan.js" + ), + topsort: __webpack_require__( + /* ! ./topsort */ "./node_modules/graphlibrary/lib/alg/topsort.js" + ), + }; + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/is-acyclic.js": + /* !*********************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/is-acyclic.js ***! + \*********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var topsort = __webpack_require__( + /* ! ./topsort */ "./node_modules/graphlibrary/lib/alg/topsort.js" + ); + + module.exports = isAcyclic; + + function isAcyclic(g) { + try { + topsort(g); + } catch (e) { + if (e instanceof topsort.CycleException) { + return false; + } + + throw e; + } + + return true; + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/postorder.js": + /* !********************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/postorder.js ***! + \********************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var dfs = __webpack_require__( + /* ! ./dfs */ "./node_modules/graphlibrary/lib/alg/dfs.js" + ); + + module.exports = postorder; + + function postorder(g, vs) { + return dfs(g, vs, "post"); + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/preorder.js": + /* !*******************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/preorder.js ***! + \*******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var dfs = __webpack_require__( + /* ! ./dfs */ "./node_modules/graphlibrary/lib/alg/dfs.js" + ); + + module.exports = preorder; + + function preorder(g, vs) { + return dfs(g, vs, "pre"); + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/prim.js": + /* !***************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/prim.js ***! + \***************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + var Graph = __webpack_require__( + /* ! ../graph */ "./node_modules/graphlibrary/lib/graph.js" + ); + + var PriorityQueue = __webpack_require__( + /* ! ../data/priority-queue */ "./node_modules/graphlibrary/lib/data/priority-queue.js" + ); + + module.exports = prim; + + function prim(g, weightFunc) { + var result = new Graph(); + var parents = {}; + var pq = new PriorityQueue(); + var v; + + function updateNeighbors(edge) { + var w = edge.v === v ? edge.w : edge.v; + var pri = pq.priority(w); + + if (pri !== undefined) { + var edgeWeight = weightFunc(edge); + + if (edgeWeight < pri) { + parents[w] = v; + pq.decrease(w, edgeWeight); + } + } + } + + if (g.nodeCount() === 0) { + return result; + } + + _.each(g.nodes(), function (v) { + pq.add(v, Number.POSITIVE_INFINITY); + result.setNode(v); + }); // Start from an arbitrary node + + pq.decrease(g.nodes()[0], 0); + var init = false; + + while (pq.size() > 0) { + v = pq.removeMin(); + + if (_.has(parents, v)) { + result.setEdge(v, parents[v]); + } else if (init) { + throw new Error("Input graph is not connected: " + g); + } else { + init = true; + } + + g.nodeEdges(v).forEach(updateNeighbors); + } + + return result; + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/tarjan.js": + /* !*****************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/tarjan.js ***! + \*****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + module.exports = tarjan; + + function tarjan(g) { + var index = 0; + var stack = []; + var visited = {}; // Node id -> { onStack, lowlink, index } + + var results = []; + + function dfs(v) { + var entry = (visited[v] = { + onStack: true, + lowlink: index, + index: index++, + }); + stack.push(v); + g.successors(v).forEach(function (w) { + if (!_.has(visited, w)) { + dfs(w); + entry.lowlink = Math.min( + entry.lowlink, + visited[w].lowlink + ); + } else if (visited[w].onStack) { + entry.lowlink = Math.min( + entry.lowlink, + visited[w].index + ); + } + }); + + if (entry.lowlink === entry.index) { + var cmpt = []; + var w; + + do { + w = stack.pop(); + visited[w].onStack = false; + cmpt.push(w); + } while (v !== w); + + results.push(cmpt); + } + } + + g.nodes().forEach(function (v) { + if (!_.has(visited, v)) { + dfs(v); + } + }); + return results; + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/alg/topsort.js": + /* !******************************************************!*\ + !*** ./node_modules/graphlibrary/lib/alg/topsort.js ***! + \******************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + module.exports = topsort; + topsort.CycleException = CycleException; + + function topsort(g) { + var visited = {}; + var stack = {}; + var results = []; + + function visit(node) { + if (_.has(stack, node)) { + throw new CycleException(); + } + + if (!_.has(visited, node)) { + stack[node] = true; + visited[node] = true; + + _.each(g.predecessors(node), visit); + + delete stack[node]; + results.push(node); + } + } + + _.each(g.sinks(), visit); + + if (_.size(visited) !== g.nodeCount()) { + throw new CycleException(); + } + + return results; + } + + function CycleException() {} + + CycleException.prototype = new Error(); // Must be an instance of Error to pass testing + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/data/priority-queue.js": + /* !**************************************************************!*\ + !*** ./node_modules/graphlibrary/lib/data/priority-queue.js ***! + \**************************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + module.exports = PriorityQueue; + /** + * A min-priority queue data structure. This algorithm is derived from Cormen, + * et al., "Introduction to Algorithms". The basic idea of a min-priority + * queue is that you can efficiently (in O(1) time) get the smallest key in + * the queue. Adding and removing elements takes O(log n) time. A key can + * have its priority decreased in O(log n) time. + */ + + function PriorityQueue() { + this._arr = []; + this._keyIndices = {}; + } + /** + * Returns the number of elements in the queue. Takes `O(1)` time. + */ + + PriorityQueue.prototype.size = function () { + return this._arr.length; + }; + /** + * Returns the keys that are in the queue. Takes `O(n)` time. + */ + + PriorityQueue.prototype.keys = function () { + return this._arr.map(function (x) { + return x.key; + }); + }; + /** + * Returns `true` if **key** is in the queue and `false` if not. + */ + + PriorityQueue.prototype.has = function (key) { + return _.has(this._keyIndices, key); + }; + /** + * Returns the priority for **key**. If **key** is not present in the queue + * then this function returns `undefined`. Takes `O(1)` time. + * + * @param {Object} key + */ + + PriorityQueue.prototype.priority = function (key) { + var index = this._keyIndices[key]; + + if (index !== undefined) { + return this._arr[index].priority; + } + }; + /** + * Returns the key for the minimum element in this queue. If the queue is + * empty this function throws an Error. Takes `O(1)` time. + */ + + PriorityQueue.prototype.min = function () { + if (this.size() === 0) { + throw new Error("Queue underflow"); + } + + return this._arr[0].key; + }; + /** + * Inserts a new key into the priority queue. If the key already exists in + * the queue this function returns `false`; otherwise it will return `true`. + * Takes `O(n)` time. + * + * @param {Object} key the key to add + * @param {Number} priority the initial priority for the key + */ + + PriorityQueue.prototype.add = function (key, priority) { + var keyIndices = this._keyIndices; + key = String(key); + + if (!_.has(keyIndices, key)) { + var arr = this._arr; + var index = arr.length; + keyIndices[key] = index; + arr.push({ + key: key, + priority: priority, + }); + + this._decrease(index); + + return true; + } + + return false; + }; + /** + * Removes and returns the smallest key in the queue. Takes `O(log n)` time. + */ + + PriorityQueue.prototype.removeMin = function () { + this._swap(0, this._arr.length - 1); + + var min = this._arr.pop(); + + delete this._keyIndices[min.key]; + + this._heapify(0); + + return min.key; + }; + /** + * Decreases the priority for **key** to **priority**. If the new priority is + * greater than the previous priority, this function will throw an Error. + * + * @param {Object} key the key for which to raise priority + * @param {Number} priority the new priority for the key + */ + + PriorityQueue.prototype.decrease = function (key, priority) { + var index = this._keyIndices[key]; + + if (priority > this._arr[index].priority) { + throw new Error( + "New priority is greater than current priority. " + + "Key: " + + key + + " Old: " + + this._arr[index].priority + + " New: " + + priority + ); + } + + this._arr[index].priority = priority; + + this._decrease(index); + }; + + PriorityQueue.prototype._heapify = function (i) { + var arr = this._arr; + var l = 2 * i; + var r = l + 1; + var largest = i; + + if (l < arr.length) { + largest = + arr[l].priority < arr[largest].priority ? l : largest; + + if (r < arr.length) { + largest = + arr[r].priority < arr[largest].priority + ? r + : largest; + } + + if (largest !== i) { + this._swap(i, largest); + + this._heapify(largest); + } + } + }; + + PriorityQueue.prototype._decrease = function (index) { + var arr = this._arr; + var priority = arr[index].priority; + var parent; + + while (index !== 0) { + parent = index >> 1; + + if (arr[parent].priority < priority) { + break; + } + + this._swap(index, parent); + + index = parent; + } + }; + + PriorityQueue.prototype._swap = function (i, j) { + var arr = this._arr; + var keyIndices = this._keyIndices; + var origArrI = arr[i]; + var origArrJ = arr[j]; + arr[i] = origArrJ; + arr[j] = origArrI; + keyIndices[origArrJ.key] = i; + keyIndices[origArrI.key] = j; + }; + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/graph.js": + /* !************************************************!*\ + !*** ./node_modules/graphlibrary/lib/graph.js ***! + \************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + var _ = __webpack_require__( + /* ! ./lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + module.exports = Graph; + var DEFAULT_EDGE_NAME = "\x00"; + var GRAPH_NODE = "\x00"; + var EDGE_KEY_DELIM = "\x01"; // Implementation notes: + // + // * Node id query functions should return string ids for the nodes + // * Edge id query functions should return an "edgeObj", edge object, that is + // composed of enough information to uniquely identify an edge: {v, w, name}. + // * Internally we use an "edgeId", a stringified form of the edgeObj, to + // reference edges. This is because we need a performant way to look these + // edges up and, object properties, which have string keys, are the closest + // we're going to get to a performant hashtable in JavaScript. + + function Graph(opts) { + this._isDirected = _.has(opts, "directed") + ? opts.directed + : true; + this._isMultigraph = _.has(opts, "multigraph") + ? opts.multigraph + : false; + this._isCompound = _.has(opts, "compound") + ? opts.compound + : false; // Label for the graph itself + + this._label = undefined; // Defaults to be set when creating a new node + + this._defaultNodeLabelFn = _.constant(undefined); // Defaults to be set when creating a new edge + + this._defaultEdgeLabelFn = _.constant(undefined); // V -> label + + this._nodes = {}; + + if (this._isCompound) { + // V -> parent + this._parent = {}; // V -> children + + this._children = {}; + this._children[GRAPH_NODE] = {}; + } // V -> edgeObj + + this._in = {}; // U -> v -> Number + + this._preds = {}; // V -> edgeObj + + this._out = {}; // V -> w -> Number + + this._sucs = {}; // E -> edgeObj + + this._edgeObjs = {}; // E -> label + + this._edgeLabels = {}; + } + /* Number of nodes in the graph. Should only be changed by the implementation. */ + + Graph.prototype._nodeCount = 0; + /* Number of edges in the graph. Should only be changed by the implementation. */ + + Graph.prototype._edgeCount = 0; + /* === Graph functions ========= */ + + Graph.prototype.isDirected = function () { + return this._isDirected; + }; + + Graph.prototype.isMultigraph = function () { + return this._isMultigraph; + }; + + Graph.prototype.isCompound = function () { + return this._isCompound; + }; + + Graph.prototype.setGraph = function (label) { + this._label = label; + return this; + }; + + Graph.prototype.graph = function () { + return this._label; + }; + /* === Node functions ========== */ + + Graph.prototype.setDefaultNodeLabel = function (newDefault) { + if (!_.isFunction(newDefault)) { + newDefault = _.constant(newDefault); + } + + this._defaultNodeLabelFn = newDefault; + return this; + }; + + Graph.prototype.nodeCount = function () { + return this._nodeCount; + }; + + Graph.prototype.nodes = function () { + return _.keys(this._nodes); + }; + + Graph.prototype.sources = function () { + var self = this; + return _.filter(this.nodes(), function (v) { + return _.isEmpty(self._in[v]); + }); + }; + + Graph.prototype.sinks = function () { + var self = this; + return _.filter(this.nodes(), function (v) { + return _.isEmpty(self._out[v]); + }); + }; + + Graph.prototype.setNodes = function (vs, value) { + var args = arguments; + var self = this; + + _.each(vs, function (v) { + if (args.length > 1) { + self.setNode(v, value); + } else { + self.setNode(v); + } + }); + + return this; + }; + + Graph.prototype.setNode = function (v, value) { + if (_.has(this._nodes, v)) { + if (arguments.length > 1) { + this._nodes[v] = value; + } + + return this; + } + + this._nodes[v] = + arguments.length > 1 ? value : this._defaultNodeLabelFn(v); + + if (this._isCompound) { + this._parent[v] = GRAPH_NODE; + this._children[v] = {}; + this._children[GRAPH_NODE][v] = true; + } + + this._in[v] = {}; + this._preds[v] = {}; + this._out[v] = {}; + this._sucs[v] = {}; + ++this._nodeCount; + return this; + }; + + Graph.prototype.node = function (v) { + return this._nodes[v]; + }; + + Graph.prototype.hasNode = function (v) { + return _.has(this._nodes, v); + }; + + Graph.prototype.removeNode = function (v) { + var self = this; + + if (_.has(this._nodes, v)) { + var removeEdge = function removeEdge(e) { + self.removeEdge(self._edgeObjs[e]); + }; + + delete this._nodes[v]; + + if (this._isCompound) { + this._removeFromParentsChildList(v); + + delete this._parent[v]; + + _.each(this.children(v), function (child) { + self.setParent(child); + }); + + delete this._children[v]; + } + + _.each(_.keys(this._in[v]), removeEdge); + + delete this._in[v]; + delete this._preds[v]; + + _.each(_.keys(this._out[v]), removeEdge); + + delete this._out[v]; + delete this._sucs[v]; + --this._nodeCount; + } + + return this; + }; + + Graph.prototype.setParent = function (v, parent) { + if (!this._isCompound) { + throw new Error( + "Cannot set parent in a non-compound graph" + ); + } + + if (_.isUndefined(parent)) { + parent = GRAPH_NODE; + } else { + // Coerce parent to string + parent = String(parent); + + for ( + var ancestor = parent; + !_.isUndefined(ancestor); + ancestor = this.parent(ancestor) + ) { + if (ancestor === v) { + throw new Error( + "Setting " + + parent + + " as parent of " + + v + + " would create a cycle" + ); + } + } + + this.setNode(parent); + } + + this.setNode(v); + + this._removeFromParentsChildList(v); + + this._parent[v] = parent; + this._children[parent][v] = true; + return this; + }; + + Graph.prototype._removeFromParentsChildList = function (v) { + delete this._children[this._parent[v]][v]; + }; + + Graph.prototype.parent = function (v) { + if (this._isCompound) { + var parent = this._parent[v]; + + if (parent !== GRAPH_NODE) { + return parent; + } + } + }; + + Graph.prototype.children = function (v) { + if (_.isUndefined(v)) { + v = GRAPH_NODE; + } + + if (this._isCompound) { + var children = this._children[v]; + + if (children) { + return _.keys(children); + } + } else if (v === GRAPH_NODE) { + return this.nodes(); + } else if (this.hasNode(v)) { + return []; + } + }; + + Graph.prototype.predecessors = function (v) { + var predsV = this._preds[v]; + + if (predsV) { + return _.keys(predsV); + } + }; + + Graph.prototype.successors = function (v) { + var sucsV = this._sucs[v]; + + if (sucsV) { + return _.keys(sucsV); + } + }; + + Graph.prototype.neighbors = function (v) { + var preds = this.predecessors(v); + + if (preds) { + return _.union(preds, this.successors(v)); + } + }; + + Graph.prototype.isLeaf = function (v) { + var neighbors; + + if (this.isDirected()) { + neighbors = this.successors(v); + } else { + neighbors = this.neighbors(v); + } + + return neighbors.length === 0; + }; + + Graph.prototype.filterNodes = function (filter) { + var copy = new this.constructor({ + directed: this._isDirected, + multigraph: this._isMultigraph, + compound: this._isCompound, + }); + copy.setGraph(this.graph()); + var self = this; + + _.each(this._nodes, function (value, v) { + if (filter(v)) { + copy.setNode(v, value); + } + }); + + _.each(this._edgeObjs, function (e) { + if (copy.hasNode(e.v) && copy.hasNode(e.w)) { + copy.setEdge(e, self.edge(e)); + } + }); + + var parents = {}; + + function findParent(v) { + var parent = self.parent(v); + + if (parent === undefined || copy.hasNode(parent)) { + parents[v] = parent; + return parent; + } else if (parent in parents) { + return parents[parent]; + } + return findParent(parent); + + } + + if (this._isCompound) { + _.each(copy.nodes(), function (v) { + copy.setParent(v, findParent(v)); + }); + } + + return copy; + }; + /* === Edge functions ========== */ + + Graph.prototype.setDefaultEdgeLabel = function (newDefault) { + if (!_.isFunction(newDefault)) { + newDefault = _.constant(newDefault); + } + + this._defaultEdgeLabelFn = newDefault; + return this; + }; + + Graph.prototype.edgeCount = function () { + return this._edgeCount; + }; + + Graph.prototype.edges = function () { + return _.values(this._edgeObjs); + }; + + Graph.prototype.setPath = function (vs, value) { + var self = this; + var args = arguments; + + _.reduce(vs, function (v, w) { + if (args.length > 1) { + self.setEdge(v, w, value); + } else { + self.setEdge(v, w); + } + + return w; + }); + + return this; + }; + /* + * SetEdge(v, w, [value, [name]]) + * setEdge({ v, w, [name] }, [value]) + */ + + Graph.prototype.setEdge = function () { + var v, w, name, value; + var valueSpecified = false; + var arg0 = arguments[0]; + + if ( + _typeof(arg0) === "object" && + arg0 !== null && + "v" in arg0 + ) { + v = arg0.v; + w = arg0.w; + name = arg0.name; + + if (arguments.length === 2) { + value = arguments[1]; + valueSpecified = true; + } + } else { + v = arg0; + w = arguments[1]; + name = arguments[3]; + + if (arguments.length > 2) { + value = arguments[2]; + valueSpecified = true; + } + } + + v = String(v); + w = String(w); + + if (!_.isUndefined(name)) { + name = String(name); + } + + var e = edgeArgsToId(this._isDirected, v, w, name); + + if (_.has(this._edgeLabels, e)) { + if (valueSpecified) { + this._edgeLabels[e] = value; + } + + return this; + } + + if (!_.isUndefined(name) && !this._isMultigraph) { + throw new Error( + "Cannot set a named edge when isMultigraph = false" + ); + } // It didn't exist, so we need to create it. + // First ensure the nodes exist. + + this.setNode(v); + this.setNode(w); + this._edgeLabels[e] = valueSpecified + ? value + : this._defaultEdgeLabelFn(v, w, name); + var edgeObj = edgeArgsToObj(this._isDirected, v, w, name); // Ensure we add undirected edges in a consistent way. + + v = edgeObj.v; + w = edgeObj.w; + Object.freeze(edgeObj); + this._edgeObjs[e] = edgeObj; + incrementOrInitEntry(this._preds[w], v); + incrementOrInitEntry(this._sucs[v], w); + this._in[w][e] = edgeObj; + this._out[v][e] = edgeObj; + this._edgeCount++; + return this; + }; + + Graph.prototype.edge = function (v, w, name) { + var e = + arguments.length === 1 + ? edgeObjToId(this._isDirected, arguments[0]) + : edgeArgsToId(this._isDirected, v, w, name); + return this._edgeLabels[e]; + }; + + Graph.prototype.hasEdge = function (v, w, name) { + var e = + arguments.length === 1 + ? edgeObjToId(this._isDirected, arguments[0]) + : edgeArgsToId(this._isDirected, v, w, name); + return _.has(this._edgeLabels, e); + }; + + Graph.prototype.removeEdge = function (v, w, name) { + var e = + arguments.length === 1 + ? edgeObjToId(this._isDirected, arguments[0]) + : edgeArgsToId(this._isDirected, v, w, name); + var edge = this._edgeObjs[e]; + + if (edge) { + v = edge.v; + w = edge.w; + delete this._edgeLabels[e]; + delete this._edgeObjs[e]; + decrementOrRemoveEntry(this._preds[w], v); + decrementOrRemoveEntry(this._sucs[v], w); + delete this._in[w][e]; + delete this._out[v][e]; + this._edgeCount--; + } + + return this; + }; + + Graph.prototype.inEdges = function (v, u) { + var inV = this._in[v]; + + if (inV) { + var edges = _.values(inV); + + if (!u) { + return edges; + } + + return _.filter(edges, function (edge) { + return edge.v === u; + }); + } + }; + + Graph.prototype.outEdges = function (v, w) { + var outV = this._out[v]; + + if (outV) { + var edges = _.values(outV); + + if (!w) { + return edges; + } + + return _.filter(edges, function (edge) { + return edge.w === w; + }); + } + }; + + Graph.prototype.nodeEdges = function (v, w) { + var inEdges = this.inEdges(v, w); + + if (inEdges) { + return inEdges.concat(this.outEdges(v, w)); + } + }; + + function incrementOrInitEntry(map, k) { + if (map[k]) { + map[k]++; + } else { + map[k] = 1; + } + } + + function decrementOrRemoveEntry(map, k) { + if (!--map[k]) { + delete map[k]; + } + } + + function edgeArgsToId(isDirected, v_, w_, name) { + var v = String(v_); + var w = String(w_); + + if (!isDirected && v > w) { + var tmp = v; + v = w; + w = tmp; + } + + return ( + v + + EDGE_KEY_DELIM + + w + + EDGE_KEY_DELIM + + (_.isUndefined(name) ? DEFAULT_EDGE_NAME : name) + ); + } + + function edgeArgsToObj(isDirected, v_, w_, name) { + var v = String(v_); + var w = String(w_); + + if (!isDirected && v > w) { + var tmp = v; + v = w; + w = tmp; + } + + var edgeObj = { + v: v, + w: w, + }; + + if (name) { + edgeObj.name = name; + } + + return edgeObj; + } + + function edgeObjToId(isDirected, edgeObj) { + return edgeArgsToId( + isDirected, + edgeObj.v, + edgeObj.w, + edgeObj.name + ); + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/json.js": + /* !***********************************************!*\ + !*** ./node_modules/graphlibrary/lib/json.js ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var _ = __webpack_require__( + /* ! ./lodash */ "./node_modules/graphlibrary/lib/lodash.js" + ); + + var Graph = __webpack_require__( + /* ! ./graph */ "./node_modules/graphlibrary/lib/graph.js" + ); + + module.exports = { + write: write, + read: read, + }; + + function write(g) { + var json = { + options: { + directed: g.isDirected(), + multigraph: g.isMultigraph(), + compound: g.isCompound(), + }, + nodes: writeNodes(g), + edges: writeEdges(g), + }; + + if (!_.isUndefined(g.graph())) { + json.value = _.clone(g.graph()); + } + + return json; + } + + function writeNodes(g) { + return _.map(g.nodes(), function (v) { + var nodeValue = g.node(v); + var parent = g.parent(v); + var node = { + v: v, + }; + + if (!_.isUndefined(nodeValue)) { + node.value = nodeValue; + } + + if (!_.isUndefined(parent)) { + node.parent = parent; + } + + return node; + }); + } + + function writeEdges(g) { + return _.map(g.edges(), function (e) { + var edgeValue = g.edge(e); + var edge = { + v: e.v, + w: e.w, + }; + + if (!_.isUndefined(e.name)) { + edge.name = e.name; + } + + if (!_.isUndefined(edgeValue)) { + edge.value = edgeValue; + } + + return edge; + }); + } + + function read(json) { + var g = new Graph(json.options).setGraph(json.value); + + _.each(json.nodes, function (entry) { + g.setNode(entry.v, entry.value); + + if (entry.parent) { + g.setParent(entry.v, entry.parent); + } + }); + + _.each(json.edges, function (entry) { + g.setEdge( + { + v: entry.v, + w: entry.w, + name: entry.name, + }, + entry.value + ); + }); + + return g; + } + + /***/ + }, + + /***/ "./node_modules/graphlibrary/lib/lodash.js": + /* !*************************************************!*\ + !*** ./node_modules/graphlibrary/lib/lodash.js ***! + \*************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* global window */ + var lodash; + + if (true) { + try { + lodash = __webpack_require__( + /* ! lodash */ "./node_modules/lodash/lodash.js" + ); + } catch (e) {} + } + + if (!lodash) { + lodash = window._; + } + + module.exports = lodash; + + /***/ + }, + + /***/ "./node_modules/hash-base/index.js": + /* !*****************************************!*\ + !*** ./node_modules/hash-base/index.js ***! + \*****************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var Buffer = __webpack_require__( + /* ! safe-buffer */ "./node_modules/safe-buffer/index.js" + ).Buffer; + + var Transform = __webpack_require__( + /* ! stream */ "./node_modules/stream-browserify/index.js" + ).Transform; + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + function throwIfNotStringOrBuffer(val, prefix) { + if (!Buffer.isBuffer(val) && typeof val !== "string") { + throw new TypeError( + prefix + " must be a string or a buffer" + ); + } + } + + function HashBase(blockSize) { + Transform.call(this); + this._block = Buffer.allocUnsafe(blockSize); + this._blockSize = blockSize; + this._blockOffset = 0; + this._length = [0, 0, 0, 0]; + this._finalized = false; + } + + inherits(HashBase, Transform); + + HashBase.prototype._transform = function ( + chunk, + encoding, + callback + ) { + var error = null; + + try { + this.update(chunk, encoding); + } catch (err) { + error = err; + } + + callback(error); + }; + + HashBase.prototype._flush = function (callback) { + var error = null; + + try { + this.push(this.digest()); + } catch (err) { + error = err; + } + + callback(error); + }; + + HashBase.prototype.update = function (data, encoding) { + throwIfNotStringOrBuffer(data, "Data"); + if (this._finalized) throw new Error("Digest already called"); + if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding); // Consume data + + var block = this._block; + var offset = 0; + + while ( + this._blockOffset + data.length - offset >= + this._blockSize + ) { + for (var i = this._blockOffset; i < this._blockSize; ) { + block[i++] = data[offset++]; + } + + this._update(); + + this._blockOffset = 0; + } + + while (offset < data.length) { + block[this._blockOffset++] = data[offset++]; + } // Update length + + for (var j = 0, carry = data.length * 8; carry > 0; ++j) { + this._length[j] += carry; + carry = (this._length[j] / 0x0100000000) | 0; + if (carry > 0) this._length[j] -= 0x0100000000 * carry; + } + + return this; + }; + + HashBase.prototype._update = function () { + throw new Error("_update is not implemented"); + }; + + HashBase.prototype.digest = function (encoding) { + if (this._finalized) throw new Error("Digest already called"); + this._finalized = true; + + var digest = this._digest(); + + if (encoding !== undefined) digest = digest.toString(encoding); // Reset state + + this._block.fill(0); + + this._blockOffset = 0; + + for (var i = 0; i < 4; ++i) { + this._length[i] = 0; + } + + return digest; + }; + + HashBase.prototype._digest = function () { + throw new Error("_digest is not implemented"); + }; + + module.exports = HashBase; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash.js": + /* !******************************************!*\ + !*** ./node_modules/hash.js/lib/hash.js ***! + \******************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var hash = exports; + hash.utils = __webpack_require__( + /* ! ./hash/utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + hash.common = __webpack_require__( + /* ! ./hash/common */ "./node_modules/hash.js/lib/hash/common.js" + ); + hash.sha = __webpack_require__( + /* ! ./hash/sha */ "./node_modules/hash.js/lib/hash/sha.js" + ); + hash.ripemd = __webpack_require__( + /* ! ./hash/ripemd */ "./node_modules/hash.js/lib/hash/ripemd.js" + ); + hash.hmac = __webpack_require__( + /* ! ./hash/hmac */ "./node_modules/hash.js/lib/hash/hmac.js" + ); // Proxy hash functions to the main object + + hash.sha1 = hash.sha.sha1; + hash.sha256 = hash.sha.sha256; + hash.sha224 = hash.sha.sha224; + hash.sha384 = hash.sha.sha384; + hash.sha512 = hash.sha.sha512; + hash.ripemd160 = hash.ripemd.ripemd160; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/common.js": + /* !*************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/common.js ***! + \*************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ./utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + function BlockHash() { + this.pending = null; + this.pendingTotal = 0; + this.blockSize = this.constructor.blockSize; + this.outSize = this.constructor.outSize; + this.hmacStrength = this.constructor.hmacStrength; + this.padLength = this.constructor.padLength / 8; + this.endian = "big"; + this._delta8 = this.blockSize / 8; + this._delta32 = this.blockSize / 32; + } + + exports.BlockHash = BlockHash; + + BlockHash.prototype.update = function update(msg, enc) { + // Convert message to array, pad it, and join into 32bit blocks + msg = utils.toArray(msg, enc); + if (!this.pending) this.pending = msg; + else this.pending = this.pending.concat(msg); + this.pendingTotal += msg.length; // Enough data, try updating + + if (this.pending.length >= this._delta8) { + msg = this.pending; // Process pending data in blocks + + var r = msg.length % this._delta8; + this.pending = msg.slice(msg.length - r, msg.length); + if (this.pending.length === 0) this.pending = null; + msg = utils.join32(msg, 0, msg.length - r, this.endian); + + for (var i = 0; i < msg.length; i += this._delta32) { + this._update(msg, i, i + this._delta32); + } + } + + return this; + }; + + BlockHash.prototype.digest = function digest(enc) { + this.update(this._pad()); + assert(this.pending === null); + return this._digest(enc); + }; + + BlockHash.prototype._pad = function pad() { + var len = this.pendingTotal; + var bytes = this._delta8; + var k = bytes - ((len + this.padLength) % bytes); + var res = new Array(k + this.padLength); + res[0] = 0x80; + + for (var i = 1; i < k; i++) { + res[i] = 0; + } // Append length + + len <<= 3; + + if (this.endian === "big") { + for (var t = 8; t < this.padLength; t++) { + res[i++] = 0; + } + + res[i++] = 0; + res[i++] = 0; + res[i++] = 0; + res[i++] = 0; + res[i++] = (len >>> 24) & 0xff; + res[i++] = (len >>> 16) & 0xff; + res[i++] = (len >>> 8) & 0xff; + res[i++] = len & 0xff; + } else { + res[i++] = len & 0xff; + res[i++] = (len >>> 8) & 0xff; + res[i++] = (len >>> 16) & 0xff; + res[i++] = (len >>> 24) & 0xff; + res[i++] = 0; + res[i++] = 0; + res[i++] = 0; + res[i++] = 0; + + for (t = 8; t < this.padLength; t++) { + res[i++] = 0; + } + } + + return res; + }; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/hmac.js": + /* !***********************************************!*\ + !*** ./node_modules/hash.js/lib/hash/hmac.js ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ./utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + function Hmac(hash, key, enc) { + if (!(this instanceof Hmac)) return new Hmac(hash, key, enc); + this.Hash = hash; + this.blockSize = hash.blockSize / 8; + this.outSize = hash.outSize / 8; + this.inner = null; + this.outer = null; + + this._init(utils.toArray(key, enc)); + } + + module.exports = Hmac; + + Hmac.prototype._init = function init(key) { + // Shorten key, if needed + if (key.length > this.blockSize) + key = new this.Hash().update(key).digest(); + assert(key.length <= this.blockSize); // Add padding to key + + for (var i = key.length; i < this.blockSize; i++) { + key.push(0); + } + + for (i = 0; i < key.length; i++) { + key[i] ^= 0x36; + } + + this.inner = new this.Hash().update(key); // 0x36 ^ 0x5c = 0x6a + + for (i = 0; i < key.length; i++) { + key[i] ^= 0x6a; + } + + this.outer = new this.Hash().update(key); + }; + + Hmac.prototype.update = function update(msg, enc) { + this.inner.update(msg, enc); + return this; + }; + + Hmac.prototype.digest = function digest(enc) { + this.outer.update(this.inner.digest()); + return this.outer.digest(enc); + }; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/ripemd.js": + /* !*************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/ripemd.js ***! + \*************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ./utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var common = __webpack_require__( + /* ! ./common */ "./node_modules/hash.js/lib/hash/common.js" + ); + + var rotl32 = utils.rotl32; + var sum32 = utils.sum32; + var sum32_3 = utils.sum32_3; + var sum32_4 = utils.sum32_4; + var BlockHash = common.BlockHash; + + function RIPEMD160() { + if (!(this instanceof RIPEMD160)) return new RIPEMD160(); + BlockHash.call(this); + this.h = [ + 0x67452301, + 0xefcdab89, + 0x98badcfe, + 0x10325476, + 0xc3d2e1f0, + ]; + this.endian = "little"; + } + + utils.inherits(RIPEMD160, BlockHash); + exports.ripemd160 = RIPEMD160; + RIPEMD160.blockSize = 512; + RIPEMD160.outSize = 160; + RIPEMD160.hmacStrength = 192; + RIPEMD160.padLength = 64; + + RIPEMD160.prototype._update = function update(msg, start) { + var A = this.h[0]; + var B = this.h[1]; + var C = this.h[2]; + var D = this.h[3]; + var E = this.h[4]; + var Ah = A; + var Bh = B; + var Ch = C; + var Dh = D; + var Eh = E; + + for (var j = 0; j < 80; j++) { + var T = sum32( + rotl32( + sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), + s[j] + ), + E + ); + A = E; + E = D; + D = rotl32(C, 10); + C = B; + B = T; + T = sum32( + rotl32( + sum32_4( + Ah, + f(79 - j, Bh, Ch, Dh), + msg[rh[j] + start], + Kh(j) + ), + sh[j] + ), + Eh + ); + Ah = Eh; + Eh = Dh; + Dh = rotl32(Ch, 10); + Ch = Bh; + Bh = T; + } + + T = sum32_3(this.h[1], C, Dh); + this.h[1] = sum32_3(this.h[2], D, Eh); + this.h[2] = sum32_3(this.h[3], E, Ah); + this.h[3] = sum32_3(this.h[4], A, Bh); + this.h[4] = sum32_3(this.h[0], B, Ch); + this.h[0] = T; + }; + + RIPEMD160.prototype._digest = function digest(enc) { + if (enc === "hex") return utils.toHex32(this.h, "little"); + return utils.split32(this.h, "little"); + }; + + function f(j, x, y, z) { + if (j <= 15) return x ^ y ^ z; + else if (j <= 31) return (x & y) | (~x & z); + else if (j <= 47) return (x | ~y) ^ z; + else if (j <= 63) return (x & z) | (y & ~z); + return x ^ (y | ~z); + } + + function K(j) { + if (j <= 15) return 0x00000000; + else if (j <= 31) return 0x5a827999; + else if (j <= 47) return 0x6ed9eba1; + else if (j <= 63) return 0x8f1bbcdc; + return 0xa953fd4e; + } + + function Kh(j) { + if (j <= 15) return 0x50a28be6; + else if (j <= 31) return 0x5c4dd124; + else if (j <= 47) return 0x6d703ef3; + else if (j <= 63) return 0x7a6d76e9; + return 0x00000000; + } + + var r = [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 7, + 4, + 13, + 1, + 10, + 6, + 15, + 3, + 12, + 0, + 9, + 5, + 2, + 14, + 11, + 8, + 3, + 10, + 14, + 4, + 9, + 15, + 8, + 1, + 2, + 7, + 0, + 6, + 13, + 11, + 5, + 12, + 1, + 9, + 11, + 10, + 0, + 8, + 12, + 4, + 13, + 3, + 7, + 15, + 14, + 5, + 6, + 2, + 4, + 0, + 5, + 9, + 7, + 12, + 2, + 10, + 14, + 1, + 3, + 8, + 11, + 6, + 15, + 13, + ]; + var rh = [ + 5, + 14, + 7, + 0, + 9, + 2, + 11, + 4, + 13, + 6, + 15, + 8, + 1, + 10, + 3, + 12, + 6, + 11, + 3, + 7, + 0, + 13, + 5, + 10, + 14, + 15, + 8, + 12, + 4, + 9, + 1, + 2, + 15, + 5, + 1, + 3, + 7, + 14, + 6, + 9, + 11, + 8, + 12, + 2, + 10, + 0, + 4, + 13, + 8, + 6, + 4, + 1, + 3, + 11, + 15, + 0, + 5, + 12, + 2, + 13, + 9, + 7, + 10, + 14, + 12, + 15, + 10, + 4, + 1, + 5, + 8, + 7, + 6, + 2, + 13, + 14, + 0, + 3, + 9, + 11, + ]; + var s = [ + 11, + 14, + 15, + 12, + 5, + 8, + 7, + 9, + 11, + 13, + 14, + 15, + 6, + 7, + 9, + 8, + 7, + 6, + 8, + 13, + 11, + 9, + 7, + 15, + 7, + 12, + 15, + 9, + 11, + 7, + 13, + 12, + 11, + 13, + 6, + 7, + 14, + 9, + 13, + 15, + 14, + 8, + 13, + 6, + 5, + 12, + 7, + 5, + 11, + 12, + 14, + 15, + 14, + 15, + 9, + 8, + 9, + 14, + 5, + 6, + 8, + 6, + 5, + 12, + 9, + 15, + 5, + 11, + 6, + 8, + 13, + 12, + 5, + 12, + 13, + 14, + 11, + 8, + 5, + 6, + ]; + var sh = [ + 8, + 9, + 9, + 11, + 13, + 15, + 15, + 5, + 7, + 7, + 8, + 11, + 14, + 14, + 12, + 6, + 9, + 13, + 15, + 7, + 12, + 8, + 9, + 11, + 7, + 7, + 12, + 7, + 6, + 15, + 13, + 11, + 9, + 7, + 15, + 11, + 8, + 6, + 6, + 14, + 12, + 13, + 5, + 14, + 13, + 13, + 7, + 5, + 15, + 5, + 8, + 11, + 14, + 14, + 6, + 14, + 6, + 9, + 12, + 9, + 12, + 5, + 15, + 8, + 8, + 5, + 12, + 9, + 12, + 5, + 14, + 6, + 8, + 13, + 6, + 5, + 15, + 13, + 11, + 11, + ]; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/sha.js": + /* !**********************************************!*\ + !*** ./node_modules/hash.js/lib/hash/sha.js ***! + \**********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + exports.sha1 = __webpack_require__( + /* ! ./sha/1 */ "./node_modules/hash.js/lib/hash/sha/1.js" + ); + exports.sha224 = __webpack_require__( + /* ! ./sha/224 */ "./node_modules/hash.js/lib/hash/sha/224.js" + ); + exports.sha256 = __webpack_require__( + /* ! ./sha/256 */ "./node_modules/hash.js/lib/hash/sha/256.js" + ); + exports.sha384 = __webpack_require__( + /* ! ./sha/384 */ "./node_modules/hash.js/lib/hash/sha/384.js" + ); + exports.sha512 = __webpack_require__( + /* ! ./sha/512 */ "./node_modules/hash.js/lib/hash/sha/512.js" + ); + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/sha/1.js": + /* !************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/sha/1.js ***! + \************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var common = __webpack_require__( + /* ! ../common */ "./node_modules/hash.js/lib/hash/common.js" + ); + + var shaCommon = __webpack_require__( + /* ! ./common */ "./node_modules/hash.js/lib/hash/sha/common.js" + ); + + var rotl32 = utils.rotl32; + var sum32 = utils.sum32; + var sum32_5 = utils.sum32_5; + var ft_1 = shaCommon.ft_1; + var BlockHash = common.BlockHash; + var sha1_K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]; + + function SHA1() { + if (!(this instanceof SHA1)) return new SHA1(); + BlockHash.call(this); + this.h = [ + 0x67452301, + 0xefcdab89, + 0x98badcfe, + 0x10325476, + 0xc3d2e1f0, + ]; + this.W = new Array(80); + } + + utils.inherits(SHA1, BlockHash); + module.exports = SHA1; + SHA1.blockSize = 512; + SHA1.outSize = 160; + SHA1.hmacStrength = 80; + SHA1.padLength = 64; + + SHA1.prototype._update = function _update(msg, start) { + var W = this.W; + + for (var i = 0; i < 16; i++) { + W[i] = msg[start + i]; + } + + for (; i < W.length; i++) { + W[i] = rotl32( + W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], + 1 + ); + } + + var a = this.h[0]; + var b = this.h[1]; + var c = this.h[2]; + var d = this.h[3]; + var e = this.h[4]; + + for (i = 0; i < W.length; i++) { + var s = ~~(i / 20); + var t = sum32_5( + rotl32(a, 5), + ft_1(s, b, c, d), + e, + W[i], + sha1_K[s] + ); + e = d; + d = c; + c = rotl32(b, 30); + b = a; + a = t; + } + + this.h[0] = sum32(this.h[0], a); + this.h[1] = sum32(this.h[1], b); + this.h[2] = sum32(this.h[2], c); + this.h[3] = sum32(this.h[3], d); + this.h[4] = sum32(this.h[4], e); + }; + + SHA1.prototype._digest = function digest(enc) { + if (enc === "hex") return utils.toHex32(this.h, "big"); + return utils.split32(this.h, "big"); + }; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/sha/224.js": + /* !**************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/sha/224.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var SHA256 = __webpack_require__( + /* ! ./256 */ "./node_modules/hash.js/lib/hash/sha/256.js" + ); + + function SHA224() { + if (!(this instanceof SHA224)) return new SHA224(); + SHA256.call(this); + this.h = [ + 0xc1059ed8, + 0x367cd507, + 0x3070dd17, + 0xf70e5939, + 0xffc00b31, + 0x68581511, + 0x64f98fa7, + 0xbefa4fa4, + ]; + } + + utils.inherits(SHA224, SHA256); + module.exports = SHA224; + SHA224.blockSize = 512; + SHA224.outSize = 224; + SHA224.hmacStrength = 192; + SHA224.padLength = 64; + + SHA224.prototype._digest = function digest(enc) { + // Just truncate output + if (enc === "hex") + return utils.toHex32(this.h.slice(0, 7), "big"); + return utils.split32(this.h.slice(0, 7), "big"); + }; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/sha/256.js": + /* !**************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/sha/256.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var common = __webpack_require__( + /* ! ../common */ "./node_modules/hash.js/lib/hash/common.js" + ); + + var shaCommon = __webpack_require__( + /* ! ./common */ "./node_modules/hash.js/lib/hash/sha/common.js" + ); + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + var sum32 = utils.sum32; + var sum32_4 = utils.sum32_4; + var sum32_5 = utils.sum32_5; + var ch32 = shaCommon.ch32; + var maj32 = shaCommon.maj32; + var s0_256 = shaCommon.s0_256; + var s1_256 = shaCommon.s1_256; + var g0_256 = shaCommon.g0_256; + var g1_256 = shaCommon.g1_256; + var BlockHash = common.BlockHash; + var sha256_K = [ + 0x428a2f98, + 0x71374491, + 0xb5c0fbcf, + 0xe9b5dba5, + 0x3956c25b, + 0x59f111f1, + 0x923f82a4, + 0xab1c5ed5, + 0xd807aa98, + 0x12835b01, + 0x243185be, + 0x550c7dc3, + 0x72be5d74, + 0x80deb1fe, + 0x9bdc06a7, + 0xc19bf174, + 0xe49b69c1, + 0xefbe4786, + 0x0fc19dc6, + 0x240ca1cc, + 0x2de92c6f, + 0x4a7484aa, + 0x5cb0a9dc, + 0x76f988da, + 0x983e5152, + 0xa831c66d, + 0xb00327c8, + 0xbf597fc7, + 0xc6e00bf3, + 0xd5a79147, + 0x06ca6351, + 0x14292967, + 0x27b70a85, + 0x2e1b2138, + 0x4d2c6dfc, + 0x53380d13, + 0x650a7354, + 0x766a0abb, + 0x81c2c92e, + 0x92722c85, + 0xa2bfe8a1, + 0xa81a664b, + 0xc24b8b70, + 0xc76c51a3, + 0xd192e819, + 0xd6990624, + 0xf40e3585, + 0x106aa070, + 0x19a4c116, + 0x1e376c08, + 0x2748774c, + 0x34b0bcb5, + 0x391c0cb3, + 0x4ed8aa4a, + 0x5b9cca4f, + 0x682e6ff3, + 0x748f82ee, + 0x78a5636f, + 0x84c87814, + 0x8cc70208, + 0x90befffa, + 0xa4506ceb, + 0xbef9a3f7, + 0xc67178f2, + ]; + + function SHA256() { + if (!(this instanceof SHA256)) return new SHA256(); + BlockHash.call(this); + this.h = [ + 0x6a09e667, + 0xbb67ae85, + 0x3c6ef372, + 0xa54ff53a, + 0x510e527f, + 0x9b05688c, + 0x1f83d9ab, + 0x5be0cd19, + ]; + this.k = sha256_K; + this.W = new Array(64); + } + + utils.inherits(SHA256, BlockHash); + module.exports = SHA256; + SHA256.blockSize = 512; + SHA256.outSize = 256; + SHA256.hmacStrength = 192; + SHA256.padLength = 64; + + SHA256.prototype._update = function _update(msg, start) { + var W = this.W; + + for (var i = 0; i < 16; i++) { + W[i] = msg[start + i]; + } + + for (; i < W.length; i++) { + W[i] = sum32_4( + g1_256(W[i - 2]), + W[i - 7], + g0_256(W[i - 15]), + W[i - 16] + ); + } + + var a = this.h[0]; + var b = this.h[1]; + var c = this.h[2]; + var d = this.h[3]; + var e = this.h[4]; + var f = this.h[5]; + var g = this.h[6]; + var h = this.h[7]; + assert(this.k.length === W.length); + + for (i = 0; i < W.length; i++) { + var T1 = sum32_5( + h, + s1_256(e), + ch32(e, f, g), + this.k[i], + W[i] + ); + var T2 = sum32(s0_256(a), maj32(a, b, c)); + h = g; + g = f; + f = e; + e = sum32(d, T1); + d = c; + c = b; + b = a; + a = sum32(T1, T2); + } + + this.h[0] = sum32(this.h[0], a); + this.h[1] = sum32(this.h[1], b); + this.h[2] = sum32(this.h[2], c); + this.h[3] = sum32(this.h[3], d); + this.h[4] = sum32(this.h[4], e); + this.h[5] = sum32(this.h[5], f); + this.h[6] = sum32(this.h[6], g); + this.h[7] = sum32(this.h[7], h); + }; + + SHA256.prototype._digest = function digest(enc) { + if (enc === "hex") return utils.toHex32(this.h, "big"); + return utils.split32(this.h, "big"); + }; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/sha/384.js": + /* !**************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/sha/384.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var SHA512 = __webpack_require__( + /* ! ./512 */ "./node_modules/hash.js/lib/hash/sha/512.js" + ); + + function SHA384() { + if (!(this instanceof SHA384)) return new SHA384(); + SHA512.call(this); + this.h = [ + 0xcbbb9d5d, + 0xc1059ed8, + 0x629a292a, + 0x367cd507, + 0x9159015a, + 0x3070dd17, + 0x152fecd8, + 0xf70e5939, + 0x67332667, + 0xffc00b31, + 0x8eb44a87, + 0x68581511, + 0xdb0c2e0d, + 0x64f98fa7, + 0x47b5481d, + 0xbefa4fa4, + ]; + } + + utils.inherits(SHA384, SHA512); + module.exports = SHA384; + SHA384.blockSize = 1024; + SHA384.outSize = 384; + SHA384.hmacStrength = 192; + SHA384.padLength = 128; + + SHA384.prototype._digest = function digest(enc) { + if (enc === "hex") + return utils.toHex32(this.h.slice(0, 12), "big"); + return utils.split32(this.h.slice(0, 12), "big"); + }; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/sha/512.js": + /* !**************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/sha/512.js ***! + \**************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var common = __webpack_require__( + /* ! ../common */ "./node_modules/hash.js/lib/hash/common.js" + ); + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + var rotr64_hi = utils.rotr64_hi; + var rotr64_lo = utils.rotr64_lo; + var shr64_hi = utils.shr64_hi; + var shr64_lo = utils.shr64_lo; + var sum64 = utils.sum64; + var sum64_hi = utils.sum64_hi; + var sum64_lo = utils.sum64_lo; + var sum64_4_hi = utils.sum64_4_hi; + var sum64_4_lo = utils.sum64_4_lo; + var sum64_5_hi = utils.sum64_5_hi; + var sum64_5_lo = utils.sum64_5_lo; + var BlockHash = common.BlockHash; + var sha512_K = [ + 0x428a2f98, + 0xd728ae22, + 0x71374491, + 0x23ef65cd, + 0xb5c0fbcf, + 0xec4d3b2f, + 0xe9b5dba5, + 0x8189dbbc, + 0x3956c25b, + 0xf348b538, + 0x59f111f1, + 0xb605d019, + 0x923f82a4, + 0xaf194f9b, + 0xab1c5ed5, + 0xda6d8118, + 0xd807aa98, + 0xa3030242, + 0x12835b01, + 0x45706fbe, + 0x243185be, + 0x4ee4b28c, + 0x550c7dc3, + 0xd5ffb4e2, + 0x72be5d74, + 0xf27b896f, + 0x80deb1fe, + 0x3b1696b1, + 0x9bdc06a7, + 0x25c71235, + 0xc19bf174, + 0xcf692694, + 0xe49b69c1, + 0x9ef14ad2, + 0xefbe4786, + 0x384f25e3, + 0x0fc19dc6, + 0x8b8cd5b5, + 0x240ca1cc, + 0x77ac9c65, + 0x2de92c6f, + 0x592b0275, + 0x4a7484aa, + 0x6ea6e483, + 0x5cb0a9dc, + 0xbd41fbd4, + 0x76f988da, + 0x831153b5, + 0x983e5152, + 0xee66dfab, + 0xa831c66d, + 0x2db43210, + 0xb00327c8, + 0x98fb213f, + 0xbf597fc7, + 0xbeef0ee4, + 0xc6e00bf3, + 0x3da88fc2, + 0xd5a79147, + 0x930aa725, + 0x06ca6351, + 0xe003826f, + 0x14292967, + 0x0a0e6e70, + 0x27b70a85, + 0x46d22ffc, + 0x2e1b2138, + 0x5c26c926, + 0x4d2c6dfc, + 0x5ac42aed, + 0x53380d13, + 0x9d95b3df, + 0x650a7354, + 0x8baf63de, + 0x766a0abb, + 0x3c77b2a8, + 0x81c2c92e, + 0x47edaee6, + 0x92722c85, + 0x1482353b, + 0xa2bfe8a1, + 0x4cf10364, + 0xa81a664b, + 0xbc423001, + 0xc24b8b70, + 0xd0f89791, + 0xc76c51a3, + 0x0654be30, + 0xd192e819, + 0xd6ef5218, + 0xd6990624, + 0x5565a910, + 0xf40e3585, + 0x5771202a, + 0x106aa070, + 0x32bbd1b8, + 0x19a4c116, + 0xb8d2d0c8, + 0x1e376c08, + 0x5141ab53, + 0x2748774c, + 0xdf8eeb99, + 0x34b0bcb5, + 0xe19b48a8, + 0x391c0cb3, + 0xc5c95a63, + 0x4ed8aa4a, + 0xe3418acb, + 0x5b9cca4f, + 0x7763e373, + 0x682e6ff3, + 0xd6b2b8a3, + 0x748f82ee, + 0x5defb2fc, + 0x78a5636f, + 0x43172f60, + 0x84c87814, + 0xa1f0ab72, + 0x8cc70208, + 0x1a6439ec, + 0x90befffa, + 0x23631e28, + 0xa4506ceb, + 0xde82bde9, + 0xbef9a3f7, + 0xb2c67915, + 0xc67178f2, + 0xe372532b, + 0xca273ece, + 0xea26619c, + 0xd186b8c7, + 0x21c0c207, + 0xeada7dd6, + 0xcde0eb1e, + 0xf57d4f7f, + 0xee6ed178, + 0x06f067aa, + 0x72176fba, + 0x0a637dc5, + 0xa2c898a6, + 0x113f9804, + 0xbef90dae, + 0x1b710b35, + 0x131c471b, + 0x28db77f5, + 0x23047d84, + 0x32caab7b, + 0x40c72493, + 0x3c9ebe0a, + 0x15c9bebc, + 0x431d67c4, + 0x9c100d4c, + 0x4cc5d4be, + 0xcb3e42b6, + 0x597f299c, + 0xfc657e2a, + 0x5fcb6fab, + 0x3ad6faec, + 0x6c44198c, + 0x4a475817, + ]; + + function SHA512() { + if (!(this instanceof SHA512)) return new SHA512(); + BlockHash.call(this); + this.h = [ + 0x6a09e667, + 0xf3bcc908, + 0xbb67ae85, + 0x84caa73b, + 0x3c6ef372, + 0xfe94f82b, + 0xa54ff53a, + 0x5f1d36f1, + 0x510e527f, + 0xade682d1, + 0x9b05688c, + 0x2b3e6c1f, + 0x1f83d9ab, + 0xfb41bd6b, + 0x5be0cd19, + 0x137e2179, + ]; + this.k = sha512_K; + this.W = new Array(160); + } + + utils.inherits(SHA512, BlockHash); + module.exports = SHA512; + SHA512.blockSize = 1024; + SHA512.outSize = 512; + SHA512.hmacStrength = 192; + SHA512.padLength = 128; + + SHA512.prototype._prepareBlock = function _prepareBlock( + msg, + start + ) { + var W = this.W; // 32 x 32bit words + + for (var i = 0; i < 32; i++) { + W[i] = msg[start + i]; + } + + for (; i < W.length; i += 2) { + var c0_hi = g1_512_hi(W[i - 4], W[i - 3]); // I - 2 + + var c0_lo = g1_512_lo(W[i - 4], W[i - 3]); + var c1_hi = W[i - 14]; // I - 7 + + var c1_lo = W[i - 13]; + var c2_hi = g0_512_hi(W[i - 30], W[i - 29]); // I - 15 + + var c2_lo = g0_512_lo(W[i - 30], W[i - 29]); + var c3_hi = W[i - 32]; // I - 16 + + var c3_lo = W[i - 31]; + W[i] = sum64_4_hi( + c0_hi, + c0_lo, + c1_hi, + c1_lo, + c2_hi, + c2_lo, + c3_hi, + c3_lo + ); + W[i + 1] = sum64_4_lo( + c0_hi, + c0_lo, + c1_hi, + c1_lo, + c2_hi, + c2_lo, + c3_hi, + c3_lo + ); + } + }; + + SHA512.prototype._update = function _update(msg, start) { + this._prepareBlock(msg, start); + + var W = this.W; + var ah = this.h[0]; + var al = this.h[1]; + var bh = this.h[2]; + var bl = this.h[3]; + var ch = this.h[4]; + var cl = this.h[5]; + var dh = this.h[6]; + var dl = this.h[7]; + var eh = this.h[8]; + var el = this.h[9]; + var fh = this.h[10]; + var fl = this.h[11]; + var gh = this.h[12]; + var gl = this.h[13]; + var hh = this.h[14]; + var hl = this.h[15]; + assert(this.k.length === W.length); + + for (var i = 0; i < W.length; i += 2) { + var c0_hi = hh; + var c0_lo = hl; + var c1_hi = s1_512_hi(eh, el); + var c1_lo = s1_512_lo(eh, el); + var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl); + var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl); + var c3_hi = this.k[i]; + var c3_lo = this.k[i + 1]; + var c4_hi = W[i]; + var c4_lo = W[i + 1]; + var T1_hi = sum64_5_hi( + c0_hi, + c0_lo, + c1_hi, + c1_lo, + c2_hi, + c2_lo, + c3_hi, + c3_lo, + c4_hi, + c4_lo + ); + var T1_lo = sum64_5_lo( + c0_hi, + c0_lo, + c1_hi, + c1_lo, + c2_hi, + c2_lo, + c3_hi, + c3_lo, + c4_hi, + c4_lo + ); + c0_hi = s0_512_hi(ah, al); + c0_lo = s0_512_lo(ah, al); + c1_hi = maj64_hi(ah, al, bh, bl, ch, cl); + c1_lo = maj64_lo(ah, al, bh, bl, ch, cl); + var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo); + var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo); + hh = gh; + hl = gl; + gh = fh; + gl = fl; + fh = eh; + fl = el; + eh = sum64_hi(dh, dl, T1_hi, T1_lo); + el = sum64_lo(dl, dl, T1_hi, T1_lo); + dh = ch; + dl = cl; + ch = bh; + cl = bl; + bh = ah; + bl = al; + ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo); + al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo); + } + + sum64(this.h, 0, ah, al); + sum64(this.h, 2, bh, bl); + sum64(this.h, 4, ch, cl); + sum64(this.h, 6, dh, dl); + sum64(this.h, 8, eh, el); + sum64(this.h, 10, fh, fl); + sum64(this.h, 12, gh, gl); + sum64(this.h, 14, hh, hl); + }; + + SHA512.prototype._digest = function digest(enc) { + if (enc === "hex") return utils.toHex32(this.h, "big"); + return utils.split32(this.h, "big"); + }; + + function ch64_hi(xh, xl, yh, yl, zh) { + var r = (xh & yh) ^ (~xh & zh); + if (r < 0) r += 0x100000000; + return r; + } + + function ch64_lo(xh, xl, yh, yl, zh, zl) { + var r = (xl & yl) ^ (~xl & zl); + if (r < 0) r += 0x100000000; + return r; + } + + function maj64_hi(xh, xl, yh, yl, zh) { + var r = (xh & yh) ^ (xh & zh) ^ (yh & zh); + if (r < 0) r += 0x100000000; + return r; + } + + function maj64_lo(xh, xl, yh, yl, zh, zl) { + var r = (xl & yl) ^ (xl & zl) ^ (yl & zl); + if (r < 0) r += 0x100000000; + return r; + } + + function s0_512_hi(xh, xl) { + var c0_hi = rotr64_hi(xh, xl, 28); + var c1_hi = rotr64_hi(xl, xh, 2); // 34 + + var c2_hi = rotr64_hi(xl, xh, 7); // 39 + + var r = c0_hi ^ c1_hi ^ c2_hi; + if (r < 0) r += 0x100000000; + return r; + } + + function s0_512_lo(xh, xl) { + var c0_lo = rotr64_lo(xh, xl, 28); + var c1_lo = rotr64_lo(xl, xh, 2); // 34 + + var c2_lo = rotr64_lo(xl, xh, 7); // 39 + + var r = c0_lo ^ c1_lo ^ c2_lo; + if (r < 0) r += 0x100000000; + return r; + } + + function s1_512_hi(xh, xl) { + var c0_hi = rotr64_hi(xh, xl, 14); + var c1_hi = rotr64_hi(xh, xl, 18); + var c2_hi = rotr64_hi(xl, xh, 9); // 41 + + var r = c0_hi ^ c1_hi ^ c2_hi; + if (r < 0) r += 0x100000000; + return r; + } + + function s1_512_lo(xh, xl) { + var c0_lo = rotr64_lo(xh, xl, 14); + var c1_lo = rotr64_lo(xh, xl, 18); + var c2_lo = rotr64_lo(xl, xh, 9); // 41 + + var r = c0_lo ^ c1_lo ^ c2_lo; + if (r < 0) r += 0x100000000; + return r; + } + + function g0_512_hi(xh, xl) { + var c0_hi = rotr64_hi(xh, xl, 1); + var c1_hi = rotr64_hi(xh, xl, 8); + var c2_hi = shr64_hi(xh, xl, 7); + var r = c0_hi ^ c1_hi ^ c2_hi; + if (r < 0) r += 0x100000000; + return r; + } + + function g0_512_lo(xh, xl) { + var c0_lo = rotr64_lo(xh, xl, 1); + var c1_lo = rotr64_lo(xh, xl, 8); + var c2_lo = shr64_lo(xh, xl, 7); + var r = c0_lo ^ c1_lo ^ c2_lo; + if (r < 0) r += 0x100000000; + return r; + } + + function g1_512_hi(xh, xl) { + var c0_hi = rotr64_hi(xh, xl, 19); + var c1_hi = rotr64_hi(xl, xh, 29); // 61 + + var c2_hi = shr64_hi(xh, xl, 6); + var r = c0_hi ^ c1_hi ^ c2_hi; + if (r < 0) r += 0x100000000; + return r; + } + + function g1_512_lo(xh, xl) { + var c0_lo = rotr64_lo(xh, xl, 19); + var c1_lo = rotr64_lo(xl, xh, 29); // 61 + + var c2_lo = shr64_lo(xh, xl, 6); + var r = c0_lo ^ c1_lo ^ c2_lo; + if (r < 0) r += 0x100000000; + return r; + } + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/sha/common.js": + /* !*****************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/sha/common.js ***! + \*****************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var utils = __webpack_require__( + /* ! ../utils */ "./node_modules/hash.js/lib/hash/utils.js" + ); + + var rotr32 = utils.rotr32; + + function ft_1(s, x, y, z) { + if (s === 0) return ch32(x, y, z); + if (s === 1 || s === 3) return p32(x, y, z); + if (s === 2) return maj32(x, y, z); + } + + exports.ft_1 = ft_1; + + function ch32(x, y, z) { + return (x & y) ^ (~x & z); + } + + exports.ch32 = ch32; + + function maj32(x, y, z) { + return (x & y) ^ (x & z) ^ (y & z); + } + + exports.maj32 = maj32; + + function p32(x, y, z) { + return x ^ y ^ z; + } + + exports.p32 = p32; + + function s0_256(x) { + return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22); + } + + exports.s0_256 = s0_256; + + function s1_256(x) { + return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25); + } + + exports.s1_256 = s1_256; + + function g0_256(x) { + return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3); + } + + exports.g0_256 = g0_256; + + function g1_256(x) { + return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10); + } + + exports.g1_256 = g1_256; + + /***/ + }, + + /***/ "./node_modules/hash.js/lib/hash/utils.js": + /* !************************************************!*\ + !*** ./node_modules/hash.js/lib/hash/utils.js ***! + \************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + var inherits = __webpack_require__( + /* ! inherits */ "./node_modules/inherits/inherits_browser.js" + ); + + exports.inherits = inherits; + + function isSurrogatePair(msg, i) { + if ((msg.charCodeAt(i) & 0xfc00) !== 0xd800) { + return false; + } + + if (i < 0 || i + 1 >= msg.length) { + return false; + } + + return (msg.charCodeAt(i + 1) & 0xfc00) === 0xdc00; + } + + function toArray(msg, enc) { + if (Array.isArray(msg)) return msg.slice(); + if (!msg) return []; + var res = []; + + if (typeof msg === "string") { + if (!enc) { + // Inspired by stringToUtf8ByteArray() in closure-library by Google + // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143 + // Apache License 2.0 + // https://github.com/google/closure-library/blob/master/LICENSE + var p = 0; + + for (var i = 0; i < msg.length; i++) { + var c = msg.charCodeAt(i); + + if (c < 128) { + res[p++] = c; + } else if (c < 2048) { + res[p++] = (c >> 6) | 192; + res[p++] = (c & 63) | 128; + } else if (isSurrogatePair(msg, i)) { + c = + 0x10000 + + ((c & 0x03ff) << 10) + + (msg.charCodeAt(++i) & 0x03ff); + res[p++] = (c >> 18) | 240; + res[p++] = ((c >> 12) & 63) | 128; + res[p++] = ((c >> 6) & 63) | 128; + res[p++] = (c & 63) | 128; + } else { + res[p++] = (c >> 12) | 224; + res[p++] = ((c >> 6) & 63) | 128; + res[p++] = (c & 63) | 128; + } + } + } else if (enc === "hex") { + msg = msg.replace(/[^a-z0-9]+/gi, ""); + if (msg.length % 2 !== 0) msg = "0" + msg; + + for (i = 0; i < msg.length; i += 2) { + res.push(parseInt(msg[i] + msg[i + 1], 16)); + } + } + } else { + for (i = 0; i < msg.length; i++) { + res[i] = msg[i] | 0; + } + } + + return res; + } + + exports.toArray = toArray; + + function toHex(msg) { + var res = ""; + + for (var i = 0; i < msg.length; i++) { + res += zero2(msg[i].toString(16)); + } + + return res; + } + + exports.toHex = toHex; + + function htonl(w) { + var res = + (w >>> 24) | + ((w >>> 8) & 0xff00) | + ((w << 8) & 0xff0000) | + ((w & 0xff) << 24); + return res >>> 0; + } + + exports.htonl = htonl; + + function toHex32(msg, endian) { + var res = ""; + + for (var i = 0; i < msg.length; i++) { + var w = msg[i]; + if (endian === "little") w = htonl(w); + res += zero8(w.toString(16)); + } + + return res; + } + + exports.toHex32 = toHex32; + + function zero2(word) { + if (word.length === 1) return "0" + word; + return word; + } + + exports.zero2 = zero2; + + function zero8(word) { + if (word.length === 7) return "0" + word; + else if (word.length === 6) return "00" + word; + else if (word.length === 5) return "000" + word; + else if (word.length === 4) return "0000" + word; + else if (word.length === 3) return "00000" + word; + else if (word.length === 2) return "000000" + word; + else if (word.length === 1) return "0000000" + word; + return word; + } + + exports.zero8 = zero8; + + function join32(msg, start, end, endian) { + var len = end - start; + assert(len % 4 === 0); + var res = new Array(len / 4); + + for (var i = 0, k = start; i < res.length; i++, k += 4) { + var w; + if (endian === "big") + w = + (msg[k] << 24) | + (msg[k + 1] << 16) | + (msg[k + 2] << 8) | + msg[k + 3]; + else + w = + (msg[k + 3] << 24) | + (msg[k + 2] << 16) | + (msg[k + 1] << 8) | + msg[k]; + res[i] = w >>> 0; + } + + return res; + } + + exports.join32 = join32; + + function split32(msg, endian) { + var res = new Array(msg.length * 4); + + for (var i = 0, k = 0; i < msg.length; i++, k += 4) { + var m = msg[i]; + + if (endian === "big") { + res[k] = m >>> 24; + res[k + 1] = (m >>> 16) & 0xff; + res[k + 2] = (m >>> 8) & 0xff; + res[k + 3] = m & 0xff; + } else { + res[k + 3] = m >>> 24; + res[k + 2] = (m >>> 16) & 0xff; + res[k + 1] = (m >>> 8) & 0xff; + res[k] = m & 0xff; + } + } + + return res; + } + + exports.split32 = split32; + + function rotr32(w, b) { + return (w >>> b) | (w << (32 - b)); + } + + exports.rotr32 = rotr32; + + function rotl32(w, b) { + return (w << b) | (w >>> (32 - b)); + } + + exports.rotl32 = rotl32; + + function sum32(a, b) { + return (a + b) >>> 0; + } + + exports.sum32 = sum32; + + function sum32_3(a, b, c) { + return (a + b + c) >>> 0; + } + + exports.sum32_3 = sum32_3; + + function sum32_4(a, b, c, d) { + return (a + b + c + d) >>> 0; + } + + exports.sum32_4 = sum32_4; + + function sum32_5(a, b, c, d, e) { + return (a + b + c + d + e) >>> 0; + } + + exports.sum32_5 = sum32_5; + + function sum64(buf, pos, ah, al) { + var bh = buf[pos]; + var bl = buf[pos + 1]; + var lo = (al + bl) >>> 0; + var hi = (lo < al ? 1 : 0) + ah + bh; + buf[pos] = hi >>> 0; + buf[pos + 1] = lo; + } + + exports.sum64 = sum64; + + function sum64_hi(ah, al, bh, bl) { + var lo = (al + bl) >>> 0; + var hi = (lo < al ? 1 : 0) + ah + bh; + return hi >>> 0; + } + + exports.sum64_hi = sum64_hi; + + function sum64_lo(ah, al, bh, bl) { + var lo = al + bl; + return lo >>> 0; + } + + exports.sum64_lo = sum64_lo; + + function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) { + var carry = 0; + var lo = al; + lo = (lo + bl) >>> 0; + carry += lo < al ? 1 : 0; + lo = (lo + cl) >>> 0; + carry += lo < cl ? 1 : 0; + lo = (lo + dl) >>> 0; + carry += lo < dl ? 1 : 0; + var hi = ah + bh + ch + dh + carry; + return hi >>> 0; + } + + exports.sum64_4_hi = sum64_4_hi; + + function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) { + var lo = al + bl + cl + dl; + return lo >>> 0; + } + + exports.sum64_4_lo = sum64_4_lo; + + function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) { + var carry = 0; + var lo = al; + lo = (lo + bl) >>> 0; + carry += lo < al ? 1 : 0; + lo = (lo + cl) >>> 0; + carry += lo < cl ? 1 : 0; + lo = (lo + dl) >>> 0; + carry += lo < dl ? 1 : 0; + lo = (lo + el) >>> 0; + carry += lo < el ? 1 : 0; + var hi = ah + bh + ch + dh + eh + carry; + return hi >>> 0; + } + + exports.sum64_5_hi = sum64_5_hi; + + function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) { + var lo = al + bl + cl + dl + el; + return lo >>> 0; + } + + exports.sum64_5_lo = sum64_5_lo; + + function rotr64_hi(ah, al, num) { + var r = (al << (32 - num)) | (ah >>> num); + return r >>> 0; + } + + exports.rotr64_hi = rotr64_hi; + + function rotr64_lo(ah, al, num) { + var r = (ah << (32 - num)) | (al >>> num); + return r >>> 0; + } + + exports.rotr64_lo = rotr64_lo; + + function shr64_hi(ah, al, num) { + return ah >>> num; + } + + exports.shr64_hi = shr64_hi; + + function shr64_lo(ah, al, num) { + var r = (ah << (32 - num)) | (al >>> num); + return r >>> 0; + } + + exports.shr64_lo = shr64_lo; + + /***/ + }, + + /***/ "./node_modules/he/he.js": + /* !*******************************!*\ + !*** ./node_modules/he/he.js ***! + \*******************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (module, global) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + + /* ! https://mths.be/he v1.2.0 by @mathias | MIT license */ + (function (root) { + // Detect free variables `exports`. + var freeExports = + (false ? undefined : _typeof(exports)) == "object" && + exports; // Detect free variable `module`. + + var freeModule = + (false ? undefined : _typeof(module)) == "object" && + module && + module.exports == freeExports && + module; // Detect free variable `global`, from Node.js or Browserified code, + // and use it as `root`. + + var freeGlobal = + (typeof global === "undefined" + ? "undefined" + : _typeof(global)) == "object" && global; + + if ( + freeGlobal.global === freeGlobal || + freeGlobal.window === freeGlobal + ) { + root = freeGlobal; + } + /* --------------------------------------------------------------------------*/ + // All astral symbols. + + var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; // All ASCII symbols (not just printable ASCII) except those listed in the + // first column of the overrides table. + // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides + + var regexAsciiWhitelist = /[\x01-\x7F]/g; // All BMP symbols that are not ASCII newlines, printable ASCII symbols, or + // code points listed in the first column of the overrides table on + // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides. + + var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g; + var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g; + var encodeMap = { + "\xAD": "shy", + "\u200C": "zwnj", + "\u200D": "zwj", + "\u200E": "lrm", + "\u2063": "ic", + "\u2062": "it", + "\u2061": "af", + "\u200F": "rlm", + "\u200B": "ZeroWidthSpace", + "\u2060": "NoBreak", + "\u0311": "DownBreve", + "\u20DB": "tdot", + "\u20DC": "DotDot", + "\t": "Tab", + "\n": "NewLine", + "\u2008": "puncsp", + "\u205F": "MediumSpace", + "\u2009": "thinsp", + "\u200A": "hairsp", + "\u2004": "emsp13", + "\u2002": "ensp", + "\u2005": "emsp14", + "\u2003": "emsp", + "\u2007": "numsp", + "\xA0": "nbsp", + "\u205F\u200A": "ThickSpace", + "\u203E": "oline", + _: "lowbar", + "\u2010": "dash", + "\u2013": "ndash", + "\u2014": "mdash", + "\u2015": "horbar", + ",": "comma", + ";": "semi", + "\u204F": "bsemi", + ":": "colon", + "\u2A74": "Colone", + "!": "excl", + "\xA1": "iexcl", + "?": "quest", + "\xBF": "iquest", + ".": "period", + "\u2025": "nldr", + "\u2026": "mldr", + "\xB7": "middot", + "'": "apos", + "\u2018": "lsquo", + "\u2019": "rsquo", + "\u201A": "sbquo", + "\u2039": "lsaquo", + "\u203A": "rsaquo", + '"': "quot", + "\u201C": "ldquo", + "\u201D": "rdquo", + "\u201E": "bdquo", + "\xAB": "laquo", + "\xBB": "raquo", + "(": "lpar", + ")": "rpar", + "[": "lsqb", + "]": "rsqb", + "{": "lcub", + "}": "rcub", + "\u2308": "lceil", + "\u2309": "rceil", + "\u230A": "lfloor", + "\u230B": "rfloor", + "\u2985": "lopar", + "\u2986": "ropar", + "\u298B": "lbrke", + "\u298C": "rbrke", + "\u298D": "lbrkslu", + "\u298E": "rbrksld", + "\u298F": "lbrksld", + "\u2990": "rbrkslu", + "\u2991": "langd", + "\u2992": "rangd", + "\u2993": "lparlt", + "\u2994": "rpargt", + "\u2995": "gtlPar", + "\u2996": "ltrPar", + "\u27E6": "lobrk", + "\u27E7": "robrk", + "\u27E8": "lang", + "\u27E9": "rang", + "\u27EA": "Lang", + "\u27EB": "Rang", + "\u27EC": "loang", + "\u27ED": "roang", + "\u2772": "lbbrk", + "\u2773": "rbbrk", + "\u2016": "Vert", + "\xA7": "sect", + "\xB6": "para", + "@": "commat", + "*": "ast", + "/": "sol", + undefined: null, + "&": "amp", + "#": "num", + "%": "percnt", + "\u2030": "permil", + "\u2031": "pertenk", + "\u2020": "dagger", + "\u2021": "Dagger", + "\u2022": "bull", + "\u2043": "hybull", + "\u2032": "prime", + "\u2033": "Prime", + "\u2034": "tprime", + "\u2057": "qprime", + "\u2035": "bprime", + "\u2041": "caret", + "`": "grave", + "\xB4": "acute", + "\u02DC": "tilde", + "^": "Hat", + "\xAF": "macr", + "\u02D8": "breve", + "\u02D9": "dot", + "\xA8": "die", + "\u02DA": "ring", + "\u02DD": "dblac", + "\xB8": "cedil", + "\u02DB": "ogon", + "\u02C6": "circ", + "\u02C7": "caron", + "\xB0": "deg", + "\xA9": "copy", + "\xAE": "reg", + "\u2117": "copysr", + "\u2118": "wp", + "\u211E": "rx", + "\u2127": "mho", + "\u2129": "iiota", + "\u2190": "larr", + "\u219A": "nlarr", + "\u2192": "rarr", + "\u219B": "nrarr", + "\u2191": "uarr", + "\u2193": "darr", + "\u2194": "harr", + "\u21AE": "nharr", + "\u2195": "varr", + "\u2196": "nwarr", + "\u2197": "nearr", + "\u2198": "searr", + "\u2199": "swarr", + "\u219D": "rarrw", + "\u219D\u0338": "nrarrw", + "\u219E": "Larr", + "\u219F": "Uarr", + "\u21A0": "Rarr", + "\u21A1": "Darr", + "\u21A2": "larrtl", + "\u21A3": "rarrtl", + "\u21A4": "mapstoleft", + "\u21A5": "mapstoup", + "\u21A6": "map", + "\u21A7": "mapstodown", + "\u21A9": "larrhk", + "\u21AA": "rarrhk", + "\u21AB": "larrlp", + "\u21AC": "rarrlp", + "\u21AD": "harrw", + "\u21B0": "lsh", + "\u21B1": "rsh", + "\u21B2": "ldsh", + "\u21B3": "rdsh", + "\u21B5": "crarr", + "\u21B6": "cularr", + "\u21B7": "curarr", + "\u21BA": "olarr", + "\u21BB": "orarr", + "\u21BC": "lharu", + "\u21BD": "lhard", + "\u21BE": "uharr", + "\u21BF": "uharl", + "\u21C0": "rharu", + "\u21C1": "rhard", + "\u21C2": "dharr", + "\u21C3": "dharl", + "\u21C4": "rlarr", + "\u21C5": "udarr", + "\u21C6": "lrarr", + "\u21C7": "llarr", + "\u21C8": "uuarr", + "\u21C9": "rrarr", + "\u21CA": "ddarr", + "\u21CB": "lrhar", + "\u21CC": "rlhar", + "\u21D0": "lArr", + "\u21CD": "nlArr", + "\u21D1": "uArr", + "\u21D2": "rArr", + "\u21CF": "nrArr", + "\u21D3": "dArr", + "\u21D4": "iff", + "\u21CE": "nhArr", + "\u21D5": "vArr", + "\u21D6": "nwArr", + "\u21D7": "neArr", + "\u21D8": "seArr", + "\u21D9": "swArr", + "\u21DA": "lAarr", + "\u21DB": "rAarr", + "\u21DD": "zigrarr", + "\u21E4": "larrb", + "\u21E5": "rarrb", + "\u21F5": "duarr", + "\u21FD": "loarr", + "\u21FE": "roarr", + "\u21FF": "hoarr", + "\u2200": "forall", + "\u2201": "comp", + "\u2202": "part", + "\u2202\u0338": "npart", + "\u2203": "exist", + "\u2204": "nexist", + "\u2205": "empty", + "\u2207": "Del", + "\u2208": "in", + "\u2209": "notin", + "\u220B": "ni", + "\u220C": "notni", + "\u03F6": "bepsi", + "\u220F": "prod", + "\u2210": "coprod", + "\u2211": "sum", + "+": "plus", + "\xB1": "pm", + "\xF7": "div", + "\xD7": "times", + "<": "lt", + "\u226E": "nlt", + "<\u20D2": "nvlt", + "=": "equals", + "\u2260": "ne", + "=\u20E5": "bne", + "\u2A75": "Equal", + ">": "gt", + "\u226F": "ngt", + ">\u20D2": "nvgt", + "\xAC": "not", + "|": "vert", + "\xA6": "brvbar", + "\u2212": "minus", + "\u2213": "mp", + "\u2214": "plusdo", + "\u2044": "frasl", + "\u2216": "setmn", + "\u2217": "lowast", + "\u2218": "compfn", + "\u221A": "Sqrt", + "\u221D": "prop", + "\u221E": "infin", + "\u221F": "angrt", + "\u2220": "ang", + "\u2220\u20D2": "nang", + "\u2221": "angmsd", + "\u2222": "angsph", + "\u2223": "mid", + "\u2224": "nmid", + "\u2225": "par", + "\u2226": "npar", + "\u2227": "and", + "\u2228": "or", + "\u2229": "cap", + "\u2229\uFE00": "caps", + "\u222A": "cup", + "\u222A\uFE00": "cups", + "\u222B": "int", + "\u222C": "Int", + "\u222D": "tint", + "\u2A0C": "qint", + "\u222E": "oint", + "\u222F": "Conint", + "\u2230": "Cconint", + "\u2231": "cwint", + "\u2232": "cwconint", + "\u2233": "awconint", + "\u2234": "there4", + "\u2235": "becaus", + "\u2236": "ratio", + "\u2237": "Colon", + "\u2238": "minusd", + "\u223A": "mDDot", + "\u223B": "homtht", + "\u223C": "sim", + "\u2241": "nsim", + "\u223C\u20D2": "nvsim", + "\u223D": "bsim", + "\u223D\u0331": "race", + "\u223E": "ac", + "\u223E\u0333": "acE", + "\u223F": "acd", + "\u2240": "wr", + "\u2242": "esim", + "\u2242\u0338": "nesim", + "\u2243": "sime", + "\u2244": "nsime", + "\u2245": "cong", + "\u2247": "ncong", + "\u2246": "simne", + "\u2248": "ap", + "\u2249": "nap", + "\u224A": "ape", + "\u224B": "apid", + "\u224B\u0338": "napid", + "\u224C": "bcong", + "\u224D": "CupCap", + "\u226D": "NotCupCap", + "\u224D\u20D2": "nvap", + "\u224E": "bump", + "\u224E\u0338": "nbump", + "\u224F": "bumpe", + "\u224F\u0338": "nbumpe", + "\u2250": "doteq", + "\u2250\u0338": "nedot", + "\u2251": "eDot", + "\u2252": "efDot", + "\u2253": "erDot", + "\u2254": "colone", + "\u2255": "ecolon", + "\u2256": "ecir", + "\u2257": "cire", + "\u2259": "wedgeq", + "\u225A": "veeeq", + "\u225C": "trie", + "\u225F": "equest", + "\u2261": "equiv", + "\u2262": "nequiv", + "\u2261\u20E5": "bnequiv", + "\u2264": "le", + "\u2270": "nle", + "\u2264\u20D2": "nvle", + "\u2265": "ge", + "\u2271": "nge", + "\u2265\u20D2": "nvge", + "\u2266": "lE", + "\u2266\u0338": "nlE", + "\u2267": "gE", + "\u2267\u0338": "ngE", + "\u2268\uFE00": "lvnE", + "\u2268": "lnE", + "\u2269": "gnE", + "\u2269\uFE00": "gvnE", + "\u226A": "ll", + "\u226A\u0338": "nLtv", + "\u226A\u20D2": "nLt", + "\u226B": "gg", + "\u226B\u0338": "nGtv", + "\u226B\u20D2": "nGt", + "\u226C": "twixt", + "\u2272": "lsim", + "\u2274": "nlsim", + "\u2273": "gsim", + "\u2275": "ngsim", + "\u2276": "lg", + "\u2278": "ntlg", + "\u2277": "gl", + "\u2279": "ntgl", + "\u227A": "pr", + "\u2280": "npr", + "\u227B": "sc", + "\u2281": "nsc", + "\u227C": "prcue", + "\u22E0": "nprcue", + "\u227D": "sccue", + "\u22E1": "nsccue", + "\u227E": "prsim", + "\u227F": "scsim", + "\u227F\u0338": "NotSucceedsTilde", + "\u2282": "sub", + "\u2284": "nsub", + "\u2282\u20D2": "vnsub", + "\u2283": "sup", + "\u2285": "nsup", + "\u2283\u20D2": "vnsup", + "\u2286": "sube", + "\u2288": "nsube", + "\u2287": "supe", + "\u2289": "nsupe", + "\u228A\uFE00": "vsubne", + "\u228A": "subne", + "\u228B\uFE00": "vsupne", + "\u228B": "supne", + "\u228D": "cupdot", + "\u228E": "uplus", + "\u228F": "sqsub", + "\u228F\u0338": "NotSquareSubset", + "\u2290": "sqsup", + "\u2290\u0338": "NotSquareSuperset", + "\u2291": "sqsube", + "\u22E2": "nsqsube", + "\u2292": "sqsupe", + "\u22E3": "nsqsupe", + "\u2293": "sqcap", + "\u2293\uFE00": "sqcaps", + "\u2294": "sqcup", + "\u2294\uFE00": "sqcups", + "\u2295": "oplus", + "\u2296": "ominus", + "\u2297": "otimes", + "\u2298": "osol", + "\u2299": "odot", + "\u229A": "ocir", + "\u229B": "oast", + "\u229D": "odash", + "\u229E": "plusb", + "\u229F": "minusb", + "\u22A0": "timesb", + "\u22A1": "sdotb", + "\u22A2": "vdash", + "\u22AC": "nvdash", + "\u22A3": "dashv", + "\u22A4": "top", + "\u22A5": "bot", + "\u22A7": "models", + "\u22A8": "vDash", + "\u22AD": "nvDash", + "\u22A9": "Vdash", + "\u22AE": "nVdash", + "\u22AA": "Vvdash", + "\u22AB": "VDash", + "\u22AF": "nVDash", + "\u22B0": "prurel", + "\u22B2": "vltri", + "\u22EA": "nltri", + "\u22B3": "vrtri", + "\u22EB": "nrtri", + "\u22B4": "ltrie", + "\u22EC": "nltrie", + "\u22B4\u20D2": "nvltrie", + "\u22B5": "rtrie", + "\u22ED": "nrtrie", + "\u22B5\u20D2": "nvrtrie", + "\u22B6": "origof", + "\u22B7": "imof", + "\u22B8": "mumap", + "\u22B9": "hercon", + "\u22BA": "intcal", + "\u22BB": "veebar", + "\u22BD": "barvee", + "\u22BE": "angrtvb", + "\u22BF": "lrtri", + "\u22C0": "Wedge", + "\u22C1": "Vee", + "\u22C2": "xcap", + "\u22C3": "xcup", + "\u22C4": "diam", + "\u22C5": "sdot", + "\u22C6": "Star", + "\u22C7": "divonx", + "\u22C8": "bowtie", + "\u22C9": "ltimes", + "\u22CA": "rtimes", + "\u22CB": "lthree", + "\u22CC": "rthree", + "\u22CD": "bsime", + "\u22CE": "cuvee", + "\u22CF": "cuwed", + "\u22D0": "Sub", + "\u22D1": "Sup", + "\u22D2": "Cap", + "\u22D3": "Cup", + "\u22D4": "fork", + "\u22D5": "epar", + "\u22D6": "ltdot", + "\u22D7": "gtdot", + "\u22D8": "Ll", + "\u22D8\u0338": "nLl", + "\u22D9": "Gg", + "\u22D9\u0338": "nGg", + "\u22DA\uFE00": "lesg", + "\u22DA": "leg", + "\u22DB": "gel", + "\u22DB\uFE00": "gesl", + "\u22DE": "cuepr", + "\u22DF": "cuesc", + "\u22E6": "lnsim", + "\u22E7": "gnsim", + "\u22E8": "prnsim", + "\u22E9": "scnsim", + "\u22EE": "vellip", + "\u22EF": "ctdot", + "\u22F0": "utdot", + "\u22F1": "dtdot", + "\u22F2": "disin", + "\u22F3": "isinsv", + "\u22F4": "isins", + "\u22F5": "isindot", + "\u22F5\u0338": "notindot", + "\u22F6": "notinvc", + "\u22F7": "notinvb", + "\u22F9": "isinE", + "\u22F9\u0338": "notinE", + "\u22FA": "nisd", + "\u22FB": "xnis", + "\u22FC": "nis", + "\u22FD": "notnivc", + "\u22FE": "notnivb", + "\u2305": "barwed", + "\u2306": "Barwed", + "\u230C": "drcrop", + "\u230D": "dlcrop", + "\u230E": "urcrop", + "\u230F": "ulcrop", + "\u2310": "bnot", + "\u2312": "profline", + "\u2313": "profsurf", + "\u2315": "telrec", + "\u2316": "target", + "\u231C": "ulcorn", + "\u231D": "urcorn", + "\u231E": "dlcorn", + "\u231F": "drcorn", + "\u2322": "frown", + "\u2323": "smile", + "\u232D": "cylcty", + "\u232E": "profalar", + "\u2336": "topbot", + "\u233D": "ovbar", + "\u233F": "solbar", + "\u237C": "angzarr", + "\u23B0": "lmoust", + "\u23B1": "rmoust", + "\u23B4": "tbrk", + "\u23B5": "bbrk", + "\u23B6": "bbrktbrk", + "\u23DC": "OverParenthesis", + "\u23DD": "UnderParenthesis", + "\u23DE": "OverBrace", + "\u23DF": "UnderBrace", + "\u23E2": "trpezium", + "\u23E7": "elinters", + "\u2423": "blank", + "\u2500": "boxh", + "\u2502": "boxv", + "\u250C": "boxdr", + "\u2510": "boxdl", + "\u2514": "boxur", + "\u2518": "boxul", + "\u251C": "boxvr", + "\u2524": "boxvl", + "\u252C": "boxhd", + "\u2534": "boxhu", + "\u253C": "boxvh", + "\u2550": "boxH", + "\u2551": "boxV", + "\u2552": "boxdR", + "\u2553": "boxDr", + "\u2554": "boxDR", + "\u2555": "boxdL", + "\u2556": "boxDl", + "\u2557": "boxDL", + "\u2558": "boxuR", + "\u2559": "boxUr", + "\u255A": "boxUR", + "\u255B": "boxuL", + "\u255C": "boxUl", + "\u255D": "boxUL", + "\u255E": "boxvR", + "\u255F": "boxVr", + "\u2560": "boxVR", + "\u2561": "boxvL", + "\u2562": "boxVl", + "\u2563": "boxVL", + "\u2564": "boxHd", + "\u2565": "boxhD", + "\u2566": "boxHD", + "\u2567": "boxHu", + "\u2568": "boxhU", + "\u2569": "boxHU", + "\u256A": "boxvH", + "\u256B": "boxVh", + "\u256C": "boxVH", + "\u2580": "uhblk", + "\u2584": "lhblk", + "\u2588": "block", + "\u2591": "blk14", + "\u2592": "blk12", + "\u2593": "blk34", + "\u25A1": "squ", + "\u25AA": "squf", + "\u25AB": "EmptyVerySmallSquare", + "\u25AD": "rect", + "\u25AE": "marker", + "\u25B1": "fltns", + "\u25B3": "xutri", + "\u25B4": "utrif", + "\u25B5": "utri", + "\u25B8": "rtrif", + "\u25B9": "rtri", + "\u25BD": "xdtri", + "\u25BE": "dtrif", + "\u25BF": "dtri", + "\u25C2": "ltrif", + "\u25C3": "ltri", + "\u25CA": "loz", + "\u25CB": "cir", + "\u25EC": "tridot", + "\u25EF": "xcirc", + "\u25F8": "ultri", + "\u25F9": "urtri", + "\u25FA": "lltri", + "\u25FB": "EmptySmallSquare", + "\u25FC": "FilledSmallSquare", + "\u2605": "starf", + "\u2606": "star", + "\u260E": "phone", + "\u2640": "female", + "\u2642": "male", + "\u2660": "spades", + "\u2663": "clubs", + "\u2665": "hearts", + "\u2666": "diams", + "\u266A": "sung", + "\u2713": "check", + "\u2717": "cross", + "\u2720": "malt", + "\u2736": "sext", + "\u2758": "VerticalSeparator", + "\u27C8": "bsolhsub", + "\u27C9": "suphsol", + "\u27F5": "xlarr", + "\u27F6": "xrarr", + "\u27F7": "xharr", + "\u27F8": "xlArr", + "\u27F9": "xrArr", + "\u27FA": "xhArr", + "\u27FC": "xmap", + "\u27FF": "dzigrarr", + "\u2902": "nvlArr", + "\u2903": "nvrArr", + "\u2904": "nvHarr", + "\u2905": "Map", + "\u290C": "lbarr", + "\u290D": "rbarr", + "\u290E": "lBarr", + "\u290F": "rBarr", + "\u2910": "RBarr", + "\u2911": "DDotrahd", + "\u2912": "UpArrowBar", + "\u2913": "DownArrowBar", + "\u2916": "Rarrtl", + "\u2919": "latail", + "\u291A": "ratail", + "\u291B": "lAtail", + "\u291C": "rAtail", + "\u291D": "larrfs", + "\u291E": "rarrfs", + "\u291F": "larrbfs", + "\u2920": "rarrbfs", + "\u2923": "nwarhk", + "\u2924": "nearhk", + "\u2925": "searhk", + "\u2926": "swarhk", + "\u2927": "nwnear", + "\u2928": "toea", + "\u2929": "tosa", + "\u292A": "swnwar", + "\u2933": "rarrc", + "\u2933\u0338": "nrarrc", + "\u2935": "cudarrr", + "\u2936": "ldca", + "\u2937": "rdca", + "\u2938": "cudarrl", + "\u2939": "larrpl", + "\u293C": "curarrm", + "\u293D": "cularrp", + "\u2945": "rarrpl", + "\u2948": "harrcir", + "\u2949": "Uarrocir", + "\u294A": "lurdshar", + "\u294B": "ldrushar", + "\u294E": "LeftRightVector", + "\u294F": "RightUpDownVector", + "\u2950": "DownLeftRightVector", + "\u2951": "LeftUpDownVector", + "\u2952": "LeftVectorBar", + "\u2953": "RightVectorBar", + "\u2954": "RightUpVectorBar", + "\u2955": "RightDownVectorBar", + "\u2956": "DownLeftVectorBar", + "\u2957": "DownRightVectorBar", + "\u2958": "LeftUpVectorBar", + "\u2959": "LeftDownVectorBar", + "\u295A": "LeftTeeVector", + "\u295B": "RightTeeVector", + "\u295C": "RightUpTeeVector", + "\u295D": "RightDownTeeVector", + "\u295E": "DownLeftTeeVector", + "\u295F": "DownRightTeeVector", + "\u2960": "LeftUpTeeVector", + "\u2961": "LeftDownTeeVector", + "\u2962": "lHar", + "\u2963": "uHar", + "\u2964": "rHar", + "\u2965": "dHar", + "\u2966": "luruhar", + "\u2967": "ldrdhar", + "\u2968": "ruluhar", + "\u2969": "rdldhar", + "\u296A": "lharul", + "\u296B": "llhard", + "\u296C": "rharul", + "\u296D": "lrhard", + "\u296E": "udhar", + "\u296F": "duhar", + "\u2970": "RoundImplies", + "\u2971": "erarr", + "\u2972": "simrarr", + "\u2973": "larrsim", + "\u2974": "rarrsim", + "\u2975": "rarrap", + "\u2976": "ltlarr", + "\u2978": "gtrarr", + "\u2979": "subrarr", + "\u297B": "suplarr", + "\u297C": "lfisht", + "\u297D": "rfisht", + "\u297E": "ufisht", + "\u297F": "dfisht", + "\u299A": "vzigzag", + "\u299C": "vangrt", + "\u299D": "angrtvbd", + "\u29A4": "ange", + "\u29A5": "range", + "\u29A6": "dwangle", + "\u29A7": "uwangle", + "\u29A8": "angmsdaa", + "\u29A9": "angmsdab", + "\u29AA": "angmsdac", + "\u29AB": "angmsdad", + "\u29AC": "angmsdae", + "\u29AD": "angmsdaf", + "\u29AE": "angmsdag", + "\u29AF": "angmsdah", + "\u29B0": "bemptyv", + "\u29B1": "demptyv", + "\u29B2": "cemptyv", + "\u29B3": "raemptyv", + "\u29B4": "laemptyv", + "\u29B5": "ohbar", + "\u29B6": "omid", + "\u29B7": "opar", + "\u29B9": "operp", + "\u29BB": "olcross", + "\u29BC": "odsold", + "\u29BE": "olcir", + "\u29BF": "ofcir", + "\u29C0": "olt", + "\u29C1": "ogt", + "\u29C2": "cirscir", + "\u29C3": "cirE", + "\u29C4": "solb", + "\u29C5": "bsolb", + "\u29C9": "boxbox", + "\u29CD": "trisb", + "\u29CE": "rtriltri", + "\u29CF": "LeftTriangleBar", + "\u29CF\u0338": "NotLeftTriangleBar", + "\u29D0": "RightTriangleBar", + "\u29D0\u0338": "NotRightTriangleBar", + "\u29DC": "iinfin", + "\u29DD": "infintie", + "\u29DE": "nvinfin", + "\u29E3": "eparsl", + "\u29E4": "smeparsl", + "\u29E5": "eqvparsl", + "\u29EB": "lozf", + "\u29F4": "RuleDelayed", + "\u29F6": "dsol", + "\u2A00": "xodot", + "\u2A01": "xoplus", + "\u2A02": "xotime", + "\u2A04": "xuplus", + "\u2A06": "xsqcup", + "\u2A0D": "fpartint", + "\u2A10": "cirfnint", + "\u2A11": "awint", + "\u2A12": "rppolint", + "\u2A13": "scpolint", + "\u2A14": "npolint", + "\u2A15": "pointint", + "\u2A16": "quatint", + "\u2A17": "intlarhk", + "\u2A22": "pluscir", + "\u2A23": "plusacir", + "\u2A24": "simplus", + "\u2A25": "plusdu", + "\u2A26": "plussim", + "\u2A27": "plustwo", + "\u2A29": "mcomma", + "\u2A2A": "minusdu", + "\u2A2D": "loplus", + "\u2A2E": "roplus", + "\u2A2F": "Cross", + "\u2A30": "timesd", + "\u2A31": "timesbar", + "\u2A33": "smashp", + "\u2A34": "lotimes", + "\u2A35": "rotimes", + "\u2A36": "otimesas", + "\u2A37": "Otimes", + "\u2A38": "odiv", + "\u2A39": "triplus", + "\u2A3A": "triminus", + "\u2A3B": "tritime", + "\u2A3C": "iprod", + "\u2A3F": "amalg", + "\u2A40": "capdot", + "\u2A42": "ncup", + "\u2A43": "ncap", + "\u2A44": "capand", + "\u2A45": "cupor", + "\u2A46": "cupcap", + "\u2A47": "capcup", + "\u2A48": "cupbrcap", + "\u2A49": "capbrcup", + "\u2A4A": "cupcup", + "\u2A4B": "capcap", + "\u2A4C": "ccups", + "\u2A4D": "ccaps", + "\u2A50": "ccupssm", + "\u2A53": "And", + "\u2A54": "Or", + "\u2A55": "andand", + "\u2A56": "oror", + "\u2A57": "orslope", + "\u2A58": "andslope", + "\u2A5A": "andv", + "\u2A5B": "orv", + "\u2A5C": "andd", + "\u2A5D": "ord", + "\u2A5F": "wedbar", + "\u2A66": "sdote", + "\u2A6A": "simdot", + "\u2A6D": "congdot", + "\u2A6D\u0338": "ncongdot", + "\u2A6E": "easter", + "\u2A6F": "apacir", + "\u2A70": "apE", + "\u2A70\u0338": "napE", + "\u2A71": "eplus", + "\u2A72": "pluse", + "\u2A73": "Esim", + "\u2A77": "eDDot", + "\u2A78": "equivDD", + "\u2A79": "ltcir", + "\u2A7A": "gtcir", + "\u2A7B": "ltquest", + "\u2A7C": "gtquest", + "\u2A7D": "les", + "\u2A7D\u0338": "nles", + "\u2A7E": "ges", + "\u2A7E\u0338": "nges", + "\u2A7F": "lesdot", + "\u2A80": "gesdot", + "\u2A81": "lesdoto", + "\u2A82": "gesdoto", + "\u2A83": "lesdotor", + "\u2A84": "gesdotol", + "\u2A85": "lap", + "\u2A86": "gap", + "\u2A87": "lne", + "\u2A88": "gne", + "\u2A89": "lnap", + "\u2A8A": "gnap", + "\u2A8B": "lEg", + "\u2A8C": "gEl", + "\u2A8D": "lsime", + "\u2A8E": "gsime", + "\u2A8F": "lsimg", + "\u2A90": "gsiml", + "\u2A91": "lgE", + "\u2A92": "glE", + "\u2A93": "lesges", + "\u2A94": "gesles", + "\u2A95": "els", + "\u2A96": "egs", + "\u2A97": "elsdot", + "\u2A98": "egsdot", + "\u2A99": "el", + "\u2A9A": "eg", + "\u2A9D": "siml", + "\u2A9E": "simg", + "\u2A9F": "simlE", + "\u2AA0": "simgE", + "\u2AA1": "LessLess", + "\u2AA1\u0338": "NotNestedLessLess", + "\u2AA2": "GreaterGreater", + "\u2AA2\u0338": "NotNestedGreaterGreater", + "\u2AA4": "glj", + "\u2AA5": "gla", + "\u2AA6": "ltcc", + "\u2AA7": "gtcc", + "\u2AA8": "lescc", + "\u2AA9": "gescc", + "\u2AAA": "smt", + "\u2AAB": "lat", + "\u2AAC": "smte", + "\u2AAC\uFE00": "smtes", + "\u2AAD": "late", + "\u2AAD\uFE00": "lates", + "\u2AAE": "bumpE", + "\u2AAF": "pre", + "\u2AAF\u0338": "npre", + "\u2AB0": "sce", + "\u2AB0\u0338": "nsce", + "\u2AB3": "prE", + "\u2AB4": "scE", + "\u2AB5": "prnE", + "\u2AB6": "scnE", + "\u2AB7": "prap", + "\u2AB8": "scap", + "\u2AB9": "prnap", + "\u2ABA": "scnap", + "\u2ABB": "Pr", + "\u2ABC": "Sc", + "\u2ABD": "subdot", + "\u2ABE": "supdot", + "\u2ABF": "subplus", + "\u2AC0": "supplus", + "\u2AC1": "submult", + "\u2AC2": "supmult", + "\u2AC3": "subedot", + "\u2AC4": "supedot", + "\u2AC5": "subE", + "\u2AC5\u0338": "nsubE", + "\u2AC6": "supE", + "\u2AC6\u0338": "nsupE", + "\u2AC7": "subsim", + "\u2AC8": "supsim", + "\u2ACB\uFE00": "vsubnE", + "\u2ACB": "subnE", + "\u2ACC\uFE00": "vsupnE", + "\u2ACC": "supnE", + "\u2ACF": "csub", + "\u2AD0": "csup", + "\u2AD1": "csube", + "\u2AD2": "csupe", + "\u2AD3": "subsup", + "\u2AD4": "supsub", + "\u2AD5": "subsub", + "\u2AD6": "supsup", + "\u2AD7": "suphsub", + "\u2AD8": "supdsub", + "\u2AD9": "forkv", + "\u2ADA": "topfork", + "\u2ADB": "mlcp", + "\u2AE4": "Dashv", + "\u2AE6": "Vdashl", + "\u2AE7": "Barv", + "\u2AE8": "vBar", + "\u2AE9": "vBarv", + "\u2AEB": "Vbar", + "\u2AEC": "Not", + "\u2AED": "bNot", + "\u2AEE": "rnmid", + "\u2AEF": "cirmid", + "\u2AF0": "midcir", + "\u2AF1": "topcir", + "\u2AF2": "nhpar", + "\u2AF3": "parsim", + "\u2AFD": "parsl", + "\u2AFD\u20E5": "nparsl", + "\u266D": "flat", + "\u266E": "natur", + "\u266F": "sharp", + "\xA4": "curren", + "\xA2": "cent", + $: "dollar", + "\xA3": "pound", + "\xA5": "yen", + "\u20AC": "euro", + "\xB9": "sup1", + "\xBD": "half", + "\u2153": "frac13", + "\xBC": "frac14", + "\u2155": "frac15", + "\u2159": "frac16", + "\u215B": "frac18", + "\xB2": "sup2", + "\u2154": "frac23", + "\u2156": "frac25", + "\xB3": "sup3", + "\xBE": "frac34", + "\u2157": "frac35", + "\u215C": "frac38", + "\u2158": "frac45", + "\u215A": "frac56", + "\u215D": "frac58", + "\u215E": "frac78", + "\uD835\uDCB6": "ascr", + "\uD835\uDD52": "aopf", + "\uD835\uDD1E": "afr", + "\uD835\uDD38": "Aopf", + "\uD835\uDD04": "Afr", + "\uD835\uDC9C": "Ascr", + "\xAA": "ordf", + "\xE1": "aacute", + "\xC1": "Aacute", + "\xE0": "agrave", + "\xC0": "Agrave", + "\u0103": "abreve", + "\u0102": "Abreve", + "\xE2": "acirc", + "\xC2": "Acirc", + "\xE5": "aring", + "\xC5": "angst", + "\xE4": "auml", + "\xC4": "Auml", + "\xE3": "atilde", + "\xC3": "Atilde", + "\u0105": "aogon", + "\u0104": "Aogon", + "\u0101": "amacr", + "\u0100": "Amacr", + "\xE6": "aelig", + "\xC6": "AElig", + "\uD835\uDCB7": "bscr", + "\uD835\uDD53": "bopf", + "\uD835\uDD1F": "bfr", + "\uD835\uDD39": "Bopf", + "\u212C": "Bscr", + "\uD835\uDD05": "Bfr", + "\uD835\uDD20": "cfr", + "\uD835\uDCB8": "cscr", + "\uD835\uDD54": "copf", + "\u212D": "Cfr", + "\uD835\uDC9E": "Cscr", + "\u2102": "Copf", + "\u0107": "cacute", + "\u0106": "Cacute", + "\u0109": "ccirc", + "\u0108": "Ccirc", + "\u010D": "ccaron", + "\u010C": "Ccaron", + "\u010B": "cdot", + "\u010A": "Cdot", + "\xE7": "ccedil", + "\xC7": "Ccedil", + "\u2105": "incare", + "\uD835\uDD21": "dfr", + "\u2146": "dd", + "\uD835\uDD55": "dopf", + "\uD835\uDCB9": "dscr", + "\uD835\uDC9F": "Dscr", + "\uD835\uDD07": "Dfr", + "\u2145": "DD", + "\uD835\uDD3B": "Dopf", + "\u010F": "dcaron", + "\u010E": "Dcaron", + "\u0111": "dstrok", + "\u0110": "Dstrok", + "\xF0": "eth", + "\xD0": "ETH", + "\u2147": "ee", + "\u212F": "escr", + "\uD835\uDD22": "efr", + "\uD835\uDD56": "eopf", + "\u2130": "Escr", + "\uD835\uDD08": "Efr", + "\uD835\uDD3C": "Eopf", + "\xE9": "eacute", + "\xC9": "Eacute", + "\xE8": "egrave", + "\xC8": "Egrave", + "\xEA": "ecirc", + "\xCA": "Ecirc", + "\u011B": "ecaron", + "\u011A": "Ecaron", + "\xEB": "euml", + "\xCB": "Euml", + "\u0117": "edot", + "\u0116": "Edot", + "\u0119": "eogon", + "\u0118": "Eogon", + "\u0113": "emacr", + "\u0112": "Emacr", + "\uD835\uDD23": "ffr", + "\uD835\uDD57": "fopf", + "\uD835\uDCBB": "fscr", + "\uD835\uDD09": "Ffr", + "\uD835\uDD3D": "Fopf", + "\u2131": "Fscr", + "\uFB00": "fflig", + "\uFB03": "ffilig", + "\uFB04": "ffllig", + "\uFB01": "filig", + fj: "fjlig", + "\uFB02": "fllig", + "\u0192": "fnof", + "\u210A": "gscr", + "\uD835\uDD58": "gopf", + "\uD835\uDD24": "gfr", + "\uD835\uDCA2": "Gscr", + "\uD835\uDD3E": "Gopf", + "\uD835\uDD0A": "Gfr", + "\u01F5": "gacute", + "\u011F": "gbreve", + "\u011E": "Gbreve", + "\u011D": "gcirc", + "\u011C": "Gcirc", + "\u0121": "gdot", + "\u0120": "Gdot", + "\u0122": "Gcedil", + "\uD835\uDD25": "hfr", + "\u210E": "planckh", + "\uD835\uDCBD": "hscr", + "\uD835\uDD59": "hopf", + "\u210B": "Hscr", + "\u210C": "Hfr", + "\u210D": "Hopf", + "\u0125": "hcirc", + "\u0124": "Hcirc", + "\u210F": "hbar", + "\u0127": "hstrok", + "\u0126": "Hstrok", + "\uD835\uDD5A": "iopf", + "\uD835\uDD26": "ifr", + "\uD835\uDCBE": "iscr", + "\u2148": "ii", + "\uD835\uDD40": "Iopf", + "\u2110": "Iscr", + "\u2111": "Im", + "\xED": "iacute", + "\xCD": "Iacute", + "\xEC": "igrave", + "\xCC": "Igrave", + "\xEE": "icirc", + "\xCE": "Icirc", + "\xEF": "iuml", + "\xCF": "Iuml", + "\u0129": "itilde", + "\u0128": "Itilde", + "\u0130": "Idot", + "\u012F": "iogon", + "\u012E": "Iogon", + "\u012B": "imacr", + "\u012A": "Imacr", + "\u0133": "ijlig", + "\u0132": "IJlig", + "\u0131": "imath", + "\uD835\uDCBF": "jscr", + "\uD835\uDD5B": "jopf", + "\uD835\uDD27": "jfr", + "\uD835\uDCA5": "Jscr", + "\uD835\uDD0D": "Jfr", + "\uD835\uDD41": "Jopf", + "\u0135": "jcirc", + "\u0134": "Jcirc", + "\u0237": "jmath", + "\uD835\uDD5C": "kopf", + "\uD835\uDCC0": "kscr", + "\uD835\uDD28": "kfr", + "\uD835\uDCA6": "Kscr", + "\uD835\uDD42": "Kopf", + "\uD835\uDD0E": "Kfr", + "\u0137": "kcedil", + "\u0136": "Kcedil", + "\uD835\uDD29": "lfr", + "\uD835\uDCC1": "lscr", + "\u2113": "ell", + "\uD835\uDD5D": "lopf", + "\u2112": "Lscr", + "\uD835\uDD0F": "Lfr", + "\uD835\uDD43": "Lopf", + "\u013A": "lacute", + "\u0139": "Lacute", + "\u013E": "lcaron", + "\u013D": "Lcaron", + "\u013C": "lcedil", + "\u013B": "Lcedil", + "\u0142": "lstrok", + "\u0141": "Lstrok", + "\u0140": "lmidot", + "\u013F": "Lmidot", + "\uD835\uDD2A": "mfr", + "\uD835\uDD5E": "mopf", + "\uD835\uDCC2": "mscr", + "\uD835\uDD10": "Mfr", + "\uD835\uDD44": "Mopf", + "\u2133": "Mscr", + "\uD835\uDD2B": "nfr", + "\uD835\uDD5F": "nopf", + "\uD835\uDCC3": "nscr", + "\u2115": "Nopf", + "\uD835\uDCA9": "Nscr", + "\uD835\uDD11": "Nfr", + "\u0144": "nacute", + "\u0143": "Nacute", + "\u0148": "ncaron", + "\u0147": "Ncaron", + "\xF1": "ntilde", + "\xD1": "Ntilde", + "\u0146": "ncedil", + "\u0145": "Ncedil", + "\u2116": "numero", + "\u014B": "eng", + "\u014A": "ENG", + "\uD835\uDD60": "oopf", + "\uD835\uDD2C": "ofr", + "\u2134": "oscr", + "\uD835\uDCAA": "Oscr", + "\uD835\uDD12": "Ofr", + "\uD835\uDD46": "Oopf", + "\xBA": "ordm", + "\xF3": "oacute", + "\xD3": "Oacute", + "\xF2": "ograve", + "\xD2": "Ograve", + "\xF4": "ocirc", + "\xD4": "Ocirc", + "\xF6": "ouml", + "\xD6": "Ouml", + "\u0151": "odblac", + "\u0150": "Odblac", + "\xF5": "otilde", + "\xD5": "Otilde", + "\xF8": "oslash", + "\xD8": "Oslash", + "\u014D": "omacr", + "\u014C": "Omacr", + "\u0153": "oelig", + "\u0152": "OElig", + "\uD835\uDD2D": "pfr", + "\uD835\uDCC5": "pscr", + "\uD835\uDD61": "popf", + "\u2119": "Popf", + "\uD835\uDD13": "Pfr", + "\uD835\uDCAB": "Pscr", + "\uD835\uDD62": "qopf", + "\uD835\uDD2E": "qfr", + "\uD835\uDCC6": "qscr", + "\uD835\uDCAC": "Qscr", + "\uD835\uDD14": "Qfr", + "\u211A": "Qopf", + "\u0138": "kgreen", + "\uD835\uDD2F": "rfr", + "\uD835\uDD63": "ropf", + "\uD835\uDCC7": "rscr", + "\u211B": "Rscr", + "\u211C": "Re", + "\u211D": "Ropf", + "\u0155": "racute", + "\u0154": "Racute", + "\u0159": "rcaron", + "\u0158": "Rcaron", + "\u0157": "rcedil", + "\u0156": "Rcedil", + "\uD835\uDD64": "sopf", + "\uD835\uDCC8": "sscr", + "\uD835\uDD30": "sfr", + "\uD835\uDD4A": "Sopf", + "\uD835\uDD16": "Sfr", + "\uD835\uDCAE": "Sscr", + "\u24C8": "oS", + "\u015B": "sacute", + "\u015A": "Sacute", + "\u015D": "scirc", + "\u015C": "Scirc", + "\u0161": "scaron", + "\u0160": "Scaron", + "\u015F": "scedil", + "\u015E": "Scedil", + "\xDF": "szlig", + "\uD835\uDD31": "tfr", + "\uD835\uDCC9": "tscr", + "\uD835\uDD65": "topf", + "\uD835\uDCAF": "Tscr", + "\uD835\uDD17": "Tfr", + "\uD835\uDD4B": "Topf", + "\u0165": "tcaron", + "\u0164": "Tcaron", + "\u0163": "tcedil", + "\u0162": "Tcedil", + "\u2122": "trade", + "\u0167": "tstrok", + "\u0166": "Tstrok", + "\uD835\uDCCA": "uscr", + "\uD835\uDD66": "uopf", + "\uD835\uDD32": "ufr", + "\uD835\uDD4C": "Uopf", + "\uD835\uDD18": "Ufr", + "\uD835\uDCB0": "Uscr", + "\xFA": "uacute", + "\xDA": "Uacute", + "\xF9": "ugrave", + "\xD9": "Ugrave", + "\u016D": "ubreve", + "\u016C": "Ubreve", + "\xFB": "ucirc", + "\xDB": "Ucirc", + "\u016F": "uring", + "\u016E": "Uring", + "\xFC": "uuml", + "\xDC": "Uuml", + "\u0171": "udblac", + "\u0170": "Udblac", + "\u0169": "utilde", + "\u0168": "Utilde", + "\u0173": "uogon", + "\u0172": "Uogon", + "\u016B": "umacr", + "\u016A": "Umacr", + "\uD835\uDD33": "vfr", + "\uD835\uDD67": "vopf", + "\uD835\uDCCB": "vscr", + "\uD835\uDD19": "Vfr", + "\uD835\uDD4D": "Vopf", + "\uD835\uDCB1": "Vscr", + "\uD835\uDD68": "wopf", + "\uD835\uDCCC": "wscr", + "\uD835\uDD34": "wfr", + "\uD835\uDCB2": "Wscr", + "\uD835\uDD4E": "Wopf", + "\uD835\uDD1A": "Wfr", + "\u0175": "wcirc", + "\u0174": "Wcirc", + "\uD835\uDD35": "xfr", + "\uD835\uDCCD": "xscr", + "\uD835\uDD69": "xopf", + "\uD835\uDD4F": "Xopf", + "\uD835\uDD1B": "Xfr", + "\uD835\uDCB3": "Xscr", + "\uD835\uDD36": "yfr", + "\uD835\uDCCE": "yscr", + "\uD835\uDD6A": "yopf", + "\uD835\uDCB4": "Yscr", + "\uD835\uDD1C": "Yfr", + "\uD835\uDD50": "Yopf", + "\xFD": "yacute", + "\xDD": "Yacute", + "\u0177": "ycirc", + "\u0176": "Ycirc", + "\xFF": "yuml", + "\u0178": "Yuml", + "\uD835\uDCCF": "zscr", + "\uD835\uDD37": "zfr", + "\uD835\uDD6B": "zopf", + "\u2128": "Zfr", + "\u2124": "Zopf", + "\uD835\uDCB5": "Zscr", + "\u017A": "zacute", + "\u0179": "Zacute", + "\u017E": "zcaron", + "\u017D": "Zcaron", + "\u017C": "zdot", + "\u017B": "Zdot", + "\u01B5": "imped", + "\xFE": "thorn", + "\xDE": "THORN", + "\u0149": "napos", + "\u03B1": "alpha", + "\u0391": "Alpha", + "\u03B2": "beta", + "\u0392": "Beta", + "\u03B3": "gamma", + "\u0393": "Gamma", + "\u03B4": "delta", + "\u0394": "Delta", + "\u03B5": "epsi", + "\u03F5": "epsiv", + "\u0395": "Epsilon", + "\u03DD": "gammad", + "\u03DC": "Gammad", + "\u03B6": "zeta", + "\u0396": "Zeta", + "\u03B7": "eta", + "\u0397": "Eta", + "\u03B8": "theta", + "\u03D1": "thetav", + "\u0398": "Theta", + "\u03B9": "iota", + "\u0399": "Iota", + "\u03BA": "kappa", + "\u03F0": "kappav", + "\u039A": "Kappa", + "\u03BB": "lambda", + "\u039B": "Lambda", + "\u03BC": "mu", + "\xB5": "micro", + "\u039C": "Mu", + "\u03BD": "nu", + "\u039D": "Nu", + "\u03BE": "xi", + "\u039E": "Xi", + "\u03BF": "omicron", + "\u039F": "Omicron", + "\u03C0": "pi", + "\u03D6": "piv", + "\u03A0": "Pi", + "\u03C1": "rho", + "\u03F1": "rhov", + "\u03A1": "Rho", + "\u03C3": "sigma", + "\u03A3": "Sigma", + "\u03C2": "sigmaf", + "\u03C4": "tau", + "\u03A4": "Tau", + "\u03C5": "upsi", + "\u03A5": "Upsilon", + "\u03D2": "Upsi", + "\u03C6": "phi", + "\u03D5": "phiv", + "\u03A6": "Phi", + "\u03C7": "chi", + "\u03A7": "Chi", + "\u03C8": "psi", + "\u03A8": "Psi", + "\u03C9": "omega", + "\u03A9": "ohm", + "\u0430": "acy", + "\u0410": "Acy", + "\u0431": "bcy", + "\u0411": "Bcy", + "\u0432": "vcy", + "\u0412": "Vcy", + "\u0433": "gcy", + "\u0413": "Gcy", + "\u0453": "gjcy", + "\u0403": "GJcy", + "\u0434": "dcy", + "\u0414": "Dcy", + "\u0452": "djcy", + "\u0402": "DJcy", + "\u0435": "iecy", + "\u0415": "IEcy", + "\u0451": "iocy", + "\u0401": "IOcy", + "\u0454": "jukcy", + "\u0404": "Jukcy", + "\u0436": "zhcy", + "\u0416": "ZHcy", + "\u0437": "zcy", + "\u0417": "Zcy", + "\u0455": "dscy", + "\u0405": "DScy", + "\u0438": "icy", + "\u0418": "Icy", + "\u0456": "iukcy", + "\u0406": "Iukcy", + "\u0457": "yicy", + "\u0407": "YIcy", + "\u0439": "jcy", + "\u0419": "Jcy", + "\u0458": "jsercy", + "\u0408": "Jsercy", + "\u043A": "kcy", + "\u041A": "Kcy", + "\u045C": "kjcy", + "\u040C": "KJcy", + "\u043B": "lcy", + "\u041B": "Lcy", + "\u0459": "ljcy", + "\u0409": "LJcy", + "\u043C": "mcy", + "\u041C": "Mcy", + "\u043D": "ncy", + "\u041D": "Ncy", + "\u045A": "njcy", + "\u040A": "NJcy", + "\u043E": "ocy", + "\u041E": "Ocy", + "\u043F": "pcy", + "\u041F": "Pcy", + "\u0440": "rcy", + "\u0420": "Rcy", + "\u0441": "scy", + "\u0421": "Scy", + "\u0442": "tcy", + "\u0422": "Tcy", + "\u045B": "tshcy", + "\u040B": "TSHcy", + "\u0443": "ucy", + "\u0423": "Ucy", + "\u045E": "ubrcy", + "\u040E": "Ubrcy", + "\u0444": "fcy", + "\u0424": "Fcy", + "\u0445": "khcy", + "\u0425": "KHcy", + "\u0446": "tscy", + "\u0426": "TScy", + "\u0447": "chcy", + "\u0427": "CHcy", + "\u045F": "dzcy", + "\u040F": "DZcy", + "\u0448": "shcy", + "\u0428": "SHcy", + "\u0449": "shchcy", + "\u0429": "SHCHcy", + "\u044A": "hardcy", + "\u042A": "HARDcy", + "\u044B": "ycy", + "\u042B": "Ycy", + "\u044C": "softcy", + "\u042C": "SOFTcy", + "\u044D": "ecy", + "\u042D": "Ecy", + "\u044E": "yucy", + "\u042E": "YUcy", + "\u044F": "yacy", + "\u042F": "YAcy", + "\u2135": "aleph", + "\u2136": "beth", + "\u2137": "gimel", + "\u2138": "daleth", + }; + var regexEscape = /["&'<>`]/g; + var escapeMap = { + '"': """, + "&": "&", + "'": "'", + "<": "<", + // See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the + // following is not strictly necessary unless it’s part of a tag or an + // unquoted attribute value. We’re only escaping it to support those + // situations, and for XML support. + ">": ">", + // In Internet Explorer ≤ 8, the backtick character can be used + // to break out of (un)quoted attribute values or HTML comments. + // See http://html5sec.org/#102, http://html5sec.org/#108, and + // http://html5sec.org/#133. + "`": "`", + }; + var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/; + var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; + var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g; + var decodeMap = { + aacute: "\xE1", + Aacute: "\xC1", + abreve: "\u0103", + Abreve: "\u0102", + ac: "\u223E", + acd: "\u223F", + acE: "\u223E\u0333", + acirc: "\xE2", + Acirc: "\xC2", + acute: "\xB4", + acy: "\u0430", + Acy: "\u0410", + aelig: "\xE6", + AElig: "\xC6", + af: "\u2061", + afr: "\uD835\uDD1E", + Afr: "\uD835\uDD04", + agrave: "\xE0", + Agrave: "\xC0", + alefsym: "\u2135", + aleph: "\u2135", + alpha: "\u03B1", + Alpha: "\u0391", + amacr: "\u0101", + Amacr: "\u0100", + amalg: "\u2A3F", + amp: "&", + AMP: "&", + and: "\u2227", + And: "\u2A53", + andand: "\u2A55", + andd: "\u2A5C", + andslope: "\u2A58", + andv: "\u2A5A", + ang: "\u2220", + ange: "\u29A4", + angle: "\u2220", + angmsd: "\u2221", + angmsdaa: "\u29A8", + angmsdab: "\u29A9", + angmsdac: "\u29AA", + angmsdad: "\u29AB", + angmsdae: "\u29AC", + angmsdaf: "\u29AD", + angmsdag: "\u29AE", + angmsdah: "\u29AF", + angrt: "\u221F", + angrtvb: "\u22BE", + angrtvbd: "\u299D", + angsph: "\u2222", + angst: "\xC5", + angzarr: "\u237C", + aogon: "\u0105", + Aogon: "\u0104", + aopf: "\uD835\uDD52", + Aopf: "\uD835\uDD38", + ap: "\u2248", + apacir: "\u2A6F", + ape: "\u224A", + apE: "\u2A70", + apid: "\u224B", + apos: "'", + ApplyFunction: "\u2061", + approx: "\u2248", + approxeq: "\u224A", + aring: "\xE5", + Aring: "\xC5", + ascr: "\uD835\uDCB6", + Ascr: "\uD835\uDC9C", + Assign: "\u2254", + ast: "*", + asymp: "\u2248", + asympeq: "\u224D", + atilde: "\xE3", + Atilde: "\xC3", + auml: "\xE4", + Auml: "\xC4", + awconint: "\u2233", + awint: "\u2A11", + backcong: "\u224C", + backepsilon: "\u03F6", + backprime: "\u2035", + backsim: "\u223D", + backsimeq: "\u22CD", + Backslash: "\u2216", + Barv: "\u2AE7", + barvee: "\u22BD", + barwed: "\u2305", + Barwed: "\u2306", + barwedge: "\u2305", + bbrk: "\u23B5", + bbrktbrk: "\u23B6", + bcong: "\u224C", + bcy: "\u0431", + Bcy: "\u0411", + bdquo: "\u201E", + becaus: "\u2235", + because: "\u2235", + Because: "\u2235", + bemptyv: "\u29B0", + bepsi: "\u03F6", + bernou: "\u212C", + Bernoullis: "\u212C", + beta: "\u03B2", + Beta: "\u0392", + beth: "\u2136", + between: "\u226C", + bfr: "\uD835\uDD1F", + Bfr: "\uD835\uDD05", + bigcap: "\u22C2", + bigcirc: "\u25EF", + bigcup: "\u22C3", + bigodot: "\u2A00", + bigoplus: "\u2A01", + bigotimes: "\u2A02", + bigsqcup: "\u2A06", + bigstar: "\u2605", + bigtriangledown: "\u25BD", + bigtriangleup: "\u25B3", + biguplus: "\u2A04", + bigvee: "\u22C1", + bigwedge: "\u22C0", + bkarow: "\u290D", + blacklozenge: "\u29EB", + blacksquare: "\u25AA", + blacktriangle: "\u25B4", + blacktriangledown: "\u25BE", + blacktriangleleft: "\u25C2", + blacktriangleright: "\u25B8", + blank: "\u2423", + blk12: "\u2592", + blk14: "\u2591", + blk34: "\u2593", + block: "\u2588", + bne: "=\u20E5", + bnequiv: "\u2261\u20E5", + bnot: "\u2310", + bNot: "\u2AED", + bopf: "\uD835\uDD53", + Bopf: "\uD835\uDD39", + bot: "\u22A5", + bottom: "\u22A5", + bowtie: "\u22C8", + boxbox: "\u29C9", + boxdl: "\u2510", + boxdL: "\u2555", + boxDl: "\u2556", + boxDL: "\u2557", + boxdr: "\u250C", + boxdR: "\u2552", + boxDr: "\u2553", + boxDR: "\u2554", + boxh: "\u2500", + boxH: "\u2550", + boxhd: "\u252C", + boxhD: "\u2565", + boxHd: "\u2564", + boxHD: "\u2566", + boxhu: "\u2534", + boxhU: "\u2568", + boxHu: "\u2567", + boxHU: "\u2569", + boxminus: "\u229F", + boxplus: "\u229E", + boxtimes: "\u22A0", + boxul: "\u2518", + boxuL: "\u255B", + boxUl: "\u255C", + boxUL: "\u255D", + boxur: "\u2514", + boxuR: "\u2558", + boxUr: "\u2559", + boxUR: "\u255A", + boxv: "\u2502", + boxV: "\u2551", + boxvh: "\u253C", + boxvH: "\u256A", + boxVh: "\u256B", + boxVH: "\u256C", + boxvl: "\u2524", + boxvL: "\u2561", + boxVl: "\u2562", + boxVL: "\u2563", + boxvr: "\u251C", + boxvR: "\u255E", + boxVr: "\u255F", + boxVR: "\u2560", + bprime: "\u2035", + breve: "\u02D8", + Breve: "\u02D8", + brvbar: "\xA6", + bscr: "\uD835\uDCB7", + Bscr: "\u212C", + bsemi: "\u204F", + bsim: "\u223D", + bsime: "\u22CD", + bsol: "\\", + bsolb: "\u29C5", + bsolhsub: "\u27C8", + bull: "\u2022", + bullet: "\u2022", + bump: "\u224E", + bumpe: "\u224F", + bumpE: "\u2AAE", + bumpeq: "\u224F", + Bumpeq: "\u224E", + cacute: "\u0107", + Cacute: "\u0106", + cap: "\u2229", + Cap: "\u22D2", + capand: "\u2A44", + capbrcup: "\u2A49", + capcap: "\u2A4B", + capcup: "\u2A47", + capdot: "\u2A40", + CapitalDifferentialD: "\u2145", + caps: "\u2229\uFE00", + caret: "\u2041", + caron: "\u02C7", + Cayleys: "\u212D", + ccaps: "\u2A4D", + ccaron: "\u010D", + Ccaron: "\u010C", + ccedil: "\xE7", + Ccedil: "\xC7", + ccirc: "\u0109", + Ccirc: "\u0108", + Cconint: "\u2230", + ccups: "\u2A4C", + ccupssm: "\u2A50", + cdot: "\u010B", + Cdot: "\u010A", + cedil: "\xB8", + Cedilla: "\xB8", + cemptyv: "\u29B2", + cent: "\xA2", + centerdot: "\xB7", + CenterDot: "\xB7", + cfr: "\uD835\uDD20", + Cfr: "\u212D", + chcy: "\u0447", + CHcy: "\u0427", + check: "\u2713", + checkmark: "\u2713", + chi: "\u03C7", + Chi: "\u03A7", + cir: "\u25CB", + circ: "\u02C6", + circeq: "\u2257", + circlearrowleft: "\u21BA", + circlearrowright: "\u21BB", + circledast: "\u229B", + circledcirc: "\u229A", + circleddash: "\u229D", + CircleDot: "\u2299", + circledR: "\xAE", + circledS: "\u24C8", + CircleMinus: "\u2296", + CirclePlus: "\u2295", + CircleTimes: "\u2297", + cire: "\u2257", + cirE: "\u29C3", + cirfnint: "\u2A10", + cirmid: "\u2AEF", + cirscir: "\u29C2", + ClockwiseContourIntegral: "\u2232", + CloseCurlyDoubleQuote: "\u201D", + CloseCurlyQuote: "\u2019", + clubs: "\u2663", + clubsuit: "\u2663", + colon: ":", + Colon: "\u2237", + colone: "\u2254", + Colone: "\u2A74", + coloneq: "\u2254", + comma: ",", + commat: "@", + comp: "\u2201", + compfn: "\u2218", + complement: "\u2201", + complexes: "\u2102", + cong: "\u2245", + congdot: "\u2A6D", + Congruent: "\u2261", + conint: "\u222E", + Conint: "\u222F", + ContourIntegral: "\u222E", + copf: "\uD835\uDD54", + Copf: "\u2102", + coprod: "\u2210", + Coproduct: "\u2210", + copy: "\xA9", + COPY: "\xA9", + copysr: "\u2117", + CounterClockwiseContourIntegral: "\u2233", + crarr: "\u21B5", + cross: "\u2717", + Cross: "\u2A2F", + cscr: "\uD835\uDCB8", + Cscr: "\uD835\uDC9E", + csub: "\u2ACF", + csube: "\u2AD1", + csup: "\u2AD0", + csupe: "\u2AD2", + ctdot: "\u22EF", + cudarrl: "\u2938", + cudarrr: "\u2935", + cuepr: "\u22DE", + cuesc: "\u22DF", + cularr: "\u21B6", + cularrp: "\u293D", + cup: "\u222A", + Cup: "\u22D3", + cupbrcap: "\u2A48", + cupcap: "\u2A46", + CupCap: "\u224D", + cupcup: "\u2A4A", + cupdot: "\u228D", + cupor: "\u2A45", + cups: "\u222A\uFE00", + curarr: "\u21B7", + curarrm: "\u293C", + curlyeqprec: "\u22DE", + curlyeqsucc: "\u22DF", + curlyvee: "\u22CE", + curlywedge: "\u22CF", + curren: "\xA4", + curvearrowleft: "\u21B6", + curvearrowright: "\u21B7", + cuvee: "\u22CE", + cuwed: "\u22CF", + cwconint: "\u2232", + cwint: "\u2231", + cylcty: "\u232D", + dagger: "\u2020", + Dagger: "\u2021", + daleth: "\u2138", + darr: "\u2193", + dArr: "\u21D3", + Darr: "\u21A1", + dash: "\u2010", + dashv: "\u22A3", + Dashv: "\u2AE4", + dbkarow: "\u290F", + dblac: "\u02DD", + dcaron: "\u010F", + Dcaron: "\u010E", + dcy: "\u0434", + Dcy: "\u0414", + dd: "\u2146", + DD: "\u2145", + ddagger: "\u2021", + ddarr: "\u21CA", + DDotrahd: "\u2911", + ddotseq: "\u2A77", + deg: "\xB0", + Del: "\u2207", + delta: "\u03B4", + Delta: "\u0394", + demptyv: "\u29B1", + dfisht: "\u297F", + dfr: "\uD835\uDD21", + Dfr: "\uD835\uDD07", + dHar: "\u2965", + dharl: "\u21C3", + dharr: "\u21C2", + DiacriticalAcute: "\xB4", + DiacriticalDot: "\u02D9", + DiacriticalDoubleAcute: "\u02DD", + DiacriticalGrave: "`", + DiacriticalTilde: "\u02DC", + diam: "\u22C4", + diamond: "\u22C4", + Diamond: "\u22C4", + diamondsuit: "\u2666", + diams: "\u2666", + die: "\xA8", + DifferentialD: "\u2146", + digamma: "\u03DD", + disin: "\u22F2", + div: "\xF7", + divide: "\xF7", + divideontimes: "\u22C7", + divonx: "\u22C7", + djcy: "\u0452", + DJcy: "\u0402", + dlcorn: "\u231E", + dlcrop: "\u230D", + dollar: "$", + dopf: "\uD835\uDD55", + Dopf: "\uD835\uDD3B", + dot: "\u02D9", + Dot: "\xA8", + DotDot: "\u20DC", + doteq: "\u2250", + doteqdot: "\u2251", + DotEqual: "\u2250", + dotminus: "\u2238", + dotplus: "\u2214", + dotsquare: "\u22A1", + doublebarwedge: "\u2306", + DoubleContourIntegral: "\u222F", + DoubleDot: "\xA8", + DoubleDownArrow: "\u21D3", + DoubleLeftArrow: "\u21D0", + DoubleLeftRightArrow: "\u21D4", + DoubleLeftTee: "\u2AE4", + DoubleLongLeftArrow: "\u27F8", + DoubleLongLeftRightArrow: "\u27FA", + DoubleLongRightArrow: "\u27F9", + DoubleRightArrow: "\u21D2", + DoubleRightTee: "\u22A8", + DoubleUpArrow: "\u21D1", + DoubleUpDownArrow: "\u21D5", + DoubleVerticalBar: "\u2225", + downarrow: "\u2193", + Downarrow: "\u21D3", + DownArrow: "\u2193", + DownArrowBar: "\u2913", + DownArrowUpArrow: "\u21F5", + DownBreve: "\u0311", + downdownarrows: "\u21CA", + downharpoonleft: "\u21C3", + downharpoonright: "\u21C2", + DownLeftRightVector: "\u2950", + DownLeftTeeVector: "\u295E", + DownLeftVector: "\u21BD", + DownLeftVectorBar: "\u2956", + DownRightTeeVector: "\u295F", + DownRightVector: "\u21C1", + DownRightVectorBar: "\u2957", + DownTee: "\u22A4", + DownTeeArrow: "\u21A7", + drbkarow: "\u2910", + drcorn: "\u231F", + drcrop: "\u230C", + dscr: "\uD835\uDCB9", + Dscr: "\uD835\uDC9F", + dscy: "\u0455", + DScy: "\u0405", + dsol: "\u29F6", + dstrok: "\u0111", + Dstrok: "\u0110", + dtdot: "\u22F1", + dtri: "\u25BF", + dtrif: "\u25BE", + duarr: "\u21F5", + duhar: "\u296F", + dwangle: "\u29A6", + dzcy: "\u045F", + DZcy: "\u040F", + dzigrarr: "\u27FF", + eacute: "\xE9", + Eacute: "\xC9", + easter: "\u2A6E", + ecaron: "\u011B", + Ecaron: "\u011A", + ecir: "\u2256", + ecirc: "\xEA", + Ecirc: "\xCA", + ecolon: "\u2255", + ecy: "\u044D", + Ecy: "\u042D", + eDDot: "\u2A77", + edot: "\u0117", + eDot: "\u2251", + Edot: "\u0116", + ee: "\u2147", + efDot: "\u2252", + efr: "\uD835\uDD22", + Efr: "\uD835\uDD08", + eg: "\u2A9A", + egrave: "\xE8", + Egrave: "\xC8", + egs: "\u2A96", + egsdot: "\u2A98", + el: "\u2A99", + Element: "\u2208", + elinters: "\u23E7", + ell: "\u2113", + els: "\u2A95", + elsdot: "\u2A97", + emacr: "\u0113", + Emacr: "\u0112", + empty: "\u2205", + emptyset: "\u2205", + EmptySmallSquare: "\u25FB", + emptyv: "\u2205", + EmptyVerySmallSquare: "\u25AB", + emsp: "\u2003", + emsp13: "\u2004", + emsp14: "\u2005", + eng: "\u014B", + ENG: "\u014A", + ensp: "\u2002", + eogon: "\u0119", + Eogon: "\u0118", + eopf: "\uD835\uDD56", + Eopf: "\uD835\uDD3C", + epar: "\u22D5", + eparsl: "\u29E3", + eplus: "\u2A71", + epsi: "\u03B5", + epsilon: "\u03B5", + Epsilon: "\u0395", + epsiv: "\u03F5", + eqcirc: "\u2256", + eqcolon: "\u2255", + eqsim: "\u2242", + eqslantgtr: "\u2A96", + eqslantless: "\u2A95", + Equal: "\u2A75", + equals: "=", + EqualTilde: "\u2242", + equest: "\u225F", + Equilibrium: "\u21CC", + equiv: "\u2261", + equivDD: "\u2A78", + eqvparsl: "\u29E5", + erarr: "\u2971", + erDot: "\u2253", + escr: "\u212F", + Escr: "\u2130", + esdot: "\u2250", + esim: "\u2242", + Esim: "\u2A73", + eta: "\u03B7", + Eta: "\u0397", + eth: "\xF0", + ETH: "\xD0", + euml: "\xEB", + Euml: "\xCB", + euro: "\u20AC", + excl: "!", + exist: "\u2203", + Exists: "\u2203", + expectation: "\u2130", + exponentiale: "\u2147", + ExponentialE: "\u2147", + fallingdotseq: "\u2252", + fcy: "\u0444", + Fcy: "\u0424", + female: "\u2640", + ffilig: "\uFB03", + fflig: "\uFB00", + ffllig: "\uFB04", + ffr: "\uD835\uDD23", + Ffr: "\uD835\uDD09", + filig: "\uFB01", + FilledSmallSquare: "\u25FC", + FilledVerySmallSquare: "\u25AA", + fjlig: "fj", + flat: "\u266D", + fllig: "\uFB02", + fltns: "\u25B1", + fnof: "\u0192", + fopf: "\uD835\uDD57", + Fopf: "\uD835\uDD3D", + forall: "\u2200", + ForAll: "\u2200", + fork: "\u22D4", + forkv: "\u2AD9", + Fouriertrf: "\u2131", + fpartint: "\u2A0D", + frac12: "\xBD", + frac13: "\u2153", + frac14: "\xBC", + frac15: "\u2155", + frac16: "\u2159", + frac18: "\u215B", + frac23: "\u2154", + frac25: "\u2156", + frac34: "\xBE", + frac35: "\u2157", + frac38: "\u215C", + frac45: "\u2158", + frac56: "\u215A", + frac58: "\u215D", + frac78: "\u215E", + frasl: "\u2044", + frown: "\u2322", + fscr: "\uD835\uDCBB", + Fscr: "\u2131", + gacute: "\u01F5", + gamma: "\u03B3", + Gamma: "\u0393", + gammad: "\u03DD", + Gammad: "\u03DC", + gap: "\u2A86", + gbreve: "\u011F", + Gbreve: "\u011E", + Gcedil: "\u0122", + gcirc: "\u011D", + Gcirc: "\u011C", + gcy: "\u0433", + Gcy: "\u0413", + gdot: "\u0121", + Gdot: "\u0120", + ge: "\u2265", + gE: "\u2267", + gel: "\u22DB", + gEl: "\u2A8C", + geq: "\u2265", + geqq: "\u2267", + geqslant: "\u2A7E", + ges: "\u2A7E", + gescc: "\u2AA9", + gesdot: "\u2A80", + gesdoto: "\u2A82", + gesdotol: "\u2A84", + gesl: "\u22DB\uFE00", + gesles: "\u2A94", + gfr: "\uD835\uDD24", + Gfr: "\uD835\uDD0A", + gg: "\u226B", + Gg: "\u22D9", + ggg: "\u22D9", + gimel: "\u2137", + gjcy: "\u0453", + GJcy: "\u0403", + gl: "\u2277", + gla: "\u2AA5", + glE: "\u2A92", + glj: "\u2AA4", + gnap: "\u2A8A", + gnapprox: "\u2A8A", + gne: "\u2A88", + gnE: "\u2269", + gneq: "\u2A88", + gneqq: "\u2269", + gnsim: "\u22E7", + gopf: "\uD835\uDD58", + Gopf: "\uD835\uDD3E", + grave: "`", + GreaterEqual: "\u2265", + GreaterEqualLess: "\u22DB", + GreaterFullEqual: "\u2267", + GreaterGreater: "\u2AA2", + GreaterLess: "\u2277", + GreaterSlantEqual: "\u2A7E", + GreaterTilde: "\u2273", + gscr: "\u210A", + Gscr: "\uD835\uDCA2", + gsim: "\u2273", + gsime: "\u2A8E", + gsiml: "\u2A90", + gt: ">", + Gt: "\u226B", + GT: ">", + gtcc: "\u2AA7", + gtcir: "\u2A7A", + gtdot: "\u22D7", + gtlPar: "\u2995", + gtquest: "\u2A7C", + gtrapprox: "\u2A86", + gtrarr: "\u2978", + gtrdot: "\u22D7", + gtreqless: "\u22DB", + gtreqqless: "\u2A8C", + gtrless: "\u2277", + gtrsim: "\u2273", + gvertneqq: "\u2269\uFE00", + gvnE: "\u2269\uFE00", + Hacek: "\u02C7", + hairsp: "\u200A", + half: "\xBD", + hamilt: "\u210B", + hardcy: "\u044A", + HARDcy: "\u042A", + harr: "\u2194", + hArr: "\u21D4", + harrcir: "\u2948", + harrw: "\u21AD", + Hat: "^", + hbar: "\u210F", + hcirc: "\u0125", + Hcirc: "\u0124", + hearts: "\u2665", + heartsuit: "\u2665", + hellip: "\u2026", + hercon: "\u22B9", + hfr: "\uD835\uDD25", + Hfr: "\u210C", + HilbertSpace: "\u210B", + hksearow: "\u2925", + hkswarow: "\u2926", + hoarr: "\u21FF", + homtht: "\u223B", + hookleftarrow: "\u21A9", + hookrightarrow: "\u21AA", + hopf: "\uD835\uDD59", + Hopf: "\u210D", + horbar: "\u2015", + HorizontalLine: "\u2500", + hscr: "\uD835\uDCBD", + Hscr: "\u210B", + hslash: "\u210F", + hstrok: "\u0127", + Hstrok: "\u0126", + HumpDownHump: "\u224E", + HumpEqual: "\u224F", + hybull: "\u2043", + hyphen: "\u2010", + iacute: "\xED", + Iacute: "\xCD", + ic: "\u2063", + icirc: "\xEE", + Icirc: "\xCE", + icy: "\u0438", + Icy: "\u0418", + Idot: "\u0130", + iecy: "\u0435", + IEcy: "\u0415", + iexcl: "\xA1", + iff: "\u21D4", + ifr: "\uD835\uDD26", + Ifr: "\u2111", + igrave: "\xEC", + Igrave: "\xCC", + ii: "\u2148", + iiiint: "\u2A0C", + iiint: "\u222D", + iinfin: "\u29DC", + iiota: "\u2129", + ijlig: "\u0133", + IJlig: "\u0132", + Im: "\u2111", + imacr: "\u012B", + Imacr: "\u012A", + image: "\u2111", + ImaginaryI: "\u2148", + imagline: "\u2110", + imagpart: "\u2111", + imath: "\u0131", + imof: "\u22B7", + imped: "\u01B5", + Implies: "\u21D2", + in: "\u2208", + incare: "\u2105", + infin: "\u221E", + infintie: "\u29DD", + inodot: "\u0131", + int: "\u222B", + Int: "\u222C", + intcal: "\u22BA", + integers: "\u2124", + Integral: "\u222B", + intercal: "\u22BA", + Intersection: "\u22C2", + intlarhk: "\u2A17", + intprod: "\u2A3C", + InvisibleComma: "\u2063", + InvisibleTimes: "\u2062", + iocy: "\u0451", + IOcy: "\u0401", + iogon: "\u012F", + Iogon: "\u012E", + iopf: "\uD835\uDD5A", + Iopf: "\uD835\uDD40", + iota: "\u03B9", + Iota: "\u0399", + iprod: "\u2A3C", + iquest: "\xBF", + iscr: "\uD835\uDCBE", + Iscr: "\u2110", + isin: "\u2208", + isindot: "\u22F5", + isinE: "\u22F9", + isins: "\u22F4", + isinsv: "\u22F3", + isinv: "\u2208", + it: "\u2062", + itilde: "\u0129", + Itilde: "\u0128", + iukcy: "\u0456", + Iukcy: "\u0406", + iuml: "\xEF", + Iuml: "\xCF", + jcirc: "\u0135", + Jcirc: "\u0134", + jcy: "\u0439", + Jcy: "\u0419", + jfr: "\uD835\uDD27", + Jfr: "\uD835\uDD0D", + jmath: "\u0237", + jopf: "\uD835\uDD5B", + Jopf: "\uD835\uDD41", + jscr: "\uD835\uDCBF", + Jscr: "\uD835\uDCA5", + jsercy: "\u0458", + Jsercy: "\u0408", + jukcy: "\u0454", + Jukcy: "\u0404", + kappa: "\u03BA", + Kappa: "\u039A", + kappav: "\u03F0", + kcedil: "\u0137", + Kcedil: "\u0136", + kcy: "\u043A", + Kcy: "\u041A", + kfr: "\uD835\uDD28", + Kfr: "\uD835\uDD0E", + kgreen: "\u0138", + khcy: "\u0445", + KHcy: "\u0425", + kjcy: "\u045C", + KJcy: "\u040C", + kopf: "\uD835\uDD5C", + Kopf: "\uD835\uDD42", + kscr: "\uD835\uDCC0", + Kscr: "\uD835\uDCA6", + lAarr: "\u21DA", + lacute: "\u013A", + Lacute: "\u0139", + laemptyv: "\u29B4", + lagran: "\u2112", + lambda: "\u03BB", + Lambda: "\u039B", + lang: "\u27E8", + Lang: "\u27EA", + langd: "\u2991", + langle: "\u27E8", + lap: "\u2A85", + Laplacetrf: "\u2112", + laquo: "\xAB", + larr: "\u2190", + lArr: "\u21D0", + Larr: "\u219E", + larrb: "\u21E4", + larrbfs: "\u291F", + larrfs: "\u291D", + larrhk: "\u21A9", + larrlp: "\u21AB", + larrpl: "\u2939", + larrsim: "\u2973", + larrtl: "\u21A2", + lat: "\u2AAB", + latail: "\u2919", + lAtail: "\u291B", + late: "\u2AAD", + lates: "\u2AAD\uFE00", + lbarr: "\u290C", + lBarr: "\u290E", + lbbrk: "\u2772", + lbrace: "{", + lbrack: "[", + lbrke: "\u298B", + lbrksld: "\u298F", + lbrkslu: "\u298D", + lcaron: "\u013E", + Lcaron: "\u013D", + lcedil: "\u013C", + Lcedil: "\u013B", + lceil: "\u2308", + lcub: "{", + lcy: "\u043B", + Lcy: "\u041B", + ldca: "\u2936", + ldquo: "\u201C", + ldquor: "\u201E", + ldrdhar: "\u2967", + ldrushar: "\u294B", + ldsh: "\u21B2", + le: "\u2264", + lE: "\u2266", + LeftAngleBracket: "\u27E8", + leftarrow: "\u2190", + Leftarrow: "\u21D0", + LeftArrow: "\u2190", + LeftArrowBar: "\u21E4", + LeftArrowRightArrow: "\u21C6", + leftarrowtail: "\u21A2", + LeftCeiling: "\u2308", + LeftDoubleBracket: "\u27E6", + LeftDownTeeVector: "\u2961", + LeftDownVector: "\u21C3", + LeftDownVectorBar: "\u2959", + LeftFloor: "\u230A", + leftharpoondown: "\u21BD", + leftharpoonup: "\u21BC", + leftleftarrows: "\u21C7", + leftrightarrow: "\u2194", + Leftrightarrow: "\u21D4", + LeftRightArrow: "\u2194", + leftrightarrows: "\u21C6", + leftrightharpoons: "\u21CB", + leftrightsquigarrow: "\u21AD", + LeftRightVector: "\u294E", + LeftTee: "\u22A3", + LeftTeeArrow: "\u21A4", + LeftTeeVector: "\u295A", + leftthreetimes: "\u22CB", + LeftTriangle: "\u22B2", + LeftTriangleBar: "\u29CF", + LeftTriangleEqual: "\u22B4", + LeftUpDownVector: "\u2951", + LeftUpTeeVector: "\u2960", + LeftUpVector: "\u21BF", + LeftUpVectorBar: "\u2958", + LeftVector: "\u21BC", + LeftVectorBar: "\u2952", + leg: "\u22DA", + lEg: "\u2A8B", + leq: "\u2264", + leqq: "\u2266", + leqslant: "\u2A7D", + les: "\u2A7D", + lescc: "\u2AA8", + lesdot: "\u2A7F", + lesdoto: "\u2A81", + lesdotor: "\u2A83", + lesg: "\u22DA\uFE00", + lesges: "\u2A93", + lessapprox: "\u2A85", + lessdot: "\u22D6", + lesseqgtr: "\u22DA", + lesseqqgtr: "\u2A8B", + LessEqualGreater: "\u22DA", + LessFullEqual: "\u2266", + LessGreater: "\u2276", + lessgtr: "\u2276", + LessLess: "\u2AA1", + lesssim: "\u2272", + LessSlantEqual: "\u2A7D", + LessTilde: "\u2272", + lfisht: "\u297C", + lfloor: "\u230A", + lfr: "\uD835\uDD29", + Lfr: "\uD835\uDD0F", + lg: "\u2276", + lgE: "\u2A91", + lHar: "\u2962", + lhard: "\u21BD", + lharu: "\u21BC", + lharul: "\u296A", + lhblk: "\u2584", + ljcy: "\u0459", + LJcy: "\u0409", + ll: "\u226A", + Ll: "\u22D8", + llarr: "\u21C7", + llcorner: "\u231E", + Lleftarrow: "\u21DA", + llhard: "\u296B", + lltri: "\u25FA", + lmidot: "\u0140", + Lmidot: "\u013F", + lmoust: "\u23B0", + lmoustache: "\u23B0", + lnap: "\u2A89", + lnapprox: "\u2A89", + lne: "\u2A87", + lnE: "\u2268", + lneq: "\u2A87", + lneqq: "\u2268", + lnsim: "\u22E6", + loang: "\u27EC", + loarr: "\u21FD", + lobrk: "\u27E6", + longleftarrow: "\u27F5", + Longleftarrow: "\u27F8", + LongLeftArrow: "\u27F5", + longleftrightarrow: "\u27F7", + Longleftrightarrow: "\u27FA", + LongLeftRightArrow: "\u27F7", + longmapsto: "\u27FC", + longrightarrow: "\u27F6", + Longrightarrow: "\u27F9", + LongRightArrow: "\u27F6", + looparrowleft: "\u21AB", + looparrowright: "\u21AC", + lopar: "\u2985", + lopf: "\uD835\uDD5D", + Lopf: "\uD835\uDD43", + loplus: "\u2A2D", + lotimes: "\u2A34", + lowast: "\u2217", + lowbar: "_", + LowerLeftArrow: "\u2199", + LowerRightArrow: "\u2198", + loz: "\u25CA", + lozenge: "\u25CA", + lozf: "\u29EB", + lpar: "(", + lparlt: "\u2993", + lrarr: "\u21C6", + lrcorner: "\u231F", + lrhar: "\u21CB", + lrhard: "\u296D", + lrm: "\u200E", + lrtri: "\u22BF", + lsaquo: "\u2039", + lscr: "\uD835\uDCC1", + Lscr: "\u2112", + lsh: "\u21B0", + Lsh: "\u21B0", + lsim: "\u2272", + lsime: "\u2A8D", + lsimg: "\u2A8F", + lsqb: "[", + lsquo: "\u2018", + lsquor: "\u201A", + lstrok: "\u0142", + Lstrok: "\u0141", + lt: "<", + Lt: "\u226A", + LT: "<", + ltcc: "\u2AA6", + ltcir: "\u2A79", + ltdot: "\u22D6", + lthree: "\u22CB", + ltimes: "\u22C9", + ltlarr: "\u2976", + ltquest: "\u2A7B", + ltri: "\u25C3", + ltrie: "\u22B4", + ltrif: "\u25C2", + ltrPar: "\u2996", + lurdshar: "\u294A", + luruhar: "\u2966", + lvertneqq: "\u2268\uFE00", + lvnE: "\u2268\uFE00", + macr: "\xAF", + male: "\u2642", + malt: "\u2720", + maltese: "\u2720", + map: "\u21A6", + Map: "\u2905", + mapsto: "\u21A6", + mapstodown: "\u21A7", + mapstoleft: "\u21A4", + mapstoup: "\u21A5", + marker: "\u25AE", + mcomma: "\u2A29", + mcy: "\u043C", + Mcy: "\u041C", + mdash: "\u2014", + mDDot: "\u223A", + measuredangle: "\u2221", + MediumSpace: "\u205F", + Mellintrf: "\u2133", + mfr: "\uD835\uDD2A", + Mfr: "\uD835\uDD10", + mho: "\u2127", + micro: "\xB5", + mid: "\u2223", + midast: "*", + midcir: "\u2AF0", + middot: "\xB7", + minus: "\u2212", + minusb: "\u229F", + minusd: "\u2238", + minusdu: "\u2A2A", + MinusPlus: "\u2213", + mlcp: "\u2ADB", + mldr: "\u2026", + mnplus: "\u2213", + models: "\u22A7", + mopf: "\uD835\uDD5E", + Mopf: "\uD835\uDD44", + mp: "\u2213", + mscr: "\uD835\uDCC2", + Mscr: "\u2133", + mstpos: "\u223E", + mu: "\u03BC", + Mu: "\u039C", + multimap: "\u22B8", + mumap: "\u22B8", + nabla: "\u2207", + nacute: "\u0144", + Nacute: "\u0143", + nang: "\u2220\u20D2", + nap: "\u2249", + napE: "\u2A70\u0338", + napid: "\u224B\u0338", + napos: "\u0149", + napprox: "\u2249", + natur: "\u266E", + natural: "\u266E", + naturals: "\u2115", + nbsp: "\xA0", + nbump: "\u224E\u0338", + nbumpe: "\u224F\u0338", + ncap: "\u2A43", + ncaron: "\u0148", + Ncaron: "\u0147", + ncedil: "\u0146", + Ncedil: "\u0145", + ncong: "\u2247", + ncongdot: "\u2A6D\u0338", + ncup: "\u2A42", + ncy: "\u043D", + Ncy: "\u041D", + ndash: "\u2013", + ne: "\u2260", + nearhk: "\u2924", + nearr: "\u2197", + neArr: "\u21D7", + nearrow: "\u2197", + nedot: "\u2250\u0338", + NegativeMediumSpace: "\u200B", + NegativeThickSpace: "\u200B", + NegativeThinSpace: "\u200B", + NegativeVeryThinSpace: "\u200B", + nequiv: "\u2262", + nesear: "\u2928", + nesim: "\u2242\u0338", + NestedGreaterGreater: "\u226B", + NestedLessLess: "\u226A", + NewLine: "\n", + nexist: "\u2204", + nexists: "\u2204", + nfr: "\uD835\uDD2B", + Nfr: "\uD835\uDD11", + nge: "\u2271", + ngE: "\u2267\u0338", + ngeq: "\u2271", + ngeqq: "\u2267\u0338", + ngeqslant: "\u2A7E\u0338", + nges: "\u2A7E\u0338", + nGg: "\u22D9\u0338", + ngsim: "\u2275", + ngt: "\u226F", + nGt: "\u226B\u20D2", + ngtr: "\u226F", + nGtv: "\u226B\u0338", + nharr: "\u21AE", + nhArr: "\u21CE", + nhpar: "\u2AF2", + ni: "\u220B", + nis: "\u22FC", + nisd: "\u22FA", + niv: "\u220B", + njcy: "\u045A", + NJcy: "\u040A", + nlarr: "\u219A", + nlArr: "\u21CD", + nldr: "\u2025", + nle: "\u2270", + nlE: "\u2266\u0338", + nleftarrow: "\u219A", + nLeftarrow: "\u21CD", + nleftrightarrow: "\u21AE", + nLeftrightarrow: "\u21CE", + nleq: "\u2270", + nleqq: "\u2266\u0338", + nleqslant: "\u2A7D\u0338", + nles: "\u2A7D\u0338", + nless: "\u226E", + nLl: "\u22D8\u0338", + nlsim: "\u2274", + nlt: "\u226E", + nLt: "\u226A\u20D2", + nltri: "\u22EA", + nltrie: "\u22EC", + nLtv: "\u226A\u0338", + nmid: "\u2224", + NoBreak: "\u2060", + NonBreakingSpace: "\xA0", + nopf: "\uD835\uDD5F", + Nopf: "\u2115", + not: "\xAC", + Not: "\u2AEC", + NotCongruent: "\u2262", + NotCupCap: "\u226D", + NotDoubleVerticalBar: "\u2226", + NotElement: "\u2209", + NotEqual: "\u2260", + NotEqualTilde: "\u2242\u0338", + NotExists: "\u2204", + NotGreater: "\u226F", + NotGreaterEqual: "\u2271", + NotGreaterFullEqual: "\u2267\u0338", + NotGreaterGreater: "\u226B\u0338", + NotGreaterLess: "\u2279", + NotGreaterSlantEqual: "\u2A7E\u0338", + NotGreaterTilde: "\u2275", + NotHumpDownHump: "\u224E\u0338", + NotHumpEqual: "\u224F\u0338", + notin: "\u2209", + notindot: "\u22F5\u0338", + notinE: "\u22F9\u0338", + notinva: "\u2209", + notinvb: "\u22F7", + notinvc: "\u22F6", + NotLeftTriangle: "\u22EA", + NotLeftTriangleBar: "\u29CF\u0338", + NotLeftTriangleEqual: "\u22EC", + NotLess: "\u226E", + NotLessEqual: "\u2270", + NotLessGreater: "\u2278", + NotLessLess: "\u226A\u0338", + NotLessSlantEqual: "\u2A7D\u0338", + NotLessTilde: "\u2274", + NotNestedGreaterGreater: "\u2AA2\u0338", + NotNestedLessLess: "\u2AA1\u0338", + notni: "\u220C", + notniva: "\u220C", + notnivb: "\u22FE", + notnivc: "\u22FD", + NotPrecedes: "\u2280", + NotPrecedesEqual: "\u2AAF\u0338", + NotPrecedesSlantEqual: "\u22E0", + NotReverseElement: "\u220C", + NotRightTriangle: "\u22EB", + NotRightTriangleBar: "\u29D0\u0338", + NotRightTriangleEqual: "\u22ED", + NotSquareSubset: "\u228F\u0338", + NotSquareSubsetEqual: "\u22E2", + NotSquareSuperset: "\u2290\u0338", + NotSquareSupersetEqual: "\u22E3", + NotSubset: "\u2282\u20D2", + NotSubsetEqual: "\u2288", + NotSucceeds: "\u2281", + NotSucceedsEqual: "\u2AB0\u0338", + NotSucceedsSlantEqual: "\u22E1", + NotSucceedsTilde: "\u227F\u0338", + NotSuperset: "\u2283\u20D2", + NotSupersetEqual: "\u2289", + NotTilde: "\u2241", + NotTildeEqual: "\u2244", + NotTildeFullEqual: "\u2247", + NotTildeTilde: "\u2249", + NotVerticalBar: "\u2224", + npar: "\u2226", + nparallel: "\u2226", + nparsl: "\u2AFD\u20E5", + npart: "\u2202\u0338", + npolint: "\u2A14", + npr: "\u2280", + nprcue: "\u22E0", + npre: "\u2AAF\u0338", + nprec: "\u2280", + npreceq: "\u2AAF\u0338", + nrarr: "\u219B", + nrArr: "\u21CF", + nrarrc: "\u2933\u0338", + nrarrw: "\u219D\u0338", + nrightarrow: "\u219B", + nRightarrow: "\u21CF", + nrtri: "\u22EB", + nrtrie: "\u22ED", + nsc: "\u2281", + nsccue: "\u22E1", + nsce: "\u2AB0\u0338", + nscr: "\uD835\uDCC3", + Nscr: "\uD835\uDCA9", + nshortmid: "\u2224", + nshortparallel: "\u2226", + nsim: "\u2241", + nsime: "\u2244", + nsimeq: "\u2244", + nsmid: "\u2224", + nspar: "\u2226", + nsqsube: "\u22E2", + nsqsupe: "\u22E3", + nsub: "\u2284", + nsube: "\u2288", + nsubE: "\u2AC5\u0338", + nsubset: "\u2282\u20D2", + nsubseteq: "\u2288", + nsubseteqq: "\u2AC5\u0338", + nsucc: "\u2281", + nsucceq: "\u2AB0\u0338", + nsup: "\u2285", + nsupe: "\u2289", + nsupE: "\u2AC6\u0338", + nsupset: "\u2283\u20D2", + nsupseteq: "\u2289", + nsupseteqq: "\u2AC6\u0338", + ntgl: "\u2279", + ntilde: "\xF1", + Ntilde: "\xD1", + ntlg: "\u2278", + ntriangleleft: "\u22EA", + ntrianglelefteq: "\u22EC", + ntriangleright: "\u22EB", + ntrianglerighteq: "\u22ED", + nu: "\u03BD", + Nu: "\u039D", + num: "#", + numero: "\u2116", + numsp: "\u2007", + nvap: "\u224D\u20D2", + nvdash: "\u22AC", + nvDash: "\u22AD", + nVdash: "\u22AE", + nVDash: "\u22AF", + nvge: "\u2265\u20D2", + nvgt: ">\u20D2", + nvHarr: "\u2904", + nvinfin: "\u29DE", + nvlArr: "\u2902", + nvle: "\u2264\u20D2", + nvlt: "<\u20D2", + nvltrie: "\u22B4\u20D2", + nvrArr: "\u2903", + nvrtrie: "\u22B5\u20D2", + nvsim: "\u223C\u20D2", + nwarhk: "\u2923", + nwarr: "\u2196", + nwArr: "\u21D6", + nwarrow: "\u2196", + nwnear: "\u2927", + oacute: "\xF3", + Oacute: "\xD3", + oast: "\u229B", + ocir: "\u229A", + ocirc: "\xF4", + Ocirc: "\xD4", + ocy: "\u043E", + Ocy: "\u041E", + odash: "\u229D", + odblac: "\u0151", + Odblac: "\u0150", + odiv: "\u2A38", + odot: "\u2299", + odsold: "\u29BC", + oelig: "\u0153", + OElig: "\u0152", + ofcir: "\u29BF", + ofr: "\uD835\uDD2C", + Ofr: "\uD835\uDD12", + ogon: "\u02DB", + ograve: "\xF2", + Ograve: "\xD2", + ogt: "\u29C1", + ohbar: "\u29B5", + ohm: "\u03A9", + oint: "\u222E", + olarr: "\u21BA", + olcir: "\u29BE", + olcross: "\u29BB", + oline: "\u203E", + olt: "\u29C0", + omacr: "\u014D", + Omacr: "\u014C", + omega: "\u03C9", + Omega: "\u03A9", + omicron: "\u03BF", + Omicron: "\u039F", + omid: "\u29B6", + ominus: "\u2296", + oopf: "\uD835\uDD60", + Oopf: "\uD835\uDD46", + opar: "\u29B7", + OpenCurlyDoubleQuote: "\u201C", + OpenCurlyQuote: "\u2018", + operp: "\u29B9", + oplus: "\u2295", + or: "\u2228", + Or: "\u2A54", + orarr: "\u21BB", + ord: "\u2A5D", + order: "\u2134", + orderof: "\u2134", + ordf: "\xAA", + ordm: "\xBA", + origof: "\u22B6", + oror: "\u2A56", + orslope: "\u2A57", + orv: "\u2A5B", + oS: "\u24C8", + oscr: "\u2134", + Oscr: "\uD835\uDCAA", + oslash: "\xF8", + Oslash: "\xD8", + osol: "\u2298", + otilde: "\xF5", + Otilde: "\xD5", + otimes: "\u2297", + Otimes: "\u2A37", + otimesas: "\u2A36", + ouml: "\xF6", + Ouml: "\xD6", + ovbar: "\u233D", + OverBar: "\u203E", + OverBrace: "\u23DE", + OverBracket: "\u23B4", + OverParenthesis: "\u23DC", + par: "\u2225", + para: "\xB6", + parallel: "\u2225", + parsim: "\u2AF3", + parsl: "\u2AFD", + part: "\u2202", + PartialD: "\u2202", + pcy: "\u043F", + Pcy: "\u041F", + percnt: "%", + period: ".", + permil: "\u2030", + perp: "\u22A5", + pertenk: "\u2031", + pfr: "\uD835\uDD2D", + Pfr: "\uD835\uDD13", + phi: "\u03C6", + Phi: "\u03A6", + phiv: "\u03D5", + phmmat: "\u2133", + phone: "\u260E", + pi: "\u03C0", + Pi: "\u03A0", + pitchfork: "\u22D4", + piv: "\u03D6", + planck: "\u210F", + planckh: "\u210E", + plankv: "\u210F", + plus: "+", + plusacir: "\u2A23", + plusb: "\u229E", + pluscir: "\u2A22", + plusdo: "\u2214", + plusdu: "\u2A25", + pluse: "\u2A72", + PlusMinus: "\xB1", + plusmn: "\xB1", + plussim: "\u2A26", + plustwo: "\u2A27", + pm: "\xB1", + Poincareplane: "\u210C", + pointint: "\u2A15", + popf: "\uD835\uDD61", + Popf: "\u2119", + pound: "\xA3", + pr: "\u227A", + Pr: "\u2ABB", + prap: "\u2AB7", + prcue: "\u227C", + pre: "\u2AAF", + prE: "\u2AB3", + prec: "\u227A", + precapprox: "\u2AB7", + preccurlyeq: "\u227C", + Precedes: "\u227A", + PrecedesEqual: "\u2AAF", + PrecedesSlantEqual: "\u227C", + PrecedesTilde: "\u227E", + preceq: "\u2AAF", + precnapprox: "\u2AB9", + precneqq: "\u2AB5", + precnsim: "\u22E8", + precsim: "\u227E", + prime: "\u2032", + Prime: "\u2033", + primes: "\u2119", + prnap: "\u2AB9", + prnE: "\u2AB5", + prnsim: "\u22E8", + prod: "\u220F", + Product: "\u220F", + profalar: "\u232E", + profline: "\u2312", + profsurf: "\u2313", + prop: "\u221D", + Proportion: "\u2237", + Proportional: "\u221D", + propto: "\u221D", + prsim: "\u227E", + prurel: "\u22B0", + pscr: "\uD835\uDCC5", + Pscr: "\uD835\uDCAB", + psi: "\u03C8", + Psi: "\u03A8", + puncsp: "\u2008", + qfr: "\uD835\uDD2E", + Qfr: "\uD835\uDD14", + qint: "\u2A0C", + qopf: "\uD835\uDD62", + Qopf: "\u211A", + qprime: "\u2057", + qscr: "\uD835\uDCC6", + Qscr: "\uD835\uDCAC", + quaternions: "\u210D", + quatint: "\u2A16", + quest: "?", + questeq: "\u225F", + quot: '"', + QUOT: '"', + rAarr: "\u21DB", + race: "\u223D\u0331", + racute: "\u0155", + Racute: "\u0154", + radic: "\u221A", + raemptyv: "\u29B3", + rang: "\u27E9", + Rang: "\u27EB", + rangd: "\u2992", + range: "\u29A5", + rangle: "\u27E9", + raquo: "\xBB", + rarr: "\u2192", + rArr: "\u21D2", + Rarr: "\u21A0", + rarrap: "\u2975", + rarrb: "\u21E5", + rarrbfs: "\u2920", + rarrc: "\u2933", + rarrfs: "\u291E", + rarrhk: "\u21AA", + rarrlp: "\u21AC", + rarrpl: "\u2945", + rarrsim: "\u2974", + rarrtl: "\u21A3", + Rarrtl: "\u2916", + rarrw: "\u219D", + ratail: "\u291A", + rAtail: "\u291C", + ratio: "\u2236", + rationals: "\u211A", + rbarr: "\u290D", + rBarr: "\u290F", + RBarr: "\u2910", + rbbrk: "\u2773", + rbrace: "}", + rbrack: "]", + rbrke: "\u298C", + rbrksld: "\u298E", + rbrkslu: "\u2990", + rcaron: "\u0159", + Rcaron: "\u0158", + rcedil: "\u0157", + Rcedil: "\u0156", + rceil: "\u2309", + rcub: "}", + rcy: "\u0440", + Rcy: "\u0420", + rdca: "\u2937", + rdldhar: "\u2969", + rdquo: "\u201D", + rdquor: "\u201D", + rdsh: "\u21B3", + Re: "\u211C", + real: "\u211C", + realine: "\u211B", + realpart: "\u211C", + reals: "\u211D", + rect: "\u25AD", + reg: "\xAE", + REG: "\xAE", + ReverseElement: "\u220B", + ReverseEquilibrium: "\u21CB", + ReverseUpEquilibrium: "\u296F", + rfisht: "\u297D", + rfloor: "\u230B", + rfr: "\uD835\uDD2F", + Rfr: "\u211C", + rHar: "\u2964", + rhard: "\u21C1", + rharu: "\u21C0", + rharul: "\u296C", + rho: "\u03C1", + Rho: "\u03A1", + rhov: "\u03F1", + RightAngleBracket: "\u27E9", + rightarrow: "\u2192", + Rightarrow: "\u21D2", + RightArrow: "\u2192", + RightArrowBar: "\u21E5", + RightArrowLeftArrow: "\u21C4", + rightarrowtail: "\u21A3", + RightCeiling: "\u2309", + RightDoubleBracket: "\u27E7", + RightDownTeeVector: "\u295D", + RightDownVector: "\u21C2", + RightDownVectorBar: "\u2955", + RightFloor: "\u230B", + rightharpoondown: "\u21C1", + rightharpoonup: "\u21C0", + rightleftarrows: "\u21C4", + rightleftharpoons: "\u21CC", + rightrightarrows: "\u21C9", + rightsquigarrow: "\u219D", + RightTee: "\u22A2", + RightTeeArrow: "\u21A6", + RightTeeVector: "\u295B", + rightthreetimes: "\u22CC", + RightTriangle: "\u22B3", + RightTriangleBar: "\u29D0", + RightTriangleEqual: "\u22B5", + RightUpDownVector: "\u294F", + RightUpTeeVector: "\u295C", + RightUpVector: "\u21BE", + RightUpVectorBar: "\u2954", + RightVector: "\u21C0", + RightVectorBar: "\u2953", + ring: "\u02DA", + risingdotseq: "\u2253", + rlarr: "\u21C4", + rlhar: "\u21CC", + rlm: "\u200F", + rmoust: "\u23B1", + rmoustache: "\u23B1", + rnmid: "\u2AEE", + roang: "\u27ED", + roarr: "\u21FE", + robrk: "\u27E7", + ropar: "\u2986", + ropf: "\uD835\uDD63", + Ropf: "\u211D", + roplus: "\u2A2E", + rotimes: "\u2A35", + RoundImplies: "\u2970", + rpar: ")", + rpargt: "\u2994", + rppolint: "\u2A12", + rrarr: "\u21C9", + Rrightarrow: "\u21DB", + rsaquo: "\u203A", + rscr: "\uD835\uDCC7", + Rscr: "\u211B", + rsh: "\u21B1", + Rsh: "\u21B1", + rsqb: "]", + rsquo: "\u2019", + rsquor: "\u2019", + rthree: "\u22CC", + rtimes: "\u22CA", + rtri: "\u25B9", + rtrie: "\u22B5", + rtrif: "\u25B8", + rtriltri: "\u29CE", + RuleDelayed: "\u29F4", + ruluhar: "\u2968", + rx: "\u211E", + sacute: "\u015B", + Sacute: "\u015A", + sbquo: "\u201A", + sc: "\u227B", + Sc: "\u2ABC", + scap: "\u2AB8", + scaron: "\u0161", + Scaron: "\u0160", + sccue: "\u227D", + sce: "\u2AB0", + scE: "\u2AB4", + scedil: "\u015F", + Scedil: "\u015E", + scirc: "\u015D", + Scirc: "\u015C", + scnap: "\u2ABA", + scnE: "\u2AB6", + scnsim: "\u22E9", + scpolint: "\u2A13", + scsim: "\u227F", + scy: "\u0441", + Scy: "\u0421", + sdot: "\u22C5", + sdotb: "\u22A1", + sdote: "\u2A66", + searhk: "\u2925", + searr: "\u2198", + seArr: "\u21D8", + searrow: "\u2198", + sect: "\xA7", + semi: ";", + seswar: "\u2929", + setminus: "\u2216", + setmn: "\u2216", + sext: "\u2736", + sfr: "\uD835\uDD30", + Sfr: "\uD835\uDD16", + sfrown: "\u2322", + sharp: "\u266F", + shchcy: "\u0449", + SHCHcy: "\u0429", + shcy: "\u0448", + SHcy: "\u0428", + ShortDownArrow: "\u2193", + ShortLeftArrow: "\u2190", + shortmid: "\u2223", + shortparallel: "\u2225", + ShortRightArrow: "\u2192", + ShortUpArrow: "\u2191", + shy: "\xAD", + sigma: "\u03C3", + Sigma: "\u03A3", + sigmaf: "\u03C2", + sigmav: "\u03C2", + sim: "\u223C", + simdot: "\u2A6A", + sime: "\u2243", + simeq: "\u2243", + simg: "\u2A9E", + simgE: "\u2AA0", + siml: "\u2A9D", + simlE: "\u2A9F", + simne: "\u2246", + simplus: "\u2A24", + simrarr: "\u2972", + slarr: "\u2190", + SmallCircle: "\u2218", + smallsetminus: "\u2216", + smashp: "\u2A33", + smeparsl: "\u29E4", + smid: "\u2223", + smile: "\u2323", + smt: "\u2AAA", + smte: "\u2AAC", + smtes: "\u2AAC\uFE00", + softcy: "\u044C", + SOFTcy: "\u042C", + sol: "/", + solb: "\u29C4", + solbar: "\u233F", + sopf: "\uD835\uDD64", + Sopf: "\uD835\uDD4A", + spades: "\u2660", + spadesuit: "\u2660", + spar: "\u2225", + sqcap: "\u2293", + sqcaps: "\u2293\uFE00", + sqcup: "\u2294", + sqcups: "\u2294\uFE00", + Sqrt: "\u221A", + sqsub: "\u228F", + sqsube: "\u2291", + sqsubset: "\u228F", + sqsubseteq: "\u2291", + sqsup: "\u2290", + sqsupe: "\u2292", + sqsupset: "\u2290", + sqsupseteq: "\u2292", + squ: "\u25A1", + square: "\u25A1", + Square: "\u25A1", + SquareIntersection: "\u2293", + SquareSubset: "\u228F", + SquareSubsetEqual: "\u2291", + SquareSuperset: "\u2290", + SquareSupersetEqual: "\u2292", + SquareUnion: "\u2294", + squarf: "\u25AA", + squf: "\u25AA", + srarr: "\u2192", + sscr: "\uD835\uDCC8", + Sscr: "\uD835\uDCAE", + ssetmn: "\u2216", + ssmile: "\u2323", + sstarf: "\u22C6", + star: "\u2606", + Star: "\u22C6", + starf: "\u2605", + straightepsilon: "\u03F5", + straightphi: "\u03D5", + strns: "\xAF", + sub: "\u2282", + Sub: "\u22D0", + subdot: "\u2ABD", + sube: "\u2286", + subE: "\u2AC5", + subedot: "\u2AC3", + submult: "\u2AC1", + subne: "\u228A", + subnE: "\u2ACB", + subplus: "\u2ABF", + subrarr: "\u2979", + subset: "\u2282", + Subset: "\u22D0", + subseteq: "\u2286", + subseteqq: "\u2AC5", + SubsetEqual: "\u2286", + subsetneq: "\u228A", + subsetneqq: "\u2ACB", + subsim: "\u2AC7", + subsub: "\u2AD5", + subsup: "\u2AD3", + succ: "\u227B", + succapprox: "\u2AB8", + succcurlyeq: "\u227D", + Succeeds: "\u227B", + SucceedsEqual: "\u2AB0", + SucceedsSlantEqual: "\u227D", + SucceedsTilde: "\u227F", + succeq: "\u2AB0", + succnapprox: "\u2ABA", + succneqq: "\u2AB6", + succnsim: "\u22E9", + succsim: "\u227F", + SuchThat: "\u220B", + sum: "\u2211", + Sum: "\u2211", + sung: "\u266A", + sup: "\u2283", + Sup: "\u22D1", + sup1: "\xB9", + sup2: "\xB2", + sup3: "\xB3", + supdot: "\u2ABE", + supdsub: "\u2AD8", + supe: "\u2287", + supE: "\u2AC6", + supedot: "\u2AC4", + Superset: "\u2283", + SupersetEqual: "\u2287", + suphsol: "\u27C9", + suphsub: "\u2AD7", + suplarr: "\u297B", + supmult: "\u2AC2", + supne: "\u228B", + supnE: "\u2ACC", + supplus: "\u2AC0", + supset: "\u2283", + Supset: "\u22D1", + supseteq: "\u2287", + supseteqq: "\u2AC6", + supsetneq: "\u228B", + supsetneqq: "\u2ACC", + supsim: "\u2AC8", + supsub: "\u2AD4", + supsup: "\u2AD6", + swarhk: "\u2926", + swarr: "\u2199", + swArr: "\u21D9", + swarrow: "\u2199", + swnwar: "\u292A", + szlig: "\xDF", + Tab: "\t", + target: "\u2316", + tau: "\u03C4", + Tau: "\u03A4", + tbrk: "\u23B4", + tcaron: "\u0165", + Tcaron: "\u0164", + tcedil: "\u0163", + Tcedil: "\u0162", + tcy: "\u0442", + Tcy: "\u0422", + tdot: "\u20DB", + telrec: "\u2315", + tfr: "\uD835\uDD31", + Tfr: "\uD835\uDD17", + there4: "\u2234", + therefore: "\u2234", + Therefore: "\u2234", + theta: "\u03B8", + Theta: "\u0398", + thetasym: "\u03D1", + thetav: "\u03D1", + thickapprox: "\u2248", + thicksim: "\u223C", + ThickSpace: "\u205F\u200A", + thinsp: "\u2009", + ThinSpace: "\u2009", + thkap: "\u2248", + thksim: "\u223C", + thorn: "\xFE", + THORN: "\xDE", + tilde: "\u02DC", + Tilde: "\u223C", + TildeEqual: "\u2243", + TildeFullEqual: "\u2245", + TildeTilde: "\u2248", + times: "\xD7", + timesb: "\u22A0", + timesbar: "\u2A31", + timesd: "\u2A30", + tint: "\u222D", + toea: "\u2928", + top: "\u22A4", + topbot: "\u2336", + topcir: "\u2AF1", + topf: "\uD835\uDD65", + Topf: "\uD835\uDD4B", + topfork: "\u2ADA", + tosa: "\u2929", + tprime: "\u2034", + trade: "\u2122", + TRADE: "\u2122", + triangle: "\u25B5", + triangledown: "\u25BF", + triangleleft: "\u25C3", + trianglelefteq: "\u22B4", + triangleq: "\u225C", + triangleright: "\u25B9", + trianglerighteq: "\u22B5", + tridot: "\u25EC", + trie: "\u225C", + triminus: "\u2A3A", + TripleDot: "\u20DB", + triplus: "\u2A39", + trisb: "\u29CD", + tritime: "\u2A3B", + trpezium: "\u23E2", + tscr: "\uD835\uDCC9", + Tscr: "\uD835\uDCAF", + tscy: "\u0446", + TScy: "\u0426", + tshcy: "\u045B", + TSHcy: "\u040B", + tstrok: "\u0167", + Tstrok: "\u0166", + twixt: "\u226C", + twoheadleftarrow: "\u219E", + twoheadrightarrow: "\u21A0", + uacute: "\xFA", + Uacute: "\xDA", + uarr: "\u2191", + uArr: "\u21D1", + Uarr: "\u219F", + Uarrocir: "\u2949", + ubrcy: "\u045E", + Ubrcy: "\u040E", + ubreve: "\u016D", + Ubreve: "\u016C", + ucirc: "\xFB", + Ucirc: "\xDB", + ucy: "\u0443", + Ucy: "\u0423", + udarr: "\u21C5", + udblac: "\u0171", + Udblac: "\u0170", + udhar: "\u296E", + ufisht: "\u297E", + ufr: "\uD835\uDD32", + Ufr: "\uD835\uDD18", + ugrave: "\xF9", + Ugrave: "\xD9", + uHar: "\u2963", + uharl: "\u21BF", + uharr: "\u21BE", + uhblk: "\u2580", + ulcorn: "\u231C", + ulcorner: "\u231C", + ulcrop: "\u230F", + ultri: "\u25F8", + umacr: "\u016B", + Umacr: "\u016A", + uml: "\xA8", + UnderBar: "_", + UnderBrace: "\u23DF", + UnderBracket: "\u23B5", + UnderParenthesis: "\u23DD", + Union: "\u22C3", + UnionPlus: "\u228E", + uogon: "\u0173", + Uogon: "\u0172", + uopf: "\uD835\uDD66", + Uopf: "\uD835\uDD4C", + uparrow: "\u2191", + Uparrow: "\u21D1", + UpArrow: "\u2191", + UpArrowBar: "\u2912", + UpArrowDownArrow: "\u21C5", + updownarrow: "\u2195", + Updownarrow: "\u21D5", + UpDownArrow: "\u2195", + UpEquilibrium: "\u296E", + upharpoonleft: "\u21BF", + upharpoonright: "\u21BE", + uplus: "\u228E", + UpperLeftArrow: "\u2196", + UpperRightArrow: "\u2197", + upsi: "\u03C5", + Upsi: "\u03D2", + upsih: "\u03D2", + upsilon: "\u03C5", + Upsilon: "\u03A5", + UpTee: "\u22A5", + UpTeeArrow: "\u21A5", + upuparrows: "\u21C8", + urcorn: "\u231D", + urcorner: "\u231D", + urcrop: "\u230E", + uring: "\u016F", + Uring: "\u016E", + urtri: "\u25F9", + uscr: "\uD835\uDCCA", + Uscr: "\uD835\uDCB0", + utdot: "\u22F0", + utilde: "\u0169", + Utilde: "\u0168", + utri: "\u25B5", + utrif: "\u25B4", + uuarr: "\u21C8", + uuml: "\xFC", + Uuml: "\xDC", + uwangle: "\u29A7", + vangrt: "\u299C", + varepsilon: "\u03F5", + varkappa: "\u03F0", + varnothing: "\u2205", + varphi: "\u03D5", + varpi: "\u03D6", + varpropto: "\u221D", + varr: "\u2195", + vArr: "\u21D5", + varrho: "\u03F1", + varsigma: "\u03C2", + varsubsetneq: "\u228A\uFE00", + varsubsetneqq: "\u2ACB\uFE00", + varsupsetneq: "\u228B\uFE00", + varsupsetneqq: "\u2ACC\uFE00", + vartheta: "\u03D1", + vartriangleleft: "\u22B2", + vartriangleright: "\u22B3", + vBar: "\u2AE8", + Vbar: "\u2AEB", + vBarv: "\u2AE9", + vcy: "\u0432", + Vcy: "\u0412", + vdash: "\u22A2", + vDash: "\u22A8", + Vdash: "\u22A9", + VDash: "\u22AB", + Vdashl: "\u2AE6", + vee: "\u2228", + Vee: "\u22C1", + veebar: "\u22BB", + veeeq: "\u225A", + vellip: "\u22EE", + verbar: "|", + Verbar: "\u2016", + vert: "|", + Vert: "\u2016", + VerticalBar: "\u2223", + VerticalLine: "|", + VerticalSeparator: "\u2758", + VerticalTilde: "\u2240", + VeryThinSpace: "\u200A", + vfr: "\uD835\uDD33", + Vfr: "\uD835\uDD19", + vltri: "\u22B2", + vnsub: "\u2282\u20D2", + vnsup: "\u2283\u20D2", + vopf: "\uD835\uDD67", + Vopf: "\uD835\uDD4D", + vprop: "\u221D", + vrtri: "\u22B3", + vscr: "\uD835\uDCCB", + Vscr: "\uD835\uDCB1", + vsubne: "\u228A\uFE00", + vsubnE: "\u2ACB\uFE00", + vsupne: "\u228B\uFE00", + vsupnE: "\u2ACC\uFE00", + Vvdash: "\u22AA", + vzigzag: "\u299A", + wcirc: "\u0175", + Wcirc: "\u0174", + wedbar: "\u2A5F", + wedge: "\u2227", + Wedge: "\u22C0", + wedgeq: "\u2259", + weierp: "\u2118", + wfr: "\uD835\uDD34", + Wfr: "\uD835\uDD1A", + wopf: "\uD835\uDD68", + Wopf: "\uD835\uDD4E", + wp: "\u2118", + wr: "\u2240", + wreath: "\u2240", + wscr: "\uD835\uDCCC", + Wscr: "\uD835\uDCB2", + xcap: "\u22C2", + xcirc: "\u25EF", + xcup: "\u22C3", + xdtri: "\u25BD", + xfr: "\uD835\uDD35", + Xfr: "\uD835\uDD1B", + xharr: "\u27F7", + xhArr: "\u27FA", + xi: "\u03BE", + Xi: "\u039E", + xlarr: "\u27F5", + xlArr: "\u27F8", + xmap: "\u27FC", + xnis: "\u22FB", + xodot: "\u2A00", + xopf: "\uD835\uDD69", + Xopf: "\uD835\uDD4F", + xoplus: "\u2A01", + xotime: "\u2A02", + xrarr: "\u27F6", + xrArr: "\u27F9", + xscr: "\uD835\uDCCD", + Xscr: "\uD835\uDCB3", + xsqcup: "\u2A06", + xuplus: "\u2A04", + xutri: "\u25B3", + xvee: "\u22C1", + xwedge: "\u22C0", + yacute: "\xFD", + Yacute: "\xDD", + yacy: "\u044F", + YAcy: "\u042F", + ycirc: "\u0177", + Ycirc: "\u0176", + ycy: "\u044B", + Ycy: "\u042B", + yen: "\xA5", + yfr: "\uD835\uDD36", + Yfr: "\uD835\uDD1C", + yicy: "\u0457", + YIcy: "\u0407", + yopf: "\uD835\uDD6A", + Yopf: "\uD835\uDD50", + yscr: "\uD835\uDCCE", + Yscr: "\uD835\uDCB4", + yucy: "\u044E", + YUcy: "\u042E", + yuml: "\xFF", + Yuml: "\u0178", + zacute: "\u017A", + Zacute: "\u0179", + zcaron: "\u017E", + Zcaron: "\u017D", + zcy: "\u0437", + Zcy: "\u0417", + zdot: "\u017C", + Zdot: "\u017B", + zeetrf: "\u2128", + ZeroWidthSpace: "\u200B", + zeta: "\u03B6", + Zeta: "\u0396", + zfr: "\uD835\uDD37", + Zfr: "\u2128", + zhcy: "\u0436", + ZHcy: "\u0416", + zigrarr: "\u21DD", + zopf: "\uD835\uDD6B", + Zopf: "\u2124", + zscr: "\uD835\uDCCF", + Zscr: "\uD835\uDCB5", + zwj: "\u200D", + zwnj: "\u200C", + }; + var decodeMapLegacy = { + aacute: "\xE1", + Aacute: "\xC1", + acirc: "\xE2", + Acirc: "\xC2", + acute: "\xB4", + aelig: "\xE6", + AElig: "\xC6", + agrave: "\xE0", + Agrave: "\xC0", + amp: "&", + AMP: "&", + aring: "\xE5", + Aring: "\xC5", + atilde: "\xE3", + Atilde: "\xC3", + auml: "\xE4", + Auml: "\xC4", + brvbar: "\xA6", + ccedil: "\xE7", + Ccedil: "\xC7", + cedil: "\xB8", + cent: "\xA2", + copy: "\xA9", + COPY: "\xA9", + curren: "\xA4", + deg: "\xB0", + divide: "\xF7", + eacute: "\xE9", + Eacute: "\xC9", + ecirc: "\xEA", + Ecirc: "\xCA", + egrave: "\xE8", + Egrave: "\xC8", + eth: "\xF0", + ETH: "\xD0", + euml: "\xEB", + Euml: "\xCB", + frac12: "\xBD", + frac14: "\xBC", + frac34: "\xBE", + gt: ">", + GT: ">", + iacute: "\xED", + Iacute: "\xCD", + icirc: "\xEE", + Icirc: "\xCE", + iexcl: "\xA1", + igrave: "\xEC", + Igrave: "\xCC", + iquest: "\xBF", + iuml: "\xEF", + Iuml: "\xCF", + laquo: "\xAB", + lt: "<", + LT: "<", + macr: "\xAF", + micro: "\xB5", + middot: "\xB7", + nbsp: "\xA0", + not: "\xAC", + ntilde: "\xF1", + Ntilde: "\xD1", + oacute: "\xF3", + Oacute: "\xD3", + ocirc: "\xF4", + Ocirc: "\xD4", + ograve: "\xF2", + Ograve: "\xD2", + ordf: "\xAA", + ordm: "\xBA", + oslash: "\xF8", + Oslash: "\xD8", + otilde: "\xF5", + Otilde: "\xD5", + ouml: "\xF6", + Ouml: "\xD6", + para: "\xB6", + plusmn: "\xB1", + pound: "\xA3", + quot: '"', + QUOT: '"', + raquo: "\xBB", + reg: "\xAE", + REG: "\xAE", + sect: "\xA7", + shy: "\xAD", + sup1: "\xB9", + sup2: "\xB2", + sup3: "\xB3", + szlig: "\xDF", + thorn: "\xFE", + THORN: "\xDE", + times: "\xD7", + uacute: "\xFA", + Uacute: "\xDA", + ucirc: "\xFB", + Ucirc: "\xDB", + ugrave: "\xF9", + Ugrave: "\xD9", + uml: "\xA8", + uuml: "\xFC", + Uuml: "\xDC", + yacute: "\xFD", + Yacute: "\xDD", + yen: "\xA5", + yuml: "\xFF", + }; + var decodeMapNumeric = { + 0: "\uFFFD", + 128: "\u20AC", + 130: "\u201A", + 131: "\u0192", + 132: "\u201E", + 133: "\u2026", + 134: "\u2020", + 135: "\u2021", + 136: "\u02C6", + 137: "\u2030", + 138: "\u0160", + 139: "\u2039", + 140: "\u0152", + 142: "\u017D", + 145: "\u2018", + 146: "\u2019", + 147: "\u201C", + 148: "\u201D", + 149: "\u2022", + 150: "\u2013", + 151: "\u2014", + 152: "\u02DC", + 153: "\u2122", + 154: "\u0161", + 155: "\u203A", + 156: "\u0153", + 158: "\u017E", + 159: "\u0178", + }; + var invalidReferenceCodePoints = [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 11, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 64976, + 64977, + 64978, + 64979, + 64980, + 64981, + 64982, + 64983, + 64984, + 64985, + 64986, + 64987, + 64988, + 64989, + 64990, + 64991, + 64992, + 64993, + 64994, + 64995, + 64996, + 64997, + 64998, + 64999, + 65000, + 65001, + 65002, + 65003, + 65004, + 65005, + 65006, + 65007, + 65534, + 65535, + 131070, + 131071, + 196606, + 196607, + 262142, + 262143, + 327678, + 327679, + 393214, + 393215, + 458750, + 458751, + 524286, + 524287, + 589822, + 589823, + 655358, + 655359, + 720894, + 720895, + 786430, + 786431, + 851966, + 851967, + 917502, + 917503, + 983038, + 983039, + 1048574, + 1048575, + 1114110, + 1114111, + ]; + /* --------------------------------------------------------------------------*/ + + var stringFromCharCode = String.fromCharCode; + var object = {}; + var hasOwnProperty = object.hasOwnProperty; + + var has = function has(object, propertyName) { + return hasOwnProperty.call(object, propertyName); + }; + + var contains = function contains(array, value) { + var index = -1; + var length = array.length; + + while (++index < length) { + if (array[index] == value) { + return true; + } + } + + return false; + }; + + var merge = function merge(options, defaults) { + if (!options) { + return defaults; + } + + var result = {}; + var key; + + for (key in defaults) { + // A `hasOwnProperty` check is not needed here, since only recognized + // option names are used anyway. Any others are ignored. + result[key] = has(options, key) + ? options[key] + : defaults[key]; + } + + return result; + }; // Modified version of `ucs2encode`; see https://mths.be/punycode. + + var codePointToSymbol = function codePointToSymbol( + codePoint, + strict + ) { + var output = ""; + + if ( + (codePoint >= 0xd800 && codePoint <= 0xdfff) || + codePoint > 0x10ffff + ) { + // See issue #4: + // “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is + // greater than 0x10FFFF, then this is a parse error. Return a U+FFFD + // REPLACEMENT CHARACTER.” + if (strict) { + parseError( + "character reference outside the permissible Unicode range" + ); + } + + return "\uFFFD"; + } + + if (has(decodeMapNumeric, codePoint)) { + if (strict) { + parseError("disallowed character reference"); + } + + return decodeMapNumeric[codePoint]; + } + + if ( + strict && + contains(invalidReferenceCodePoints, codePoint) + ) { + parseError("disallowed character reference"); + } + + if (codePoint > 0xffff) { + codePoint -= 0x10000; + output += stringFromCharCode( + ((codePoint >>> 10) & 0x3ff) | 0xd800 + ); + codePoint = 0xdc00 | (codePoint & 0x3ff); + } + + output += stringFromCharCode(codePoint); + return output; + }; + + var hexEscape = function hexEscape(codePoint) { + return ( + "&#x" + codePoint.toString(16).toUpperCase() + ";" + ); + }; + + var decEscape = function decEscape(codePoint) { + return "&#" + codePoint + ";"; + }; + + var parseError = function parseError(message) { + throw Error("Parse error: " + message); + }; + /* --------------------------------------------------------------------------*/ + + var encode = function encode(string, options) { + options = merge(options, encode.options); + var strict = options.strict; + + if (strict && regexInvalidRawCodePoint.test(string)) { + parseError("forbidden code point"); + } + + var encodeEverything = options.encodeEverything; + var useNamedReferences = options.useNamedReferences; + var allowUnsafeSymbols = options.allowUnsafeSymbols; + var escapeCodePoint = options.decimal + ? decEscape + : hexEscape; + + var escapeBmpSymbol = function escapeBmpSymbol(symbol) { + return escapeCodePoint(symbol.charCodeAt(0)); + }; + + if (encodeEverything) { + // Encode ASCII symbols. + string = string.replace( + regexAsciiWhitelist, + function (symbol) { + // Use named references if requested & possible. + if ( + useNamedReferences && + has(encodeMap, symbol) + ) { + return "&" + encodeMap[symbol] + ";"; + } + + return escapeBmpSymbol(symbol); + } + ); // Shorten a few escapes that represent two symbols, of which at least one + // is within the ASCII range. + + if (useNamedReferences) { + string = string + .replace(/>\u20D2/g, ">⃒") + .replace(/<\u20D2/g, "<⃒") + .replace(/fj/g, "fj"); + } // Encode non-ASCII symbols. + + if (useNamedReferences) { + // Encode non-ASCII symbols that can be replaced with a named reference. + string = string.replace( + regexEncodeNonAscii, + function (string) { + // Note: there is no need to check `has(encodeMap, string)` here. + return "&" + encodeMap[string] + ";"; + } + ); + } // Note: any remaining non-ASCII symbols are handled outside of the `if`. + } else if (useNamedReferences) { + // Apply named character references. + // Encode `<>"'&` using named character references. + if (!allowUnsafeSymbols) { + string = string.replace(regexEscape, function ( + string + ) { + return "&" + encodeMap[string] + ";"; // No need to check `has()` here + }); + } // Shorten escapes that represent two symbols, of which at least one is + // `<>"'&`. + + string = string + .replace(/>\u20D2/g, ">⃒") + .replace(/<\u20D2/g, "<⃒"); // Encode non-ASCII symbols that can be replaced with a named reference. + + string = string.replace( + regexEncodeNonAscii, + function (string) { + // Note: there is no need to check `has(encodeMap, string)` here. + return "&" + encodeMap[string] + ";"; + } + ); + } else if (!allowUnsafeSymbols) { + // Encode `<>"'&` using hexadecimal escapes, now that they’re not handled + // using named character references. + string = string.replace( + regexEscape, + escapeBmpSymbol + ); + } + + return ( + string // Encode astral symbols. + .replace(regexAstralSymbols, function ($0) { + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + var high = $0.charCodeAt(0); + var low = $0.charCodeAt(1); + var codePoint = + (high - 0xd800) * 0x400 + + low - + 0xdc00 + + 0x10000; + return escapeCodePoint(codePoint); + }) // Encode any remaining BMP symbols that are not printable ASCII symbols + // using a hexadecimal escape. + .replace(regexBmpWhitelist, escapeBmpSymbol) + ); + }; // Expose default options (so they can be overridden globally). + + encode.options = { + allowUnsafeSymbols: false, + encodeEverything: false, + strict: false, + useNamedReferences: false, + decimal: false, + }; + + var decode = function decode(html, options) { + options = merge(options, decode.options); + var strict = options.strict; + + if (strict && regexInvalidEntity.test(html)) { + parseError("malformed character reference"); + } + + return html.replace(regexDecode, function ( + $0, + $1, + $2, + $3, + $4, + $5, + $6, + $7, + $8 + ) { + var codePoint; + var semicolon; + var decDigits; + var hexDigits; + var reference; + var next; + + if ($1) { + reference = $1; // Note: there is no need to check `has(decodeMap, reference)`. + + return decodeMap[reference]; + } + + if ($2) { + // Decode named character references without trailing `;`, e.g. `&`. + // This is only a parse error if it gets converted to `&`, or if it is + // followed by `=` in an attribute context. + reference = $2; + next = $3; + + if (next && options.isAttributeValue) { + if (strict && next == "=") { + parseError( + "`&` did not start a character reference" + ); + } + + return $0; + } + if (strict) { + parseError( + "named character reference was not terminated by a semicolon" + ); + } // Note: there is no need to check `has(decodeMapLegacy, reference)`. + + return ( + decodeMapLegacy[reference] + + (next || "") + ); + + } + + if ($4) { + // Decode decimal escapes, e.g. `𝌆`. + decDigits = $4; + semicolon = $5; + + if (strict && !semicolon) { + parseError( + "character reference was not terminated by a semicolon" + ); + } + + codePoint = parseInt(decDigits, 10); + return codePointToSymbol(codePoint, strict); + } + + if ($6) { + // Decode hexadecimal escapes, e.g. `𝌆`. + hexDigits = $6; + semicolon = $7; + + if (strict && !semicolon) { + parseError( + "character reference was not terminated by a semicolon" + ); + } + + codePoint = parseInt(hexDigits, 16); + return codePointToSymbol(codePoint, strict); + } // If we’re still here, `if ($7)` is implied; it’s an ambiguous + // ampersand for sure. https://mths.be/notes/ambiguous-ampersands + + if (strict) { + parseError( + "named character reference was not terminated by a semicolon" + ); + } + + return $0; + }); + }; // Expose default options (so they can be overridden globally). + + decode.options = { + isAttributeValue: false, + strict: false, + }; + + var escape = function escape(string) { + return string.replace(regexEscape, function ($0) { + // Note: there is no need to check `has(escapeMap, $0)` here. + return escapeMap[$0]; + }); + }; + /* --------------------------------------------------------------------------*/ + + var he = { + version: "1.2.0", + encode: encode, + decode: decode, + escape: escape, + unescape: decode, + }; // Some AMD build optimizers, like r.js, check for specific condition patterns + // like the following: + + if ( + typeof define === "function" && + _typeof(define.amd) == "object" && + define.amd + ) { + define(function () { + return he; + }); + } else if (freeExports && !freeExports.nodeType) { + if (freeModule) { + // In Node.js, io.js, or RingoJS v0.8.0+ + freeModule.exports = he; + } else { + // In Narwhal or RingoJS v0.7.0- + for (var key in he) { + has(he, key) && (freeExports[key] = he[key]); + } + } + } else { + // In Rhino or a web browser + root.he = he; + } + })(this); + /* WEBPACK VAR INJECTION */ + }.call( + this, + __webpack_require__( + /* ! ./../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js" + )(module), + __webpack_require__( + /* ! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js" + ) + )); + + /***/ + }, + + /***/ "./node_modules/hmac-drbg/lib/hmac-drbg.js": + /* !*************************************************!*\ + !*** ./node_modules/hmac-drbg/lib/hmac-drbg.js ***! + \*************************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + var hash = __webpack_require__( + /* ! hash.js */ "./node_modules/hash.js/lib/hash.js" + ); + + var utils = __webpack_require__( + /* ! minimalistic-crypto-utils */ "./node_modules/minimalistic-crypto-utils/lib/utils.js" + ); + + var assert = __webpack_require__( + /* ! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js" + ); + + function HmacDRBG(options) { + if (!(this instanceof HmacDRBG)) return new HmacDRBG(options); + this.hash = options.hash; + this.predResist = Boolean(options.predResist); + this.outLen = this.hash.outSize; + this.minEntropy = options.minEntropy || this.hash.hmacStrength; + this._reseed = null; + this.reseedInterval = null; + this.K = null; + this.V = null; + var entropy = utils.toArray( + options.entropy, + options.entropyEnc || "hex" + ); + var nonce = utils.toArray( + options.nonce, + options.nonceEnc || "hex" + ); + var pers = utils.toArray( + options.pers, + options.persEnc || "hex" + ); + assert( + entropy.length >= this.minEntropy / 8, + "Not enough entropy. Minimum is: " + + this.minEntropy + + " bits" + ); + + this._init(entropy, nonce, pers); + } + + module.exports = HmacDRBG; + + HmacDRBG.prototype._init = function init(entropy, nonce, pers) { + var seed = entropy.concat(nonce).concat(pers); + this.K = new Array(this.outLen / 8); + this.V = new Array(this.outLen / 8); + + for (var i = 0; i < this.V.length; i++) { + this.K[i] = 0x00; + this.V[i] = 0x01; + } + + this._update(seed); + + this._reseed = 1; + this.reseedInterval = 0x1000000000000; // 2^48 + }; + + HmacDRBG.prototype._hmac = function hmac() { + return new hash.hmac(this.hash, this.K); + }; + + HmacDRBG.prototype._update = function update(seed) { + var kmac = this._hmac().update(this.V).update([0x00]); + + if (seed) kmac = kmac.update(seed); + this.K = kmac.digest(); + this.V = this._hmac().update(this.V).digest(); + if (!seed) return; + this.K = this._hmac() + .update(this.V) + .update([0x01]) + .update(seed) + .digest(); + this.V = this._hmac().update(this.V).digest(); + }; + + HmacDRBG.prototype.reseed = function reseed( + entropy, + entropyEnc, + add, + addEnc + ) { + // Optional entropy enc + if (typeof entropyEnc !== "string") { + addEnc = add; + add = entropyEnc; + entropyEnc = null; + } + + entropy = utils.toArray(entropy, entropyEnc); + add = utils.toArray(add, addEnc); + assert( + entropy.length >= this.minEntropy / 8, + "Not enough entropy. Minimum is: " + + this.minEntropy + + " bits" + ); + + this._update(entropy.concat(add || [])); + + this._reseed = 1; + }; + + HmacDRBG.prototype.generate = function generate( + len, + enc, + add, + addEnc + ) { + if (this._reseed > this.reseedInterval) + throw new Error("Reseed is required"); // Optional encoding + + if (typeof enc !== "string") { + addEnc = add; + add = enc; + enc = null; + } // Optional additional data + + if (add) { + add = utils.toArray(add, addEnc || "hex"); + + this._update(add); + } + + var temp = []; + + while (temp.length < len) { + this.V = this._hmac().update(this.V).digest(); + temp = temp.concat(this.V); + } + + var res = temp.slice(0, len); + + this._update(add); + + this._reseed++; + return utils.encode(res, enc); + }; + + /***/ + }, + + /***/ "./node_modules/ieee754/index.js": + /* !***************************************!*\ + !*** ./node_modules/ieee754/index.js ***! + \***************************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var nBits = -7; + var i = isLE ? nBytes - 1 : 0; + var d = isLE ? -1 : 1; + var s = buffer[offset + i]; + i += d; + e = s & ((1 << -nBits) - 1); + s >>= -nBits; + nBits += eLen; + + for ( + ; + nBits > 0; + e = e * 256 + buffer[offset + i], i += d, nBits -= 8 + ) {} + + m = e & ((1 << -nBits) - 1); + e >>= -nBits; + nBits += mLen; + + for ( + ; + nBits > 0; + m = m * 256 + buffer[offset + i], i += d, nBits -= 8 + ) {} + + if (e === 0) { + e = 1 - eBias; + } else if (e === eMax) { + return m ? NaN : (s ? -1 : 1) * Infinity; + } else { + m += Math.pow(2, mLen); + e -= eBias; + } + + return (s ? -1 : 1) * m * Math.pow(2, e - mLen); + }; + + exports.write = function ( + buffer, + value, + offset, + isLE, + mLen, + nBytes + ) { + var e, m, c; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0; + var i = isLE ? 0 : nBytes - 1; + var d = isLE ? 1 : -1; + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; + value = Math.abs(value); + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0; + e = eMax; + } else { + e = Math.floor(Math.log(value) / Math.LN2); + + if (value * (c = Math.pow(2, -e)) < 1) { + e--; + c *= 2; + } + + if (e + eBias >= 1) { + value += rt / c; + } else { + value += rt * Math.pow(2, 1 - eBias); + } + + if (value * c >= 2) { + e++; + c /= 2; + } + + if (e + eBias >= eMax) { + m = 0; + e = eMax; + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen); + e += eBias; + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); + e = 0; + } + } + + for ( + ; + mLen >= 8; + buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8 + ) {} + + e = (e << mLen) | m; + eLen += mLen; + + for ( + ; + eLen > 0; + buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8 + ) {} + + buffer[offset + i - d] |= s * 128; + }; + + /***/ + }, + + /***/ "./node_modules/inherits/inherits_browser.js": + /* !***************************************************!*\ + !*** ./node_modules/inherits/inherits_browser.js ***! + \***************************************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + if (typeof Object.create === "function") { + // Implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true, + }, + }); + } + }; + } else { + // Old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + + var TempCtor = function TempCtor() {}; + + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } + }; + } + + /***/ + }, + + /***/ "./node_modules/is-regexp/index.js": + /* !*****************************************!*\ + !*** ./node_modules/is-regexp/index.js ***! + \*****************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + "use strict"; + + module.exports = function (re) { + return Object.prototype.toString.call(re) === "[object RegExp]"; + }; + + /***/ + }, + + /***/ "./node_modules/isarray/index.js": + /* !***************************************!*\ + !*** ./node_modules/isarray/index.js ***! + \***************************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + var toString = {}.toString; + + module.exports = + Array.isArray || + function (arr) { + return toString.call(arr) == "[object Array]"; + }; + + /***/ + }, + + /***/ "./node_modules/lodash/lodash.js": + /* !***************************************!*\ + !*** ./node_modules/lodash/lodash.js ***! + \***************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + /* WEBPACK VAR INJECTION */ (function (global, module) { + function _typeof(obj) { + if ( + typeof Symbol === "function" && + typeof Symbol.iterator === "symbol" + ) { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && + typeof Symbol === "function" && + obj.constructor === Symbol && + obj !== Symbol.prototype + ? "symbol" + : typeof obj; + }; + } + return _typeof(obj); + } + /** + * @license + * Lodash + * Copyright OpenJS Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + (function () { + /** Used as a safe reference for `undefined` in pre-ES5 environments. */ var undefined; + /** Used as the semantic version number. */ var VERSION = + "4.17.15"; + /** Used as the size to enable large array optimizations. */ var LARGE_ARRAY_SIZE = 200; + /** Error message constants. */ var CORE_ERROR_TEXT = + "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", + FUNC_ERROR_TEXT = "Expected a function"; + /** Used to stand-in for `undefined` hash values. */ var HASH_UNDEFINED = + "__lodash_hash_undefined__"; + /** Used as the maximum memoize cache size. */ var MAX_MEMOIZE_SIZE = 500; + /** Used as the internal argument placeholder. */ var PLACEHOLDER = + "__lodash_placeholder__"; + /** Used to compose bitmasks for cloning. */ var CLONE_DEEP_FLAG = 1, + CLONE_FLAT_FLAG = 2, + CLONE_SYMBOLS_FLAG = 4; + /** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + /** Used to compose bitmasks for function metadata. */ var WRAP_BIND_FLAG = 1, + WRAP_BIND_KEY_FLAG = 2, + WRAP_CURRY_BOUND_FLAG = 4, + WRAP_CURRY_FLAG = 8, + WRAP_CURRY_RIGHT_FLAG = 16, + WRAP_PARTIAL_FLAG = 32, + WRAP_PARTIAL_RIGHT_FLAG = 64, + WRAP_ARY_FLAG = 128, + WRAP_REARG_FLAG = 256, + WRAP_FLIP_FLAG = 512; + /** Used as default options for `_.truncate`. */ var DEFAULT_TRUNC_LENGTH = 30, + DEFAULT_TRUNC_OMISSION = "..."; + /** Used to detect hot functions by number of calls within a span of milliseconds. */ var HOT_COUNT = 800, + HOT_SPAN = 16; + /** Used to indicate the type of lazy iteratees. */ var LAZY_FILTER_FLAG = 1, + LAZY_MAP_FLAG = 2, + LAZY_WHILE_FLAG = 3; + /** Used as references for various `Number` constants. */ var INFINITY = + 1 / 0, + MAX_SAFE_INTEGER = 9007199254740991, + MAX_INTEGER = 1.7976931348623157e308, + NAN = 0 / 0; + /** Used as references for the maximum length and index of an array. */ var MAX_ARRAY_LENGTH = 4294967295, + MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, + HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; + /** Used to associate wrap methods with their bit flags. */ var wrapFlags = [ + ["ary", WRAP_ARY_FLAG], + ["bind", WRAP_BIND_FLAG], + ["bindKey", WRAP_BIND_KEY_FLAG], + ["curry", WRAP_CURRY_FLAG], + ["curryRight", WRAP_CURRY_RIGHT_FLAG], + ["flip", WRAP_FLIP_FLAG], + ["partial", WRAP_PARTIAL_FLAG], + ["partialRight", WRAP_PARTIAL_RIGHT_FLAG], + ["rearg", WRAP_REARG_FLAG], + ]; + /** `Object#toString` result references. */ var argsTag = + "[object Arguments]", + arrayTag = "[object Array]", + asyncTag = "[object AsyncFunction]", + boolTag = "[object Boolean]", + dateTag = "[object Date]", + domExcTag = "[object DOMException]", + errorTag = "[object Error]", + funcTag = "[object Function]", + genTag = "[object GeneratorFunction]", + mapTag = "[object Map]", + numberTag = "[object Number]", + nullTag = "[object Null]", + objectTag = "[object Object]", + promiseTag = "[object Promise]", + proxyTag = "[object Proxy]", + regexpTag = "[object RegExp]", + setTag = "[object Set]", + stringTag = "[object String]", + symbolTag = "[object Symbol]", + undefinedTag = "[object Undefined]", + weakMapTag = "[object WeakMap]", + weakSetTag = "[object WeakSet]"; + 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 match empty string literals in compiled template source. */ var reEmptyStringLeading = /\b__p \+= '';/g, + reEmptyStringMiddle = /\b(__p \+=) '' \+/g, + reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; + /** Used to match HTML entities and HTML characters. */ var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, + reUnescapedHtml = /[&<>"']/g, + reHasEscapedHtml = RegExp(reEscapedHtml.source), + reHasUnescapedHtml = RegExp(reUnescapedHtml.source); + /** Used to match template delimiters. */ var reEscape = /<%-([\s\S]+?)%>/g, + reEvaluate = /<%([\s\S]+?)%>/g, + reInterpolate = /<%=([\s\S]+?)%>/g; + /** Used to match property names within property paths. */ var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, + reHasRegExpChar = RegExp(reRegExpChar.source); + /** Used to match leading and trailing whitespace. */ var reTrim = /^\s+|\s+$/g, + reTrimStart = /^\s+/, + reTrimEnd = /\s+$/; + /** Used to match wrap detail comments. */ var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, + reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, + reSplitDetails = /,? & /; + /** Used to match words composed of alphanumeric characters. */ var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + /** Used to match backslashes in property paths. */ var reEscapeChar = /\\(\\)?/g; + /** + * Used to match + * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components). + */ var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; + /** Used to match `RegExp` flags from their coerced string values. */ var reFlags = /\w*$/; + /** Used to detect bad signed hexadecimal string values. */ var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + /** Used to detect binary string values. */ var reIsBinary = /^0b[01]+$/i; + /** Used to detect host constructors (Safari). */ var reIsHostCtor = /^\[object .+?Constructor\]$/; + /** Used to detect octal string values. */ var reIsOctal = /^0o[0-7]+$/i; + /** Used to detect unsigned integer values. */ var reIsUint = /^(?:0|[1-9]\d*)$/; + /** Used to match Latin Unicode letters (excluding mathematical operators). */ var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + /** Used to ensure capturing order of template delimiters. */ var reNoMatch = /($^)/; + /** Used to match unescaped characters in compiled string literals. */ var reUnescapedString = /['\n\r\u2028\u2029\\]/g; + /** Used to compose unicode character classes. */ var rsAstralRange = + "\\ud800-\\udfff", + rsComboMarksRange = "\\u0300-\\u036f", + reComboHalfMarksRange = "\\ufe20-\\ufe2f", + rsComboSymbolsRange = "\\u20d0-\\u20ff", + rsComboRange = + rsComboMarksRange + + reComboHalfMarksRange + + rsComboSymbolsRange, + rsDingbatRange = "\\u2700-\\u27bf", + rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", + rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", + rsNonCharRange = + "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", + rsPunctuationRange = "\\u2000-\\u206f", + rsSpaceRange = + " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", + rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", + rsVarRange = "\\ufe0e\\ufe0f", + rsBreakRange = + rsMathOpRange + + rsNonCharRange + + rsPunctuationRange + + rsSpaceRange; + /** Used to compose unicode capture groups. */ var rsApos = + "['\u2019]", + rsAstral = "[" + rsAstralRange + "]", + rsBreak = "[" + rsBreakRange + "]", + rsCombo = "[" + rsComboRange + "]", + rsDigits = "\\d+", + rsDingbat = "[" + rsDingbatRange + "]", + rsLower = "[" + rsLowerRange + "]", + rsMisc = + "[^" + + rsAstralRange + + rsBreakRange + + rsDigits + + rsDingbatRange + + rsLowerRange + + rsUpperRange + + "]", + rsFitz = "\\ud83c[\\udffb-\\udfff]", + rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", + rsNonAstral = "[^" + rsAstralRange + "]", + rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", + rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", + rsUpper = "[" + rsUpperRange + "]", + rsZWJ = "\\u200d"; + /** Used to compose unicode regexes. */ var rsMiscLower = + "(?:" + rsLower + "|" + rsMisc + ")", + rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", + rsOptContrLower = + "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", + rsOptContrUpper = + "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", + reOptMod = rsModifier + "?", + rsOptVar = "[" + rsVarRange + "]?", + rsOptJoin = + "(?:" + + rsZWJ + + "(?:" + + [rsNonAstral, rsRegional, rsSurrPair].join("|") + + ")" + + rsOptVar + + reOptMod + + ")*", + rsOrdLower = + "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", + rsOrdUpper = + "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", + rsSeq = rsOptVar + reOptMod + rsOptJoin, + rsEmoji = + "(?:" + + [rsDingbat, rsRegional, rsSurrPair].join("|") + + ")" + + rsSeq, + rsSymbol = + "(?:" + + [ + rsNonAstral + rsCombo + "?", + rsCombo, + rsRegional, + rsSurrPair, + rsAstral, + ].join("|") + + ")"; + /** Used to match apostrophes. */ var reApos = RegExp( + rsApos, + "g" + ); + /** + * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and + * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). + */ var reComboMark = RegExp(rsCombo, "g"); + /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ var reUnicode = RegExp( + rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, + "g" + ); + /** Used to match complex or compound words. */ var reUnicodeWord = RegExp( + [ + rsUpper + + "?" + + rsLower + + "+" + + rsOptContrLower + + "(?=" + + [rsBreak, rsUpper, "$"].join("|") + + ")", + rsMiscUpper + + "+" + + rsOptContrUpper + + "(?=" + + [rsBreak, rsUpper + rsMiscLower, "$"].join( + "|" + ) + + ")", + rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower, + rsUpper + "+" + rsOptContrUpper, + rsOrdUpper, + rsOrdLower, + rsDigits, + rsEmoji, + ].join("|"), + "g" + ); + /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ var reHasUnicode = RegExp( + "[" + + rsZWJ + + rsAstralRange + + rsComboRange + + rsVarRange + + "]" + ); + /** Used to detect strings that need a more robust regexp to match words. */ var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; + /** Used to assign default `context` object properties. */ var contextProps = [ + "Array", + "Buffer", + "DataView", + "Date", + "Error", + "Float32Array", + "Float64Array", + "Function", + "Int8Array", + "Int16Array", + "Int32Array", + "Map", + "Math", + "Object", + "Promise", + "RegExp", + "Set", + "String", + "Symbol", + "TypeError", + "Uint8Array", + "Uint8ClampedArray", + "Uint16Array", + "Uint32Array", + "WeakMap", + "_", + "clearTimeout", + "isFinite", + "parseInt", + "setTimeout", + ]; + /** Used to make template sourceURLs easier to identify. */ var templateCounter = -1; + /** 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; + /** 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; + /** Used to map Latin Unicode letters to basic Latin letters. */ var deburredLetters = { + // Latin-1 Supplement block. + "\xc0": "A", + "\xc1": "A", + "\xc2": "A", + "\xc3": "A", + "\xc4": "A", + "\xc5": "A", + "\xe0": "a", + "\xe1": "a", + "\xe2": "a", + "\xe3": "a", + "\xe4": "a", + "\xe5": "a", + "\xc7": "C", + "\xe7": "c", + "\xd0": "D", + "\xf0": "d", + "\xc8": "E", + "\xc9": "E", + "\xca": "E", + "\xcb": "E", + "\xe8": "e", + "\xe9": "e", + "\xea": "e", + "\xeb": "e", + "\xcc": "I", + "\xcd": "I", + "\xce": "I", + "\xcf": "I", + "\xec": "i", + "\xed": "i", + "\xee": "i", + "\xef": "i", + "\xd1": "N", + "\xf1": "n", + "\xd2": "O", + "\xd3": "O", + "\xd4": "O", + "\xd5": "O", + "\xd6": "O", + "\xd8": "O", + "\xf2": "o", + "\xf3": "o", + "\xf4": "o", + "\xf5": "o", + "\xf6": "o", + "\xf8": "o", + "\xd9": "U", + "\xda": "U", + "\xdb": "U", + "\xdc": "U", + "\xf9": "u", + "\xfa": "u", + "\xfb": "u", + "\xfc": "u", + "\xdd": "Y", + "\xfd": "y", + "\xff": "y", + "\xc6": "Ae", + "\xe6": "ae", + "\xde": "Th", + "\xfe": "th", + "\xdf": "ss", // Latin Extended-A block. + "\u0100": "A", + "\u0102": "A", + "\u0104": "A", + "\u0101": "a", + "\u0103": "a", + "\u0105": "a", + "\u0106": "C", + "\u0108": "C", + "\u010A": "C", + "\u010C": "C", + "\u0107": "c", + "\u0109": "c", + "\u010B": "c", + "\u010D": "c", + "\u010E": "D", + "\u0110": "D", + "\u010F": "d", + "\u0111": "d", + "\u0112": "E", + "\u0114": "E", + "\u0116": "E", + "\u0118": "E", + "\u011A": "E", + "\u0113": "e", + "\u0115": "e", + "\u0117": "e", + "\u0119": "e", + "\u011B": "e", + "\u011C": "G", + "\u011E": "G", + "\u0120": "G", + "\u0122": "G", + "\u011D": "g", + "\u011F": "g", + "\u0121": "g", + "\u0123": "g", + "\u0124": "H", + "\u0126": "H", + "\u0125": "h", + "\u0127": "h", + "\u0128": "I", + "\u012A": "I", + "\u012C": "I", + "\u012E": "I", + "\u0130": "I", + "\u0129": "i", + "\u012B": "i", + "\u012D": "i", + "\u012F": "i", + "\u0131": "i", + "\u0134": "J", + "\u0135": "j", + "\u0136": "K", + "\u0137": "k", + "\u0138": "k", + "\u0139": "L", + "\u013B": "L", + "\u013D": "L", + "\u013F": "L", + "\u0141": "L", + "\u013A": "l", + "\u013C": "l", + "\u013E": "l", + "\u0140": "l", + "\u0142": "l", + "\u0143": "N", + "\u0145": "N", + "\u0147": "N", + "\u014A": "N", + "\u0144": "n", + "\u0146": "n", + "\u0148": "n", + "\u014B": "n", + "\u014C": "O", + "\u014E": "O", + "\u0150": "O", + "\u014D": "o", + "\u014F": "o", + "\u0151": "o", + "\u0154": "R", + "\u0156": "R", + "\u0158": "R", + "\u0155": "r", + "\u0157": "r", + "\u0159": "r", + "\u015A": "S", + "\u015C": "S", + "\u015E": "S", + "\u0160": "S", + "\u015B": "s", + "\u015D": "s", + "\u015F": "s", + "\u0161": "s", + "\u0162": "T", + "\u0164": "T", + "\u0166": "T", + "\u0163": "t", + "\u0165": "t", + "\u0167": "t", + "\u0168": "U", + "\u016A": "U", + "\u016C": "U", + "\u016E": "U", + "\u0170": "U", + "\u0172": "U", + "\u0169": "u", + "\u016B": "u", + "\u016D": "u", + "\u016F": "u", + "\u0171": "u", + "\u0173": "u", + "\u0174": "W", + "\u0175": "w", + "\u0176": "Y", + "\u0177": "y", + "\u0178": "Y", + "\u0179": "Z", + "\u017B": "Z", + "\u017D": "Z", + "\u017A": "z", + "\u017C": "z", + "\u017E": "z", + "\u0132": "IJ", + "\u0133": "ij", + "\u0152": "Oe", + "\u0153": "oe", + "\u0149": "'n", + "\u017F": "s", + }; + /** Used to map characters to HTML entities. */ var htmlEscapes = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'", + }; + /** Used to map HTML entities to characters. */ var htmlUnescapes = { + "&": "&", + "<": "<", + ">": ">", + """: '"', + "'": "'", + }; + /** Used to escape characters for inclusion in compiled string literals. */ var stringEscapes = { + "\\": "\\", + "'": "'", + "\n": "n", + "\r": "r", + "\u2028": "u2028", + "\u2029": "u2029", + }; + /** Built-in method references without a dependency on `root`. */ var freeParseFloat = parseFloat, + freeParseInt = parseInt; + /** Detect free variable `global` from Node.js. */ var freeGlobal = + (typeof global === "undefined" + ? "undefined" + : _typeof(global)) == "object" && + global && + global.Object === Object && + global; + /** Detect free variable `self`. */ var freeSelf = + (typeof self === "undefined" + ? "undefined" + : _typeof(self)) == "object" && + self && + self.Object === Object && + self; + /** Used as a reference to the global object. */ var root = + freeGlobal || freeSelf || Function("return this")(); + /** Detect free variable `exports`. */ var freeExports = + (false ? undefined : _typeof(exports)) == "object" && + exports && + !exports.nodeType && + exports; + /** Detect free variable `module`. */ var freeModule = + freeExports && + (false ? undefined : _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 { + // Use `util.types` for Node.js 10+. + var types = + freeModule && + freeModule.require && + freeModule.require("util").types; + if (types) { + return types; + } // Legacy `process.binding('util')` for Node.js < 10. + return ( + freeProcess && + freeProcess.binding && + freeProcess.binding("util") + ); + } catch (e) {} + })(); + /* Node.js helper references. */ var nodeIsArrayBuffer = + nodeUtil && nodeUtil.isArrayBuffer, + nodeIsDate = nodeUtil && nodeUtil.isDate, + nodeIsMap = nodeUtil && nodeUtil.isMap, + nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, + nodeIsSet = nodeUtil && nodeUtil.isSet, + nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; + /* --------------------------------------------------------------------------*/ /** + * 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); + } + /** + * A specialized version of `baseAggregator` for arrays. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */ function arrayAggregator( + array, + setter, + iteratee, + accumulator + ) { + var index = -1, + length = array == null ? 0 : array.length; + while (++index < length) { + var value = array[index]; + setter(accumulator, value, iteratee(value), array); + } + return accumulator; + } + /** + * 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; + } + /** + * A specialized version of `_.forEachRight` 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 arrayEachRight(array, iteratee) { + var length = array == null ? 0 : array.length; + while (length--) { + if ( + iteratee(array[length], length, array) === false + ) { + break; + } + } + return array; + } + /** + * A specialized version of `_.every` 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 {Boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + */ function arrayEvery(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + while (++index < length) { + if (!predicate(array[index], index, array)) { + return false; + } + } + return true; + } + /** + * 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; + } + /** + * A specialized version of `_.includes` for arrays without support for + * specifying an index to search from. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @returns {Boolean} Returns `true` if `target` is found, else `false`. + */ function arrayIncludes(array, value) { + var length = array == null ? 0 : array.length; + return Boolean(length) && baseIndexOf(array, value, 0) > -1; + } + /** + * This function is like `arrayIncludes` except that it accepts a comparator. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @param {Function} comparator The comparator invoked per element. + * @returns {Boolean} Returns `true` if `target` is found, else `false`. + */ function arrayIncludesWith(array, value, comparator) { + var index = -1, + length = array == null ? 0 : array.length; + while (++index < length) { + if (comparator(value, array[index])) { + return true; + } + } + return false; + } + /** + * 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; + } + /** + * 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; + } + /** + * 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; + } + /** + * A specialized version of `_.reduceRight` 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 last element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ function arrayReduceRight( + array, + iteratee, + accumulator, + initAccum + ) { + var length = array == null ? 0 : array.length; + if (initAccum && length) { + accumulator = array[--length]; + } + while (length--) { + accumulator = iteratee( + accumulator, + array[length], + length, + array + ); + } + return accumulator; + } + /** + * A specialized version of `_.some` 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 {Boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ function arraySome(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; + } + /** + * Gets the size of an ASCII `string`. + * + * @private + * @param {string} string The string inspect. + * @returns {number} Returns the string size. + */ var asciiSize = baseProperty("length"); + /** + * Converts an ASCII `string` to an array. + * + * @private + * @param {String} string The string to convert. + * @returns {Array} Returns the converted array. + */ function asciiToArray(string) { + return string.split(""); + } + /** + * Splits an ASCII `string` into an array of its words. + * + * @private + * @param {String} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ function asciiWords(string) { + return string.match(reAsciiWord) || []; + } + /** + * The base implementation of methods like `_.findKey` and `_.findLastKey`, + * without support for iteratee shorthands, which iterates over `collection` + * using `eachFunc`. + * + * @private + * @param {Array|Object} collection The collection to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the found element or its key, else `undefined`. + */ function baseFindKey(collection, predicate, eachFunc) { + var result; + eachFunc(collection, function (value, key, collection) { + if (predicate(value, key, collection)) { + result = key; + return false; + } + }); + return result; + } + /** + * The base implementation of `_.findIndex` and `_.findLastIndex` without + * support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {Number} fromIndex The index to search from. + * @param {Boolean} [fromRight] Specify iterating from right to left. + * @returns {Number} Returns the index of the matched value, else `-1`. + */ function baseFindIndex( + array, + predicate, + fromIndex, + fromRight + ) { + var length = array.length, + index = fromIndex + (fromRight ? 1 : -1); + while (fromRight ? index-- : ++index < length) { + if (predicate(array[index], index, array)) { + return index; + } + } + return -1; + } + /** + * The base implementation of `_.indexOf` without `fromIndex` bounds checks. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {Number} fromIndex The index to search from. + * @returns {Number} Returns the index of the matched value, else `-1`. + */ function baseIndexOf(array, value, fromIndex) { + return value === value + ? strictIndexOf(array, value, fromIndex) + : baseFindIndex(array, baseIsNaN, fromIndex); + } + /** + * This function is like `baseIndexOf` except that it accepts a comparator. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {Number} fromIndex The index to search from. + * @param {Function} comparator The comparator invoked per element. + * @returns {Number} Returns the index of the matched value, else `-1`. + */ function baseIndexOfWith( + array, + value, + fromIndex, + comparator + ) { + var index = fromIndex - 1, + length = array.length; + while (++index < length) { + if (comparator(array[index], value)) { + return index; + } + } + return -1; + } + /** + * The base implementation of `_.isNaN` without support for number objects. + * + * @private + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is `NaN`, else `false`. + */ function baseIsNaN(value) { + return value !== value; + } + /** + * The base implementation of `_.mean` and `_.meanBy` without support for + * iteratee shorthands. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Number} Returns the mean. + */ function baseMean(array, iteratee) { + var length = array == null ? 0 : array.length; + return length ? baseSum(array, iteratee) / length : NAN; + } + /** + * The base implementation of `_.property` without support for deep paths. + * + * @private + * @param {String} key The key of the property to get. + * @returns {Function} Returns the new accessor function. + */ function baseProperty(key) { + return function (object) { + return object == null ? undefined : object[key]; + }; + } + /** + * The base implementation of `_.propertyOf` without support for deep paths. + * + * @private + * @param {Object} object The object to query. + * @returns {Function} Returns the new accessor function. + */ function basePropertyOf(object) { + return function (key) { + return object == null ? undefined : object[key]; + }; + } + /** + * The base implementation of `_.reduce` and `_.reduceRight`, without support + * for iteratee shorthands, which iterates over `collection` using `eachFunc`. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} accumulator The initial value. + * @param {Boolean} initAccum Specify using the first or last element of + * `collection` as the initial value. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the accumulated value. + */ function baseReduce( + collection, + iteratee, + accumulator, + initAccum, + eachFunc + ) { + eachFunc(collection, function ( + value, + index, + collection + ) { + accumulator = initAccum + ? ((initAccum = false), value) + : iteratee( + accumulator, + value, + index, + collection + ); + }); + return accumulator; + } + /** + * The base implementation of `_.sortBy` which uses `comparer` to define the + * sort order of `array` and replaces criteria objects with their corresponding + * values. + * + * @private + * @param {Array} array The array to sort. + * @param {Function} comparer The function to define sort order. + * @returns {Array} Returns `array`. + */ function baseSortBy(array, comparer) { + var length = array.length; + array.sort(comparer); + while (length--) { + array[length] = array[length].value; + } + return array; + } + /** + * The base implementation of `_.sum` and `_.sumBy` without support for + * iteratee shorthands. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Number} Returns the sum. + */ function baseSum(array, iteratee) { + var result, + index = -1, + length = array.length; + while (++index < length) { + var current = iteratee(array[index]); + if (current !== undefined) { + result = + result === undefined + ? current + : result + current; + } + } + return result; + } + /** + * 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; + } + /** + * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array + * of key-value pairs for `object` corresponding to the property names of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the key-value pairs. + */ function baseToPairs(object, props) { + return arrayMap(props, function (key) { + return [key, object[key]]; + }); + } + /** + * 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); + }; + } + /** + * The base implementation of `_.values` and `_.valuesIn` which creates an + * array of `object` property values corresponding to the property names + * of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the array of property values. + */ function baseValues(object, props) { + return arrayMap(props, function (key) { + return object[key]; + }); + } + /** + * Checks if a `cache` value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {String} key The key of the entry to check. + * @returns {Boolean} Returns `true` if an entry for `key` exists, else `false`. + */ function cacheHas(cache, key) { + return cache.has(key); + } + /** + * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {Number} Returns the index of the first unmatched string symbol. + */ function charsStartIndex(strSymbols, chrSymbols) { + var index = -1, + length = strSymbols.length; + while ( + ++index < length && + baseIndexOf(chrSymbols, strSymbols[index], 0) > -1 + ) {} + return index; + } + /** + * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {Number} Returns the index of the last unmatched string symbol. + */ function charsEndIndex(strSymbols, chrSymbols) { + var index = strSymbols.length; + while ( + index-- && + baseIndexOf(chrSymbols, strSymbols[index], 0) > -1 + ) {} + return index; + } + /** + * Gets the number of `placeholder` occurrences in `array`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} placeholder The placeholder to search for. + * @returns {Number} Returns the placeholder count. + */ function countHolders(array, placeholder) { + var length = array.length, + result = 0; + while (length--) { + if (array[length] === placeholder) { + ++result; + } + } + return result; + } + /** + * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A + * letters to basic Latin letters. + * + * @private + * @param {string} letter The matched letter to deburr. + * @returns {string} Returns the deburred letter. + */ var deburrLetter = basePropertyOf(deburredLetters); + /** + * Used by `_.escape` to convert characters to HTML entities. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */ var escapeHtmlChar = basePropertyOf(htmlEscapes); + /** + * Used by `_.template` to escape characters for inclusion in compiled string literals. + * + * @private + * @param {String} chr The matched character to escape. + * @returns {String} Returns the escaped character. + */ function escapeStringChar(chr) { + return "\\" + stringEscapes[chr]; + } + /** + * 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]; + } + /** + * Checks if `string` contains Unicode symbols. + * + * @private + * @param {String} string The string to inspect. + * @returns {Boolean} Returns `true` if a symbol is found, else `false`. + */ function hasUnicode(string) { + return reHasUnicode.test(string); + } + /** + * Checks if `string` contains a word composed of Unicode symbols. + * + * @private + * @param {String} string The string to inspect. + * @returns {Boolean} Returns `true` if a word is found, else `false`. + */ function hasUnicodeWord(string) { + return reHasUnicodeWord.test(string); + } + /** + * Converts `iterator` to an array. + * + * @private + * @param {Object} iterator The iterator to convert. + * @returns {Array} Returns the converted array. + */ function iteratorToArray(iterator) { + var data, + result = []; + while (!(data = iterator.next()).done) { + result.push(data.value); + } + return result; + } + /** + * 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; + } + /** + * 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)); + }; + } + /** + * Replaces all `placeholder` elements in `array` with an internal placeholder + * and returns an array of their indexes. + * + * @private + * @param {Array} array The array to modify. + * @param {*} placeholder The placeholder to replace. + * @returns {Array} Returns the new array of placeholder indexes. + */ function replaceHolders(array, placeholder) { + var index = -1, + length = array.length, + resIndex = 0, + result = []; + while (++index < length) { + var value = array[index]; + if ( + value === placeholder || + value === PLACEHOLDER + ) { + array[index] = PLACEHOLDER; + result[resIndex++] = index; + } + } + return result; + } + /** + * 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; + } + /** + * Converts `set` to its value-value pairs. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the value-value pairs. + */ function setToPairs(set) { + var index = -1, + result = Array(set.size); + set.forEach(function (value) { + result[++index] = [value, value]; + }); + return result; + } + /** + * A specialized version of `_.indexOf` which performs strict equality + * comparisons of values, i.e. `===`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {Number} fromIndex The index to search from. + * @returns {Number} Returns the index of the matched value, else `-1`. + */ function strictIndexOf(array, value, fromIndex) { + var index = fromIndex - 1, + length = array.length; + while (++index < length) { + if (array[index] === value) { + return index; + } + } + return -1; + } + /** + * A specialized version of `_.lastIndexOf` which performs strict equality + * comparisons of values, i.e. `===`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {Number} fromIndex The index to search from. + * @returns {Number} Returns the index of the matched value, else `-1`. + */ function strictLastIndexOf(array, value, fromIndex) { + var index = fromIndex + 1; + while (index--) { + if (array[index] === value) { + return index; + } + } + return index; + } + /** + * Gets the number of symbols in `string`. + * + * @private + * @param {String} string The string to inspect. + * @returns {Number} Returns the string size. + */ function stringSize(string) { + return hasUnicode(string) + ? unicodeSize(string) + : asciiSize(string); + } + /** + * Converts `string` to an array. + * + * @private + * @param {String} string The string to convert. + * @returns {Array} Returns the converted array. + */ function stringToArray(string) { + return hasUnicode(string) + ? unicodeToArray(string) + : asciiToArray(string); + } + /** + * Used by `_.unescape` to convert HTML entities to characters. + * + * @private + * @param {string} chr The matched character to unescape. + * @returns {string} Returns the unescaped character. + */ var unescapeHtmlChar = basePropertyOf(htmlUnescapes); + /** + * Gets the size of a Unicode `string`. + * + * @private + * @param {String} string The string inspect. + * @returns {Number} Returns the string size. + */ function unicodeSize(string) { + var result = (reUnicode.lastIndex = 0); + while (reUnicode.test(string)) { + ++result; + } + return result; + } + /** + * Converts a Unicode `string` to an array. + * + * @private + * @param {String} string The string to convert. + * @returns {Array} Returns the converted array. + */ function unicodeToArray(string) { + return string.match(reUnicode) || []; + } + /** + * Splits a Unicode `string` into an array of its words. + * + * @private + * @param {String} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ function unicodeWords(string) { + return string.match(reUnicodeWord) || []; + } + /* --------------------------------------------------------------------------*/ /** + * Create a new pristine `lodash` function using the `context` object. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Util + * @param {Object} [context=root] The context object. + * @returns {Function} Returns a new `lodash` function. + * @example + * + * _.mixin({ 'foo': _.constant('foo') }); + * + * var lodash = _.runInContext(); + * lodash.mixin({ 'bar': lodash.constant('bar') }); + * + * _.isFunction(_.foo); + * // => true + * _.isFunction(_.bar); + * // => false + * + * lodash.isFunction(lodash.foo); + * // => false + * lodash.isFunction(lodash.bar); + * // => true + * + * // Create a suped-up `defer` in Node.js. + * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; + */ var runInContext = function runInContext(context) { + context = + context == null + ? root + : _.defaults( + root.Object(), + context, + _.pick(root, contextProps) + ); + /** Built-in constructor references. */ var Array = + context.Array, + Date = context.Date, + Error = context.Error, + Function = context.Function, + Math = context.Math, + Object = context.Object, + RegExp = context.RegExp, + String = context.String, + TypeError = context.TypeError; + /** Used for built-in method references. */ var arrayProto = + Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + /** Used to detect overreaching core-js shims. */ var coreJsData = + context["__core-js_shared__"]; + /** 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 generate unique IDs. */ var idCounter = 0; + /** 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 : ""; + })(); + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ var nativeObjectToString = objectProto.toString; + /** Used to infer the `Object` constructor. */ var objectCtorString = funcToString.call( + Object + ); + /** Used to restore the original `_` reference in `_.noConflict`. */ var oldDash = + root._; + /** Used to detect if a method is native. */ var reIsNative = RegExp( + "^" + + funcToString + .call(hasOwnProperty) + .replace(reRegExpChar, "\\$&") + .replace( + /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, + "$1.*?" + ) + + "$" + ); + /** Built-in value references. */ var Buffer = moduleExports + ? context.Buffer + : undefined, + _Symbol = context.Symbol, + Uint8Array = context.Uint8Array, + allocUnsafe = Buffer + ? Buffer.allocUnsafe + : undefined, + getPrototype = overArg( + Object.getPrototypeOf, + Object + ), + objectCreate = Object.create, + propertyIsEnumerable = + objectProto.propertyIsEnumerable, + splice = arrayProto.splice, + spreadableSymbol = _Symbol + ? _Symbol.isConcatSpreadable + : undefined, + symIterator = _Symbol + ? _Symbol.iterator + : undefined, + symToStringTag = _Symbol + ? _Symbol.toStringTag + : undefined; + var defineProperty = (function () { + try { + var func = getNative(Object, "defineProperty"); + func({}, "", {}); + return func; + } catch (e) {} + })(); + /** Mocked built-ins. */ var ctxClearTimeout = + context.clearTimeout !== root.clearTimeout && + context.clearTimeout, + ctxNow = + Date && Date.now !== root.Date.now && Date.now, + ctxSetTimeout = + context.setTimeout !== root.setTimeout && + context.setTimeout; + /* Built-in method references for those with the same name as other `lodash` methods. */ var nativeCeil = + Math.ceil, + nativeFloor = Math.floor, + nativeGetSymbols = Object.getOwnPropertySymbols, + nativeIsBuffer = Buffer + ? Buffer.isBuffer + : undefined, + nativeIsFinite = context.isFinite, + nativeJoin = arrayProto.join, + nativeKeys = overArg(Object.keys, Object), + nativeMax = Math.max, + nativeMin = Math.min, + nativeNow = Date.now, + nativeParseInt = context.parseInt, + nativeRandom = Math.random, + nativeReverse = arrayProto.reverse; + /* Built-in method references that are verified to be native. */ var DataView = getNative( + context, + "DataView" + ), + Map = getNative(context, "Map"), + Promise = getNative(context, "Promise"), + Set = getNative(context, "Set"), + WeakMap = getNative(context, "WeakMap"), + nativeCreate = getNative(Object, "create"); + /** Used to store function metadata. */ var metaMap = + WeakMap && new WeakMap(); + /** Used to lookup unminified function names. */ var realNames = {}; + /** Used to detect maps, sets, and weakmaps. */ var dataViewCtorString = toSource( + DataView + ), + mapCtorString = toSource(Map), + promiseCtorString = toSource(Promise), + setCtorString = toSource(Set), + weakMapCtorString = toSource(WeakMap); + /** Used to convert symbols to primitives and strings. */ var symbolProto = _Symbol + ? _Symbol.prototype + : undefined, + symbolValueOf = symbolProto + ? symbolProto.valueOf + : undefined, + symbolToString = symbolProto + ? symbolProto.toString + : undefined; + /* ------------------------------------------------------------------------*/ /** + * Creates a `lodash` object which wraps `value` to enable implicit method + * chain sequences. Methods that operate on and return arrays, collections, + * and functions can be chained together. Methods that retrieve a single value + * or may return a primitive value will automatically end the chain sequence + * and return the unwrapped value. Otherwise, the value must be unwrapped + * with `_#value`. + * + * Explicit chain sequences, which must be unwrapped with `_#value`, may be + * enabled using `_.chain`. + * + * The execution of chained methods is lazy, that is, it's deferred until + * `_#value` is implicitly or explicitly called. + * + * Lazy evaluation allows several methods to support shortcut fusion. + * Shortcut fusion is an optimization to merge iteratee calls; this avoids + * the creation of intermediate arrays and can greatly reduce the number of + * iteratee executions. Sections of a chain sequence qualify for shortcut + * fusion if the section is applied to an array and iteratees accept only + * one argument. The heuristic for whether a section qualifies for shortcut + * fusion is subject to change. + * + * Chaining is supported in custom builds as long as the `_#value` method is + * directly or indirectly included in the build. + * + * In addition to lodash methods, wrappers have `Array` and `String` methods. + * + * The wrapper `Array` methods are: + * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` + * + * The wrapper `String` methods are: + * `replace` and `split` + * + * The wrapper methods that support shortcut fusion are: + * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, + * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, + * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` + * + * The chainable wrapper methods are: + * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, + * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, + * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, + * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, + * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, + * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, + * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, + * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, + * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, + * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, + * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, + * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, + * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, + * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, + * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, + * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, + * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, + * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, + * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, + * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, + * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, + * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, + * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, + * `zipObject`, `zipObjectDeep`, and `zipWith` + * + * The wrapper methods that are **not** chainable by default are: + * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, + * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`, + * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`, + * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`, + * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`, + * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`, + * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`, + * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, + * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`, + * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`, + * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, + * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, + * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`, + * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`, + * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, + * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`, + * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, + * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`, + * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`, + * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`, + * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`, + * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`, + * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`, + * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`, + * `upperFirst`, `value`, and `words` + * + * @name _ + * @class + * @category Seq + * @param {*} value The value to wrap in a `lodash` instance. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2, 3]); + * + * // Returns an unwrapped value. + * wrapped.reduce(_.add); + * // => 6 + * + * // Returns a wrapped value. + * var squares = wrapped.map(square); + * + * _.isArray(squares); + * // => false + * + * _.isArray(squares.value()); + * // => true + */ function lodash(value) { + if ( + isObjectLike(value) && + !isArray(value) && + !(value instanceof LazyWrapper) + ) { + if (value instanceof LodashWrapper) { + return value; + } + if (hasOwnProperty.call(value, "__wrapped__")) { + return wrapperClone(value); + } + } + return new LodashWrapper(value); + } + /** + * 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; + }; + })(); + /** + * The function whose prototype chain sequence wrappers inherit from. + * + * @private + */ function baseLodash() {} // No operation performed. + /** + * The base constructor for creating `lodash` wrapper objects. + * + * @private + * @param {*} value The value to wrap. + * @param {Boolean} [chainAll] Enable explicit method chain sequences. + */ function LodashWrapper(value, chainAll) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__chain__ = Boolean(chainAll); + this.__index__ = 0; + this.__values__ = undefined; + } + /** + * By default, the template delimiters used by lodash are like those in + * embedded Ruby (ERB) as well as ES2015 template strings. Change the + * following template settings to use alternative delimiters. + * + * @static + * @memberOf _ + * @type {Object} + */ lodash.templateSettings = { + /** + * Used to detect `data` property values to be HTML-escaped. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ escape: reEscape, + /** + * Used to detect code to be evaluated. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ evaluate: reEvaluate, + /** + * Used to detect `data` property values to inject. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ interpolate: reInterpolate, + /** + * Used to reference the data object in the template text. + * + * @memberOf _.templateSettings + * @type {string} + */ variable: "", + /** + * Used to import variables into the compiled template. + * + * @memberOf _.templateSettings + * @type {Object} + */ imports: { + /** + * A reference to the `lodash` function. + * + * @memberOf _.templateSettings.imports + * @type {Function} + */ _: lodash, + }, + }; // Ensure wrappers are instances of `baseLodash`. + lodash.prototype = baseLodash.prototype; + lodash.prototype.constructor = lodash; + LodashWrapper.prototype = baseCreate( + baseLodash.prototype + ); + LodashWrapper.prototype.constructor = LodashWrapper; + /* ------------------------------------------------------------------------*/ /** + * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. + * + * @private + * @class + * @param {*} value The value to wrap. + */ function LazyWrapper(value) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__dir__ = 1; + this.__filtered__ = false; + this.__iteratees__ = []; + this.__takeCount__ = MAX_ARRAY_LENGTH; + this.__views__ = []; + } + /** + * Creates a clone of the lazy wrapper object. + * + * @private + * @name clone + * @memberOf LazyWrapper + * @returns {Object} Returns the cloned `LazyWrapper` object. + */ function lazyClone() { + var result = new LazyWrapper(this.__wrapped__); + result.__actions__ = copyArray(this.__actions__); + result.__dir__ = this.__dir__; + result.__filtered__ = this.__filtered__; + result.__iteratees__ = copyArray( + this.__iteratees__ + ); + result.__takeCount__ = this.__takeCount__; + result.__views__ = copyArray(this.__views__); + return result; + } + /** + * Reverses the direction of lazy iteration. + * + * @private + * @name reverse + * @memberOf LazyWrapper + * @returns {Object} Returns the new reversed `LazyWrapper` object. + */ function lazyReverse() { + if (this.__filtered__) { + var result = new LazyWrapper(this); + result.__dir__ = -1; + result.__filtered__ = true; + } else { + result = this.clone(); + result.__dir__ *= -1; + } + return result; + } + /** + * Extracts the unwrapped value from its lazy wrapper. + * + * @private + * @name value + * @memberOf LazyWrapper + * @returns {*} Returns the unwrapped value. + */ function lazyValue() { + var array = this.__wrapped__.value(), + dir = this.__dir__, + isArr = isArray(array), + isRight = dir < 0, + arrLength = isArr ? array.length : 0, + view = getView(0, arrLength, this.__views__), + start = view.start, + end = view.end, + length = end - start, + index = isRight ? end : start - 1, + iteratees = this.__iteratees__, + iterLength = iteratees.length, + resIndex = 0, + takeCount = nativeMin( + length, + this.__takeCount__ + ); + if ( + !isArr || + (!isRight && + arrLength == length && + takeCount == length) + ) { + return baseWrapperValue( + array, + this.__actions__ + ); + } + var result = []; + outer: while (length-- && resIndex < takeCount) { + index += dir; + var iterIndex = -1, + value = array[index]; + while (++iterIndex < iterLength) { + var data = iteratees[iterIndex], + iteratee = data.iteratee, + type = data.type, + computed = iteratee(value); + if (type == LAZY_MAP_FLAG) { + value = computed; + } else if (!computed) { + if (type == LAZY_FILTER_FLAG) { + continue outer; + } else { + break outer; + } + } + } + result[resIndex++] = value; + } + return result; + } // Ensure `LazyWrapper` is an instance of `baseLodash`. + LazyWrapper.prototype = baseCreate( + baseLodash.prototype + ); + LazyWrapper.prototype.constructor = LazyWrapper; + /* ------------------------------------------------------------------------*/ /** + * Creates a hash object. + * + * @private + * @class + * @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]); + } + } + /** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ function hashClear() { + this.__data__ = nativeCreate + ? nativeCreate(null) + : {}; + this.size = 0; + } + /** + * 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; + } + /** + * 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; + } + /** + * 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); + } + /** + * 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; + } // Add methods to `Hash`. + Hash.prototype.clear = hashClear; + Hash.prototype.delete = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + /* ------------------------------------------------------------------------*/ /** + * Creates an list cache object. + * + * @private + * @class + * @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]); + } + } + /** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ function listCacheClear() { + this.__data__ = []; + this.size = 0; + } + /** + * 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; + } + /** + * 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]; + } + /** + * 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; + } + /** + * 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; + } // Add methods to `ListCache`. + ListCache.prototype.clear = listCacheClear; + ListCache.prototype.delete = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + /* ------------------------------------------------------------------------*/ /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @class + * @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]); + } + } + /** + * 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(), + }; + } + /** + * 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; + } + /** + * 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); + } + /** + * 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); + } + /** + * 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; + } // Add methods to `MapCache`. + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype.delete = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + /* ------------------------------------------------------------------------*/ /** + * + * Creates an array cache object to store unique values. + * + * @private + * @class + * @param {Array} [values] The values to cache. + */ function SetCache(values) { + var index = -1, + length = values == null ? 0 : values.length; + this.__data__ = new MapCache(); + while (++index < length) { + this.add(values[index]); + } + } + /** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; + } + /** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {Number} Returns `true` if `value` is found, else `false`. + */ function setCacheHas(value) { + return this.__data__.has(value); + } // Add methods to `SetCache`. + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; + SetCache.prototype.has = setCacheHas; + /* ------------------------------------------------------------------------*/ /** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @class + * @param {Array} [entries] The key-value pairs to cache. + */ function Stack(entries) { + var data = (this.__data__ = new ListCache(entries)); + this.size = data.size; + } + /** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ function stackClear() { + this.__data__ = new ListCache(); + this.size = 0; + } + /** + * 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; + } + /** + * 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); + } + /** + * 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); + } + /** + * 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; + } // Add methods to `Stack`. + Stack.prototype.clear = stackClear; + Stack.prototype.delete = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + /* ------------------------------------------------------------------------*/ /** + * 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; + } + /** + * A specialized version of `_.sample` for arrays. + * + * @private + * @param {Array} array The array to sample. + * @returns {*} Returns the random element. + */ function arraySample(array) { + var length = array.length; + return length + ? array[baseRandom(0, length - 1)] + : undefined; + } + /** + * A specialized version of `_.sampleSize` for arrays. + * + * @private + * @param {Array} array The array to sample. + * @param {Number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */ function arraySampleSize(array, n) { + return shuffleSelf( + copyArray(array), + baseClamp(n, 0, array.length) + ); + } + /** + * A specialized version of `_.shuffle` for arrays. + * + * @private + * @param {Array} array The array to shuffle. + * @returns {Array} Returns the new shuffled array. + */ function arrayShuffle(array) { + return shuffleSelf(copyArray(array)); + } + /** + * 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); + } + } + /** + * 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); + } + } + /** + * 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; + } + /** + * Aggregates elements of `collection` on `accumulator` with keys transformed + * by `iteratee` and values set by `setter`. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */ function baseAggregator( + collection, + setter, + iteratee, + accumulator + ) { + baseEach(collection, function ( + value, + key, + collection + ) { + setter( + accumulator, + value, + iteratee(value), + collection + ); + }); + return accumulator; + } + /** + * 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) + ); + } + /** + * 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) + ); + } + /** + * 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; + } + } + /** + * The base implementation of `_.at` without support for individual paths. + * + * @private + * @param {Object} object The object to iterate over. + * @param {String[]} paths The property paths to pick. + * @returns {Array} Returns the picked elements. + */ function baseAt(object, paths) { + var index = -1, + length = paths.length, + result = Array(length), + skip = object == null; + while (++index < length) { + result[index] = skip + ? undefined + : get(object, paths[index]); + } + return result; + } + /** + * The base implementation of `_.clamp` which doesn't coerce arguments. + * + * @private + * @param {Number} number The number to clamp. + * @param {Number} [lower] The lower bound. + * @param {Number} upper The upper bound. + * @returns {Number} Returns the clamped number. + */ function baseClamp(number, lower, upper) { + if (number === number) { + if (upper !== undefined) { + number = number <= upper ? number : upper; + } + if (lower !== undefined) { + number = number >= lower ? number : lower; + } + } + return number; + } + /** + * 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, 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); + if (isSet(value)) { + value.forEach(function (subValue) { + result.add( + baseClone( + subValue, + bitmask, + customizer, + subValue, + value, + stack + ) + ); + }); + } else if (isMap(value)) { + value.forEach(function (subValue, key) { + result.set( + key, + baseClone( + subValue, + bitmask, + customizer, + key, + value, + stack + ) + ); + }); + } + 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; + } + /** + * The base implementation of `_.conforms` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property predicates to conform to. + * @returns {Function} Returns the new spec function. + */ function baseConforms(source) { + var props = keys(source); + return function (object) { + return baseConformsTo(object, source, props); + }; + } + /** + * The base implementation of `_.conformsTo` which accepts `props` to check. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {Boolean} Returns `true` if `object` conforms, else `false`. + */ function baseConformsTo(object, source, props) { + var length = props.length; + if (object == null) { + return !length; + } + object = Object(object); + while (length--) { + var key = props[length], + predicate = source[key], + value = object[key]; + if ( + (value === undefined && !(key in object)) || + !predicate(value) + ) { + return false; + } + } + return true; + } + /** + * The base implementation of `_.delay` and `_.defer` which accepts `args` + * to provide to `func`. + * + * @private + * @param {Function} func The function to delay. + * @param {Number} wait The number of milliseconds to delay invocation. + * @param {Array} args The arguments to provide to `func`. + * @returns {Number|Object} Returns the timer id or timeout object. + */ function baseDelay(func, wait, args) { + if (typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + return setTimeout(function () { + func.apply(undefined, args); + }, wait); + } + /** + * The base implementation of methods like `_.difference` without support + * for excluding multiple arrays or iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Array} values The values to exclude. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + */ function baseDifference( + array, + values, + iteratee, + comparator + ) { + var index = -1, + includes = arrayIncludes, + isCommon = true, + length = array.length, + result = [], + valuesLength = values.length; + if (!length) { + return result; + } + if (iteratee) { + values = arrayMap(values, baseUnary(iteratee)); + } + if (comparator) { + includes = arrayIncludesWith; + isCommon = false; + } else if (values.length >= LARGE_ARRAY_SIZE) { + includes = cacheHas; + isCommon = false; + values = new SetCache(values); + } + outer: while (++index < length) { + var value = array[index], + computed = + iteratee == null + ? value + : iteratee(value); + value = comparator || value !== 0 ? value : 0; + if (isCommon && computed === computed) { + var valuesIndex = valuesLength; + while (valuesIndex--) { + if (values[valuesIndex] === computed) { + continue outer; + } + } + result.push(value); + } else if ( + !includes(values, computed, comparator) + ) { + result.push(value); + } + } + return result; + } + /** + * The base implementation of `_.forEach` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ var baseEach = createBaseEach(baseForOwn); + /** + * The base implementation of `_.forEachRight` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ var baseEachRight = createBaseEach( + baseForOwnRight, + true + ); + /** + * The base implementation of `_.every` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Boolean} Returns `true` if all elements pass the predicate check, + * else `false` + */ function baseEvery(collection, predicate) { + var result = true; + baseEach(collection, function ( + value, + index, + collection + ) { + result = Boolean(predicate(value, index, collection)); + return result; + }); + return result; + } + /** + * The base implementation of methods like `_.max` and `_.min` which accepts a + * `comparator` to determine the extremum value. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The iteratee invoked per iteration. + * @param {Function} comparator The comparator used to compare values. + * @returns {*} Returns the extremum value. + */ function baseExtremum(array, iteratee, comparator) { + var index = -1, + length = array.length; + while (++index < length) { + var value = array[index], + current = iteratee(value); + if ( + current != null && + (computed === undefined + ? current === current && + !isSymbol(current) + : comparator(current, computed)) + ) { + var computed = current, + result = value; + } + } + return result; + } + /** + * The base implementation of `_.fill` without an iteratee call guard. + * + * @private + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {Number} [start=0] The start position. + * @param {Number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + */ function baseFill(array, value, start, end) { + var length = array.length; + start = toInteger(start); + if (start < 0) { + start = -start > length ? 0 : length + start; + } + end = + end === undefined || end > length + ? length + : toInteger(end); + if (end < 0) { + end += length; + } + end = start > end ? 0 : toLength(end); + while (start < end) { + array[start++] = value; + } + return array; + } + /** + * The base implementation of `_.filter` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ function baseFilter(collection, predicate) { + var result = []; + baseEach(collection, function ( + value, + index, + collection + ) { + if (predicate(value, index, collection)) { + result.push(value); + } + }); + return result; + } + /** + * 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; + } + /** + * 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(); + /** + * This function is like `baseFor` except that it iterates over properties + * in the opposite order. + * + * @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 baseForRight = createBaseFor(true); + /** + * The base implementation of `_.forOwn` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ function baseForOwn(object, iteratee) { + return object && baseFor(object, iteratee, keys); + } + /** + * The base implementation of `_.forOwnRight` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ function baseForOwnRight(object, iteratee) { + return ( + object && baseForRight(object, iteratee, keys) + ); + } + /** + * The base implementation of `_.functions` which creates an array of + * `object` function property names filtered from `props`. + * + * @private + * @param {Object} object The object to inspect. + * @param {Array} props The property names to filter. + * @returns {Array} Returns the function names. + */ function baseFunctions(object, props) { + return arrayFilter(props, function (key) { + return isFunction(object[key]); + }); + } + /** + * 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; + } + /** + * 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)); + } + /** + * 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); + } + /** + * The base implementation of `_.gt` which doesn't coerce arguments. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {Boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + */ function baseGt(value, other) { + return value > other; + } + /** + * The base implementation of `_.has` 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 baseHas(object, key) { + return ( + object != null && + hasOwnProperty.call(object, key) + ); + } + /** + * 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); + } + /** + * The base implementation of `_.inRange` which doesn't coerce arguments. + * + * @private + * @param {Number} number The number to check. + * @param {Number} start The start of the range. + * @param {Number} end The end of the range. + * @returns {Boolean} Returns `true` if `number` is in the range, else `false`. + */ function baseInRange(number, start, end) { + return ( + number >= nativeMin(start, end) && + number < nativeMax(start, end) + ); + } + /** + * The base implementation of methods like `_.intersection`, without support + * for iteratee shorthands, that accepts an array of arrays to inspect. + * + * @private + * @param {Array} arrays The arrays to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of shared values. + */ function baseIntersection( + arrays, + iteratee, + comparator + ) { + var includes = comparator + ? arrayIncludesWith + : arrayIncludes, + length = arrays[0].length, + othLength = arrays.length, + othIndex = othLength, + caches = Array(othLength), + maxLength = Infinity, + result = []; + while (othIndex--) { + var array = arrays[othIndex]; + if (othIndex && iteratee) { + array = arrayMap( + array, + baseUnary(iteratee) + ); + } + maxLength = nativeMin(array.length, maxLength); + caches[othIndex] = + !comparator && + (iteratee || + (length >= 120 && array.length >= 120)) + ? new SetCache(othIndex && array) + : undefined; + } + array = arrays[0]; + var index = -1, + seen = caches[0]; + outer: while ( + ++index < length && + result.length < maxLength + ) { + var value = array[index], + computed = iteratee + ? iteratee(value) + : value; + value = comparator || value !== 0 ? value : 0; + if ( + !(seen + ? cacheHas(seen, computed) + : includes( + result, + computed, + comparator + )) + ) { + othIndex = othLength; + while (--othIndex) { + var cache = caches[othIndex]; + if ( + !(cache + ? cacheHas(cache, computed) + : includes( + arrays[othIndex], + computed, + comparator + )) + ) { + continue outer; + } + } + if (seen) { + seen.push(computed); + } + result.push(value); + } + } + return result; + } + /** + * The base implementation of `_.invert` and `_.invertBy` which inverts + * `object` with values transformed by `iteratee` and set by `setter`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform values. + * @param {Object} accumulator The initial inverted object. + * @returns {Function} Returns `accumulator`. + */ function baseInverter( + object, + setter, + iteratee, + accumulator + ) { + baseForOwn(object, function (value, key, object) { + setter( + accumulator, + iteratee(value), + key, + object + ); + }); + return accumulator; + } + /** + * The base implementation of `_.invoke` without support for individual + * method arguments. + * + * @private + * @param {Object} object The object to query. + * @param {Array|String} path The path of the method to invoke. + * @param {Array} args The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. + */ function baseInvoke(object, path, args) { + path = castPath(path, object); + object = parent(object, path); + var func = + object == null + ? object + : object[toKey(last(path))]; + return func == null + ? undefined + : apply(func, object, args); + } + /** + * 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 + ); + } + /** + * The base implementation of `_.isArrayBuffer` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is an array buffer, else `false`. + */ function baseIsArrayBuffer(value) { + return ( + isObjectLike(value) && + baseGetTag(value) == arrayBufferTag + ); + } + /** + * The base implementation of `_.isDate` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a date object, else `false`. + */ function baseIsDate(value) { + return ( + isObjectLike(value) && + baseGetTag(value) == dateTag + ); + } + /** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Boolean} bitmask The bitmask flags. + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Function} [customizer] The function to customize comparisons. + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {Boolean} Returns `true` if the values are equivalent, else `false`. + */ function baseIsEqual( + value, + other, + bitmask, + customizer, + stack + ) { + if (value === other) { + return true; + } + if ( + value == null || + other == null || + (!isObjectLike(value) && !isObjectLike(other)) + ) { + return value !== value && other !== other; + } + return baseIsEqualDeep( + value, + other, + bitmask, + customizer, + baseIsEqual, + stack + ); + } + /** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {Number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} [stack] Tracks traversed `object` and `other` objects. + * @returns {Boolean} Returns `true` if the objects are equivalent, else `false`. + */ function baseIsEqualDeep( + object, + other, + bitmask, + customizer, + equalFunc, + stack + ) { + var objIsArr = isArray(object), + othIsArr = isArray(other), + objTag = objIsArr ? arrayTag : getTag(object), + othTag = othIsArr ? arrayTag : getTag(other); + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + if (isSameTag && isBuffer(object)) { + if (!isBuffer(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack()); + return objIsArr || isTypedArray(object) + ? equalArrays( + object, + other, + bitmask, + customizer, + equalFunc, + stack + ) + : equalByTag( + object, + other, + objTag, + bitmask, + customizer, + equalFunc, + stack + ); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = + objIsObj && + hasOwnProperty.call( + object, + "__wrapped__" + ), + othIsWrapped = + othIsObj && + hasOwnProperty.call( + other, + "__wrapped__" + ); + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped + ? object.value() + : object, + othUnwrapped = othIsWrapped + ? other.value() + : other; + stack || (stack = new Stack()); + return equalFunc( + objUnwrapped, + othUnwrapped, + bitmask, + customizer, + stack + ); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack()); + return equalObjects( + object, + other, + bitmask, + customizer, + equalFunc, + stack + ); + } + /** + * The base implementation of `_.isMap` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a map, else `false`. + */ function baseIsMap(value) { + return ( + isObjectLike(value) && getTag(value) == mapTag + ); + } + /** + * The base implementation of `_.isMatch` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Array} matchData The property names, values, and compare flags to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {Boolean} Returns `true` if `object` is a match, else `false`. + */ function baseIsMatch( + object, + source, + matchData, + customizer + ) { + var index = matchData.length, + length = index, + noCustomizer = !customizer; + if (object == null) { + return !length; + } + object = Object(object); + while (index--) { + var data = matchData[index]; + if ( + noCustomizer && data[2] + ? data[1] !== object[data[0]] + : !(data[0] in object) + ) { + return false; + } + } + while (++index < length) { + data = matchData[index]; + var key = data[0], + objValue = object[key], + srcValue = data[1]; + if (noCustomizer && data[2]) { + if ( + objValue === undefined && + !(key in object) + ) { + return false; + } + } else { + var stack = new Stack(); + if (customizer) { + var result = customizer( + objValue, + srcValue, + key, + object, + source, + stack + ); + } + if ( + !(result === undefined + ? baseIsEqual( + srcValue, + objValue, + COMPARE_PARTIAL_FLAG | + COMPARE_UNORDERED_FLAG, + customizer, + stack + ) + : result) + ) { + return false; + } + } + } + return true; + } + /** + * 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)); + } + /** + * The base implementation of `_.isRegExp` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a regexp, else `false`. + */ function baseIsRegExp(value) { + return ( + isObjectLike(value) && + baseGetTag(value) == regexpTag + ); + } + /** + * The base implementation of `_.isSet` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a set, else `false`. + */ function baseIsSet(value) { + return ( + isObjectLike(value) && getTag(value) == setTag + ); + } + /** + * 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) && + Boolean(typedArrayTags[baseGetTag(value)]) + ); + } + /** + * The base implementation of `_.iteratee`. + * + * @private + * @param {*} [value=_.identity] The value to convert to an iteratee. + * @returns {Function} Returns the iteratee. + */ function baseIteratee(value) { + // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. + // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. + if (typeof value === "function") { + return value; + } + if (value == null) { + return identity; + } + if (_typeof(value) == "object") { + return isArray(value) + ? baseMatchesProperty(value[0], value[1]) + : baseMatches(value); + } + return property(value); + } + /** + * 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; + } + /** + * 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; + } + /** + * The base implementation of `_.lt` which doesn't coerce arguments. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {Boolean} Returns `true` if `value` is less than `other`, + * else `false`. + */ function baseLt(value, other) { + return value < other; + } + /** + * The base implementation of `_.map` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ function baseMap(collection, iteratee) { + var index = -1, + result = isArrayLike(collection) + ? Array(collection.length) + : []; + baseEach(collection, function ( + value, + key, + collection + ) { + result[++index] = iteratee( + value, + key, + collection + ); + }); + return result; + } + /** + * The base implementation of `_.matches` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property values to match. + * @returns {Function} Returns the new spec function. + */ function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable( + matchData[0][0], + matchData[0][1] + ); + } + return function (object) { + return ( + object === source || + baseIsMatch(object, source, matchData) + ); + }; + } + /** + * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. + * + * @private + * @param {String} path The path of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ function baseMatchesProperty(path, srcValue) { + if (isKey(path) && isStrictComparable(srcValue)) { + return matchesStrictComparable( + toKey(path), + srcValue + ); + } + return function (object) { + var objValue = get(object, path); + return objValue === undefined && + objValue === srcValue + ? hasIn(object, path) + : baseIsEqual( + srcValue, + objValue, + COMPARE_PARTIAL_FLAG | + COMPARE_UNORDERED_FLAG + ); + }; + } + /** + * 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) { + stack || (stack = new Stack()); + if (isObject(srcValue)) { + baseMergeDeep( + object, + source, + key, + srcIndex, + baseMerge, + customizer, + stack + ); + } else { + var newValue = customizer + ? customizer( + safeGet(object, key), + srcValue, + String(key), + object, + source, + stack + ) + : undefined; + if (newValue === undefined) { + newValue = srcValue; + } + assignMergeValue(object, key, newValue); + } + }, + keysIn + ); + } + /** + * 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 = safeGet(object, key), + srcValue = safeGet(source, key), + stacked = stack.get(srcValue); + if (stacked) { + assignMergeValue(object, key, stacked); + return; + } + var newValue = customizer + ? customizer( + objValue, + srcValue, + String(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) || + 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); + } + /** + * The base implementation of `_.nth` which doesn't coerce arguments. + * + * @private + * @param {Array} array The array to query. + * @param {Number} n The index of the element to return. + * @returns {*} Returns the nth element of `array`. + */ function baseNth(array, n) { + var length = array.length; + if (!length) { + return; + } + n += n < 0 ? length : 0; + return isIndex(n, length) ? array[n] : undefined; + } + /** + * The base implementation of `_.orderBy` without param guards. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function[]|Object[]|String[]} iteratees The iteratees to sort by. + * @param {String[]} orders The sort orders of `iteratees`. + * @returns {Array} Returns the new sorted array. + */ function baseOrderBy( + collection, + iteratees, + orders + ) { + var index = -1; + iteratees = arrayMap( + iteratees.length ? iteratees : [identity], + baseUnary(getIteratee()) + ); + var result = baseMap(collection, function ( + value, + key, + collection + ) { + var criteria = arrayMap(iteratees, function ( + iteratee + ) { + return iteratee(value); + }); + return { + criteria: criteria, + index: ++index, + value: value, + }; + }); + return baseSortBy(result, function (object, other) { + return compareMultiple(object, other, orders); + }); + } + /** + * 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); + }); + } + /** + * 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; + } + /** + * A specialized version of `baseProperty` which supports deep paths. + * + * @private + * @param {Array|String} path The path of the property to get. + * @returns {Function} Returns the new accessor function. + */ function basePropertyDeep(path) { + return function (object) { + return baseGet(object, path); + }; + } + /** + * The base implementation of `_.pullAllBy` without support for iteratee + * shorthands. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + */ function basePullAll( + array, + values, + iteratee, + comparator + ) { + var indexOf = comparator + ? baseIndexOfWith + : baseIndexOf, + index = -1, + length = values.length, + seen = array; + if (array === values) { + values = copyArray(values); + } + if (iteratee) { + seen = arrayMap(array, baseUnary(iteratee)); + } + while (++index < length) { + var fromIndex = 0, + value = values[index], + computed = iteratee + ? iteratee(value) + : value; + while ( + (fromIndex = indexOf( + seen, + computed, + fromIndex, + comparator + )) > -1 + ) { + if (seen !== array) { + splice.call(seen, fromIndex, 1); + } + splice.call(array, fromIndex, 1); + } + } + return array; + } + /** + * The base implementation of `_.pullAt` without support for individual + * indexes or capturing the removed elements. + * + * @private + * @param {Array} array The array to modify. + * @param {Number[]} indexes The indexes of elements to remove. + * @returns {Array} Returns `array`. + */ function basePullAt(array, indexes) { + var length = array ? indexes.length : 0, + lastIndex = length - 1; + while (length--) { + var index = indexes[length]; + if (length == lastIndex || index !== previous) { + var previous = index; + if (isIndex(index)) { + splice.call(array, index, 1); + } else { + baseUnset(array, index); + } + } + } + return array; + } + /** + * The base implementation of `_.random` without support for returning + * floating-point numbers. + * + * @private + * @param {Number} lower The lower bound. + * @param {Number} upper The upper bound. + * @returns {Number} Returns the random number. + */ function baseRandom(lower, upper) { + return ( + lower + + nativeFloor( + nativeRandom() * (upper - lower + 1) + ) + ); + } + /** + * The base implementation of `_.range` and `_.rangeRight` which doesn't + * coerce arguments. + * + * @private + * @param {Number} start The start of the range. + * @param {Number} end The end of the range. + * @param {Number} step The value to increment or decrement by. + * @param {Boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the range of numbers. + */ function baseRange(start, end, step, fromRight) { + var index = -1, + length = nativeMax( + nativeCeil((end - start) / (step || 1)), + 0 + ), + result = Array(length); + while (length--) { + result[fromRight ? length : ++index] = start; + start += step; + } + return result; + } + /** + * The base implementation of `_.repeat` which doesn't coerce arguments. + * + * @private + * @param {String} string The string to repeat. + * @param {Number} n The number of times to repeat the string. + * @returns {String} Returns the repeated string. + */ function baseRepeat(string, n) { + var result = ""; + if (!string || n < 1 || n > MAX_SAFE_INTEGER) { + return result; + } // Leverage the exponentiation by squaring algorithm for a faster repeat. + // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. + do { + if (n % 2) { + result += string; + } + n = nativeFloor(n / 2); + if (n) { + string += string; + } + } while (n); + return result; + } + /** + * 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), + String(func) + ); + } + /** + * The base implementation of `_.sample`. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + */ function baseSample(collection) { + return arraySample(values(collection)); + } + /** + * The base implementation of `_.sampleSize` without param guards. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @param {Number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */ function baseSampleSize(collection, n) { + var array = values(collection); + return shuffleSelf( + array, + baseClamp(n, 0, array.length) + ); + } + /** + * 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; + } + /** + * The base implementation of `setData` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to associate metadata with. + * @param {*} data The metadata. + * @returns {Function} Returns `func`. + */ var baseSetData = !metaMap + ? identity + : function (func, data) { + metaMap.set(func, data); + return func; + }; + /** + * 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, + }); + }; + /** + * The base implementation of `_.shuffle`. + * + * @private + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + */ function baseShuffle(collection) { + return shuffleSelf(values(collection)); + } + /** + * 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; + } + /** + * The base implementation of `_.some` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ function baseSome(collection, predicate) { + var result; + baseEach(collection, function ( + value, + index, + collection + ) { + result = predicate(value, index, collection); + return !result; + }); + return Boolean(result); + } + /** + * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which + * performs a binary search of `array` to determine the index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @private + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Boolean} [retHighest] Specify returning the highest qualified index. + * @returns {Number} Returns the index at which `value` should be inserted + * into `array`. + */ function baseSortedIndex(array, value, retHighest) { + var low = 0, + high = array == null ? low : array.length; + if ( + typeof value === "number" && + value === value && + high <= HALF_MAX_ARRAY_LENGTH + ) { + while (low < high) { + var mid = (low + high) >>> 1, + computed = array[mid]; + if ( + computed !== null && + !isSymbol(computed) && + (retHighest + ? computed <= value + : computed < value) + ) { + low = mid + 1; + } else { + high = mid; + } + } + return high; + } + return baseSortedIndexBy( + array, + value, + identity, + retHighest + ); + } + /** + * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` + * which invokes `iteratee` for `value` and each element of `array` to compute + * their sort ranking. The iteratee is invoked with one argument; (value). + * + * @private + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} iteratee The iteratee invoked per element. + * @param {Boolean} [retHighest] Specify returning the highest qualified index. + * @returns {Number} Returns the index at which `value` should be inserted + * into `array`. + */ function baseSortedIndexBy( + array, + value, + iteratee, + retHighest + ) { + value = iteratee(value); + var low = 0, + high = array == null ? 0 : array.length, + valIsNaN = value !== value, + valIsNull = value === null, + valIsSymbol = isSymbol(value), + valIsUndefined = value === undefined; + while (low < high) { + var mid = nativeFloor((low + high) / 2), + computed = iteratee(array[mid]), + othIsDefined = computed !== undefined, + othIsNull = computed === null, + othIsReflexive = computed === computed, + othIsSymbol = isSymbol(computed); + if (valIsNaN) { + var setLow = retHighest || othIsReflexive; + } else if (valIsUndefined) { + setLow = + othIsReflexive && + (retHighest || othIsDefined); + } else if (valIsNull) { + setLow = + othIsReflexive && + othIsDefined && + (retHighest || !othIsNull); + } else if (valIsSymbol) { + setLow = + othIsReflexive && + othIsDefined && + !othIsNull && + (retHighest || !othIsSymbol); + } else if (othIsNull || othIsSymbol) { + setLow = false; + } else { + setLow = retHighest + ? computed <= value + : computed < value; + } + if (setLow) { + low = mid + 1; + } else { + high = mid; + } + } + return nativeMin(high, MAX_ARRAY_INDEX); + } + /** + * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without + * support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ function baseSortedUniq(array, iteratee) { + var index = -1, + length = array.length, + resIndex = 0, + result = []; + while (++index < length) { + var value = array[index], + computed = iteratee + ? iteratee(value) + : value; + if (!index || !eq(computed, seen)) { + var seen = computed; + result[resIndex++] = + value === 0 ? 0 : value; + } + } + return result; + } + /** + * The base implementation of `_.toNumber` which doesn't ensure correct + * conversions of binary, hexadecimal, or octal string values. + * + * @private + * @param {*} value The value to process. + * @returns {Number} Returns the number. + */ function baseToNumber(value) { + if (typeof value === "number") { + return value; + } + if (isSymbol(value)) { + return NAN; + } + return Number(value); + } + /** + * 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 String(arrayMap(value, baseToString)); + } + if (isSymbol(value)) { + return symbolToString + ? symbolToString.call(value) + : ""; + } + var result = String(value); + return result == "0" && 1 / value == -INFINITY + ? "-0" + : result; + } + /** + * The base implementation of `_.uniqBy` without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ function baseUniq(array, iteratee, comparator) { + var index = -1, + includes = arrayIncludes, + length = array.length, + isCommon = true, + result = [], + seen = result; + if (comparator) { + isCommon = false; + includes = arrayIncludesWith; + } else if (length >= LARGE_ARRAY_SIZE) { + var set = iteratee ? null : createSet(array); + if (set) { + return setToArray(set); + } + isCommon = false; + includes = cacheHas; + seen = new SetCache(); + } else { + seen = iteratee ? [] : result; + } + outer: while (++index < length) { + var value = array[index], + computed = iteratee + ? iteratee(value) + : value; + value = comparator || value !== 0 ? value : 0; + if (isCommon && computed === computed) { + var seenIndex = seen.length; + while (seenIndex--) { + if (seen[seenIndex] === computed) { + continue outer; + } + } + if (iteratee) { + seen.push(computed); + } + result.push(value); + } else if ( + !includes(seen, computed, comparator) + ) { + if (seen !== result) { + seen.push(computed); + } + result.push(value); + } + } + return result; + } + /** + * 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))] + ); + } + /** + * The base implementation of `_.update`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|String} path The path of the property to update. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ function baseUpdate( + object, + path, + updater, + customizer + ) { + return baseSet( + object, + path, + updater(baseGet(object, path)), + customizer + ); + } + /** + * The base implementation of methods like `_.dropWhile` and `_.takeWhile` + * without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to query. + * @param {Function} predicate The function invoked per iteration. + * @param {Boolean} [isDrop] Specify dropping elements instead of taking them. + * @param {Boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the slice of `array`. + */ function baseWhile( + array, + predicate, + isDrop, + fromRight + ) { + var length = array.length, + index = fromRight ? length : -1; + while ( + (fromRight ? index-- : ++index < length) && + predicate(array[index], index, array) + ) {} + return isDrop + ? baseSlice( + array, + fromRight ? 0 : index, + fromRight ? index + 1 : length + ) + : baseSlice( + array, + fromRight ? index + 1 : 0, + fromRight ? length : index + ); + } + /** + * The base implementation of `wrapperValue` which returns the result of + * performing a sequence of actions on the unwrapped `value`, where each + * successive action is supplied the return value of the previous. + * + * @private + * @param {*} value The unwrapped value. + * @param {Array} actions Actions to perform to resolve the unwrapped value. + * @returns {*} Returns the resolved value. + */ function baseWrapperValue(value, actions) { + var result = value; + if (result instanceof LazyWrapper) { + result = result.value(); + } + return arrayReduce( + actions, + function (result, action) { + return action.func.apply( + action.thisArg, + arrayPush([result], action.args) + ); + }, + result + ); + } + /** + * The base implementation of methods like `_.xor`, without support for + * iteratee shorthands, that accepts an array of arrays to inspect. + * + * @private + * @param {Array} arrays The arrays to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of values. + */ function baseXor(arrays, iteratee, comparator) { + var length = arrays.length; + if (length < 2) { + return length ? baseUniq(arrays[0]) : []; + } + var index = -1, + result = Array(length); + while (++index < length) { + var array = arrays[index], + othIndex = -1; + while (++othIndex < length) { + if (othIndex != index) { + result[index] = baseDifference( + result[index] || array, + arrays[othIndex], + iteratee, + comparator + ); + } + } + } + return baseUniq( + baseFlatten(result, 1), + iteratee, + comparator + ); + } + /** + * This base implementation of `_.zipObject` which assigns values using `assignFunc`. + * + * @private + * @param {Array} props The property identifiers. + * @param {Array} values The property values. + * @param {Function} assignFunc The function to assign values. + * @returns {Object} Returns the new object. + */ function baseZipObject(props, values, assignFunc) { + var index = -1, + length = props.length, + valsLength = values.length, + result = {}; + while (++index < length) { + var value = + index < valsLength + ? values[index] + : undefined; + assignFunc(result, props[index], value); + } + return result; + } + /** + * Casts `value` to an empty array if it's not an array like object. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array|Object} Returns the cast array-like object. + */ function castArrayLikeObject(value) { + return isArrayLikeObject(value) ? value : []; + } + /** + * Casts `value` to `identity` if it's not a function. + * + * @private + * @param {*} value The value to inspect. + * @returns {Function} Returns cast function. + */ function castFunction(value) { + return typeof value === "function" + ? value + : identity; + } + /** + * 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)); + } + /** + * A `baseRest` alias which can be replaced with `identity` by module + * replacement plugins. + * + * @private + * @type {Function} + * @param {Function} func The function to apply a rest parameter to. + * @returns {Function} Returns the new function. + */ var castRest = baseRest; + /** + * Casts `array` to a slice if it's needed. + * + * @private + * @param {Array} array The array to inspect. + * @param {Number} start The start position. + * @param {Number} [end=array.length] The end position. + * @returns {Array} Returns the cast slice. + */ function castSlice(array, start, end) { + var length = array.length; + end = end === undefined ? length : end; + return !start && end >= length + ? array + : baseSlice(array, start, end); + } + /** + * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout). + * + * @private + * @param {Number|Object} id The timer id or timeout object of the timer to clear. + */ var clearTimeout = + ctxClearTimeout || + function (id) { + return root.clearTimeout(id); + }; + /** + * 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; + } + /** + * 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; + } + /** + * 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 + ); + } + /** + * 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; + } + /** + * 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)) + : {}; + } + /** + * 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 + ); + } + /** + * Compares values to sort them in ascending order. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {Number} Returns the sort order indicator for `value`. + */ function compareAscending(value, other) { + if (value !== other) { + var valIsDefined = value !== undefined, + valIsNull = value === null, + valIsReflexive = value === value, + valIsSymbol = isSymbol(value); + var othIsDefined = other !== undefined, + othIsNull = other === null, + othIsReflexive = other === other, + othIsSymbol = isSymbol(other); + if ( + (!othIsNull && + !othIsSymbol && + !valIsSymbol && + value > other) || + (valIsSymbol && + othIsDefined && + othIsReflexive && + !othIsNull && + !othIsSymbol) || + (valIsNull && + othIsDefined && + othIsReflexive) || + (!valIsDefined && othIsReflexive) || + !valIsReflexive + ) { + return 1; + } + if ( + (!valIsNull && + !valIsSymbol && + !othIsSymbol && + value < other) || + (othIsSymbol && + valIsDefined && + valIsReflexive && + !valIsNull && + !valIsSymbol) || + (othIsNull && + valIsDefined && + valIsReflexive) || + (!othIsDefined && valIsReflexive) || + !othIsReflexive + ) { + return -1; + } + } + return 0; + } + /** + * Used by `_.orderBy` to compare multiple properties of a value to another + * and stable sort them. + * + * If `orders` is unspecified, all values are sorted in ascending order. Otherwise, + * specify an order of "desc" for descending or "asc" for ascending sort order + * of corresponding values. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {Boolean[]|String[]} orders The order to sort by for each property. + * @returns {Number} Returns the sort order indicator for `object`. + */ function compareMultiple(object, other, orders) { + var index = -1, + objCriteria = object.criteria, + othCriteria = other.criteria, + length = objCriteria.length, + ordersLength = orders.length; + while (++index < length) { + var result = compareAscending( + objCriteria[index], + othCriteria[index] + ); + if (result) { + if (index >= ordersLength) { + return result; + } + var order = orders[index]; + return result * (order == "desc" ? -1 : 1); + } + } // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications + // that causes it, under certain circumstances, to provide the same value for + // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 + // for more details. + // + // This also ensures a stable sort in V8 and other engines. + // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. + return object.index - other.index; + } + /** + * Creates an array that is the composition of partially applied arguments, + * placeholders, and provided arguments into a single array of arguments. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to prepend to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */ function composeArgs( + args, + partials, + holders, + isCurried + ) { + var argsIndex = -1, + argsLength = args.length, + holdersLength = holders.length, + leftIndex = -1, + leftLength = partials.length, + rangeLength = nativeMax( + argsLength - holdersLength, + 0 + ), + result = Array(leftLength + rangeLength), + isUncurried = !isCurried; + while (++leftIndex < leftLength) { + result[leftIndex] = partials[leftIndex]; + } + while (++argsIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[holders[argsIndex]] = + args[argsIndex]; + } + } + while (rangeLength--) { + result[leftIndex++] = args[argsIndex++]; + } + return result; + } + /** + * This function is like `composeArgs` except that the arguments composition + * is tailored for `_.partialRight`. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to append to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */ function composeArgsRight( + args, + partials, + holders, + isCurried + ) { + var argsIndex = -1, + argsLength = args.length, + holdersIndex = -1, + holdersLength = holders.length, + rightIndex = -1, + rightLength = partials.length, + rangeLength = nativeMax( + argsLength - holdersLength, + 0 + ), + result = Array(rangeLength + rightLength), + isUncurried = !isCurried; + while (++argsIndex < rangeLength) { + result[argsIndex] = args[argsIndex]; + } + var offset = argsIndex; + while (++rightIndex < rightLength) { + result[offset + rightIndex] = + partials[rightIndex]; + } + while (++holdersIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[offset + holders[holdersIndex]] = + args[argsIndex++]; + } + } + return result; + } + /** + * 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; + } + /** + * 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; + } + /** + * 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 + ); + } + /** + * 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 + ); + } + /** + * Creates a function like `_.groupBy`. + * + * @private + * @param {Function} setter The function to set accumulator values. + * @param {Function} [initializer] The accumulator object initializer. + * @returns {Function} Returns the new aggregator function. + */ function createAggregator(setter, initializer) { + return function (collection, iteratee) { + var func = isArray(collection) + ? arrayAggregator + : baseAggregator, + accumulator = initializer + ? initializer() + : {}; + return func( + collection, + setter, + getIteratee(iteratee, 2), + accumulator + ); + }; + } + /** + * 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; + }); + } + /** + * Creates a `baseEach` or `baseEachRight` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {Boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ function createBaseEach(eachFunc, fromRight) { + return function (collection, iteratee) { + if (collection == null) { + return collection; + } + if (!isArrayLike(collection)) { + return eachFunc(collection, iteratee); + } + var length = collection.length, + index = fromRight ? length : -1, + iterable = Object(collection); + while (fromRight ? index-- : ++index < length) { + if ( + iteratee( + iterable[index], + index, + iterable + ) === false + ) { + break; + } + } + return collection; + }; + } + /** + * 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; + }; + } + /** + * Creates a function that wraps `func` to invoke it with the optional `this` + * binding of `thisArg`. + * + * @private + * @param {Function} func The function to wrap. + * @param {Number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} [thisArg] The `this` binding of `func`. + * @returns {Function} Returns the new wrapped function. + */ function createBind(func, bitmask, thisArg) { + var isBind = bitmask & WRAP_BIND_FLAG, + Ctor = createCtor(func); + function wrapper() { + var fn = + this && + this !== root && + this instanceof wrapper + ? Ctor + : func; + return fn.apply( + isBind ? thisArg : this, + arguments + ); + } + return wrapper; + } + /** + * Creates a function like `_.lowerFirst`. + * + * @private + * @param {String} methodName The name of the `String` case method to use. + * @returns {Function} Returns the new case function. + */ function createCaseFirst(methodName) { + return function (string) { + string = toString(string); + var strSymbols = hasUnicode(string) + ? stringToArray(string) + : undefined; + var chr = strSymbols + ? strSymbols[0] + : string.charAt(0); + var trailing = strSymbols + ? castSlice(strSymbols, 1).join("") + : string.slice(1); + return chr[methodName]() + trailing; + }; + } + /** + * Creates a function like `_.camelCase`. + * + * @private + * @param {Function} callback The function to combine each word. + * @returns {Function} Returns the new compounder function. + */ function createCompounder(callback) { + return function (string) { + return arrayReduce( + words(deburr(string).replace(reApos, "")), + callback, + "" + ); + }; + } + /** + * Creates a function that produces an instance of `Ctor` regardless of + * whether it was invoked as part of a `new` expression or by `call` or `apply`. + * + * @private + * @param {Function} Ctor The constructor to wrap. + * @returns {Function} Returns the new wrapped function. + */ function createCtor(Ctor) { + return function () { + // Use a `switch` statement to work with class constructors. See + // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist + // for more details. + var args = arguments; + switch (args.length) { + case 0: + return new Ctor(); + case 1: + return new Ctor(args[0]); + case 2: + return new Ctor(args[0], args[1]); + case 3: + return new Ctor( + args[0], + args[1], + args[2] + ); + case 4: + return new Ctor( + args[0], + args[1], + args[2], + args[3] + ); + case 5: + return new Ctor( + args[0], + args[1], + args[2], + args[3], + args[4] + ); + case 6: + return new Ctor( + args[0], + args[1], + args[2], + args[3], + args[4], + args[5] + ); + case 7: + return new Ctor( + args[0], + args[1], + args[2], + args[3], + args[4], + args[5], + args[6] + ); + } + var thisBinding = baseCreate(Ctor.prototype), + result = Ctor.apply(thisBinding, args); // Mimic the constructor's `return` behavior. + // See https://es5.github.io/#x13.2.2 for more details. + return isObject(result) ? result : thisBinding; + }; + } + /** + * Creates a function that wraps `func` to enable currying. + * + * @private + * @param {Function} func The function to wrap. + * @param {Number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {Number} arity The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ function createCurry(func, bitmask, arity) { + var Ctor = createCtor(func); + function wrapper() { + var length = arguments.length, + args = Array(length), + index = length, + placeholder = getHolder(wrapper); + while (index--) { + args[index] = arguments[index]; + } + var holders = + length < 3 && + args[0] !== placeholder && + args[length - 1] !== placeholder + ? [] + : replaceHolders(args, placeholder); + length -= holders.length; + if (length < arity) { + return createRecurry( + func, + bitmask, + createHybrid, + wrapper.placeholder, + undefined, + args, + holders, + undefined, + undefined, + arity - length + ); + } + var fn = + this && + this !== root && + this instanceof wrapper + ? Ctor + : func; + return apply(fn, this, args); + } + return wrapper; + } + /** + * Creates a `_.find` or `_.findLast` function. + * + * @private + * @param {Function} findIndexFunc The function to find the collection index. + * @returns {Function} Returns the new find function. + */ function createFind(findIndexFunc) { + return function (collection, predicate, fromIndex) { + var iterable = Object(collection); + if (!isArrayLike(collection)) { + var iteratee = getIteratee(predicate, 3); + collection = keys(collection); + predicate = function predicate(key) { + return iteratee( + iterable[key], + key, + iterable + ); + }; + } + var index = findIndexFunc( + collection, + predicate, + fromIndex + ); + return index > -1 + ? iterable[ + iteratee ? collection[index] : index + ] + : undefined; + }; + } + /** + * Creates a `_.flow` or `_.flowRight` function. + * + * @private + * @param {Boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new flow function. + */ function createFlow(fromRight) { + return flatRest(function (funcs) { + var length = funcs.length, + index = length, + prereq = LodashWrapper.prototype.thru; + if (fromRight) { + funcs.reverse(); + } + while (index--) { + var func = funcs[index]; + if (typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + if ( + prereq && + !wrapper && + getFuncName(func) == "wrapper" + ) { + var wrapper = new LodashWrapper( + [], + true + ); + } + } + index = wrapper ? index : length; + while (++index < length) { + func = funcs[index]; + var funcName = getFuncName(func), + data = + funcName == "wrapper" + ? getData(func) + : undefined; + if ( + data && + isLaziable(data[0]) && + data[1] == + (WRAP_ARY_FLAG | + WRAP_CURRY_FLAG | + WRAP_PARTIAL_FLAG | + WRAP_REARG_FLAG) && + !data[4].length && + data[9] == 1 + ) { + wrapper = wrapper[ + getFuncName(data[0]) + ].apply(wrapper, data[3]); + } else { + wrapper = + func.length == 1 && isLaziable(func) + ? wrapper[funcName]() + : wrapper.thru(func); + } + } + return function () { + var args = arguments, + value = args[0]; + if ( + wrapper && + args.length == 1 && + isArray(value) + ) { + return wrapper.plant(value).value(); + } + var index = 0, + result = length + ? funcs[index].apply(this, args) + : value; + while (++index < length) { + result = funcs[index].call( + this, + result + ); + } + return result; + }; + }); + } + /** + * Creates a function that wraps `func` to invoke it with optional `this` + * binding of `thisArg`, partial application, and currying. + * + * @private + * @param {Function|String} func The function or method name to wrap. + * @param {Number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to prepend to those provided to + * the new function. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [partialsRight] The arguments to append to those provided + * to the new function. + * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {Number} [ary] The arity cap of `func`. + * @param {Number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ function createHybrid( + func, + bitmask, + thisArg, + partials, + holders, + partialsRight, + holdersRight, + argPos, + ary, + arity + ) { + var isAry = bitmask & WRAP_ARY_FLAG, + isBind = bitmask & WRAP_BIND_FLAG, + isBindKey = bitmask & WRAP_BIND_KEY_FLAG, + isCurried = + bitmask & + (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), + isFlip = bitmask & WRAP_FLIP_FLAG, + Ctor = isBindKey ? undefined : createCtor(func); + function wrapper() { + var length = arguments.length, + args = Array(length), + index = length; + while (index--) { + args[index] = arguments[index]; + } + if (isCurried) { + var placeholder = getHolder(wrapper), + holdersCount = countHolders( + args, + placeholder + ); + } + if (partials) { + args = composeArgs( + args, + partials, + holders, + isCurried + ); + } + if (partialsRight) { + args = composeArgsRight( + args, + partialsRight, + holdersRight, + isCurried + ); + } + length -= holdersCount; + if (isCurried && length < arity) { + var newHolders = replaceHolders( + args, + placeholder + ); + return createRecurry( + func, + bitmask, + createHybrid, + wrapper.placeholder, + thisArg, + args, + newHolders, + argPos, + ary, + arity - length + ); + } + var thisBinding = isBind ? thisArg : this, + fn = isBindKey ? thisBinding[func] : func; + length = args.length; + if (argPos) { + args = reorder(args, argPos); + } else if (isFlip && length > 1) { + args.reverse(); + } + if (isAry && ary < length) { + args.length = ary; + } + if ( + this && + this !== root && + this instanceof wrapper + ) { + fn = Ctor || createCtor(fn); + } + return fn.apply(thisBinding, args); + } + return wrapper; + } + /** + * Creates a function like `_.invertBy`. + * + * @private + * @param {Function} setter The function to set accumulator values. + * @param {Function} toIteratee The function to resolve iteratees. + * @returns {Function} Returns the new inverter function. + */ function createInverter(setter, toIteratee) { + return function (object, iteratee) { + return baseInverter( + object, + setter, + toIteratee(iteratee), + {} + ); + }; + } + /** + * Creates a function that performs a mathematical operation on two values. + * + * @private + * @param {Function} operator The function to perform the operation. + * @param {Number} [defaultValue] The value used for `undefined` arguments. + * @returns {Function} Returns the new mathematical operation function. + */ function createMathOperation( + operator, + defaultValue + ) { + return function (value, other) { + var result; + if ( + value === undefined && + other === undefined + ) { + return defaultValue; + } + if (value !== undefined) { + result = value; + } + if (other !== undefined) { + if (result === undefined) { + return other; + } + if ( + typeof value === "string" || + typeof other === "string" + ) { + value = baseToString(value); + other = baseToString(other); + } else { + value = baseToNumber(value); + other = baseToNumber(other); + } + result = operator(value, other); + } + return result; + }; + } + /** + * Creates a function like `_.over`. + * + * @private + * @param {Function} arrayFunc The function to iterate over iteratees. + * @returns {Function} Returns the new over function. + */ function createOver(arrayFunc) { + return flatRest(function (iteratees) { + iteratees = arrayMap( + iteratees, + baseUnary(getIteratee()) + ); + return baseRest(function (args) { + var thisArg = this; + return arrayFunc(iteratees, function ( + iteratee + ) { + return apply(iteratee, thisArg, args); + }); + }); + }); + } + /** + * Creates the padding for `string` based on `length`. The `chars` string + * is truncated if the number of characters exceeds `length`. + * + * @private + * @param {Number} length The padding length. + * @param {String} [chars=' '] The string used as padding. + * @returns {String} Returns the padding for `string`. + */ function createPadding(length, chars) { + chars = + chars === undefined ? " " : baseToString(chars); + var charsLength = chars.length; + if (charsLength < 2) { + return charsLength + ? baseRepeat(chars, length) + : chars; + } + var result = baseRepeat( + chars, + nativeCeil(length / stringSize(chars)) + ); + return hasUnicode(chars) + ? castSlice( + stringToArray(result), + 0, + length + ).join("") + : result.slice(0, length); + } + /** + * Creates a function that wraps `func` to invoke it with the `this` binding + * of `thisArg` and `partials` prepended to the arguments it receives. + * + * @private + * @param {Function} func The function to wrap. + * @param {Number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} partials The arguments to prepend to those provided to + * the new function. + * @returns {Function} Returns the new wrapped function. + */ function createPartial( + func, + bitmask, + thisArg, + partials + ) { + var isBind = bitmask & WRAP_BIND_FLAG, + Ctor = createCtor(func); + function wrapper() { + var argsIndex = -1, + argsLength = arguments.length, + leftIndex = -1, + leftLength = partials.length, + args = Array(leftLength + argsLength), + fn = + this && + this !== root && + this instanceof wrapper + ? Ctor + : func; + while (++leftIndex < leftLength) { + args[leftIndex] = partials[leftIndex]; + } + while (argsLength--) { + args[leftIndex++] = arguments[++argsIndex]; + } + return apply(fn, isBind ? thisArg : this, args); + } + return wrapper; + } + /** + * Creates a `_.range` or `_.rangeRight` function. + * + * @private + * @param {Boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new range function. + */ function createRange(fromRight) { + return function (start, end, step) { + if ( + step && + typeof step !== "number" && + isIterateeCall(start, end, step) + ) { + end = step = undefined; + } // Ensure the sign of `-0` is preserved. + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + step = + step === undefined + ? start < end + ? 1 + : -1 + : toFinite(step); + return baseRange(start, end, step, fromRight); + }; + } + /** + * Creates a function that performs a relational operation on two values. + * + * @private + * @param {Function} operator The function to perform the operation. + * @returns {Function} Returns the new relational operation function. + */ function createRelationalOperation(operator) { + return function (value, other) { + if ( + !( + typeof value === "string" && + typeof other === "string" + ) + ) { + value = toNumber(value); + other = toNumber(other); + } + return operator(value, other); + }; + } + /** + * Creates a function that wraps `func` to continue currying. + * + * @private + * @param {Function} func The function to wrap. + * @param {Number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {Function} wrapFunc The function to create the `func` wrapper. + * @param {*} placeholder The placeholder value. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to prepend to those provided to + * the new function. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {Number} [ary] The arity cap of `func`. + * @param {Number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ function createRecurry( + func, + bitmask, + wrapFunc, + placeholder, + thisArg, + partials, + holders, + argPos, + ary, + arity + ) { + var isCurry = bitmask & WRAP_CURRY_FLAG, + newHolders = isCurry ? holders : undefined, + newHoldersRight = isCurry ? undefined : holders, + newPartials = isCurry ? partials : undefined, + newPartialsRight = isCurry + ? undefined + : partials; + bitmask |= isCurry + ? WRAP_PARTIAL_FLAG + : WRAP_PARTIAL_RIGHT_FLAG; + bitmask &= ~(isCurry + ? WRAP_PARTIAL_RIGHT_FLAG + : WRAP_PARTIAL_FLAG); + if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { + bitmask &= ~( + WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG + ); + } + var newData = [ + func, + bitmask, + thisArg, + newPartials, + newHolders, + newPartialsRight, + newHoldersRight, + argPos, + ary, + arity, + ]; + var result = wrapFunc.apply(undefined, newData); + if (isLaziable(func)) { + setData(result, newData); + } + result.placeholder = placeholder; + return setWrapToString(result, func, bitmask); + } + /** + * Creates a function like `_.round`. + * + * @private + * @param {String} methodName The name of the `Math` method to use when rounding. + * @returns {Function} Returns the new round function. + */ function createRound(methodName) { + var func = Math[methodName]; + return function (number, precision) { + number = toNumber(number); + precision = + precision == null + ? 0 + : nativeMin(toInteger(precision), 292); + if (precision && nativeIsFinite(number)) { + // Shift with exponential notation to avoid floating-point issues. + // See [MDN](https://mdn.io/round#Examples) for more details. + var pair = (toString(number) + "e").split( + "e" + ), + value = func( + pair[0] + + "e" + + (Number(pair[1]) + precision) + ); + pair = (toString(value) + "e").split("e"); + return Number(pair[0] + + "e" + + (Number(pair[1]) - precision)); + } + return func(number); + }; + } + /** + * Creates a set object of `values`. + * + * @private + * @param {Array} values The values to add to the set. + * @returns {Object} Returns the new set. + */ var createSet = !( + Set && + 1 / setToArray(new Set([, -0]))[1] == INFINITY + ) + ? noop + : function (values) { + return new Set(values); + }; + /** + * Creates a `_.toPairs` or `_.toPairsIn` function. + * + * @private + * @param {Function} keysFunc The function to get the keys of a given object. + * @returns {Function} Returns the new pairs function. + */ function createToPairs(keysFunc) { + return function (object) { + var tag = getTag(object); + if (tag == mapTag) { + return mapToArray(object); + } + if (tag == setTag) { + return setToPairs(object); + } + return baseToPairs(object, keysFunc(object)); + }; + } + /** + * Creates a function that either curries or invokes `func` with optional + * `this` binding and partially applied arguments. + * + * @private + * @param {Function|String} func The function or method name to wrap. + * @param {Number} bitmask The bitmask flags. + * 1 - `_.bind` + * 2 - `_.bindKey` + * 4 - `_.curry` or `_.curryRight` of a bound function + * 8 - `_.curry` + * 16 - `_.curryRight` + * 32 - `_.partial` + * 64 - `_.partialRight` + * 128 - `_.rearg` + * 256 - `_.ary` + * 512 - `_.flip` + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to be partially applied. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {Number} [ary] The arity cap of `func`. + * @param {Number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ function createWrap( + func, + bitmask, + thisArg, + partials, + holders, + argPos, + ary, + arity + ) { + var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; + if (!isBindKey && typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + var length = partials ? partials.length : 0; + if (!length) { + bitmask &= ~( + WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG + ); + partials = holders = undefined; + } + ary = + ary === undefined + ? ary + : nativeMax(toInteger(ary), 0); + arity = + arity === undefined ? arity : toInteger(arity); + length -= holders ? holders.length : 0; + if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { + var partialsRight = partials, + holdersRight = holders; + partials = holders = undefined; + } + var data = isBindKey ? undefined : getData(func); + var newData = [ + func, + bitmask, + thisArg, + partials, + holders, + partialsRight, + holdersRight, + argPos, + ary, + arity, + ]; + if (data) { + mergeData(newData, data); + } + func = newData[0]; + bitmask = newData[1]; + thisArg = newData[2]; + partials = newData[3]; + holders = newData[4]; + arity = newData[9] = + newData[9] === undefined + ? isBindKey + ? 0 + : func.length + : nativeMax(newData[9] - length, 0); + if ( + !arity && + bitmask & + (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG) + ) { + bitmask &= ~( + WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG + ); + } + if (!bitmask || bitmask == WRAP_BIND_FLAG) { + var result = createBind(func, bitmask, thisArg); + } else if ( + bitmask == WRAP_CURRY_FLAG || + bitmask == WRAP_CURRY_RIGHT_FLAG + ) { + result = createCurry(func, bitmask, arity); + } else if ( + (bitmask == WRAP_PARTIAL_FLAG || + bitmask == + (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && + !holders.length + ) { + result = createPartial( + func, + bitmask, + thisArg, + partials + ); + } else { + result = createHybrid.apply(undefined, newData); + } + var setter = data ? baseSetData : setData; + return setWrapToString( + setter(result, newData), + func, + bitmask + ); + } + /** + * Used by `_.defaults` to customize its `_.assignIn` use to assign properties + * of source objects to the destination object for all destination properties + * that resolve to `undefined`. + * + * @private + * @param {*} objValue The destination value. + * @param {*} srcValue The source value. + * @param {String} key The key of the property to assign. + * @param {Object} object The parent object of `objValue`. + * @returns {*} Returns the value to assign. + */ function customDefaultsAssignIn( + objValue, + srcValue, + key, + object + ) { + if ( + objValue === undefined || + (eq(objValue, objectProto[key]) && + !hasOwnProperty.call(object, key)) + ) { + return srcValue; + } + return objValue; + } + /** + * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source + * objects into destination objects that are passed thru. + * + * @private + * @param {*} objValue The destination value. + * @param {*} srcValue The source value. + * @param {String} key The key of the property to merge. + * @param {Object} object The parent object of `objValue`. + * @param {Object} source The parent object of `srcValue`. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + * @returns {*} Returns the value to assign. + */ function customDefaultsMerge( + objValue, + srcValue, + key, + object, + source, + stack + ) { + if (isObject(objValue) && isObject(srcValue)) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, objValue); + baseMerge( + objValue, + srcValue, + undefined, + customDefaultsMerge, + stack + ); + stack.delete(srcValue); + } + return objValue; + } + /** + * 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; + } + /** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {Number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {Boolean} Returns `true` if the arrays are equivalent, else `false`. + */ function equalArrays( + array, + other, + bitmask, + customizer, + equalFunc, + stack + ) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + arrLength = array.length, + othLength = other.length; + if ( + arrLength != othLength && + !(isPartial && othLength > arrLength) + ) { + return false; + } // Assume cyclic values are equal. + var stacked = stack.get(array); + if (stacked && stack.get(other)) { + return stacked == other; + } + var index = -1, + result = true, + seen = + bitmask & COMPARE_UNORDERED_FLAG + ? new SetCache() + : undefined; + stack.set(array, other); + stack.set(other, array); // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + if (customizer) { + var compared = isPartial + ? customizer( + othValue, + arrValue, + index, + other, + array, + stack + ) + : customizer( + arrValue, + othValue, + index, + array, + other, + stack + ); + } + if (compared !== undefined) { + if (compared) { + continue; + } + result = false; + break; + } // Recursively compare arrays (susceptible to call stack limits). + if (seen) { + if ( + !arraySome(other, function ( + othValue, + othIndex + ) { + if ( + !cacheHas(seen, othIndex) && + (arrValue === othValue || + equalFunc( + arrValue, + othValue, + bitmask, + customizer, + stack + )) + ) { + return seen.push(othIndex); + } + }) + ) { + result = false; + break; + } + } else if ( + !( + arrValue === othValue || + equalFunc( + arrValue, + othValue, + bitmask, + customizer, + stack + ) + ) + ) { + result = false; + break; + } + } + stack.delete(array); + stack.delete(other); + return result; + } + /** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {String} tag The `toStringTag` of the objects to compare. + * @param {Number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {Boolean} Returns `true` if the objects are equivalent, else `false`. + */ function equalByTag( + object, + other, + tag, + bitmask, + customizer, + equalFunc, + stack + ) { + switch (tag) { + case dataViewTag: + if ( + object.byteLength != other.byteLength || + object.byteOffset != other.byteOffset + ) { + return false; + } + object = object.buffer; + other = other.buffer; + case arrayBufferTag: + if ( + object.byteLength != other.byteLength || + !equalFunc( + new Uint8Array(object), + new Uint8Array(other) + ) + ) { + return false; + } + return true; + case boolTag: + case dateTag: + case numberTag: // Coerce booleans to `1` or `0` and dates to milliseconds. + // Invalid dates are coerced to `NaN`. + return eq(Number(object), Number(other)); + case errorTag: + return ( + object.name == other.name && + object.message == other.message + ); + case regexpTag: + case stringTag: // Coerce regexes to strings and treat strings, primitives and objects, + // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring + // for more details. + return object == String(other); + case mapTag: + var convert = mapToArray; + case setTag: + var isPartial = + bitmask & COMPARE_PARTIAL_FLAG; + convert || (convert = setToArray); + if ( + object.size != other.size && + !isPartial + ) { + return false; + } // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG; // Recursively compare objects (susceptible to call stack limits). + stack.set(object, other); + var result = equalArrays( + convert(object), + convert(other), + bitmask, + customizer, + equalFunc, + stack + ); + stack.delete(object); + return result; + case symbolTag: + if (symbolValueOf) { + return ( + symbolValueOf.call(object) == + symbolValueOf.call(other) + ); + } + } + return false; + } + /** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {Number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {Boolean} Returns `true` if the objects are equivalent, else `false`. + */ function equalObjects( + object, + other, + bitmask, + customizer, + equalFunc, + stack + ) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + objProps = getAllKeys(object), + objLength = objProps.length, + othProps = getAllKeys(other), + othLength = othProps.length; + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if ( + !(isPartial + ? key in other + : hasOwnProperty.call(other, key)) + ) { + return false; + } + } // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked && stack.get(other)) { + return stacked == other; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key]; + if (customizer) { + var compared = isPartial + ? customizer( + othValue, + objValue, + key, + other, + object, + stack + ) + : customizer( + objValue, + othValue, + key, + object, + other, + stack + ); + } // Recursively compare objects (susceptible to call stack limits). + if ( + !(compared === undefined + ? objValue === othValue || + equalFunc( + objValue, + othValue, + bitmask, + customizer, + stack + ) + : compared) + ) { + result = false; + break; + } + skipCtor || (skipCtor = key == "constructor"); + } + if (result && !skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; // Non `Object` object instances with different constructors are not equal. + if ( + objCtor != othCtor && + "constructor" in object && + "constructor" in other && + !( + typeof objCtor === "function" && + objCtor instanceof objCtor && + typeof othCtor === "function" && + othCtor instanceof othCtor + ) + ) { + result = false; + } + } + stack.delete(object); + stack.delete(other); + return result; + } + /** + * 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), + String(func) + ); + } + /** + * 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); + } + /** + * 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); + } + /** + * Gets metadata for `func`. + * + * @private + * @param {Function} func The function to query. + * @returns {*} Returns the metadata for `func`. + */ var getData = !metaMap + ? noop + : function (func) { + return metaMap.get(func); + }; + /** + * Gets the name of `func`. + * + * @private + * @param {Function} func The function to query. + * @returns {String} Returns the function name. + */ function getFuncName(func) { + var result = String(func.name), + array = realNames[result], + length = hasOwnProperty.call(realNames, result) + ? array.length + : 0; + while (length--) { + var data = array[length], + otherFunc = data.func; + if (otherFunc == null || otherFunc == func) { + return data.name; + } + } + return result; + } + /** + * Gets the argument placeholder value for `func`. + * + * @private + * @param {Function} func The function to inspect. + * @returns {*} Returns the placeholder value. + */ function getHolder(func) { + var object = hasOwnProperty.call( + lodash, + "placeholder" + ) + ? lodash + : func; + return object.placeholder; + } + /** + * Gets the appropriate "iteratee" function. If `_.iteratee` is customized, + * this function returns the custom method, otherwise it returns `baseIteratee`. + * If arguments are provided, the chosen function is invoked with them and + * its result is returned. + * + * @private + * @param {*} [value] The value to convert to an iteratee. + * @param {Number} [arity] The arity of the created iteratee. + * @returns {Function} Returns the chosen function or its result. + */ function getIteratee() { + var result = lodash.iteratee || iteratee; + result = + result === iteratee ? baseIteratee : result; + return arguments.length + ? result(arguments[0], arguments[1]) + : result; + } + /** + * 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; + } + /** + * Gets the property names, values, and compare flags of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the match data of `object`. + */ function getMatchData(object) { + var result = keys(object), + length = result.length; + while (length--) { + var key = result[length], + value = object[key]; + result[length] = [ + key, + value, + isStrictComparable(value), + ]; + } + return result; + } + /** + * 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; + } + /** + * 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; + } + /** + * 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 + ); + } + ); + }; + /** + * 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; + }; + /** + * 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 getTag(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; + }; + } + /** + * Gets the view, applying any `transforms` to the `start` and `end` positions. + * + * @private + * @param {Number} start The start of the view. + * @param {Number} end The end of the view. + * @param {Array} transforms The transformations to apply to the view. + * @returns {Object} Returns an object containing the `start` and `end` + * positions of the view. + */ function getView(start, end, transforms) { + var index = -1, + length = transforms.length; + while (++index < length) { + var data = transforms[index], + size = data.size; + switch (data.type) { + case "drop": + start += size; + break; + case "dropRight": + end -= size; + break; + case "take": + end = nativeMin(end, start + size); + break; + case "takeRight": + start = nativeMax(start, end - size); + break; + } + } + return {start: start, end: end}; + } + /** + * Extracts wrapper details from the `source` body comment. + * + * @private + * @param {String} source The source to inspect. + * @returns {Array} Returns the wrapper details. + */ function getWrapDetails(source) { + var match = source.match(reWrapDetails); + return match ? match[1].split(reSplitDetails) : []; + } + /** + * 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 ( + Boolean(length) && + isLength(length) && + isIndex(key, length) && + (isArray(object) || isArguments(object)) + ); + } + /** + * 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 = new 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; + } + /** + * 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)) + : {}; + } + /** + * Initializes an object clone based on its `toStringTag`. + * + * **Note:** This function only supports cloning values with tags of + * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. + * + * @private + * @param {Object} object The object to clone. + * @param {String} tag The `toStringTag` of the object to clone. + * @param {Boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the initialized clone. + */ function initCloneByTag(object, tag, isDeep) { + var Ctor = object.constructor; + switch (tag) { + case arrayBufferTag: + return cloneArrayBuffer(object); + case boolTag: + case dateTag: + return new Ctor(Number(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 new Ctor(); + case numberTag: + case stringTag: + return new Ctor(object); + case regexpTag: + return cloneRegExp(object); + case setTag: + return new Ctor(); + case symbolTag: + return cloneSymbol(object); + } + } + /** + * Inserts wrapper `details` in a comment at the top of the `source` body. + * + * @private + * @param {String} source The source to modify. + * @returns {Array} details The details to insert. + * @returns {String} Returns the modified source. + */ function insertWrapDetails(source, details) { + var length = details.length; + if (!length) { + return source; + } + var lastIndex = length - 1; + details[lastIndex] = + (length > 1 ? "& " : "") + details[lastIndex]; + details = details.join(length > 2 ? ", " : " "); + return source.replace( + reWrapComment, + "{\n/* [wrapped with " + details + "] */\n" + ); + } + /** + * 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) || + Boolean(spreadableSymbol && + value && + value[spreadableSymbol]) + ); + } + /** + * 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) { + var type = _typeof(value); + length = length == null ? MAX_SAFE_INTEGER : length; + return ( + Boolean(length) && + (type == "number" || + (type != "symbol" && + reIsUint.test(value))) && + value > -1 && + value % 1 == 0 && + value < length + ); + } + /** + * 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; + } + /** + * 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)) + ); + } + /** + * 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; + } + /** + * Checks if `func` has a lazy counterpart. + * + * @private + * @param {Function} func The function to check. + * @returns {Boolean} Returns `true` if `func` has a lazy counterpart, + * else `false`. + */ function isLaziable(func) { + var funcName = getFuncName(func), + other = lodash[funcName]; + if ( + typeof other !== "function" || + !(funcName in LazyWrapper.prototype) + ) { + return false; + } + if (func === other) { + return true; + } + var data = getData(other); + return Boolean(data) && func === data[0]; + } + /** + * 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 Boolean(maskSrcKey) && maskSrcKey in func; + } + /** + * Checks if `func` is capable of being masked. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `func` is maskable, else `false`. + */ var isMaskable = coreJsData + ? isFunction + : stubFalse; + /** + * 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; + } + /** + * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. + * + * @private + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` if suitable for strict + * equality comparisons, else `false`. + */ function isStrictComparable(value) { + return value === value && !isObject(value); + } + /** + * A specialized version of `matchesProperty` for source values suitable + * for strict equality comparisons, i.e. `===`. + * + * @private + * @param {String} key The key of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ function matchesStrictComparable(key, srcValue) { + return function (object) { + if (object == null) { + return false; + } + return ( + object[key] === srcValue && + (srcValue !== undefined || + key in Object(object)) + ); + }; + } + /** + * 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; + } + /** + * Merges the function metadata of `source` into `data`. + * + * Merging metadata reduces the number of wrappers used to invoke a function. + * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` + * may be applied regardless of execution order. Methods like `_.ary` and + * `_.rearg` modify function arguments, making the order in which they are + * executed important, preventing the merging of metadata. However, we make + * an exception for a safe combined case where curried functions have `_.ary` + * and or `_.rearg` applied. + * + * @private + * @param {Array} data The destination metadata. + * @param {Array} source The source metadata. + * @returns {Array} Returns `data`. + */ function mergeData(data, source) { + var bitmask = data[1], + srcBitmask = source[1], + newBitmask = bitmask | srcBitmask, + isCommon = + newBitmask < + (WRAP_BIND_FLAG | + WRAP_BIND_KEY_FLAG | + WRAP_ARY_FLAG); + var isCombo = + (srcBitmask == WRAP_ARY_FLAG && + bitmask == WRAP_CURRY_FLAG) || + (srcBitmask == WRAP_ARY_FLAG && + bitmask == WRAP_REARG_FLAG && + data[7].length <= source[8]) || + (srcBitmask == + (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && + source[7].length <= source[8] && + bitmask == WRAP_CURRY_FLAG); // Exit early if metadata can't be merged. + if (!(isCommon || isCombo)) { + return data; + } // Use source `thisArg` if available. + if (srcBitmask & WRAP_BIND_FLAG) { + data[2] = source[2]; // Set when currying a bound function. + newBitmask |= + bitmask & WRAP_BIND_FLAG + ? 0 + : WRAP_CURRY_BOUND_FLAG; + } // Compose partial arguments. + var value = source[3]; + if (value) { + var partials = data[3]; + data[3] = partials + ? composeArgs(partials, value, source[4]) + : value; + data[4] = partials + ? replaceHolders(data[3], PLACEHOLDER) + : source[4]; + } // Compose partial right arguments. + value = source[5]; + if (value) { + partials = data[5]; + data[5] = partials + ? composeArgsRight( + partials, + value, + source[6] + ) + : value; + data[6] = partials + ? replaceHolders(data[5], PLACEHOLDER) + : source[6]; + } // Use source `argPos` if available. + value = source[7]; + if (value) { + data[7] = value; + } // Use source `ary` if it's smaller. + if (srcBitmask & WRAP_ARY_FLAG) { + data[8] = + data[8] == null + ? source[8] + : nativeMin(data[8], source[8]); + } // Use source `arity` if one is not provided. + if (data[9] == null) { + data[9] = source[9]; + } // Use source `func` and merge bitmasks. + data[0] = source[0]; + data[1] = newBitmask; + return data; + } + /** + * 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; + } + /** + * 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); + } + /** + * 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); + }; + } + /** + * 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)); + } + /** + * Reorder `array` according to the specified indexes where the element at + * the first index is assigned as the first element, the element at + * the second index is assigned as the second element, and so on. + * + * @private + * @param {Array} array The array to reorder. + * @param {Array} indexes The arranged array indexes. + * @returns {Array} Returns `array`. + */ function reorder(array, indexes) { + var arrLength = array.length, + length = nativeMin(indexes.length, arrLength), + oldArray = copyArray(array); + while (length--) { + var index = indexes[length]; + array[length] = isIndex(index, arrLength) + ? oldArray[index] + : undefined; + } + return array; + } + /** + * Gets the value at `key`, unless `key` is "__proto__" or "constructor". + * + * @private + * @param {Object} object The object to query. + * @param {String} key The key of the property to get. + * @returns {*} Returns the property value. + */ function safeGet(object, key) { + if ( + key === "constructor" && + typeof object[key] === "function" + ) { + return; + } + if (key == "__proto__") { + return; + } + return object[key]; + } + /** + * Sets metadata for `func`. + * + * **Note:** If this function becomes hot, i.e. is invoked a lot in a short + * period of time, it will trip its breaker and transition to an identity + * function to avoid garbage collection pauses in V8. See + * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070) + * for more details. + * + * @private + * @param {Function} func The function to associate metadata with. + * @param {*} data The metadata. + * @returns {Function} Returns `func`. + */ var setData = shortOut(baseSetData); + /** + * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout). + * + * @private + * @param {Function} func The function to delay. + * @param {Number} wait The number of milliseconds to delay invocation. + * @returns {Number|Object} Returns the timer id or timeout object. + */ var setTimeout = + ctxSetTimeout || + function (func, wait) { + return root.setTimeout(func, wait); + }; + /** + * 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); + /** + * Sets the `toString` method of `wrapper` to mimic the source of `reference` + * with wrapper details in a comment at the top of the source body. + * + * @private + * @param {Function} wrapper The function to modify. + * @param {Function} reference The reference function. + * @param {Number} bitmask The bitmask flags. See `createWrap` for more details. + * @returns {Function} Returns `wrapper`. + */ function setWrapToString( + wrapper, + reference, + bitmask + ) { + var source = String(reference); + return setToString( + wrapper, + insertWrapDetails( + source, + updateWrapDetails( + getWrapDetails(source), + bitmask + ) + ) + ); + } + /** + * 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); + }; + } + /** + * A specialized version of `_.shuffle` which mutates and sets the size of `array`. + * + * @private + * @param {Array} array The array to shuffle. + * @param {Number} [size=array.length] The size of `array`. + * @returns {Array} Returns `array`. + */ function shuffleSelf(array, size) { + var index = -1, + length = array.length, + lastIndex = length - 1; + size = size === undefined ? length : size; + while (++index < size) { + var rand = baseRandom(index, lastIndex), + value = array[rand]; + array[rand] = array[index]; + array[index] = value; + } + array.length = size; + return array; + } + /** + * 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 (string.charCodeAt(0) === 46 /* . */) { + result.push(""); + } + string.replace(rePropName, function ( + match, + number, + quote, + subString + ) { + result.push( + quote + ? subString.replace(reEscapeChar, "$1") + : number || match + ); + }); + return result; + }); + /** + * 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 = String(value); + return result == "0" && 1 / value == -INFINITY + ? "-0" + : result; + } + /** + * 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 String(func); + } catch (e) {} + } + return ""; + } + /** + * Updates wrapper `details` based on `bitmask` flags. + * + * @private + * @returns {Array} details The details to modify. + * @param {Number} bitmask The bitmask flags. See `createWrap` for more details. + * @returns {Array} Returns `details`. + */ function updateWrapDetails(details, bitmask) { + arrayEach(wrapFlags, function (pair) { + var value = "_." + pair[0]; + if ( + bitmask & pair[1] && + !arrayIncludes(details, value) + ) { + details.push(value); + } + }); + return details.sort(); + } + /** + * Creates a clone of `wrapper`. + * + * @private + * @param {Object} wrapper The wrapper to clone. + * @returns {Object} Returns the cloned wrapper. + */ function wrapperClone(wrapper) { + if (wrapper instanceof LazyWrapper) { + return wrapper.clone(); + } + var result = new LodashWrapper( + wrapper.__wrapped__, + wrapper.__chain__ + ); + result.__actions__ = copyArray(wrapper.__actions__); + result.__index__ = wrapper.__index__; + result.__values__ = wrapper.__values__; + return result; + } + /* ------------------------------------------------------------------------*/ /** + * Creates an array of elements split into groups the length of `size`. + * If `array` can't be split evenly, the final chunk will be the remaining + * elements. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to process. + * @param {Number} [size=1] The length of each chunk + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the new array of chunks. + * @example + * + * _.chunk(['a', 'b', 'c', 'd'], 2); + * // => [['a', 'b'], ['c', 'd']] + * + * _.chunk(['a', 'b', 'c', 'd'], 3); + * // => [['a', 'b', 'c'], ['d']] + */ function chunk(array, size, guard) { + if ( + guard + ? isIterateeCall(array, size, guard) + : size === undefined + ) { + size = 1; + } else { + size = nativeMax(toInteger(size), 0); + } + var length = array == null ? 0 : array.length; + if (!length || size < 1) { + return []; + } + var index = 0, + resIndex = 0, + result = Array(nativeCeil(length / size)); + while (index < length) { + result[resIndex++] = baseSlice( + array, + index, + (index += size) + ); + } + return result; + } + /** + * Creates an array with all falsey values removed. The values `false`, `null`, + * `0`, `""`, `undefined`, and `NaN` are falsey. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to compact. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.compact([0, 1, false, 2, '', 3]); + * // => [1, 2, 3] + */ function compact(array) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + while (++index < length) { + var value = array[index]; + if (value) { + result[resIndex++] = value; + } + } + return result; + } + /** + * Creates a new array concatenating `array` with any additional arrays + * and/or values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to concatenate. + * @param {...*} [values] The values to concatenate. + * @returns {Array} Returns the new concatenated array. + * @example + * + * var array = [1]; + * var other = _.concat(array, 2, [3], [[4]]); + * + * console.log(other); + * // => [1, 2, 3, [4]] + * + * console.log(array); + * // => [1] + */ function concat() { + var length = arguments.length; + if (!length) { + return []; + } + var args = Array(length - 1), + array = arguments[0], + index = length; + while (index--) { + args[index - 1] = arguments[index]; + } + return arrayPush( + isArray(array) ? copyArray(array) : [array], + baseFlatten(args, 1) + ); + } + /** + * Creates an array of `array` values not included in the other given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * **Note:** Unlike `_.pullAll`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.without, _.xor + * @example + * + * _.difference([2, 1], [2, 3]); + * // => [1] + */ var difference = baseRest(function (array, values) { + return isArrayLikeObject(array) + ? baseDifference( + array, + baseFlatten( + values, + 1, + isArrayLikeObject, + true + ) + ) + : []; + }); + /** + * This method is like `_.difference` except that it accepts `iteratee` which + * is invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * **Note:** Unlike `_.pullAllBy`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2] + * + * // The `_.property` iteratee shorthand. + * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ var differenceBy = baseRest(function ( + array, + values + ) { + var iteratee = last(values); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return isArrayLikeObject(array) + ? baseDifference( + array, + baseFlatten( + values, + 1, + isArrayLikeObject, + true + ), + getIteratee(iteratee, 2) + ) + : []; + }); + /** + * This method is like `_.difference` except that it accepts `comparator` + * which is invoked to compare elements of `array` to `values`. The order and + * references of result values are determined by the first array. The comparator + * is invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.pullAllWith`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * + * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); + * // => [{ 'x': 2, 'y': 1 }] + */ var differenceWith = baseRest(function ( + array, + values + ) { + var comparator = last(values); + if (isArrayLikeObject(comparator)) { + comparator = undefined; + } + return isArrayLikeObject(array) + ? baseDifference( + array, + baseFlatten( + values, + 1, + isArrayLikeObject, + true + ), + undefined, + comparator + ) + : []; + }); + /** + * Creates a slice of `array` with `n` elements dropped from the beginning. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Array + * @param {Array} array The array to query. + * @param {Number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.drop([1, 2, 3]); + * // => [2, 3] + * + * _.drop([1, 2, 3], 2); + * // => [3] + * + * _.drop([1, 2, 3], 5); + * // => [] + * + * _.drop([1, 2, 3], 0); + * // => [1, 2, 3] + */ function drop(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = guard || n === undefined ? 1 : toInteger(n); + return baseSlice(array, n < 0 ? 0 : n, length); + } + /** + * Creates a slice of `array` with `n` elements dropped from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.dropRight([1, 2, 3]); + * // => [1, 2] + * + * _.dropRight([1, 2, 3], 2); + * // => [1] + * + * _.dropRight([1, 2, 3], 5); + * // => [] + * + * _.dropRight([1, 2, 3], 0); + * // => [1, 2, 3] + */ function dropRight(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = guard || n === undefined ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, 0, n < 0 ? 0 : n); + } + /** + * Creates a slice of `array` excluding elements dropped from the end. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.dropRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney'] + * + * // The `_.matches` iteratee shorthand. + * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropRightWhile(users, ['active', false]); + * // => objects for ['barney'] + * + * // The `_.property` iteratee shorthand. + * _.dropRightWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */ function dropRightWhile(array, predicate) { + return array && array.length + ? baseWhile( + array, + getIteratee(predicate, 3), + true, + true + ) + : []; + } + /** + * Creates a slice of `array` excluding elements dropped from the beginning. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.dropWhile(users, function(o) { return !o.active; }); + * // => objects for ['pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.dropWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropWhile(users, ['active', false]); + * // => objects for ['pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.dropWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */ function dropWhile(array, predicate) { + return array && array.length + ? baseWhile( + array, + getIteratee(predicate, 3), + true + ) + : []; + } + /** + * Fills elements of `array` with `value` from `start` up to, but not + * including, `end`. + * + * **Note:** This method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Array + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {Number} [start=0] The start position. + * @param {Number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.fill(array, 'a'); + * console.log(array); + * // => ['a', 'a', 'a'] + * + * _.fill(Array(3), 2); + * // => [2, 2, 2] + * + * _.fill([4, 6, 8, 10], '*', 1, 3); + * // => [4, '*', '*', 10] + */ function fill(array, value, start, end) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + if ( + start && + typeof start !== "number" && + isIterateeCall(array, value, start) + ) { + start = 0; + end = length; + } + return baseFill(array, value, start, end); + } + /** + * This method is like `_.find` except that it returns the index of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {Number} [fromIndex=0] The index to search from. + * @returns {Number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.findIndex(users, function(o) { return o.user == 'barney'; }); + * // => 0 + * + * // The `_.matches` iteratee shorthand. + * _.findIndex(users, { 'user': 'fred', 'active': false }); + * // => 1 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findIndex(users, ['active', false]); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.findIndex(users, 'active'); + * // => 2 + */ function findIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = + fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length + index, 0); + } + return baseFindIndex( + array, + getIteratee(predicate, 3), + index + ); + } + /** + * This method is like `_.findIndex` except that it iterates over elements + * of `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {Number} [fromIndex=array.length-1] The index to search from. + * @returns {Number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }); + * // => 2 + * + * // The `_.matches` iteratee shorthand. + * _.findLastIndex(users, { 'user': 'barney', 'active': true }); + * // => 0 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastIndex(users, ['active', false]); + * // => 2 + * + * // The `_.property` iteratee shorthand. + * _.findLastIndex(users, 'active'); + * // => 0 + */ function findLastIndex( + array, + predicate, + fromIndex + ) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = length - 1; + if (fromIndex !== undefined) { + index = toInteger(fromIndex); + index = + fromIndex < 0 + ? nativeMax(length + index, 0) + : nativeMin(index, length - 1); + } + return baseFindIndex( + array, + getIteratee(predicate, 3), + index, + true + ); + } + /** + * 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) : []; + } + /** + * Recursively flattens `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flattenDeep([1, [2, [3, [4]], 5]]); + * // => [1, 2, 3, 4, 5] + */ function flattenDeep(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, INFINITY) : []; + } + /** + * Recursively flatten `array` up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Array + * @param {Array} array The array to flatten. + * @param {Number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * var array = [1, [2, [3, [4]], 5]]; + * + * _.flattenDepth(array, 1); + * // => [1, 2, [3, [4]], 5] + * + * _.flattenDepth(array, 2); + * // => [1, 2, 3, [4], 5] + */ function flattenDepth(array, depth) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + depth = depth === undefined ? 1 : toInteger(depth); + return baseFlatten(array, depth); + } + /** + * The inverse of `_.toPairs`; this method returns an object composed + * from key-value `pairs`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} pairs The key-value pairs. + * @returns {Object} Returns the new object. + * @example + * + * _.fromPairs([['a', 1], ['b', 2]]); + * // => { 'a': 1, 'b': 2 } + */ function fromPairs(pairs) { + var index = -1, + length = pairs == null ? 0 : pairs.length, + result = {}; + while (++index < length) { + var pair = pairs[index]; + result[pair[0]] = pair[1]; + } + return result; + } + /** + * Gets the first element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias first + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the first element of `array`. + * @example + * + * _.head([1, 2, 3]); + * // => 1 + * + * _.head([]); + * // => undefined + */ function head(array) { + return array && array.length ? array[0] : undefined; + } + /** + * Gets the index at which the first occurrence of `value` is found in `array` + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. If `fromIndex` is negative, it's used as the + * offset from the end of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {Number} [fromIndex=0] The index to search from. + * @returns {Number} Returns the index of the matched value, else `-1`. + * @example + * + * _.indexOf([1, 2, 1, 2], 2); + * // => 1 + * + * // Search from the `fromIndex`. + * _.indexOf([1, 2, 1, 2], 2, 2); + * // => 3 + */ function indexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = + fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length + index, 0); + } + return baseIndexOf(array, value, index); + } + /** + * Gets all but the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.initial([1, 2, 3]); + * // => [1, 2] + */ function initial(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 0, -1) : []; + } + /** + * Creates an array of unique values that are included in all given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersection([2, 1], [2, 3]); + * // => [2] + */ var intersection = baseRest(function (arrays) { + var mapped = arrayMap(arrays, castArrayLikeObject); + return mapped.length && mapped[0] === arrays[0] + ? baseIntersection(mapped) + : []; + }); + /** + * This method is like `_.intersection` except that it accepts `iteratee` + * which is invoked for each element of each `arrays` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + * + * // The `_.property` iteratee shorthand. + * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }] + */ var intersectionBy = baseRest(function (arrays) { + var iteratee = last(arrays), + mapped = arrayMap(arrays, castArrayLikeObject); + if (iteratee === last(mapped)) { + iteratee = undefined; + } else { + mapped.pop(); + } + return mapped.length && mapped[0] === arrays[0] + ? baseIntersection( + mapped, + getIteratee(iteratee, 2) + ) + : []; + }); + /** + * This method is like `_.intersection` except that it accepts `comparator` + * which is invoked to compare elements of `arrays`. The order and references + * of result values are determined by the first array. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.intersectionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }] + */ var intersectionWith = baseRest(function (arrays) { + var comparator = last(arrays), + mapped = arrayMap(arrays, castArrayLikeObject); + comparator = + typeof comparator === "function" + ? comparator + : undefined; + if (comparator) { + mapped.pop(); + } + return mapped.length && mapped[0] === arrays[0] + ? baseIntersection( + mapped, + undefined, + comparator + ) + : []; + }); + /** + * Converts all elements in `array` into a string separated by `separator`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to convert. + * @param {String} [separator=','] The element separator. + * @returns {String} Returns the joined string. + * @example + * + * _.join(['a', 'b', 'c'], '~'); + * // => 'a~b~c' + */ function join(array, separator) { + return array == null + ? "" + : nativeJoin.call(array, separator); + } + /** + * 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; + } + /** + * This method is like `_.indexOf` except that it iterates over elements of + * `array` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {Number} [fromIndex=array.length-1] The index to search from. + * @returns {Number} Returns the index of the matched value, else `-1`. + * @example + * + * _.lastIndexOf([1, 2, 1, 2], 2); + * // => 3 + * + * // Search from the `fromIndex`. + * _.lastIndexOf([1, 2, 1, 2], 2, 2); + * // => 1 + */ function lastIndexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = length; + if (fromIndex !== undefined) { + index = toInteger(fromIndex); + index = + index < 0 + ? nativeMax(length + index, 0) + : nativeMin(index, length - 1); + } + return value === value + ? strictLastIndexOf(array, value, index) + : baseFindIndex(array, baseIsNaN, index, true); + } + /** + * Gets the element at index `n` of `array`. If `n` is negative, the nth + * element from the end is returned. + * + * @static + * @memberOf _ + * @since 4.11.0 + * @category Array + * @param {Array} array The array to query. + * @param {Number} [n=0] The index of the element to return. + * @returns {*} Returns the nth element of `array`. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * + * _.nth(array, 1); + * // => 'b' + * + * _.nth(array, -2); + * // => 'c'; + */ function nth(array, n) { + return array && array.length + ? baseNth(array, toInteger(n)) + : undefined; + } + /** + * Removes all given values from `array` using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove` + * to remove elements from an array by predicate. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...*} [values] The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pull(array, 'a', 'c'); + * console.log(array); + * // => ['b', 'b'] + */ var pull = baseRest(pullAll); + /** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pullAll(array, ['a', 'c']); + * console.log(array); + * // => ['b', 'b'] + */ function pullAll(array, values) { + return array && + array.length && + values && + values.length + ? basePullAll(array, values) + : array; + } + /** + * This method is like `_.pullAll` except that it accepts `iteratee` which is + * invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The iteratee is invoked with one argument: (value). + * + * **Note:** Unlike `_.differenceBy`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ function pullAllBy(array, values, iteratee) { + return array && + array.length && + values && + values.length + ? basePullAll( + array, + values, + getIteratee(iteratee, 2) + ) + : array; + } + /** + * This method is like `_.pullAll` except that it accepts `comparator` which + * is invoked to compare elements of `array` to `values`. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ function pullAllWith(array, values, comparator) { + return array && + array.length && + values && + values.length + ? basePullAll( + array, + values, + undefined, + comparator + ) + : array; + } + /** + * Removes elements from `array` corresponding to `indexes` and returns an + * array of removed elements. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...(number|number[])} [indexes] The indexes of elements to remove. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * var pulled = _.pullAt(array, [1, 3]); + * + * console.log(array); + * // => ['a', 'c'] + * + * console.log(pulled); + * // => ['b', 'd'] + */ var pullAt = flatRest(function (array, indexes) { + var length = array == null ? 0 : array.length, + result = baseAt(array, indexes); + basePullAt( + array, + arrayMap(indexes, function (index) { + return isIndex(index, length) + ? Number(index) + : index; + }).sort(compareAscending) + ); + return result; + }); + /** + * Removes all elements from `array` that `predicate` returns truthy for + * and returns an array of the removed elements. The predicate is invoked + * with three arguments: (value, index, array). + * + * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` + * to pull elements from an array by value. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = [1, 2, 3, 4]; + * var evens = _.remove(array, function(n) { + * return n % 2 == 0; + * }); + * + * console.log(array); + * // => [1, 3] + * + * console.log(evens); + * // => [2, 4] + */ function remove(array, predicate) { + var result = []; + if (!(array && array.length)) { + return result; + } + var index = -1, + indexes = [], + length = array.length; + predicate = getIteratee(predicate, 3); + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result.push(value); + indexes.push(index); + } + } + basePullAt(array, indexes); + return result; + } + /** + * Reverses `array` so that the first element becomes the last, the second + * element becomes the second to last, and so on. + * + * **Note:** This method mutates `array` and is based on + * [`Array#reverse`](https://mdn.io/Array/reverse). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.reverse(array); + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ function reverse(array) { + return array == null + ? array + : nativeReverse.call(array); + } + /** + * Creates a slice of `array` from `start` up to, but not including, `end`. + * + * **Note:** This method is used instead of + * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are + * returned. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @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 slice(array, start, end) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + if ( + end && + typeof end !== "number" && + isIterateeCall(array, start, end) + ) { + start = 0; + end = length; + } else { + start = start == null ? 0 : toInteger(start); + end = + end === undefined ? length : toInteger(end); + } + return baseSlice(array, start, end); + } + /** + * Uses a binary search to determine the lowest index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {Number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedIndex([30, 50], 40); + * // => 1 + */ function sortedIndex(array, value) { + return baseSortedIndex(array, value); + } + /** + * This method is like `_.sortedIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.sortedIndexBy(objects, { 'x': 4 }, 'x'); + * // => 0 + */ function sortedIndexBy(array, value, iteratee) { + return baseSortedIndexBy( + array, + value, + getIteratee(iteratee, 2) + ); + } + /** + * This method is like `_.indexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {Number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedIndexOf([4, 5, 5, 5, 6], 5); + * // => 1 + */ function sortedIndexOf(array, value) { + var length = array == null ? 0 : array.length; + if (length) { + var index = baseSortedIndex(array, value); + if (index < length && eq(array[index], value)) { + return index; + } + } + return -1; + } + /** + * This method is like `_.sortedIndex` except that it returns the highest + * index at which `value` should be inserted into `array` in order to + * maintain its sort order. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {Number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedLastIndex([4, 5, 5, 5, 6], 5); + * // => 4 + */ function sortedLastIndex(array, value) { + return baseSortedIndex(array, value, true); + } + /** + * This method is like `_.sortedLastIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 1 + * + * // The `_.property` iteratee shorthand. + * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x'); + * // => 1 + */ function sortedLastIndexBy(array, value, iteratee) { + return baseSortedIndexBy( + array, + value, + getIteratee(iteratee, 2), + true + ); + } + /** + * This method is like `_.lastIndexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {Number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5); + * // => 3 + */ function sortedLastIndexOf(array, value) { + var length = array == null ? 0 : array.length; + if (length) { + var index = + baseSortedIndex(array, value, true) - 1; + if (eq(array[index], value)) { + return index; + } + } + return -1; + } + /** + * This method is like `_.uniq` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniq([1, 1, 2]); + * // => [1, 2] + */ function sortedUniq(array) { + return array && array.length + ? baseSortedUniq(array) + : []; + } + /** + * This method is like `_.uniqBy` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); + * // => [1.1, 2.3] + */ function sortedUniqBy(array, iteratee) { + return array && array.length + ? baseSortedUniq( + array, + getIteratee(iteratee, 2) + ) + : []; + } + /** + * Gets all but the first element of `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.tail([1, 2, 3]); + * // => [2, 3] + */ function tail(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 1, length) : []; + } + /** + * Creates a slice of `array` with `n` elements taken from the beginning. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @param {Number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.take([1, 2, 3]); + * // => [1] + * + * _.take([1, 2, 3], 2); + * // => [1, 2] + * + * _.take([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.take([1, 2, 3], 0); + * // => [] + */ function take(array, n, guard) { + if (!(array && array.length)) { + return []; + } + n = guard || n === undefined ? 1 : toInteger(n); + return baseSlice(array, 0, n < 0 ? 0 : n); + } + /** + * Creates a slice of `array` with `n` elements taken from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.takeRight([1, 2, 3]); + * // => [3] + * + * _.takeRight([1, 2, 3], 2); + * // => [2, 3] + * + * _.takeRight([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.takeRight([1, 2, 3], 0); + * // => [] + */ function takeRight(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = guard || n === undefined ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, n < 0 ? 0 : n, length); + } + /** + * Creates a slice of `array` with elements taken from the end. Elements are + * taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.takeRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeRightWhile(users, ['active', false]); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.takeRightWhile(users, 'active'); + * // => [] + */ function takeRightWhile(array, predicate) { + return array && array.length + ? baseWhile( + array, + getIteratee(predicate, 3), + false, + true + ) + : []; + } + /** + * Creates a slice of `array` with elements taken from the beginning. Elements + * are taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.takeWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matches` iteratee shorthand. + * _.takeWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeWhile(users, ['active', false]); + * // => objects for ['barney', 'fred'] + * + * // The `_.property` iteratee shorthand. + * _.takeWhile(users, 'active'); + * // => [] + */ function takeWhile(array, predicate) { + return array && array.length + ? baseWhile(array, getIteratee(predicate, 3)) + : []; + } + /** + * Creates an array of unique values, in order, from all given arrays using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.union([2], [1, 2]); + * // => [2, 1] + */ var union = baseRest(function (arrays) { + return baseUniq( + baseFlatten(arrays, 1, isArrayLikeObject, true) + ); + }); + /** + * This method is like `_.union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which uniqueness is computed. Result values are chosen from the first + * array in which the value occurs. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ var unionBy = baseRest(function (arrays) { + var iteratee = last(arrays); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return baseUniq( + baseFlatten(arrays, 1, isArrayLikeObject, true), + getIteratee(iteratee, 2) + ); + }); + /** + * This method is like `_.union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. Result values are chosen from + * the first array in which the value occurs. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.unionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ var unionWith = baseRest(function (arrays) { + var comparator = last(arrays); + comparator = + typeof comparator === "function" + ? comparator + : undefined; + return baseUniq( + baseFlatten(arrays, 1, isArrayLikeObject, true), + undefined, + comparator + ); + }); + /** + * Creates a duplicate-free version of an array, using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons, in which only the first occurrence of each element + * is kept. The order of result values is determined by the order they occur + * in the array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniq([2, 1, 2]); + * // => [2, 1] + */ function uniq(array) { + return array && array.length ? baseUniq(array) : []; + } + /** + * This method is like `_.uniq` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * uniqueness is computed. The order of result values is determined by the + * order they occur in the array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ function uniqBy(array, iteratee) { + return array && array.length + ? baseUniq(array, getIteratee(iteratee, 2)) + : []; + } + /** + * This method is like `_.uniq` except that it accepts `comparator` which + * is invoked to compare elements of `array`. The order of result values is + * determined by the order they occur in the array.The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.uniqWith(objects, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] + */ function uniqWith(array, comparator) { + comparator = + typeof comparator === "function" + ? comparator + : undefined; + return array && array.length + ? baseUniq(array, undefined, comparator) + : []; + } + /** + * This method is like `_.zip` except that it accepts an array of grouped + * elements and creates an array regrouping the elements to their pre-zip + * configuration. + * + * @static + * @memberOf _ + * @since 1.2.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + * + * _.unzip(zipped); + * // => [['a', 'b'], [1, 2], [true, false]] + */ function unzip(array) { + if (!(array && array.length)) { + return []; + } + var length = 0; + array = arrayFilter(array, function (group) { + if (isArrayLikeObject(group)) { + length = nativeMax(group.length, length); + return true; + } + }); + return baseTimes(length, function (index) { + return arrayMap(array, baseProperty(index)); + }); + } + /** + * This method is like `_.unzip` except that it accepts `iteratee` to specify + * how regrouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @param {Function} [iteratee=_.identity] The function to combine + * regrouped values. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip([1, 2], [10, 20], [100, 200]); + * // => [[1, 10, 100], [2, 20, 200]] + * + * _.unzipWith(zipped, _.add); + * // => [3, 30, 300] + */ function unzipWith(array, iteratee) { + if (!(array && array.length)) { + return []; + } + var result = unzip(array); + if (iteratee == null) { + return result; + } + return arrayMap(result, function (group) { + return apply(iteratee, undefined, group); + }); + } + /** + * Creates an array excluding all given values using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.pull`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...*} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.xor + * @example + * + * _.without([2, 1, 2, 3], 1, 2); + * // => [3] + */ var without = baseRest(function (array, values) { + return isArrayLikeObject(array) + ? baseDifference(array, values) + : []; + }); + /** + * Creates an array of unique values that is the + * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) + * of the given arrays. The order of result values is determined by the order + * they occur in the arrays. + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.without + * @example + * + * _.xor([2, 1], [2, 3]); + * // => [1, 3] + */ var xor = baseRest(function (arrays) { + return baseXor( + arrayFilter(arrays, isArrayLikeObject) + ); + }); + /** + * This method is like `_.xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which by which they're compared. The order of result values is determined + * by the order they occur in the arrays. The iteratee is invoked with one + * argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2, 3.4] + * + * // The `_.property` iteratee shorthand. + * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ var xorBy = baseRest(function (arrays) { + var iteratee = last(arrays); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return baseXor( + arrayFilter(arrays, isArrayLikeObject), + getIteratee(iteratee, 2) + ); + }); + /** + * This method is like `_.xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The order of result values is + * determined by the order they occur in the arrays. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.xorWith(objects, others, _.isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ var xorWith = baseRest(function (arrays) { + var comparator = last(arrays); + comparator = + typeof comparator === "function" + ? comparator + : undefined; + return baseXor( + arrayFilter(arrays, isArrayLikeObject), + undefined, + comparator + ); + }); + /** + * Creates an array of grouped elements, the first of which contains the + * first elements of the given arrays, the second of which contains the + * second elements of the given arrays, and so on. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + */ var zip = baseRest(unzip); + /** + * This method is like `_.fromPairs` except that it accepts two arrays, + * one of property identifiers and one of corresponding values. + * + * @static + * @memberOf _ + * @since 0.4.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObject(['a', 'b'], [1, 2]); + * // => { 'a': 1, 'b': 2 } + */ function zipObject(props, values) { + return baseZipObject( + props || [], + values || [], + assignValue + ); + } + /** + * This method is like `_.zipObject` except that it supports property paths. + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); + * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } + */ function zipObjectDeep(props, values) { + return baseZipObject( + props || [], + values || [], + baseSet + ); + } + /** + * This method is like `_.zip` except that it accepts `iteratee` to specify + * how grouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @param {Function} [iteratee=_.identity] The function to combine + * grouped values. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { + * return a + b + c; + * }); + * // => [111, 222] + */ var zipWith = baseRest(function (arrays) { + var length = arrays.length, + iteratee = + length > 1 ? arrays[length - 1] : undefined; + iteratee = + typeof iteratee === "function" + ? (arrays.pop(), iteratee) + : undefined; + return unzipWith(arrays, iteratee); + }); + /* ------------------------------------------------------------------------*/ /** + * Creates a `lodash` wrapper instance that wraps `value` with explicit method + * chain sequences enabled. The result of such sequences must be unwrapped + * with `_#value`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Seq + * @param {*} value The value to wrap. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'pebbles', 'age': 1 } + * ]; + * + * var youngest = _ + * .chain(users) + * .sortBy('age') + * .map(function(o) { + * return o.user + ' is ' + o.age; + * }) + * .head() + * .value(); + * // => 'pebbles is 1' + */ function chain(value) { + var result = lodash(value); + result.__chain__ = true; + return result; + } + /** + * This method invokes `interceptor` and returns `value`. The interceptor + * is invoked with one argument; (value). The purpose of this method is to + * "tap into" a method chain sequence in order to modify intermediate results. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns `value`. + * @example + * + * _([1, 2, 3]) + * .tap(function(array) { + * // Mutate input array. + * array.pop(); + * }) + * .reverse() + * .value(); + * // => [2, 1] + */ function tap(value, interceptor) { + interceptor(value); + return value; + } + /** + * This method is like `_.tap` except that it returns the result of `interceptor`. + * The purpose of this method is to "pass thru" values replacing intermediate + * results in a method chain sequence. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns the result of `interceptor`. + * @example + * + * _(' abc ') + * .chain() + * .trim() + * .thru(function(value) { + * return [value]; + * }) + * .value(); + * // => ['abc'] + */ function thru(value, interceptor) { + return interceptor(value); + } + /** + * This method is the wrapper version of `_.at`. + * + * @name at + * @memberOf _ + * @since 1.0.0 + * @category Seq + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _(object).at(['a[0].b.c', 'a[1]']).value(); + * // => [3, 4] + */ var wrapperAt = flatRest(function (paths) { + var length = paths.length, + start = length ? paths[0] : 0, + value = this.__wrapped__, + interceptor = function interceptor(object) { + return baseAt(object, paths); + }; + if ( + length > 1 || + this.__actions__.length || + !(value instanceof LazyWrapper) || + !isIndex(start) + ) { + return this.thru(interceptor); + } + value = value.slice( + start, + Number(start) + (length ? 1 : 0) + ); + value.__actions__.push({ + func: thru, + args: [interceptor], + thisArg: undefined, + }); + return new LodashWrapper( + value, + this.__chain__ + ).thru(function (array) { + if (length && !array.length) { + array.push(undefined); + } + return array; + }); + }); + /** + * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. + * + * @name chain + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * // A sequence without explicit chaining. + * _(users).head(); + * // => { 'user': 'barney', 'age': 36 } + * + * // A sequence with explicit chaining. + * _(users) + * .chain() + * .head() + * .pick('user') + * .value(); + * // => { 'user': 'barney' } + */ function wrapperChain() { + return chain(this); + } + /** + * Executes the chain sequence and returns the wrapped result. + * + * @name commit + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2]; + * var wrapped = _(array).push(3); + * + * console.log(array); + * // => [1, 2] + * + * wrapped = wrapped.commit(); + * console.log(array); + * // => [1, 2, 3] + * + * wrapped.last(); + * // => 3 + * + * console.log(array); + * // => [1, 2, 3] + */ function wrapperCommit() { + return new LodashWrapper( + this.value(), + this.__chain__ + ); + } + /** + * Gets the next value on a wrapped object following the + * [iterator protocol](https://mdn.io/iteration_protocols#iterator). + * + * @name next + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the next iterator value. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped.next(); + * // => { 'done': false, 'value': 1 } + * + * wrapped.next(); + * // => { 'done': false, 'value': 2 } + * + * wrapped.next(); + * // => { 'done': true, 'value': undefined } + */ function wrapperNext() { + if (this.__values__ === undefined) { + this.__values__ = toArray(this.value()); + } + var done = this.__index__ >= this.__values__.length, + value = done + ? undefined + : this.__values__[this.__index__++]; + return {done: done, value: value}; + } + /** + * Enables the wrapper to be iterable. + * + * @name Symbol.iterator + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the wrapper object. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped[Symbol.iterator]() === wrapped; + * // => true + * + * Array.from(wrapped); + * // => [1, 2] + */ function wrapperToIterator() { + return this; + } + /** + * Creates a clone of the chain sequence planting `value` as the wrapped value. + * + * @name plant + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @param {*} value The value to plant. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2]).map(square); + * var other = wrapped.plant([3, 4]); + * + * other.value(); + * // => [9, 16] + * + * wrapped.value(); + * // => [1, 4] + */ function wrapperPlant(value) { + var result, + parent = this; + while (parent instanceof baseLodash) { + var clone = wrapperClone(parent); + clone.__index__ = 0; + clone.__values__ = undefined; + if (result) { + previous.__wrapped__ = clone; + } else { + result = clone; + } + var previous = clone; + parent = parent.__wrapped__; + } + previous.__wrapped__ = value; + return result; + } + /** + * This method is the wrapper version of `_.reverse`. + * + * **Note:** This method mutates the wrapped array. + * + * @name reverse + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2, 3]; + * + * _(array).reverse().value() + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ function wrapperReverse() { + var value = this.__wrapped__; + if (value instanceof LazyWrapper) { + var wrapped = value; + if (this.__actions__.length) { + wrapped = new LazyWrapper(this); + } + wrapped = wrapped.reverse(); + wrapped.__actions__.push({ + func: thru, + args: [reverse], + thisArg: undefined, + }); + return new LodashWrapper( + wrapped, + this.__chain__ + ); + } + return this.thru(reverse); + } + /** + * Executes the chain sequence to resolve the unwrapped value. + * + * @name value + * @memberOf _ + * @since 0.1.0 + * @alias toJSON, valueOf + * @category Seq + * @returns {*} Returns the resolved unwrapped value. + * @example + * + * _([1, 2, 3]).value(); + * // => [1, 2, 3] + */ function wrapperValue() { + return baseWrapperValue( + this.__wrapped__, + this.__actions__ + ); + } + /* ------------------------------------------------------------------------*/ /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the number of times the key was returned by `iteratee`. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.countBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': 1, '6': 2 } + * + * // The `_.property` iteratee shorthand. + * _.countBy(['one', 'two', 'three'], 'length'); + * // => { '3': 2, '5': 1 } + */ var countBy = createAggregator(function ( + result, + value, + key + ) { + if (hasOwnProperty.call(result, key)) { + ++result[key]; + } else { + baseAssignValue(result, key, 1); + } + }); + /** + * Checks if `predicate` returns truthy for **all** elements of `collection`. + * Iteration is stopped once `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * **Note:** This method returns `true` for + * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because + * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of + * elements of empty collections. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + * @example + * + * _.every([true, 1, null, 'yes'], Boolean); + * // => false + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.every(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.every(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.every(users, 'active'); + * // => false + */ function every(collection, predicate, guard) { + var func = isArray(collection) + ? arrayEvery + : baseEvery; + if ( + guard && + isIterateeCall(collection, predicate, guard) + ) { + predicate = undefined; + } + return func(collection, getIteratee(predicate, 3)); + } + /** + * Iterates over elements of `collection`, returning an array of all elements + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * **Note:** Unlike `_.remove`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.reject + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * _.filter(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.filter(users, { 'age': 36, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.filter(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.filter(users, 'active'); + * // => objects for ['barney'] + */ function filter(collection, predicate) { + var func = isArray(collection) + ? arrayFilter + : baseFilter; + return func(collection, getIteratee(predicate, 3)); + } + /** + * Iterates over elements of `collection`, returning the first element + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false }, + * { 'user': 'pebbles', 'age': 1, 'active': true } + * ]; + * + * _.find(users, function(o) { return o.age < 40; }); + * // => object for 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.find(users, { 'age': 1, 'active': true }); + * // => object for 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.find(users, ['active', false]); + * // => object for 'fred' + * + * // The `_.property` iteratee shorthand. + * _.find(users, 'active'); + * // => object for 'barney' + */ var find = createFind(findIndex); + /** + * This method is like `_.find` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=collection.length-1] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * _.findLast([1, 2, 3, 4], function(n) { + * return n % 2 == 1; + * }); + * // => 3 + */ var findLast = createFind(findLastIndex); + /** + * Creates a flattened array of values by running each element in `collection` + * thru `iteratee` and flattening the mapped results. The iteratee is invoked + * with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [n, n]; + * } + * + * _.flatMap([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ function flatMap(collection, iteratee) { + return baseFlatten(map(collection, iteratee), 1); + } + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDeep([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ function flatMapDeep(collection, iteratee) { + return baseFlatten( + map(collection, iteratee), + INFINITY + ); + } + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {Number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDepth([1, 2], duplicate, 2); + * // => [[1, 1], [2, 2]] + */ function flatMapDepth(collection, iteratee, depth) { + depth = depth === undefined ? 1 : toInteger(depth); + return baseFlatten( + map(collection, iteratee), + depth + ); + } + /** + * Iterates over elements of `collection` and invokes `iteratee` for each element. + * The iteratee is invoked with three arguments: (value, index|key, collection). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * **Note:** As with other "Collections" methods, objects with a "length" + * property are iterated like arrays. To avoid this behavior use `_.forIn` + * or `_.forOwn` for object iteration. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias each + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEachRight + * @example + * + * _.forEach([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `1` then `2`. + * + * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ function forEach(collection, iteratee) { + var func = isArray(collection) + ? arrayEach + : baseEach; + return func(collection, getIteratee(iteratee, 3)); + } + /** + * This method is like `_.forEach` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @alias eachRight + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEach + * @example + * + * _.forEachRight([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `2` then `1`. + */ function forEachRight(collection, iteratee) { + var func = isArray(collection) + ? arrayEachRight + : baseEachRight; + return func(collection, getIteratee(iteratee, 3)); + } + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The order of grouped values + * is determined by the order they occur in `collection`. The corresponding + * value of each key is an array of elements responsible for generating the + * key. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.groupBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': [4.2], '6': [6.1, 6.3] } + * + * // The `_.property` iteratee shorthand. + * _.groupBy(['one', 'two', 'three'], 'length'); + * // => { '3': ['one', 'two'], '5': ['three'] } + */ var groupBy = createAggregator(function ( + result, + value, + key + ) { + if (hasOwnProperty.call(result, key)) { + result[key].push(value); + } else { + baseAssignValue(result, key, [value]); + } + }); + /** + * Checks if `value` is in `collection`. If `collection` is a string, it's + * checked for a substring of `value`, otherwise + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * is used for equality comparisons. If `fromIndex` is negative, it's used as + * the offset from the end of `collection`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|String} collection The collection to inspect. + * @param {*} value The value to search for. + * @param {Number} [fromIndex=0] The index to search from. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {Boolean} Returns `true` if `value` is found, else `false`. + * @example + * + * _.includes([1, 2, 3], 1); + * // => true + * + * _.includes([1, 2, 3], 1, 2); + * // => false + * + * _.includes({ 'a': 1, 'b': 2 }, 1); + * // => true + * + * _.includes('abcd', 'bc'); + * // => true + */ function includes( + collection, + value, + fromIndex, + guard + ) { + collection = isArrayLike(collection) + ? collection + : values(collection); + fromIndex = + fromIndex && !guard ? toInteger(fromIndex) : 0; + var length = collection.length; + if (fromIndex < 0) { + fromIndex = nativeMax(length + fromIndex, 0); + } + return isString(collection) + ? fromIndex <= length && + collection.indexOf(value, fromIndex) > -1 + : Boolean(length) && + baseIndexOf( + collection, + value, + fromIndex + ) > -1; + } + /** + * Invokes the method at `path` of each element in `collection`, returning + * an array of the results of each invoked method. Any additional arguments + * are provided to each invoked method. If `path` is a function, it's invoked + * for, and `this` bound to, each element in `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array|Function|string} path The path of the method to invoke or + * the function invoked per iteration. + * @param {...*} [args] The arguments to invoke each method with. + * @returns {Array} Returns the array of results. + * @example + * + * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); + * // => [[1, 5, 7], [1, 2, 3]] + * + * _.invokeMap([123, 456], String.prototype.split, ''); + * // => [['1', '2', '3'], ['4', '5', '6']] + */ var invokeMap = baseRest(function ( + collection, + path, + args + ) { + var index = -1, + isFunc = typeof path === "function", + result = isArrayLike(collection) + ? Array(collection.length) + : []; + baseEach(collection, function (value) { + result[++index] = isFunc + ? apply(path, value, args) + : baseInvoke(value, path, args); + }); + return result; + }); + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the last element responsible for generating the key. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * var array = [ + * { 'dir': 'left', 'code': 97 }, + * { 'dir': 'right', 'code': 100 } + * ]; + * + * _.keyBy(array, function(o) { + * return String.fromCharCode(o.code); + * }); + * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } + * + * _.keyBy(array, 'dir'); + * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } + */ var keyBy = createAggregator(function ( + result, + value, + key + ) { + baseAssignValue(result, key, value); + }); + /** + * Creates an array of values by running each element in `collection` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. + * + * The guarded methods are: + * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, + * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, + * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, + * `template`, `trim`, `trimEnd`, `trimStart`, and `words` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + * @example + * + * function square(n) { + * return n * n; + * } + * + * _.map([4, 8], square); + * // => [16, 64] + * + * _.map({ 'a': 4, 'b': 8 }, square); + * // => [16, 64] (iteration order is not guaranteed) + * + * var users = [ + * { 'user': 'barney' }, + * { 'user': 'fred' } + * ]; + * + * // The `_.property` iteratee shorthand. + * _.map(users, 'user'); + * // => ['barney', 'fred'] + */ function map(collection, iteratee) { + var func = isArray(collection) ? arrayMap : baseMap; + return func(collection, getIteratee(iteratee, 3)); + } + /** + * This method is like `_.sortBy` except that it allows specifying the sort + * orders of the iteratees to sort by. If `orders` is unspecified, all values + * are sorted in ascending order. Otherwise, specify an order of "desc" for + * descending or "asc" for ascending sort order of corresponding values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] + * The iteratees to sort by. + * @param {string[]} [orders] The sort orders of `iteratees`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 34 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'barney', 'age': 36 } + * ]; + * + * // Sort by `user` in ascending order and by `age` in descending order. + * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] + */ function orderBy( + collection, + iteratees, + orders, + guard + ) { + if (collection == null) { + return []; + } + if (!isArray(iteratees)) { + iteratees = + iteratees == null ? [] : [iteratees]; + } + orders = guard ? undefined : orders; + if (!isArray(orders)) { + orders = orders == null ? [] : [orders]; + } + return baseOrderBy(collection, iteratees, orders); + } + /** + * Creates an array of elements split into two groups, the first of which + * contains elements `predicate` returns truthy for, the second of which + * contains elements `predicate` returns falsey for. The predicate is + * invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the array of grouped elements. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true }, + * { 'user': 'pebbles', 'age': 1, 'active': false } + * ]; + * + * _.partition(users, function(o) { return o.active; }); + * // => objects for [['fred'], ['barney', 'pebbles']] + * + * // The `_.matches` iteratee shorthand. + * _.partition(users, { 'age': 1, 'active': false }); + * // => objects for [['pebbles'], ['barney', 'fred']] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.partition(users, ['active', false]); + * // => objects for [['barney', 'pebbles'], ['fred']] + * + * // The `_.property` iteratee shorthand. + * _.partition(users, 'active'); + * // => objects for [['fred'], ['barney', 'pebbles']] + */ var partition = createAggregator( + function (result, value, key) { + result[key ? 0 : 1].push(value); + }, + function () { + return [[], []]; + } + ); + /** + * Reduces `collection` to a value which is the accumulated result of running + * each element in `collection` thru `iteratee`, where each successive + * invocation is supplied the return value of the previous. If `accumulator` + * is not given, the first element of `collection` is used as the initial + * value. The iteratee is invoked with four arguments: + * (accumulator, value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.reduce`, `_.reduceRight`, and `_.transform`. + * + * The guarded methods are: + * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, + * and `sortBy` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduceRight + * @example + * + * _.reduce([1, 2], function(sum, n) { + * return sum + n; + * }, 0); + * // => 3 + * + * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * return result; + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) + */ function reduce(collection, iteratee, accumulator) { + var func = isArray(collection) + ? arrayReduce + : baseReduce, + initAccum = arguments.length < 3; + return func( + collection, + getIteratee(iteratee, 4), + accumulator, + initAccum, + baseEach + ); + } + /** + * This method is like `_.reduce` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduce + * @example + * + * var array = [[0, 1], [2, 3], [4, 5]]; + * + * _.reduceRight(array, function(flattened, other) { + * return flattened.concat(other); + * }, []); + * // => [4, 5, 2, 3, 0, 1] + */ function reduceRight( + collection, + iteratee, + accumulator + ) { + var func = isArray(collection) + ? arrayReduceRight + : baseReduce, + initAccum = arguments.length < 3; + return func( + collection, + getIteratee(iteratee, 4), + accumulator, + initAccum, + baseEachRight + ); + } + /** + * The opposite of `_.filter`; this method returns the elements of `collection` + * that `predicate` does **not** return truthy for. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.filter + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true } + * ]; + * + * _.reject(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.reject(users, { 'age': 40, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.reject(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.reject(users, 'active'); + * // => objects for ['barney'] + */ function reject(collection, predicate) { + var func = isArray(collection) + ? arrayFilter + : baseFilter; + return func( + collection, + negate(getIteratee(predicate, 3)) + ); + } + /** + * Gets a random element from `collection`. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + * @example + * + * _.sample([1, 2, 3, 4]); + * // => 2 + */ function sample(collection) { + var func = isArray(collection) + ? arraySample + : baseSample; + return func(collection); + } + /** + * Gets `n` random elements at unique keys from `collection` up to the + * size of `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @param {Number} [n=1] The number of elements to sample. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the random elements. + * @example + * + * _.sampleSize([1, 2, 3], 2); + * // => [3, 1] + * + * _.sampleSize([1, 2, 3], 4); + * // => [2, 3, 1] + */ function sampleSize(collection, n, guard) { + if ( + guard + ? isIterateeCall(collection, n, guard) + : n === undefined + ) { + n = 1; + } else { + n = toInteger(n); + } + var func = isArray(collection) + ? arraySampleSize + : baseSampleSize; + return func(collection, n); + } + /** + * Creates an array of shuffled values, using a version of the + * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + * @example + * + * _.shuffle([1, 2, 3, 4]); + * // => [4, 1, 3, 2] + */ function shuffle(collection) { + var func = isArray(collection) + ? arrayShuffle + : baseShuffle; + return func(collection); + } + /** + * Gets the size of `collection` by returning its length for array-like + * values or the number of own enumerable string keyed properties for objects. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|String} collection The collection to inspect. + * @returns {Number} Returns the collection size. + * @example + * + * _.size([1, 2, 3]); + * // => 3 + * + * _.size({ 'a': 1, 'b': 2 }); + * // => 2 + * + * _.size('pebbles'); + * // => 7 + */ function size(collection) { + if (collection == null) { + return 0; + } + if (isArrayLike(collection)) { + return isString(collection) + ? stringSize(collection) + : collection.length; + } + var tag = getTag(collection); + if (tag == mapTag || tag == setTag) { + return collection.size; + } + return baseKeys(collection).length; + } + /** + * Checks if `predicate` returns truthy for **any** element of `collection`. + * Iteration is stopped once `predicate` returns truthy. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Boolean} Returns `true` if any element passes the predicate check, + * else `false`. + * @example + * + * _.some([null, 0, 'yes', false], Boolean); + * // => true + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.some(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.some(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.some(users, 'active'); + * // => true + */ function some(collection, predicate, guard) { + var func = isArray(collection) + ? arraySome + : baseSome; + if ( + guard && + isIterateeCall(collection, predicate, guard) + ) { + predicate = undefined; + } + return func(collection, getIteratee(predicate, 3)); + } + /** + * Creates an array of elements, sorted in ascending order by the results of + * running each element in a collection thru each iteratee. This method + * performs a stable sort, that is, it preserves the original sort order of + * equal elements. The iteratees are invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {...(Function|Function[])} [iteratees=[_.identity]] + * The iteratees to sort by. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'barney', 'age': 34 } + * ]; + * + * _.sortBy(users, [function(o) { return o.user; }]); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] + * + * _.sortBy(users, ['user', 'age']); + * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]] + */ var sortBy = baseRest(function ( + collection, + iteratees + ) { + if (collection == null) { + return []; + } + var length = iteratees.length; + if ( + length > 1 && + isIterateeCall( + collection, + iteratees[0], + iteratees[1] + ) + ) { + iteratees = []; + } else if ( + length > 2 && + isIterateeCall( + iteratees[0], + iteratees[1], + iteratees[2] + ) + ) { + iteratees = [iteratees[0]]; + } + return baseOrderBy( + collection, + baseFlatten(iteratees, 1), + [] + ); + }); + /* ------------------------------------------------------------------------*/ /** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {Number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ var now = + ctxNow || + function () { + return root.Date.now(); + }; + /* ------------------------------------------------------------------------*/ /** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Number} n The number of calls before `func` is invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var saves = ['profile', 'settings']; + * + * var done = _.after(saves.length, function() { + * console.log('done saving!'); + * }); + * + * _.forEach(saves, function(type) { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */ function after(n, func) { + if (typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function () { + if (--n < 1) { + return func.apply(this, arguments); + } + }; + } + /** + * Creates a function that invokes `func`, with up to `n` arguments, + * ignoring any additional arguments. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @param {Number} [n=func.length] The arity cap. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.ary(parseInt, 1)); + * // => [6, 8, 10] + */ function ary(func, n, guard) { + n = guard ? undefined : n; + n = func && n == null ? func.length : n; + return createWrap( + func, + WRAP_ARY_FLAG, + undefined, + undefined, + undefined, + undefined, + n + ); + } + /** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Number} n The number of calls at which `func` is no longer invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * jQuery(element).on('click', _.before(5, addContactToList)); + * // => Allows adding up to 4 contacts to the list. + */ function before(n, func) { + var result; + if (typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function () { + if (--n > 0) { + result = func.apply(this, arguments); + } + if (n <= 1) { + func = undefined; + } + return result; + }; + } + /** + * Creates a function that invokes `func` with the `this` binding of `thisArg` + * and `partials` prepended to the arguments it receives. + * + * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for partially applied arguments. + * + * **Note:** Unlike native `Function#bind`, this method doesn't set the "length" + * property of bound functions. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to bind. + * @param {*} thisArg The `this` binding of `func`. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * + * var object = { 'user': 'fred' }; + * + * var bound = _.bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * // Bound with placeholders. + * var bound = _.bind(greet, object, _, '!'); + * bound('hi'); + * // => 'hi fred!' + */ var bind = baseRest(function ( + func, + thisArg, + partials + ) { + var bitmask = WRAP_BIND_FLAG; + if (partials.length) { + var holders = replaceHolders( + partials, + getHolder(bind) + ); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap( + func, + bitmask, + thisArg, + partials, + holders + ); + }); + /** + * Creates a function that invokes the method at `object[key]` with `partials` + * prepended to the arguments it receives. + * + * This method differs from `_.bind` by allowing bound functions to reference + * methods that may be redefined or don't yet exist. See + * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) + * for more details. + * + * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Function + * @param {Object} object The object to invoke the method on. + * @param {string} key The key of the method. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * var object = { + * 'user': 'fred', + * 'greet': function(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * }; + * + * var bound = _.bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function(greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * var bound = _.bindKey(object, 'greet', _, '!'); + * bound('hi'); + * // => 'hiya fred!' + */ var bindKey = baseRest(function ( + object, + key, + partials + ) { + var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG; + if (partials.length) { + var holders = replaceHolders( + partials, + getHolder(bindKey) + ); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap( + key, + bitmask, + object, + partials, + holders + ); + }); + /** + * Creates a function that accepts arguments of `func` and either invokes + * `func` returning its result, if at least `arity` number of arguments have + * been provided, or returns a function that accepts the remaining `func` + * arguments, and so on. The arity of `func` may be specified if `func.length` + * is not sufficient. + * + * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {Number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curry(abc); + * + * curried(1)(2)(3); + * // => [1, 2, 3] + * + * curried(1, 2)(3); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(1)(_, 3)(2); + * // => [1, 2, 3] + */ function curry(func, arity, guard) { + arity = guard ? undefined : arity; + var result = createWrap( + func, + WRAP_CURRY_FLAG, + undefined, + undefined, + undefined, + undefined, + undefined, + arity + ); + result.placeholder = curry.placeholder; + return result; + } + /** + * This method is like `_.curry` except that arguments are applied to `func` + * in the manner of `_.partialRight` instead of `_.partial`. + * + * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {Number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curryRight(abc); + * + * curried(3)(2)(1); + * // => [1, 2, 3] + * + * curried(2, 3)(1); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(3)(1, _)(2); + * // => [1, 2, 3] + */ function curryRight(func, arity, guard) { + arity = guard ? undefined : arity; + var result = createWrap( + func, + WRAP_CURRY_RIGHT_FLAG, + undefined, + undefined, + undefined, + undefined, + undefined, + arity + ); + result.placeholder = curryRight.placeholder; + return result; + } + /** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {Number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {Boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {Number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {Boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + if (typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = Boolean(options.leading); + maxing = "maxWait" in options; + maxWait = maxing + ? nativeMax( + toNumber(options.maxWait) || 0, + wait + ) + : maxWait; + trailing = + "trailing" in options + ? Boolean(options.trailing) + : trailing; + } + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + timeWaiting = wait - timeSinceLastCall; + return maxing + ? nativeMin( + timeWaiting, + maxWait - timeSinceLastInvoke + ) + : timeWaiting; + } + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return ( + lastCallTime === undefined || + timeSinceLastCall >= wait || + timeSinceLastCall < 0 || + (maxing && timeSinceLastInvoke >= maxWait) + ); + } + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } // Restart the timer. + timerId = setTimeout( + timerExpired, + remainingWait(time) + ); + } + function trailingEdge(time) { + timerId = undefined; // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + function flush() { + return timerId === undefined + ? result + : trailingEdge(now()); + } + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + clearTimeout(timerId); + timerId = setTimeout( + timerExpired, + wait + ); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } + /** + * Defers invoking the `func` until the current call stack has cleared. Any + * additional arguments are provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to defer. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.defer(function(text) { + * console.log(text); + * }, 'deferred'); + * // => Logs 'deferred' after one millisecond. + */ var defer = baseRest(function (func, args) { + return baseDelay(func, 1, args); + }); + /** + * Invokes `func` after `wait` milliseconds. Any additional arguments are + * provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.delay(function(text) { + * console.log(text); + * }, 1000, 'later'); + * // => Logs 'later' after one second. + */ var delay = baseRest(function (func, wait, args) { + return baseDelay(func, toNumber(wait) || 0, args); + }); + /** + * Creates a function that invokes `func` with arguments reversed. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to flip arguments for. + * @returns {Function} Returns the new flipped function. + * @example + * + * var flipped = _.flip(function() { + * return _.toArray(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ function flip(func) { + return createWrap(func, WRAP_FLIP_FLAG); + } + /** + * 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 memoized() { + 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; + /** + * Creates a function that negates the result of the predicate `func`. The + * `func` predicate is invoked with the `this` binding and arguments of the + * created function. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} predicate The predicate to negate. + * @returns {Function} Returns the new negated function. + * @example + * + * function isEven(n) { + * return n % 2 == 0; + * } + * + * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); + * // => [1, 3, 5] + */ function negate(predicate) { + if (typeof predicate !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + return function () { + var args = arguments; + switch (args.length) { + case 0: + return !predicate.call(this); + case 1: + return !predicate.call(this, args[0]); + case 2: + return !predicate.call( + this, + args[0], + args[1] + ); + case 3: + return !predicate.call( + this, + args[0], + args[1], + args[2] + ); + } + return !predicate.apply(this, args); + }; + } + /** + * Creates a function that is restricted to invoking `func` once. Repeat calls + * to the function return the value of the first invocation. The `func` is + * invoked with the `this` binding and arguments of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var initialize = _.once(createApplication); + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ function once(func) { + return before(2, func); + } + /** + * Creates a function that invokes `func` with its arguments transformed. + * + * @static + * @since 4.0.0 + * @memberOf _ + * @category Function + * @param {Function} func The function to wrap. + * @param {...(Function|Function[])} [transforms=[_.identity]] + * The argument transforms. + * @returns {Function} Returns the new function. + * @example + * + * function doubled(n) { + * return n * 2; + * } + * + * function square(n) { + * return n * n; + * } + * + * var func = _.overArgs(function(x, y) { + * return [x, y]; + * }, [square, doubled]); + * + * func(9, 3); + * // => [81, 6] + * + * func(10, 5); + * // => [100, 10] + */ var overArgs = castRest(function ( + func, + transforms + ) { + transforms = + transforms.length == 1 && isArray(transforms[0]) + ? arrayMap( + transforms[0], + baseUnary(getIteratee()) + ) + : arrayMap( + baseFlatten(transforms, 1), + baseUnary(getIteratee()) + ); + var funcsLength = transforms.length; + return baseRest(function (args) { + var index = -1, + length = nativeMin( + args.length, + funcsLength + ); + while (++index < length) { + args[index] = transforms[index].call( + this, + args[index] + ); + } + return apply(func, this, args); + }); + }); + /** + * Creates a function that invokes `func` with `partials` prepended to the + * arguments it receives. This method is like `_.bind` except it does **not** + * alter the `this` binding. + * + * The `_.partial.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 0.2.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var sayHelloTo = _.partial(greet, 'hello'); + * sayHelloTo('fred'); + * // => 'hello fred' + * + * // Partially applied with placeholders. + * var greetFred = _.partial(greet, _, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + */ var partial = baseRest(function (func, partials) { + var holders = replaceHolders( + partials, + getHolder(partial) + ); + return createWrap( + func, + WRAP_PARTIAL_FLAG, + undefined, + partials, + holders + ); + }); + /** + * This method is like `_.partial` except that partially applied arguments + * are appended to the arguments it receives. + * + * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var greetFred = _.partialRight(greet, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + * + * // Partially applied with placeholders. + * var sayHelloTo = _.partialRight(greet, 'hello', _); + * sayHelloTo('fred'); + * // => 'hello fred' + */ var partialRight = baseRest(function ( + func, + partials + ) { + var holders = replaceHolders( + partials, + getHolder(partialRight) + ); + return createWrap( + func, + WRAP_PARTIAL_RIGHT_FLAG, + undefined, + partials, + holders + ); + }); + /** + * Creates a function that invokes `func` with arguments arranged according + * to the specified `indexes` where the argument value at the first index is + * provided as the first argument, the argument value at the second index is + * provided as the second argument, and so on. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to rearrange arguments for. + * @param {...(number|number[])} indexes The arranged argument indexes. + * @returns {Function} Returns the new function. + * @example + * + * var rearged = _.rearg(function(a, b, c) { + * return [a, b, c]; + * }, [2, 0, 1]); + * + * rearged('b', 'c', 'a') + * // => ['a', 'b', 'c'] + */ var rearg = flatRest(function (func, indexes) { + return createWrap( + func, + WRAP_REARG_FLAG, + undefined, + undefined, + undefined, + indexes + ); + }); + /** + * Creates a function that invokes `func` with the `this` binding of the + * created function and arguments from `start` and beyond provided as + * an array. + * + * **Note:** This method is based on the + * [rest parameter](https://mdn.io/rest_parameters). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @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. + * @example + * + * var say = _.rest(function(what, names) { + * return what + ' ' + _.initial(names).join(', ') + + * (_.size(names) > 1 ? ', & ' : '') + _.last(names); + * }); + * + * say('hello', 'fred', 'barney', 'pebbles'); + * // => 'hello fred, barney, & pebbles' + */ function rest(func, start) { + if (typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = + start === undefined ? start : toInteger(start); + return baseRest(func, start); + } + /** + * Creates a function that invokes `func` with the `this` binding of the + * create function and an array of arguments much like + * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). + * + * **Note:** This method is based on the + * [spread operator](https://mdn.io/spread_operator). + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Function + * @param {Function} func The function to spread arguments over. + * @param {Number} [start=0] The start position of the spread. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.spread(function(who, what) { + * return who + ' says ' + what; + * }); + * + * say(['fred', 'hello']); + * // => 'fred says hello' + * + * var numbers = Promise.all([ + * Promise.resolve(40), + * Promise.resolve(36) + * ]); + * + * numbers.then(_.spread(function(x, y) { + * return x + y; + * })); + * // => a Promise of 76 + */ function spread(func, start) { + if (typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = + start == null + ? 0 + : nativeMax(toInteger(start), 0); + return baseRest(function (args) { + var array = args[start], + otherArgs = castSlice(args, 0, start); + if (array) { + arrayPush(otherArgs, array); + } + return apply(func, this, otherArgs); + }); + } + /** + * Creates a throttled function that only invokes `func` at most once per + * every `wait` milliseconds. The throttled function comes with a `cancel` + * method to cancel delayed `func` invocations and a `flush` method to + * immediately invoke them. Provide `options` to indicate whether `func` + * should be invoked on the leading and/or trailing edge of the `wait` + * timeout. The `func` is invoked with the last arguments provided to the + * throttled function. Subsequent calls to the throttled function return the + * result of the last `func` invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the throttled function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.throttle` and `_.debounce`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to throttle. + * @param {Number} [wait=0] The number of milliseconds to throttle invocations to. + * @param {Object} [options={}] The options object. + * @param {Boolean} [options.leading=true] + * Specify invoking on the leading edge of the timeout. + * @param {Boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new throttled function. + * @example + * + * // Avoid excessively updating the position while scrolling. + * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); + * + * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. + * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); + * jQuery(element).on('click', throttled); + * + * // Cancel the trailing throttled invocation. + * jQuery(window).on('popstate', throttled.cancel); + */ function throttle(func, wait, options) { + var leading = true, + trailing = true; + if (typeof func !== "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + if (isObject(options)) { + leading = + "leading" in options + ? Boolean(options.leading) + : leading; + trailing = + "trailing" in options + ? Boolean(options.trailing) + : trailing; + } + return debounce(func, wait, { + leading: leading, + maxWait: wait, + trailing: trailing, + }); + } + /** + * Creates a function that accepts up to one argument, ignoring any + * additional arguments. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.unary(parseInt)); + * // => [6, 8, 10] + */ function unary(func) { + return ary(func, 1); + } + /** + * Creates a function that provides `value` to `wrapper` as its first + * argument. Any additional arguments provided to the function are appended + * to those provided to the `wrapper`. The wrapper is invoked with the `this` + * binding of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {*} value The value to wrap. + * @param {Function} [wrapper=identity] The wrapper function. + * @returns {Function} Returns the new function. + * @example + * + * var p = _.wrap(_.escape, function(func, text) { + * return '

' + func(text) + '

'; + * }); + * + * p('fred, barney, & pebbles'); + * // => '

fred, barney, & pebbles

' + */ function wrap(value, wrapper) { + return partial(castFunction(wrapper), value); + } + /* ------------------------------------------------------------------------*/ /** + * Casts `value` as an array if it's not one. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Lang + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast array. + * @example + * + * _.castArray(1); + * // => [1] + * + * _.castArray({ 'a': 1 }); + * // => [{ 'a': 1 }] + * + * _.castArray('abc'); + * // => ['abc'] + * + * _.castArray(null); + * // => [null] + * + * _.castArray(undefined); + * // => [undefined] + * + * _.castArray(); + * // => [] + * + * var array = [1, 2, 3]; + * console.log(_.castArray(array) === array); + * // => true + */ function castArray() { + if (!arguments.length) { + return []; + } + var value = arguments[0]; + return isArray(value) ? value : [value]; + } + /** + * Creates a shallow clone of `value`. + * + * **Note:** This method is loosely based on the + * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) + * and supports cloning arrays, array buffers, booleans, date objects, maps, + * numbers, `Object` objects, regexes, sets, strings, symbols, and typed + * arrays. The own enumerable properties of `arguments` objects are cloned + * as plain objects. An empty object is returned for uncloneable values such + * as error objects, functions, DOM nodes, and WeakMaps. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to clone. + * @returns {*} Returns the cloned value. + * @see _.cloneDeep + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var shallow = _.clone(objects); + * console.log(shallow[0] === objects[0]); + * // => true + */ function clone(value) { + return baseClone(value, CLONE_SYMBOLS_FLAG); + } + /** + * This method is like `_.clone` except that it accepts `customizer` which + * is invoked to produce the cloned value. If `customizer` returns `undefined`, + * cloning is handled by the method instead. The `customizer` is invoked with + * up to four arguments; (value [, index|key, object, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the cloned value. + * @see _.cloneDeepWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(false); + * } + * } + * + * var el = _.cloneWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 0 + */ function cloneWith(value, customizer) { + customizer = + typeof customizer === "function" + ? customizer + : undefined; + return baseClone( + value, + CLONE_SYMBOLS_FLAG, + customizer + ); + } + /** + * This method is like `_.clone` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @returns {*} Returns the deep cloned value. + * @see _.clone + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var deep = _.cloneDeep(objects); + * console.log(deep[0] === objects[0]); + * // => false + */ function cloneDeep(value) { + return baseClone( + value, + CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG + ); + } + /** + * This method is like `_.cloneWith` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the deep cloned value. + * @see _.cloneWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(true); + * } + * } + * + * var el = _.cloneDeepWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 20 + */ function cloneDeepWith(value, customizer) { + customizer = + typeof customizer === "function" + ? customizer + : undefined; + return baseClone( + value, + CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, + customizer + ); + } + /** + * Checks if `object` conforms to `source` by invoking the predicate + * properties of `source` with the corresponding property values of `object`. + * + * **Note:** This method is equivalent to `_.conforms` when `source` is + * partially applied. + * + * @static + * @memberOf _ + * @since 4.14.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {Boolean} Returns `true` if `object` conforms, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.conformsTo(object, { 'b': function(n) { return n > 1; } }); + * // => true + * + * _.conformsTo(object, { 'b': function(n) { return n > 2; } }); + * // => false + */ function conformsTo(object, source) { + return ( + source == null || + baseConformsTo(object, source, keys(source)) + ); + } + /** + * 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) + ); + } + /** + * Checks if `value` is greater than `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + * @see _.lt + * @example + * + * _.gt(3, 1); + * // => true + * + * _.gt(3, 3); + * // => false + * + * _.gt(1, 3); + * // => false + */ var gt = createRelationalOperation(baseGt); + /** + * Checks if `value` is greater than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than or equal to + * `other`, else `false`. + * @see _.lte + * @example + * + * _.gte(3, 1); + * // => true + * + * _.gte(3, 3); + * // => true + * + * _.gte(1, 3); + * // => false + */ var gte = createRelationalOperation(function ( + value, + other + ) { + return value >= other; + }); + /** + * 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" + ) + ); + }; + /** + * 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; + /** + * Checks if `value` is classified as an `ArrayBuffer` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. + * @example + * + * _.isArrayBuffer(new ArrayBuffer(2)); + * // => true + * + * _.isArrayBuffer(new Array(2)); + * // => false + */ var isArrayBuffer = nodeIsArrayBuffer + ? baseUnary(nodeIsArrayBuffer) + : baseIsArrayBuffer; + /** + * 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) + ); + } + /** + * 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); + } + /** + * Checks if `value` is classified as a boolean primitive or object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a boolean, else `false`. + * @example + * + * _.isBoolean(false); + * // => true + * + * _.isBoolean(null); + * // => false + */ function isBoolean(value) { + return ( + value === true || + value === false || + (isObjectLike(value) && + baseGetTag(value) == boolTag) + ); + } + /** + * 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; + /** + * Checks if `value` is classified as a `Date` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a date object, else `false`. + * @example + * + * _.isDate(new Date); + * // => true + * + * _.isDate('Mon April 23 2012'); + * // => false + */ var isDate = nodeIsDate + ? baseUnary(nodeIsDate) + : baseIsDate; + /** + * Checks if `value` is likely a DOM element. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a DOM element, else `false`. + * @example + * + * _.isElement(document.body); + * // => true + * + * _.isElement(''); + * // => false + */ function isElement(value) { + return ( + isObjectLike(value) && + value.nodeType === 1 && + !isPlainObject(value) + ); + } + /** + * Checks if `value` is an empty object, collection, map, or set. + * + * Objects are considered empty if they have no own enumerable string keyed + * properties. + * + * Array-like values such as `arguments` objects, arrays, buffers, strings, or + * jQuery-like collections are considered empty if they have a `length` of `0`. + * Similarly, maps and sets are considered empty if they have a `size` of `0`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is empty, else `false`. + * @example + * + * _.isEmpty(null); + * // => true + * + * _.isEmpty(true); + * // => true + * + * _.isEmpty(1); + * // => true + * + * _.isEmpty([1, 2, 3]); + * // => false + * + * _.isEmpty({ 'a': 1 }); + * // => false + */ function isEmpty(value) { + if (value == null) { + return true; + } + if ( + isArrayLike(value) && + (isArray(value) || + typeof value === "string" || + typeof value.splice === "function" || + isBuffer(value) || + isTypedArray(value) || + isArguments(value)) + ) { + return !value.length; + } + var tag = getTag(value); + if (tag == mapTag || tag == setTag) { + return !value.size; + } + if (isPrototype(value)) { + return !baseKeys(value).length; + } + for (var key in value) { + if (hasOwnProperty.call(value, key)) { + return false; + } + } + return true; + } + /** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are compared by strict equality, i.e. `===`. + * + * @static + * @memberOf _ + * @since 0.1.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 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ function isEqual(value, other) { + return baseIsEqual(value, other); + } + /** + * This method is like `_.isEqual` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with up to + * six arguments: (objValue, othValue [, index|key, object, other, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {Boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, othValue) { + * if (isGreeting(objValue) && isGreeting(othValue)) { + * return true; + * } + * } + * + * var array = ['hello', 'goodbye']; + * var other = ['hi', 'goodbye']; + * + * _.isEqualWith(array, other, customizer); + * // => true + */ function isEqualWith(value, other, customizer) { + customizer = + typeof customizer === "function" + ? customizer + : undefined; + var result = customizer + ? customizer(value, other) + : undefined; + return result === undefined + ? baseIsEqual( + value, + other, + undefined, + customizer + ) + : Boolean(result); + } + /** + * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, + * `SyntaxError`, `TypeError`, or `URIError` object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is an error object, else `false`. + * @example + * + * _.isError(new Error); + * // => true + * + * _.isError(Error); + * // => false + */ function isError(value) { + if (!isObjectLike(value)) { + return false; + } + var tag = baseGetTag(value); + return ( + tag == errorTag || + tag == domExcTag || + (typeof value.message === "string" && + typeof value.name === "string" && + !isPlainObject(value)) + ); + } + /** + * Checks if `value` is a finite primitive number. + * + * **Note:** This method is based on + * [`Number.isFinite`](https://mdn.io/Number/isFinite). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a finite number, else `false`. + * @example + * + * _.isFinite(3); + * // => true + * + * _.isFinite(Number.MIN_VALUE); + * // => true + * + * _.isFinite(Infinity); + * // => false + * + * _.isFinite('3'); + * // => false + */ function isFinite(value) { + return ( + typeof value === "number" && + nativeIsFinite(value) + ); + } + /** + * 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 + ); + } + /** + * Checks if `value` is an integer. + * + * **Note:** This method is based on + * [`Number.isInteger`](https://mdn.io/Number/isInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is an integer, else `false`. + * @example + * + * _.isInteger(3); + * // => true + * + * _.isInteger(Number.MIN_VALUE); + * // => false + * + * _.isInteger(Infinity); + * // => false + * + * _.isInteger('3'); + * // => false + */ function isInteger(value) { + return ( + typeof value === "number" && + value == toInteger(value) + ); + } + /** + * 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 + ); + } + /** + * 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") + ); + } + /** + * 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"; + } + /** + * Checks if `value` is classified as a `Map` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. + * @example + * + * _.isMap(new Map); + * // => true + * + * _.isMap(new WeakMap); + * // => false + */ var isMap = nodeIsMap + ? baseUnary(nodeIsMap) + : baseIsMap; + /** + * Performs a partial deep comparison between `object` and `source` to + * determine if `object` contains equivalent property values. + * + * **Note:** This method is equivalent to `_.matches` when `source` is + * partially applied. + * + * Partial comparisons will match empty array and empty object `source` + * values against any array or object value, respectively. See `_.isEqual` + * for a list of supported value comparisons. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @returns {Boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.isMatch(object, { 'b': 2 }); + * // => true + * + * _.isMatch(object, { 'b': 1 }); + * // => false + */ function isMatch(object, source) { + return ( + object === source || + baseIsMatch( + object, + source, + getMatchData(source) + ) + ); + } + /** + * This method is like `_.isMatch` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with five + * arguments: (objValue, srcValue, index|key, object, source). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {Boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, srcValue) { + * if (isGreeting(objValue) && isGreeting(srcValue)) { + * return true; + * } + * } + * + * var object = { 'greeting': 'hello' }; + * var source = { 'greeting': 'hi' }; + * + * _.isMatchWith(object, source, customizer); + * // => true + */ function isMatchWith(object, source, customizer) { + customizer = + typeof customizer === "function" + ? customizer + : undefined; + return baseIsMatch( + object, + source, + getMatchData(source), + customizer + ); + } + /** + * Checks if `value` is `NaN`. + * + * **Note:** This method is based on + * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as + * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for + * `undefined` and other non-number values. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is `NaN`, else `false`. + * @example + * + * _.isNaN(NaN); + * // => true + * + * _.isNaN(new Number(NaN)); + * // => true + * + * isNaN(undefined); + * // => true + * + * _.isNaN(undefined); + * // => false + */ function isNaN(value) { + // An `NaN` primitive is the only value that is not equal to itself. + // Perform the `toStringTag` check first to avoid errors with some + // ActiveX objects in IE. + return isNumber(value) && value != Number(value); + } + /** + * Checks if `value` is a pristine native function. + * + * **Note:** This method can't reliably detect native functions in the presence + * of the core-js package because core-js circumvents this kind of detection. + * Despite multiple requests, the core-js maintainer has made it clear: any + * attempt to fix the detection will be obstructed. As a result, we're left + * with little choice but to throw an error. Unfortunately, this also affects + * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), + * which rely on core-js. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a native function, + * else `false`. + * @example + * + * _.isNative(Array.prototype.push); + * // => true + * + * _.isNative(_); + * // => false + */ function isNative(value) { + if (isMaskable(value)) { + throw new Error(CORE_ERROR_TEXT); + } + return baseIsNative(value); + } + /** + * Checks if `value` is `null`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is `null`, else `false`. + * @example + * + * _.isNull(null); + * // => true + * + * _.isNull(void 0); + * // => false + */ function isNull(value) { + return value === null; + } + /** + * Checks if `value` is `null` or `undefined`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is nullish, else `false`. + * @example + * + * _.isNil(null); + * // => true + * + * _.isNil(void 0); + * // => true + * + * _.isNil(NaN); + * // => false + */ function isNil(value) { + return value == null; + } + /** + * Checks if `value` is classified as a `Number` primitive or object. + * + * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are + * classified as numbers, use the `_.isFinite` method. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a number, else `false`. + * @example + * + * _.isNumber(3); + * // => true + * + * _.isNumber(Number.MIN_VALUE); + * // => true + * + * _.isNumber(Infinity); + * // => true + * + * _.isNumber('3'); + * // => false + */ function isNumber(value) { + return ( + typeof value === "number" || + (isObjectLike(value) && + baseGetTag(value) == numberTag) + ); + } + /** + * 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 + ); + } + /** + * Checks if `value` is classified as a `RegExp` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. + * @example + * + * _.isRegExp(/abc/); + * // => true + * + * _.isRegExp('/abc/'); + * // => false + */ var isRegExp = nodeIsRegExp + ? baseUnary(nodeIsRegExp) + : baseIsRegExp; + /** + * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 + * double precision number which isn't the result of a rounded unsafe integer. + * + * **Note:** This method is based on + * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a safe integer, else `false`. + * @example + * + * _.isSafeInteger(3); + * // => true + * + * _.isSafeInteger(Number.MIN_VALUE); + * // => false + * + * _.isSafeInteger(Infinity); + * // => false + * + * _.isSafeInteger('3'); + * // => false + */ function isSafeInteger(value) { + return ( + isInteger(value) && + value >= -MAX_SAFE_INTEGER && + value <= MAX_SAFE_INTEGER + ); + } + /** + * Checks if `value` is classified as a `Set` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a set, else `false`. + * @example + * + * _.isSet(new Set); + * // => true + * + * _.isSet(new WeakSet); + * // => false + */ var isSet = nodeIsSet + ? baseUnary(nodeIsSet) + : baseIsSet; + /** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ function isString(value) { + return ( + typeof value === "string" || + (!isArray(value) && + isObjectLike(value) && + baseGetTag(value) == stringTag) + ); + } + /** + * 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) + ); + } + /** + * 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; + /** + * Checks if `value` is `undefined`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is `undefined`, else `false`. + * @example + * + * _.isUndefined(void 0); + * // => true + * + * _.isUndefined(null); + * // => false + */ function isUndefined(value) { + return value === undefined; + } + /** + * Checks if `value` is classified as a `WeakMap` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a weak map, else `false`. + * @example + * + * _.isWeakMap(new WeakMap); + * // => true + * + * _.isWeakMap(new Map); + * // => false + */ function isWeakMap(value) { + return ( + isObjectLike(value) && + getTag(value) == weakMapTag + ); + } + /** + * Checks if `value` is classified as a `WeakSet` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {Boolean} Returns `true` if `value` is a weak set, else `false`. + * @example + * + * _.isWeakSet(new WeakSet); + * // => true + * + * _.isWeakSet(new Set); + * // => false + */ function isWeakSet(value) { + return ( + isObjectLike(value) && + baseGetTag(value) == weakSetTag + ); + } + /** + * Checks if `value` is less than `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than `other`, + * else `false`. + * @see _.gt + * @example + * + * _.lt(1, 3); + * // => true + * + * _.lt(3, 3); + * // => false + * + * _.lt(3, 1); + * // => false + */ var lt = createRelationalOperation(baseLt); + /** + * Checks if `value` is less than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than or equal to + * `other`, else `false`. + * @see _.gte + * @example + * + * _.lte(1, 3); + * // => true + * + * _.lte(3, 3); + * // => true + * + * _.lte(3, 1); + * // => false + */ var lte = createRelationalOperation(function ( + value, + other + ) { + return value <= other; + }); + /** + * Converts `value` to an array. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @returns {Array} Returns the converted array. + * @example + * + * _.toArray({ 'a': 1, 'b': 2 }); + * // => [1, 2] + * + * _.toArray('abc'); + * // => ['a', 'b', 'c'] + * + * _.toArray(1); + * // => [] + * + * _.toArray(null); + * // => [] + */ function toArray(value) { + if (!value) { + return []; + } + if (isArrayLike(value)) { + return isString(value) + ? stringToArray(value) + : copyArray(value); + } + if (symIterator && value[symIterator]) { + return iteratorToArray(value[symIterator]()); + } + var tag = getTag(value), + func = + tag == mapTag + ? mapToArray + : tag == setTag + ? setToArray + : values; + return func(value); + } + /** + * Converts `value` to a finite number. + * + * @static + * @memberOf _ + * @since 4.12.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Number} Returns the converted number. + * @example + * + * _.toFinite(3.2); + * // => 3.2 + * + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toFinite('3.2'); + * // => 3.2 + */ function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === INFINITY || value === -INFINITY) { + var sign = value < 0 ? -1 : 1; + return sign * MAX_INTEGER; + } + return value === value ? value : 0; + } + /** + * Converts `value` to an integer. + * + * **Note:** This method is loosely based on + * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Number} Returns the converted integer. + * @example + * + * _.toInteger(3.2); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3.2'); + * // => 3 + */ function toInteger(value) { + var result = toFinite(value), + remainder = result % 1; + return result === result + ? remainder + ? result - remainder + : result + : 0; + } + /** + * Converts `value` to an integer suitable for use as the length of an + * array-like object. + * + * **Note:** This method is 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 convert. + * @returns {Number} Returns the converted integer. + * @example + * + * _.toLength(3.2); + * // => 3 + * + * _.toLength(Number.MIN_VALUE); + * // => 0 + * + * _.toLength(Infinity); + * // => 4294967295 + * + * _.toLength('3.2'); + * // => 3 + */ function toLength(value) { + return value + ? baseClamp( + toInteger(value), + 0, + MAX_ARRAY_LENGTH + ) + : 0; + } + /** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {Number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ function toNumber(value) { + if (typeof value === "number") { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = + typeof value.valueOf === "function" + ? value.valueOf() + : value; + value = isObject(other) ? String(other) : other; + } + if (typeof value !== "string") { + return value === 0 ? value : Number(value); + } + value = value.replace(reTrim, ""); + var isBinary = reIsBinary.test(value); + return isBinary || reIsOctal.test(value) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : reIsBadHex.test(value) + ? NAN + : Number(value); + } + /** + * 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)); + } + /** + * Converts `value` to a safe integer. A safe integer can be compared and + * represented correctly. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Number} Returns the converted integer. + * @example + * + * _.toSafeInteger(3.2); + * // => 3 + * + * _.toSafeInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toSafeInteger(Infinity); + * // => 9007199254740991 + * + * _.toSafeInteger('3.2'); + * // => 3 + */ function toSafeInteger(value) { + return value + ? baseClamp( + toInteger(value), + -MAX_SAFE_INTEGER, + MAX_SAFE_INTEGER + ) + : value === 0 + ? value + : 0; + } + /** + * 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); + } + /* ------------------------------------------------------------------------*/ /** + * Assigns own enumerable string keyed properties of source objects to the + * destination object. Source objects are applied from left to right. + * Subsequent sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object` and is loosely based on + * [`Object.assign`](https://mdn.io/Object/assign). + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assignIn + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assign({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3 } + */ var assign = createAssigner(function ( + object, + source + ) { + if (isPrototype(source) || isArrayLike(source)) { + copyObject(source, keys(source), object); + return; + } + for (var key in source) { + if (hasOwnProperty.call(source, key)) { + assignValue(object, key, source[key]); + } + } + }); + /** + * This method is like `_.assign` except that it iterates over own and + * inherited source properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias extend + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assign + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assignIn({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } + */ var assignIn = createAssigner(function ( + object, + source + ) { + copyObject(source, keysIn(source), object); + }); + /** + * This method is like `_.assignIn` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias extendWith + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignWith + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignInWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ var assignInWith = createAssigner(function ( + object, + source, + srcIndex, + customizer + ) { + copyObject( + source, + keysIn(source), + object, + customizer + ); + }); + /** + * This method is like `_.assign` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignInWith + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ var assignWith = createAssigner(function ( + object, + source, + srcIndex, + customizer + ) { + copyObject( + source, + keys(source), + object, + customizer + ); + }); + /** + * Creates an array of values corresponding to `paths` of `object`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Array} Returns the picked values. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _.at(object, ['a[0].b.c', 'a[1]']); + * // => [3, 4] + */ var at = flatRest(baseAt); + /** + * Creates an object that inherits from the `prototype` object. If a + * `properties` object is given, its own enumerable string keyed properties + * are assigned to the created object. + * + * @static + * @memberOf _ + * @since 2.3.0 + * @category Object + * @param {Object} prototype The object to inherit from. + * @param {Object} [properties] The properties to assign to the object. + * @returns {Object} Returns the new object. + * @example + * + * function Shape() { + * this.x = 0; + * this.y = 0; + * } + * + * function Circle() { + * Shape.call(this); + * } + * + * Circle.prototype = _.create(Shape.prototype, { + * 'constructor': Circle + * }); + * + * var circle = new Circle; + * circle instanceof Circle; + * // => true + * + * circle instanceof Shape; + * // => true + */ function create(prototype, properties) { + var result = baseCreate(prototype); + return properties == null + ? result + : baseAssign(result, properties); + } + /** + * Assigns own and inherited enumerable string keyed properties of source + * objects to the destination object for all destination properties that + * resolve to `undefined`. Source objects are applied from left to right. + * Once a property is set, additional values of the same property are ignored. + * + * **Note:** This method mutates `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaultsDeep + * @example + * + * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ var defaults = baseRest(function (object, sources) { + object = Object(object); + var index = -1; + var length = sources.length; + var guard = length > 2 ? sources[2] : undefined; + if ( + guard && + isIterateeCall(sources[0], sources[1], guard) + ) { + length = 1; + } + while (++index < length) { + var source = sources[index]; + var props = keysIn(source); + var propsIndex = -1; + var propsLength = props.length; + while (++propsIndex < propsLength) { + var key = props[propsIndex]; + var value = object[key]; + if ( + value === undefined || + (eq(value, objectProto[key]) && + !hasOwnProperty.call(object, key)) + ) { + object[key] = source[key]; + } + } + } + return object; + }); + /** + * This method is like `_.defaults` except that it recursively assigns + * default properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaults + * @example + * + * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); + * // => { 'a': { 'b': 2, 'c': 3 } } + */ var defaultsDeep = baseRest(function (args) { + args.push(undefined, customDefaultsMerge); + return apply(mergeWith, undefined, args); + }); + /** + * This method is like `_.find` except that it returns the key of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {String|undefined} Returns the key of the matched element, + * else `undefined`. + * @example + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findKey(users, function(o) { return o.age < 40; }); + * // => 'barney' (iteration order is not guaranteed) + * + * // The `_.matches` iteratee shorthand. + * _.findKey(users, { 'age': 1, 'active': true }); + * // => 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findKey(users, 'active'); + * // => 'barney' + */ function findKey(object, predicate) { + return baseFindKey( + object, + getIteratee(predicate, 3), + baseForOwn + ); + } + /** + * This method is like `_.findKey` except that it iterates over elements of + * a collection in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {String|undefined} Returns the key of the matched element, + * else `undefined`. + * @example + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findLastKey(users, function(o) { return o.age < 40; }); + * // => returns 'pebbles' assuming `_.findKey` returns 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.findLastKey(users, { 'age': 36, 'active': true }); + * // => 'barney' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findLastKey(users, 'active'); + * // => 'pebbles' + */ function findLastKey(object, predicate) { + return baseFindKey( + object, + getIteratee(predicate, 3), + baseForOwnRight + ); + } + /** + * Iterates over own and inherited enumerable string keyed properties of an + * object and invokes `iteratee` for each property. The iteratee is invoked + * with three arguments: (value, key, object). Iteratee functions may exit + * iteration early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forInRight + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forIn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). + */ function forIn(object, iteratee) { + return object == null + ? object + : baseFor( + object, + getIteratee(iteratee, 3), + keysIn + ); + } + /** + * This method is like `_.forIn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forIn + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forInRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. + */ function forInRight(object, iteratee) { + return object == null + ? object + : baseForRight( + object, + getIteratee(iteratee, 3), + keysIn + ); + } + /** + * Iterates over own enumerable string keyed properties of an object and + * invokes `iteratee` for each property. The iteratee is invoked with three + * arguments: (value, key, object). Iteratee functions may exit iteration + * early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwnRight + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ function forOwn(object, iteratee) { + return ( + object && + baseForOwn(object, getIteratee(iteratee, 3)) + ); + } + /** + * This method is like `_.forOwn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwn + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwnRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. + */ function forOwnRight(object, iteratee) { + return ( + object && + baseForOwnRight( + object, + getIteratee(iteratee, 3) + ) + ); + } + /** + * Creates an array of function property names from own enumerable properties + * of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functionsIn + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functions(new Foo); + * // => ['a', 'b'] + */ function functions(object) { + return object == null + ? [] + : baseFunctions(object, keys(object)); + } + /** + * Creates an array of function property names from own and inherited + * enumerable properties of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functions + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */ function functionsIn(object) { + return object == null + ? [] + : baseFunctions(object, keysIn(object)); + } + /** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|String} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ function get(object, path, defaultValue) { + var result = + object == null + ? undefined + : baseGet(object, path); + return result === undefined ? defaultValue : result; + } + /** + * Checks if `path` is a direct property of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @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 = { 'a': { 'b': 2 } }; + * var other = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b'); + * // => true + * + * _.has(object, ['a', 'b']); + * // => true + * + * _.has(other, 'a'); + * // => false + */ function has(object, path) { + return ( + object != null && hasPath(object, path, baseHas) + ); + } + /** + * 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) + ); + } + /** + * Creates an object composed of the inverted keys and values of `object`. + * If `object` contains duplicate values, subsequent values overwrite + * property assignments of previous values. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Object + * @param {Object} object The object to invert. + * @returns {Object} Returns the new inverted object. + * @example + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invert(object); + * // => { '1': 'c', '2': 'b' } + */ var invert = createInverter(function ( + result, + value, + key + ) { + if ( + value != null && + typeof value.toString !== "function" + ) { + value = nativeObjectToString.call(value); + } + result[value] = key; + }, + constant(identity)); + /** + * This method is like `_.invert` except that the inverted object is generated + * from the results of running each element of `object` thru `iteratee`. The + * corresponding inverted value of each inverted key is an array of keys + * responsible for generating the inverted value. The iteratee is invoked + * with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Object + * @param {Object} object The object to invert. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Object} Returns the new inverted object. + * @example + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invertBy(object); + * // => { '1': ['a', 'c'], '2': ['b'] } + * + * _.invertBy(object, function(value) { + * return 'group' + value; + * }); + * // => { 'group1': ['a', 'c'], 'group2': ['b'] } + */ var invertBy = createInverter(function ( + result, + value, + key + ) { + if ( + value != null && + typeof value.toString !== "function" + ) { + value = nativeObjectToString.call(value); + } + if (hasOwnProperty.call(result, value)) { + result[value].push(key); + } else { + result[value] = [key]; + } + }, + getIteratee); + /** + * Invokes the method at `path` of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the method to invoke. + * @param {...*} [args] The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. + * @example + * + * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; + * + * _.invoke(object, 'a[0].b.c.slice', 1, 3); + * // => [2, 3] + */ var invoke = baseRest(baseInvoke); + /** + * 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); + } + /** + * 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); + } + /** + * The opposite of `_.mapValues`; this method creates an object with the + * same values as `object` and keys generated by running each own enumerable + * string keyed property of `object` thru `iteratee`. The iteratee is invoked + * with three arguments: (value, key, object). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapValues + * @example + * + * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { + * return key + value; + * }); + * // => { 'a1': 1, 'b2': 2 } + */ function mapKeys(object, iteratee) { + var result = {}; + iteratee = getIteratee(iteratee, 3); + baseForOwn(object, function (value, key, object) { + baseAssignValue( + result, + iteratee(value, key, object), + value + ); + }); + return result; + } + /** + * Creates an object with the same keys as `object` and values generated + * by running each own enumerable string keyed property of `object` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, key, object). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapKeys + * @example + * + * var users = { + * 'fred': { 'user': 'fred', 'age': 40 }, + * 'pebbles': { 'user': 'pebbles', 'age': 1 } + * }; + * + * _.mapValues(users, function(o) { return o.age; }); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + * + * // The `_.property` iteratee shorthand. + * _.mapValues(users, 'age'); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + */ function mapValues(object, iteratee) { + var result = {}; + iteratee = getIteratee(iteratee, 3); + baseForOwn(object, function (value, key, object) { + baseAssignValue( + result, + key, + iteratee(value, key, object) + ); + }); + return result; + } + /** + * 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); + }); + /** + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined`, merging is handled by the + * method instead. The `customizer` is invoked with six arguments: + * (objValue, srcValue, key, object, source, stack). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; + * + * _.mergeWith(object, other, customizer); + * // => { 'a': [1, 3], 'b': [2, 4] } + */ var mergeWith = createAssigner(function ( + object, + source, + srcIndex, + customizer + ) { + baseMerge(object, source, srcIndex, customizer); + }); + /** + * 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; + }); + /** + * The opposite of `_.pickBy`; this method creates an object composed of + * the own and inherited enumerable string keyed properties of `object` that + * `predicate` doesn't return truthy for. The predicate is invoked with two + * arguments: (value, key). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omitBy(object, _.isNumber); + * // => { 'b': '2' } + */ function omitBy(object, predicate) { + return pickBy( + object, + negate(getIteratee(predicate)) + ); + } + /** + * 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); + }); + /** + * Creates an object composed of the `object` properties `predicate` returns + * truthy for. The predicate is invoked with two arguments: (value, key). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pickBy(object, _.isNumber); + * // => { 'a': 1, 'c': 3 } + */ function pickBy(object, predicate) { + if (object == null) { + return {}; + } + var props = arrayMap( + getAllKeysIn(object), + function (prop) { + return [prop]; + } + ); + predicate = getIteratee(predicate); + return basePickBy(object, props, function ( + value, + path + ) { + return predicate(value, path[0]); + }); + } + /** + * This method is like `_.get` except that if the resolved value is a + * function it's invoked with the `this` binding of its parent object and + * its result is returned. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|String} path The path of the property to resolve. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; + * + * _.result(object, 'a[0].b.c1'); + * // => 3 + * + * _.result(object, 'a[0].b.c2'); + * // => 4 + * + * _.result(object, 'a[0].b.c3', 'default'); + * // => 'default' + * + * _.result(object, 'a[0].b.c3', _.constant('default')); + * // => 'default' + */ function result(object, path, defaultValue) { + path = castPath(path, object); + var index = -1, + length = path.length; // Ensure the loop is entered when path is empty. + if (!length) { + length = 1; + object = undefined; + } + while (++index < length) { + var value = + object == null + ? undefined + : object[toKey(path[index])]; + if (value === undefined) { + index = length; + value = defaultValue; + } + object = isFunction(value) + ? value.call(object) + : value; + } + return object; + } + /** + * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, + * it's created. Arrays are created for missing index properties while objects + * are created for all other missing properties. Use `_.setWith` to customize + * `path` creation. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|String} path The path of the property to set. + * @param {*} value The value to set. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */ function set(object, path, value) { + return object == null + ? object + : baseSet(object, path, value); + } + /** + * This method is like `_.set` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @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 assigned values. + * @returns {Object} Returns `object`. + * @example + * + * var object = {}; + * + * _.setWith(object, '[0][1]', 'a', Object); + * // => { '0': { '1': 'a' } } + */ function setWith(object, path, value, customizer) { + customizer = + typeof customizer === "function" + ? customizer + : undefined; + return object == null + ? object + : baseSet(object, path, value, customizer); + } + /** + * Creates an array of own enumerable string keyed-value pairs for `object` + * which can be consumed by `_.fromPairs`. If `object` is a map or set, its + * entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entries + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairs(new Foo); + * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) + */ var toPairs = createToPairs(keys); + /** + * Creates an array of own and inherited enumerable string keyed-value pairs + * for `object` which can be consumed by `_.fromPairs`. If `object` is a map + * or set, its entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entriesIn + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairsIn(new Foo); + * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) + */ var toPairsIn = createToPairs(keysIn); + /** + * An alternative to `_.reduce`; this method transforms `object` to a new + * `accumulator` object which is the result of running each of its own + * enumerable string keyed properties thru `iteratee`, with each invocation + * potentially mutating the `accumulator` object. If `accumulator` is not + * provided, a new object with the same `[[Prototype]]` will be used. The + * iteratee is invoked with four arguments: (accumulator, value, key, object). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The custom accumulator value. + * @returns {*} Returns the accumulated value. + * @example + * + * _.transform([2, 3, 4], function(result, n) { + * result.push(n *= n); + * return n % 2 == 0; + * }, []); + * // => [4, 9] + * + * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } + */ function transform(object, iteratee, accumulator) { + var isArr = isArray(object), + isArrLike = + isArr || + isBuffer(object) || + isTypedArray(object); + iteratee = getIteratee(iteratee, 4); + if (accumulator == null) { + var Ctor = object && object.constructor; + if (isArrLike) { + accumulator = isArr ? new Ctor() : []; + } else if (isObject(object)) { + accumulator = isFunction(Ctor) + ? baseCreate(getPrototype(object)) + : {}; + } else { + accumulator = {}; + } + } + (isArrLike ? arrayEach : baseForOwn)( + object, + function (value, index, object) { + return iteratee( + accumulator, + value, + index, + object + ); + } + ); + return accumulator; + } + /** + * Removes the property at `path` of `object`. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|String} path The path of the property to unset. + * @returns {Boolean} Returns `true` if the property is deleted, else `false`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 7 } }] }; + * _.unset(object, 'a[0].b.c'); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + * + * _.unset(object, ['a', '0', 'b', 'c']); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + */ function unset(object, path) { + return object == null + ? true + : baseUnset(object, path); + } + /** + * This method is like `_.set` except that accepts `updater` to produce the + * value to set. Use `_.updateWith` to customize `path` creation. The `updater` + * is invoked with one argument: (value). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|String} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.update(object, 'a[0].b.c', function(n) { return n * n; }); + * console.log(object.a[0].b.c); + * // => 9 + * + * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); + * console.log(object.x[0].y.z); + * // => 0 + */ function update(object, path, updater) { + return object == null + ? object + : baseUpdate( + object, + path, + castFunction(updater) + ); + } + /** + * This method is like `_.update` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|String} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * var object = {}; + * + * _.updateWith(object, '[0][1]', _.constant('a'), Object); + * // => { '0': { '1': 'a' } } + */ function updateWith( + object, + path, + updater, + customizer + ) { + customizer = + typeof customizer === "function" + ? customizer + : undefined; + return object == null + ? object + : baseUpdate( + object, + path, + castFunction(updater), + customizer + ); + } + /** + * Creates an array of the own enumerable string keyed property values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.values(new Foo); + * // => [1, 2] (iteration order is not guaranteed) + * + * _.values('hi'); + * // => ['h', 'i'] + */ function values(object) { + return object == null + ? [] + : baseValues(object, keys(object)); + } + /** + * Creates an array of the own and inherited enumerable string keyed property + * values 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 values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.valuesIn(new Foo); + * // => [1, 2, 3] (iteration order is not guaranteed) + */ function valuesIn(object) { + return object == null + ? [] + : baseValues(object, keysIn(object)); + } + /* ------------------------------------------------------------------------*/ /** + * Clamps `number` within the inclusive `lower` and `upper` bounds. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Number + * @param {Number} number The number to clamp. + * @param {Number} [lower] The lower bound. + * @param {Number} upper The upper bound. + * @returns {Number} Returns the clamped number. + * @example + * + * _.clamp(-10, -5, 5); + * // => -5 + * + * _.clamp(10, -5, 5); + * // => 5 + */ function clamp(number, lower, upper) { + if (upper === undefined) { + upper = lower; + lower = undefined; + } + if (upper !== undefined) { + upper = toNumber(upper); + upper = upper === upper ? upper : 0; + } + if (lower !== undefined) { + lower = toNumber(lower); + lower = lower === lower ? lower : 0; + } + return baseClamp(toNumber(number), lower, upper); + } + /** + * Checks if `n` is between `start` and up to, but not including, `end`. If + * `end` is not specified, it's set to `start` with `start` then set to `0`. + * If `start` is greater than `end` the params are swapped to support + * negative ranges. + * + * @static + * @memberOf _ + * @since 3.3.0 + * @category Number + * @param {Number} number The number to check. + * @param {Number} [start=0] The start of the range. + * @param {Number} end The end of the range. + * @returns {Boolean} Returns `true` if `number` is in the range, else `false`. + * @see _.range, _.rangeRight + * @example + * + * _.inRange(3, 2, 4); + * // => true + * + * _.inRange(4, 8); + * // => true + * + * _.inRange(4, 2); + * // => false + * + * _.inRange(2, 2); + * // => false + * + * _.inRange(1.2, 2); + * // => true + * + * _.inRange(5.2, 4); + * // => false + * + * _.inRange(-3, -2, -6); + * // => true + */ function inRange(number, start, end) { + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + number = toNumber(number); + return baseInRange(number, start, end); + } + /** + * Produces a random number between the inclusive `lower` and `upper` bounds. + * If only one argument is provided a number between `0` and the given number + * is returned. If `floating` is `true`, or either `lower` or `upper` are + * floats, a floating-point number is returned instead of an integer. + * + * **Note:** JavaScript follows the IEEE-754 standard for resolving + * floating-point values which can produce unexpected results. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Number + * @param {Number} [lower=0] The lower bound. + * @param {Number} [upper=1] The upper bound. + * @param {Boolean} [floating] Specify returning a floating-point number. + * @returns {Number} Returns the random number. + * @example + * + * _.random(0, 5); + * // => an integer between 0 and 5 + * + * _.random(5); + * // => also an integer between 0 and 5 + * + * _.random(5, true); + * // => a floating-point number between 0 and 5 + * + * _.random(1.2, 5.2); + * // => a floating-point number between 1.2 and 5.2 + */ function random(lower, upper, floating) { + if ( + floating && + typeof floating !== "boolean" && + isIterateeCall(lower, upper, floating) + ) { + upper = floating = undefined; + } + if (floating === undefined) { + if (typeof upper === "boolean") { + floating = upper; + upper = undefined; + } else if (typeof lower === "boolean") { + floating = lower; + lower = undefined; + } + } + if (lower === undefined && upper === undefined) { + lower = 0; + upper = 1; + } else { + lower = toFinite(lower); + if (upper === undefined) { + upper = lower; + lower = 0; + } else { + upper = toFinite(upper); + } + } + if (lower > upper) { + var temp = lower; + lower = upper; + upper = temp; + } + if (floating || lower % 1 || upper % 1) { + var rand = nativeRandom(); + return nativeMin( + lower + + rand * + (upper - + lower + + freeParseFloat( + "1e-" + + ((String(rand)).length - 1) + )), + upper + ); + } + return baseRandom(lower, upper); + } + /* ------------------------------------------------------------------------*/ /** + * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the camel cased string. + * @example + * + * _.camelCase('Foo Bar'); + * // => 'fooBar' + * + * _.camelCase('--foo-bar--'); + * // => 'fooBar' + * + * _.camelCase('__FOO_BAR__'); + * // => 'fooBar' + */ var camelCase = createCompounder(function ( + result, + word, + index + ) { + word = word.toLowerCase(); + return result + (index ? capitalize(word) : word); + }); + /** + * Converts the first character of `string` to upper case and the remaining + * to lower case. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {String} [string=''] The string to capitalize. + * @returns {String} Returns the capitalized string. + * @example + * + * _.capitalize('FRED'); + * // => 'Fred' + */ function capitalize(string) { + return upperFirst(toString(string).toLowerCase()); + } + /** + * Deburrs `string` by converting + * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) + * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) + * letters to basic Latin letters and removing + * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {String} [string=''] The string to deburr. + * @returns {String} Returns the deburred string. + * @example + * + * _.deburr('déjà vu'); + * // => 'deja vu' + */ function deburr(string) { + string = toString(string); + return ( + string && + string + .replace(reLatin, deburrLetter) + .replace(reComboMark, "") + ); + } + /** + * Checks if `string` ends with the given target string. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {String} [string=''] The string to inspect. + * @param {String} [target] The string to search for. + * @param {Number} [position=string.length] The position to search up to. + * @returns {Boolean} Returns `true` if `string` ends with `target`, + * else `false`. + * @example + * + * _.endsWith('abc', 'c'); + * // => true + * + * _.endsWith('abc', 'b'); + * // => false + * + * _.endsWith('abc', 'b', 2); + * // => true + */ function endsWith(string, target, position) { + string = toString(string); + target = baseToString(target); + var length = string.length; + position = + position === undefined + ? length + : baseClamp(toInteger(position), 0, length); + var end = position; + position -= target.length; + return ( + position >= 0 && + string.slice(position, end) == target + ); + } + /** + * Converts the characters "&", "<", ">", '"', and "'" in `string` to their + * corresponding HTML entities. + * + * **Note:** No other characters are escaped. To escape additional + * characters use a third-party library like [_he_](https://mths.be/he). + * + * Though the ">" character is escaped for symmetry, characters like + * ">" and "/" don't need escaping in HTML and have no special meaning + * unless they're part of a tag or unquoted attribute value. See + * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) + * (under "semi-related fun fact") for more details. + * + * When working with HTML you should always + * [quote attribute values](http://wonko.com/post/html-escaping) to reduce + * XSS vectors. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {String} [string=''] The string to escape. + * @returns {String} Returns the escaped string. + * @example + * + * _.escape('fred, barney, & pebbles'); + * // => 'fred, barney, & pebbles' + */ function escape(string) { + string = toString(string); + return string && reHasUnescapedHtml.test(string) + ? string.replace( + reUnescapedHtml, + escapeHtmlChar + ) + : string; + } + /** + * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", + * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {String} [string=''] The string to escape. + * @returns {String} Returns the escaped string. + * @example + * + * _.escapeRegExp('[lodash](https://lodash.com/)'); + * // => '\[lodash\]\(https://lodash\.com/\)' + */ function escapeRegExp(string) { + string = toString(string); + return string && reHasRegExpChar.test(string) + ? string.replace(reRegExpChar, "\\$&") + : string; + } + /** + * Converts `string` to + * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the kebab cased string. + * @example + * + * _.kebabCase('Foo Bar'); + * // => 'foo-bar' + * + * _.kebabCase('fooBar'); + * // => 'foo-bar' + * + * _.kebabCase('__FOO_BAR__'); + * // => 'foo-bar' + */ var kebabCase = createCompounder(function ( + result, + word, + index + ) { + return ( + result + (index ? "-" : "") + word.toLowerCase() + ); + }); + /** + * Converts `string`, as space separated words, to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the lower cased string. + * @example + * + * _.lowerCase('--Foo-Bar--'); + * // => 'foo bar' + * + * _.lowerCase('fooBar'); + * // => 'foo bar' + * + * _.lowerCase('__FOO_BAR__'); + * // => 'foo bar' + */ var lowerCase = createCompounder(function ( + result, + word, + index + ) { + return ( + result + (index ? " " : "") + word.toLowerCase() + ); + }); + /** + * Converts the first character of `string` to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.lowerFirst('Fred'); + * // => 'fred' + * + * _.lowerFirst('FRED'); + * // => 'fRED' + */ var lowerFirst = createCaseFirst("toLowerCase"); + /** + * Pads `string` on the left and right sides if it's shorter than `length`. + * Padding characters are truncated if they can't be evenly divided by `length`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {String} [string=''] The string to pad. + * @param {Number} [length=0] The padding length. + * @param {String} [chars=' '] The string used as padding. + * @returns {String} Returns the padded string. + * @example + * + * _.pad('abc', 8); + * // => ' abc ' + * + * _.pad('abc', 8, '_-'); + * // => '_-abc_-_' + * + * _.pad('abc', 3); + * // => 'abc' + */ function pad(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; + if (!length || strLength >= length) { + return string; + } + var mid = (length - strLength) / 2; + return ( + createPadding(nativeFloor(mid), chars) + + string + + createPadding(nativeCeil(mid), chars) + ); + } + /** + * Pads `string` on the right side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {String} [string=''] The string to pad. + * @param {Number} [length=0] The padding length. + * @param {String} [chars=' '] The string used as padding. + * @returns {String} Returns the padded string. + * @example + * + * _.padEnd('abc', 6); + * // => 'abc ' + * + * _.padEnd('abc', 6, '_-'); + * // => 'abc_-_' + * + * _.padEnd('abc', 3); + * // => 'abc' + */ function padEnd(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; + return length && strLength < length + ? string + + createPadding(length - strLength, chars) + : string; + } + /** + * Pads `string` on the left side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {String} [string=''] The string to pad. + * @param {Number} [length=0] The padding length. + * @param {String} [chars=' '] The string used as padding. + * @returns {String} Returns the padded string. + * @example + * + * _.padStart('abc', 6); + * // => ' abc' + * + * _.padStart('abc', 6, '_-'); + * // => '_-_abc' + * + * _.padStart('abc', 3); + * // => 'abc' + */ function padStart(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; + return length && strLength < length + ? createPadding(length - strLength, chars) + + string + : string; + } + /** + * Converts `string` to an integer of the specified radix. If `radix` is + * `undefined` or `0`, a `radix` of `10` is used unless `value` is a + * hexadecimal, in which case a `radix` of `16` is used. + * + * **Note:** This method aligns with the + * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category String + * @param {String} string The string to convert. + * @param {Number} [radix=10] The radix to interpret `value` by. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Number} Returns the converted integer. + * @example + * + * _.parseInt('08'); + * // => 8 + * + * _.map(['6', '08', '10'], _.parseInt); + * // => [6, 8, 10] + */ function parseInt(string, radix, guard) { + if (guard || radix == null) { + radix = 0; + } else if (radix) { + radix = Number(radix); + } + return nativeParseInt( + toString(string).replace(reTrimStart, ""), + radix || 0 + ); + } + /** + * Repeats the given string `n` times. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {String} [string=''] The string to repeat. + * @param {Number} [n=1] The number of times to repeat the string. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {String} Returns the repeated string. + * @example + * + * _.repeat('*', 3); + * // => '***' + * + * _.repeat('abc', 2); + * // => 'abcabc' + * + * _.repeat('abc', 0); + * // => '' + */ function repeat(string, n, guard) { + if ( + guard + ? isIterateeCall(string, n, guard) + : n === undefined + ) { + n = 1; + } else { + n = toInteger(n); + } + return baseRepeat(toString(string), n); + } + /** + * Replaces matches for `pattern` in `string` with `replacement`. + * + * **Note:** This method is based on + * [`String#replace`](https://mdn.io/String/replace). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {String} [string=''] The string to modify. + * @param {RegExp|String} pattern The pattern to replace. + * @param {Function|String} replacement The match replacement. + * @returns {String} Returns the modified string. + * @example + * + * _.replace('Hi Fred', 'Fred', 'Barney'); + * // => 'Hi Barney' + */ function replace() { + var args = arguments, + string = toString(args[0]); + return args.length < 3 + ? string + : string.replace(args[1], args[2]); + } + /** + * Converts `string` to + * [snake case](https://en.wikipedia.org/wiki/Snake_case). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the snake cased string. + * @example + * + * _.snakeCase('Foo Bar'); + * // => 'foo_bar' + * + * _.snakeCase('fooBar'); + * // => 'foo_bar' + * + * _.snakeCase('--FOO-BAR--'); + * // => 'foo_bar' + */ var snakeCase = createCompounder(function ( + result, + word, + index + ) { + return ( + result + (index ? "_" : "") + word.toLowerCase() + ); + }); + /** + * Splits `string` by `separator`. + * + * **Note:** This method is based on + * [`String#split`](https://mdn.io/String/split). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {String} [string=''] The string to split. + * @param {RegExp|String} separator The separator pattern to split by. + * @param {Number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * @example + * + * _.split('a-b-c', '-', 2); + * // => ['a', 'b'] + */ function split(string, separator, limit) { + if ( + limit && + typeof limit !== "number" && + isIterateeCall(string, separator, limit) + ) { + separator = limit = undefined; + } + limit = + limit === undefined + ? MAX_ARRAY_LENGTH + : limit >>> 0; + if (!limit) { + return []; + } + string = toString(string); + if ( + string && + (typeof separator === "string" || + (separator != null && !isRegExp(separator))) + ) { + separator = baseToString(separator); + if (!separator && hasUnicode(string)) { + return castSlice( + stringToArray(string), + 0, + limit + ); + } + } + return string.split(separator, limit); + } + /** + * Converts `string` to + * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). + * + * @static + * @memberOf _ + * @since 3.1.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the start cased string. + * @example + * + * _.startCase('--foo-bar--'); + * // => 'Foo Bar' + * + * _.startCase('fooBar'); + * // => 'Foo Bar' + * + * _.startCase('__FOO_BAR__'); + * // => 'FOO BAR' + */ var startCase = createCompounder(function ( + result, + word, + index + ) { + return ( + result + (index ? " " : "") + upperFirst(word) + ); + }); + /** + * Checks if `string` starts with the given target string. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {String} [string=''] The string to inspect. + * @param {String} [target] The string to search for. + * @param {Number} [position=0] The position to search from. + * @returns {Boolean} Returns `true` if `string` starts with `target`, + * else `false`. + * @example + * + * _.startsWith('abc', 'a'); + * // => true + * + * _.startsWith('abc', 'b'); + * // => false + * + * _.startsWith('abc', 'b', 1); + * // => true + */ function startsWith(string, target, position) { + string = toString(string); + position = + position == null + ? 0 + : baseClamp( + toInteger(position), + 0, + string.length + ); + target = baseToString(target); + return ( + string.slice( + position, + position + target.length + ) == target + ); + } + /** + * Creates a compiled template function that can interpolate data properties + * in "interpolate" delimiters, HTML-escape interpolated data properties in + * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data + * properties may be accessed as free variables in the template. If a setting + * object is given, it takes precedence over `_.templateSettings` values. + * + * **Note:** In the development build `_.template` utilizes + * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) + * for easier debugging. + * + * For more information on precompiling templates see + * [lodash's custom builds documentation](https://lodash.com/custom-builds). + * + * For more information on Chrome extension sandboxes see + * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {String} [string=''] The template string. + * @param {Object} [options={}] The options object. + * @param {RegExp} [options.escape=_.templateSettings.escape] + * The HTML "escape" delimiter. + * @param {RegExp} [options.evaluate=_.templateSettings.evaluate] + * The "evaluate" delimiter. + * @param {Object} [options.imports=_.templateSettings.imports] + * An object to import into the template as free variables. + * @param {RegExp} [options.interpolate=_.templateSettings.interpolate] + * The "interpolate" delimiter. + * @param {String} [options.sourceURL='lodash.templateSources[n]'] + * The sourceURL of the compiled template. + * @param {String} [options.variable='obj'] + * The data object variable name. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the compiled template function. + * @example + * + * // Use the "interpolate" delimiter to create a compiled template. + * var compiled = _.template('hello <%= user %>!'); + * compiled({ 'user': 'fred' }); + * // => 'hello fred!' + * + * // Use the HTML "escape" delimiter to escape data property values. + * var compiled = _.template('<%- value %>'); + * compiled({ 'value': ' + * + * A summary of all options and their defaults is found [here](https://github.com/knsv/mermaid/blob/master/docs/mermaidAPI.md#mermaidapi-configuration-defaults). A description of each option follows below. + * + * @name Configuration + */ + + var config = { + /** Theme , the CSS style sheet + * + * **theme** - Choose one of the built-in themes: + * * default + * * forest + * * dark + * * neutral. + * To disable any pre-defined mermaid theme, use "null". + * + * **themeCSS** - Use your own CSS. This overrides **theme**. + * 
+                         *  "theme": "forest",
+                         *  "themeCSS": ".node rect { fill: red; }"
+                         *
+ */ + theme: "default", + themeCSS: undefined, + + /** + * **FontFamily** The font to be used for the rendered diagrams. Default value is \"trebuchet ms\", verdana, arial; + */ + fontFamily: '"trebuchet ms", verdana, arial;', + + /** + * This option decides the amount of logging to be used. + * * debug: 1 + * * info: 2 + * * warn: 3 + * * error: 4 + * * fatal: (**default**) 5 + */ + logLevel: 5, + + /** + * Sets the level of trust to be used on the parsed diagrams. + * * **strict**: (**default**) tags in text are encoded, click functionality is disabeled + * * **loose**: tags in text are allowed, click functionality is enabled + */ + securityLevel: "strict", + + /** + * This options controls whether or mermaid starts when the page loads + * **Default value true**. + */ + startOnLoad: true, + + /** + * This options controls whether or arrow markers in html code will be absolute paths or + * an anchor, #. This matters if you are using base tag settings. + * **Default value false**. + */ + arrowMarkerAbsolute: false, + + /** + * The object containing configurations specific for flowcharts + */ + flowchart: { + /** + * Flag for setting whether or not a html tag should be used for rendering labels + * on the edges. + * **Default value true**. + */ + htmlLabels: true, + + /** + * How mermaid renders curves for flowcharts. Possible values are + * * basis + * * linear **default** + * * cardinal + */ + curve: "linear", + }, + + /** + * The object containing configurations specific for sequence diagrams + */ + sequence: { + /** + * Margin to the right and left of the sequence diagram. + * **Default value 50**. + */ + diagramMarginX: 50, + + /** + * Margin to the over and under the sequence diagram. + * **Default value 10**. + */ + diagramMarginY: 10, + + /** + * Margin between actors. + * **Default value 50**. + */ + actorMargin: 50, + + /** + * Width of actor boxes + * **Default value 150**. + */ + width: 150, + + /** + * Height of actor boxes + * **Default value 65**. + */ + height: 65, + + /** + * Margin around loop boxes + * **Default value 10**. + */ + boxMargin: 10, + + /** + * Margin around the text in loop/alt/opt boxes + * **Default value 5**. + */ + boxTextMargin: 5, + + /** + * Margin around notes. + * **Default value 10**. + */ + noteMargin: 10, + + /** + * Space between messages. + * **Default value 35**. + */ + messageMargin: 35, + + /** + * Mirror actors under diagram. + * **Default value true**. + */ + mirrorActors: true, + + /** + * Depending on css styling this might need adjustment. + * Prolongs the edge of the diagram downwards. + * **Default value 1**. + */ + bottomMarginAdj: 1, + + /** + * When this flag is set the height and width is set to 100% and is then scaling with the + * available space if not the absolute space required is used. + * **Default value true**. + */ + useMaxWidth: true, + + /** + * This will display arrows that start and begin at the same node as right angles, rather than a curve + * **Default value false**. + */ + rightAngles: false, + + /** + * This will show the node numbers + * **Default value false**. + */ + showSequenceNumbers: false, + }, + + /** + * The object containing configurations specific for gantt diagrams* + */ + gantt: { + /** + * Margin top for the text over the gantt diagram + * **Default value 25**. + */ + titleTopMargin: 25, + + /** + * The height of the bars in the graph + * **Default value 20**. + */ + barHeight: 20, + + /** + * The margin between the different activities in the gantt diagram. + * **Default value 4**. + */ + barGap: 4, + + /** + * Margin between title and gantt diagram and between axis and gantt diagram. + * **Default value 50**. + */ + topPadding: 50, + + /** + * The space allocated for the section name to the left of the activities. + * **Default value 75**. + */ + leftPadding: 75, + + /** + * Vertical starting position of the grid lines. + * **Default value 35**. + */ + gridLineStartPadding: 35, + + /** + * Font size ... + * **Default value 11**. + */ + fontSize: 11, + + /** + * Font family ... + * **Default value '"Open-Sans", "sans-serif"'**. + */ + fontFamily: '"Open-Sans", "sans-serif"', + + /** + * The number of alternating section styles. + * **Default value 4**. + */ + numberSectionStyles: 4, + + /** + * Datetime format of the axis. This might need adjustment to match your locale and preferences + * **Default value '%Y-%m-%d'**. + */ + axisFormat: "%Y-%m-%d", + }, + class: {}, + git: {}, + state: + ((_state = { + dividerMargin: 10, + sizeUnit: 5, + padding: 5, + textHeight: 10, + titleShift: -15, + noteMargin: 10, + forkWidth: 70, + forkHeight: 7, + }), + _defineProperty(_state, "padding", 5), + _defineProperty(_state, "miniPadding", 2), + _defineProperty(_state, "fontSizeFactor", 5.02), + _defineProperty(_state, "fontSize", 24), + _defineProperty(_state, "labelHeight", 16), + _defineProperty(_state, "edgeLengthFactor", "20"), + _defineProperty(_state, "compositTitleSize", 35), + _defineProperty(_state, "radius", 5), + _state), + }; + Object(_logger__WEBPACK_IMPORTED_MODULE_4__.setLogLevel)( + config.logLevel + ); + Object(_config__WEBPACK_IMPORTED_MODULE_3__.setConfig)(config); + + function parse(text) { + var graphType = _utils__WEBPACK_IMPORTED_MODULE_5__.default.detectType(text); + var parser; + _logger__WEBPACK_IMPORTED_MODULE_4__.logger.debug( + "Type " + graphType + ); + + switch (graphType) { + case "git": + parser = + _diagrams_git_parser_gitGraph__WEBPACK_IMPORTED_MODULE_22___default.a; + parser.parser.yy = + _diagrams_git_gitGraphAst__WEBPACK_IMPORTED_MODULE_23__.default; + break; + + case "flowchart": + _diagrams_flowchart_flowDb__WEBPACK_IMPORTED_MODULE_8__.default.clear(); + parser = + _diagrams_flowchart_parser_flow__WEBPACK_IMPORTED_MODULE_7___default.a; + parser.parser.yy = + _diagrams_flowchart_flowDb__WEBPACK_IMPORTED_MODULE_8__.default; + break; + + case "sequence": + parser = + _diagrams_sequence_parser_sequenceDiagram__WEBPACK_IMPORTED_MODULE_10___default.a; + parser.parser.yy = + _diagrams_sequence_sequenceDb__WEBPACK_IMPORTED_MODULE_11__.default; + break; + + case "gantt": + parser = + _diagrams_gantt_parser_gantt__WEBPACK_IMPORTED_MODULE_13___default.a; + parser.parser.yy = + _diagrams_gantt_ganttDb__WEBPACK_IMPORTED_MODULE_14__.default; + break; + + case "class": + parser = + _diagrams_class_parser_classDiagram__WEBPACK_IMPORTED_MODULE_16___default.a; + parser.parser.yy = + _diagrams_class_classDb__WEBPACK_IMPORTED_MODULE_17__.default; + break; + + case "state": + parser = + _diagrams_state_parser_stateDiagram__WEBPACK_IMPORTED_MODULE_19___default.a; + parser.parser.yy = + _diagrams_state_stateDb__WEBPACK_IMPORTED_MODULE_20__.default; + break; + + case "info": + _logger__WEBPACK_IMPORTED_MODULE_4__.logger.debug( + "info info info" + ); + console.warn( + "In API", + _package_json__WEBPACK_IMPORTED_MODULE_2__.version + ); + parser = + _diagrams_info_parser_info__WEBPACK_IMPORTED_MODULE_25___default.a; + parser.parser.yy = + _diagrams_info_infoDb__WEBPACK_IMPORTED_MODULE_26__.default; + break; + + case "pie": + _logger__WEBPACK_IMPORTED_MODULE_4__.logger.debug( + "pie" + ); + parser = + _diagrams_pie_parser_pie__WEBPACK_IMPORTED_MODULE_28___default.a; + parser.parser.yy = + _diagrams_pie_pieDb__WEBPACK_IMPORTED_MODULE_29__.default; + break; + } + + parser.parser.yy.parseError = function (str, hash) { + var error = { + str: str, + hash: hash, + }; + throw error; + }; + + parser.parse(text); + } + + var encodeEntities = function encodeEntities(text) { + var txt = text; + txt = txt.replace(/style.*:\S*#.*;/g, function (s) { + var innerTxt = s.substring(0, s.length - 1); + return innerTxt; + }); + txt = txt.replace(/classDef.*:\S*#.*;/g, function (s) { + var innerTxt = s.substring(0, s.length - 1); + return innerTxt; + }); + txt = txt.replace(/#\w+;/g, function (s) { + var innerTxt = s.substring(1, s.length - 1); + var isInt = /^\+?\d+$/.test(innerTxt); + + if (isInt) { + return "fl°°" + innerTxt + "¶ß"; + } + return "fl°" + innerTxt + "¶ß"; + + }); + return txt; + }; + var decodeEntities = function decodeEntities(text) { + var txt = text; + txt = txt.replace(/fl°°/g, function () { + return "&#"; + }); + txt = txt.replace(/fl°/g, function () { + return "&"; + }); + txt = txt.replace(/¶ß/g, function () { + return ";"; + }); + return txt; + }; + /** + * Function that renders an svg with a graph from a chart definition. Usage example below. + * + * ```js + * mermaidAPI.initialize({ + * startOnLoad:true + * }); + * $(function(){ + * const graphDefinition = 'graph TB\na-->b'; + * const cb = function(svgGraph){ + * console.log(svgGraph); + * }; + * mermaidAPI.render('id1',graphDefinition,cb); + * }); + *``` + * @param id the id of the element to be rendered + * @param txt the graph definition + * @param cb callback which is called after rendering is finished with the svg code as inparam. + * @param container selector to element in which a div with the graph temporarily will be inserted. In one is + * provided a hidden div will be inserted in the body of the page instead. The element will be removed when rendering is + * completed. + */ + + var render = function render(id, txt, cb, container) { + if (typeof container !== "undefined") { + container.innerHTML = ""; + d3__WEBPACK_IMPORTED_MODULE_0__.select(container) + .append("div") + .attr("id", "d" + id) + .attr("style", "font-family: " + config.fontFamily) + .append("svg") + .attr("id", id) + .attr("width", "100%") + .attr("xmlns", "http://www.w3.org/2000/svg") + .append("g"); + } else { + var existingSvg = document.getElementById(id); + + if (existingSvg) { + existingSvg.remove(); + } + + var _element = document.querySelector("#" + "d" + id); + + if (_element) { + _element.innerHTML = ""; + } + + d3__WEBPACK_IMPORTED_MODULE_0__.select("body") + .append("div") + .attr("id", "d" + id) + .append("svg") + .attr("id", id) + .attr("width", "100%") + .attr("xmlns", "http://www.w3.org/2000/svg") + .append("g"); + } + + window.txt = txt; + txt = encodeEntities(txt); + var element = d3__WEBPACK_IMPORTED_MODULE_0__.select( + "#d" + id + ).node(); + var graphType = _utils__WEBPACK_IMPORTED_MODULE_5__.default.detectType(txt); // Insert inline style into svg + + var svg = element.firstChild; + var firstChild = svg.firstChild; // Pre-defined theme + + var style = themes[config.theme]; + + if (style === undefined) { + style = ""; + } // User provided theme CSS + + if (config.themeCSS !== undefined) { + style += "\n".concat(config.themeCSS); + } // User provided theme CSS + + if (config.fontFamily !== undefined) { + style += "\n:root { --mermaid-font-family: ".concat( + config.fontFamily, + "}" + ); + } // User provided theme CSS + + if (config.altFontFamily !== undefined) { + style += "\n:root { --mermaid-alt-font-family: ".concat( + config.altFontFamily, + "}" + ); + } // ClassDef + + if (graphType === "flowchart") { + var classes = _diagrams_flowchart_flowRenderer__WEBPACK_IMPORTED_MODULE_6__.default.getClasses(txt); + + for (var className in classes) { + style += "\n." + .concat(className, " > * { ") + .concat( + classes[className].styles.join(" !important; "), + " !important; }" + ); + } + } + + var style1 = document.createElement("style"); + style1.innerHTML = scope_css__WEBPACK_IMPORTED_MODULE_1___default()( + style, + "#".concat(id) + ); + svg.insertBefore(style1, firstChild); + var style2 = document.createElement("style"); + var cs = window.getComputedStyle(svg); + style2.innerHTML = "#" + .concat(id, " {\n color: ") + .concat(cs.color, ";\n font: ") + .concat(cs.font, ";\n }"); + svg.insertBefore(style2, firstChild); + + switch (graphType) { + case "git": + config.flowchart.arrowMarkerAbsolute = + config.arrowMarkerAbsolute; + _diagrams_git_gitGraphRenderer__WEBPACK_IMPORTED_MODULE_21__.default.setConf(config.git); + _diagrams_git_gitGraphRenderer__WEBPACK_IMPORTED_MODULE_21__.default.draw(txt, id, false); + break; + + case "flowchart": + config.flowchart.arrowMarkerAbsolute = + config.arrowMarkerAbsolute; + _diagrams_flowchart_flowRenderer__WEBPACK_IMPORTED_MODULE_6__.default.setConf(config.flowchart); + _diagrams_flowchart_flowRenderer__WEBPACK_IMPORTED_MODULE_6__.default.draw(txt, id, false); + break; + + case "sequence": + config.sequence.arrowMarkerAbsolute = + config.arrowMarkerAbsolute; + + if (config.sequenceDiagram) { + // Backwards compatibility + _diagrams_sequence_sequenceRenderer__WEBPACK_IMPORTED_MODULE_9__.default.setConf( + Object.assign( + config.sequence, + config.sequenceDiagram + ) + ); + console.error( + "`mermaid config.sequenceDiagram` has been renamed to `config.sequence`. Please update your mermaid config." + ); + } else { + _diagrams_sequence_sequenceRenderer__WEBPACK_IMPORTED_MODULE_9__.default.setConf(config.sequence); + } + + _diagrams_sequence_sequenceRenderer__WEBPACK_IMPORTED_MODULE_9__.default.draw(txt, id); + break; + + case "gantt": + config.gantt.arrowMarkerAbsolute = + config.arrowMarkerAbsolute; + _diagrams_gantt_ganttRenderer__WEBPACK_IMPORTED_MODULE_12__.default.setConf(config.gantt); + _diagrams_gantt_ganttRenderer__WEBPACK_IMPORTED_MODULE_12__.default.draw(txt, id); + break; + + case "class": + config.class.arrowMarkerAbsolute = + config.arrowMarkerAbsolute; + _diagrams_class_classRenderer__WEBPACK_IMPORTED_MODULE_15__.default.setConf(config.class); + _diagrams_class_classRenderer__WEBPACK_IMPORTED_MODULE_15__.default.draw(txt, id); + break; + + case "state": + // Config.class.arrowMarkerAbsolute = config.arrowMarkerAbsolute; + _diagrams_state_stateRenderer__WEBPACK_IMPORTED_MODULE_18__.default.setConf(config.state); + _diagrams_state_stateRenderer__WEBPACK_IMPORTED_MODULE_18__.default.draw(txt, id); + break; + + case "info": + config.class.arrowMarkerAbsolute = + config.arrowMarkerAbsolute; + _diagrams_info_infoRenderer__WEBPACK_IMPORTED_MODULE_24__.default.setConf(config.class); + _diagrams_info_infoRenderer__WEBPACK_IMPORTED_MODULE_24__.default.draw( + txt, + id, + _package_json__WEBPACK_IMPORTED_MODULE_2__.version + ); + break; + + case "pie": + config.class.arrowMarkerAbsolute = + config.arrowMarkerAbsolute; + _diagrams_pie_pieRenderer__WEBPACK_IMPORTED_MODULE_27__.default.setConf(config.class); + _diagrams_pie_pieRenderer__WEBPACK_IMPORTED_MODULE_27__.default.draw( + txt, + id, + _package_json__WEBPACK_IMPORTED_MODULE_2__.version + ); + break; + } + + d3__WEBPACK_IMPORTED_MODULE_0__.select( + '[id="'.concat(id, '"]') + ) + .selectAll("foreignobject > *") + .attr("xmlns", "http://www.w3.org/1999/xhtml"); + var url = ""; + + if (config.arrowMarkerAbsolute) { + url = + window.location.protocol + + "//" + + window.location.host + + window.location.pathname + + window.location.search; + url = url.replace(/\(/g, "\\("); + url = url.replace(/\)/g, "\\)"); + } // Fix for when the base tag is used + + var svgCode = d3__WEBPACK_IMPORTED_MODULE_0__.select( + "#d" + id + ) + .node() + .innerHTML.replace( + /url\(#arrowhead/g, + "url(" + url + "#arrowhead", + "g" + ); + svgCode = decodeEntities(svgCode); + + if (typeof cb !== "undefined") { + switch (graphType) { + case "flowchart": + cb( + svgCode, + _diagrams_flowchart_flowDb__WEBPACK_IMPORTED_MODULE_8__.default.bindFunctions + ); + break; + + case "gantt": + cb( + svgCode, + _diagrams_gantt_ganttDb__WEBPACK_IMPORTED_MODULE_14__.default.bindFunctions + ); + break; + + default: + cb(svgCode); + } + } else { + _logger__WEBPACK_IMPORTED_MODULE_4__.logger.debug( + "CB = undefined!" + ); + } + + var node = d3__WEBPACK_IMPORTED_MODULE_0__.select( + "#d" + id + ).node(); + + if (node !== null && typeof node.remove === "function") { + d3__WEBPACK_IMPORTED_MODULE_0__.select("#d" + id) + .node() + .remove(); + } + + return svgCode; + }; + + var setConf = function setConf(cnf) { + // Top level initially mermaid, gflow, sequenceDiagram and gantt + var lvl1Keys = Object.keys(cnf); + + for (var i = 0; i < lvl1Keys.length; i++) { + if ( + _typeof(cnf[lvl1Keys[i]]) === "object" && + cnf[lvl1Keys[i]] != null + ) { + var lvl2Keys = Object.keys(cnf[lvl1Keys[i]]); + + for (var j = 0; j < lvl2Keys.length; j++) { + _logger__WEBPACK_IMPORTED_MODULE_4__.logger.debug( + "Setting conf ", + lvl1Keys[i], + "-", + lvl2Keys[j] + ); + + if (typeof config[lvl1Keys[i]] === "undefined") { + config[lvl1Keys[i]] = {}; + } + + _logger__WEBPACK_IMPORTED_MODULE_4__.logger.debug( + "Setting config: " + + lvl1Keys[i] + + " " + + lvl2Keys[j] + + " to " + + cnf[lvl1Keys[i]][lvl2Keys[j]] + ); + config[lvl1Keys[i]][lvl2Keys[j]] = + cnf[lvl1Keys[i]][lvl2Keys[j]]; + } + } else { + config[lvl1Keys[i]] = cnf[lvl1Keys[i]]; + } + } + }; + + function initialize(options) { + _logger__WEBPACK_IMPORTED_MODULE_4__.logger.debug( + "Initializing mermaidAPI ", + _package_json__WEBPACK_IMPORTED_MODULE_2__.version + ); // Update default config with options supplied at initialization + + if (_typeof(options) === "object") { + setConf(options); + } + + Object(_config__WEBPACK_IMPORTED_MODULE_3__.setConfig)( + config + ); + Object(_logger__WEBPACK_IMPORTED_MODULE_4__.setLogLevel)( + config.logLevel + ); + } // Function getConfig () { + // console.warn('get config') + // return config + // } + + var mermaidAPI = { + render: render, + parse: parse, + initialize: initialize, + getConfig: _config__WEBPACK_IMPORTED_MODULE_3__.getConfig, + }; + /* Harmony default export */ __webpack_exports__.default = mermaidAPI; + /** + * ## mermaidAPI configuration defaults + * 
+                     *
+                     * 
+                     *
+ */ + + /***/ + }, + + /***/ "./src/themes sync recursive ^\\.\\/.*\\/index\\.scss$": + /* !***********************************************!*\ + !*** ./src/themes sync ^\.\/.*\/index\.scss$ ***! + \***********************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + var map = { + "./dark/index.scss": "./src/themes/dark/index.scss", + "./default/index.scss": "./src/themes/default/index.scss", + "./forest/index.scss": "./src/themes/forest/index.scss", + "./neutral/index.scss": "./src/themes/neutral/index.scss", + }; + + function webpackContext(req) { + var id = webpackContextResolve(req); + return __webpack_require__(id); + } + function webpackContextResolve(req) { + if (!__webpack_require__.o(map, req)) { + var e = new Error("Cannot find module '" + req + "'"); + e.code = "MODULE_NOT_FOUND"; + throw e; + } + return map[req]; + } + webpackContext.keys = function webpackContextKeys() { + return Object.keys(map); + }; + webpackContext.resolve = webpackContextResolve; + module.exports = webpackContext; + webpackContext.id = + "./src/themes sync recursive ^\\.\\/.*\\/index\\.scss$"; + + /***/ + }, + + /***/ "./src/themes/dark/index.scss": + /* !************************************!*\ + !*** ./src/themes/dark/index.scss ***! + \************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + // Css-to-string-loader: transforms styles from css-loader to a string output + + // Get the styles + var styles = __webpack_require__( + /* ! !../../../node_modules/css-loader/dist/cjs.js!../../../node_modules/sass-loader/dist/cjs.js!./index.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/dark/index.scss" + ); + + if (typeof styles === "string") { + // Return an existing string + module.exports = styles; + } else { + // Call the custom toString method from css-loader module + module.exports = styles.toString(); + } + + /***/ + }, + + /***/ "./src/themes/default/index.scss": + /* !***************************************!*\ + !*** ./src/themes/default/index.scss ***! + \***************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + // Css-to-string-loader: transforms styles from css-loader to a string output + + // Get the styles + var styles = __webpack_require__( + /* ! !../../../node_modules/css-loader/dist/cjs.js!../../../node_modules/sass-loader/dist/cjs.js!./index.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/default/index.scss" + ); + + if (typeof styles === "string") { + // Return an existing string + module.exports = styles; + } else { + // Call the custom toString method from css-loader module + module.exports = styles.toString(); + } + + /***/ + }, + + /***/ "./src/themes/forest/index.scss": + /* !**************************************!*\ + !*** ./src/themes/forest/index.scss ***! + \**************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + // Css-to-string-loader: transforms styles from css-loader to a string output + + // Get the styles + var styles = __webpack_require__( + /* ! !../../../node_modules/css-loader/dist/cjs.js!../../../node_modules/sass-loader/dist/cjs.js!./index.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/forest/index.scss" + ); + + if (typeof styles === "string") { + // Return an existing string + module.exports = styles; + } else { + // Call the custom toString method from css-loader module + module.exports = styles.toString(); + } + + /***/ + }, + + /***/ "./src/themes/neutral/index.scss": + /* !***************************************!*\ + !*** ./src/themes/neutral/index.scss ***! + \***************************************/ + /* ! no static exports found */ + /***/ function (module, exports, __webpack_require__) { + // Css-to-string-loader: transforms styles from css-loader to a string output + + // Get the styles + var styles = __webpack_require__( + /* ! !../../../node_modules/css-loader/dist/cjs.js!../../../node_modules/sass-loader/dist/cjs.js!./index.scss */ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/dist/cjs.js!./src/themes/neutral/index.scss" + ); + + if (typeof styles === "string") { + // Return an existing string + module.exports = styles; + } else { + // Call the custom toString method from css-loader module + module.exports = styles.toString(); + } + + /***/ + }, + + /***/ "./src/utils.js": + /* !**********************!*\ + !*** ./src/utils.js ***! + \**********************/ + /* ! exports provided: detectType, isSubstringInArray, interpolateToCurve, default */ + /***/ function (module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.r(__webpack_exports__); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "detectType", + function () { + return detectType; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "isSubstringInArray", + function () { + return isSubstringInArray; + } + ); + /* Harmony export (binding) */ __webpack_require__.d( + __webpack_exports__, + "interpolateToCurve", + function () { + return interpolateToCurve; + } + ); + /* Harmony import */ var d3__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__( + /* ! d3 */ "./node_modules/d3/index.js" + ); + /* Harmony import */ var _logger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__( + /* ! ./logger */ "./src/logger.js" + ); + + /** + * @function detectType + * Detects the type of the graph text. + * ```mermaid + * graph LR + * a-->b + * b-->c + * c-->d + * d-->e + * e-->f + * f-->g + * g-->h + * ``` + * + * @param {string} text The text defining the graph + * @returns {string} A graph definition key + */ + + var detectType = function detectType(text) { + text = text.replace(/^\s*%%.*\n/g, "\n"); + _logger__WEBPACK_IMPORTED_MODULE_1__.logger.debug( + "Detecting diagram type based on the text " + text + ); + + if (text.match(/^\s*sequenceDiagram/)) { + return "sequence"; + } + + if (text.match(/^\s*gantt/)) { + return "gantt"; + } + + if (text.match(/^\s*classDiagram/)) { + return "class"; + } + + if (text.match(/^\s*stateDiagram/)) { + return "state"; + } + + if (text.match(/^\s*gitGraph/)) { + return "git"; + } + + if (text.match(/^\s*info/)) { + return "info"; + } + + if (text.match(/^\s*pie/)) { + return "pie"; + } + + return "flowchart"; + }; + /** + * @function isSubstringInArray + * Detects whether a substring in present in a given array + * @param {string} str The substring to detect + * @param {array} arr The array to search + * @returns {number} the array index containing the substring or -1 if not present + **/ + + var isSubstringInArray = function isSubstringInArray(str, arr) { + for (var i = 0; i < arr.length; i++) { + if (arr[i].match(str)) return i; + } + + return -1; + }; + var interpolateToCurve = function interpolateToCurve( + interpolate, + defaultCurve + ) { + if (!interpolate) { + return defaultCurve; + } + + var curveName = "curve".concat( + interpolate.charAt(0).toUpperCase() + interpolate.slice(1) + ); + return ( + d3__WEBPACK_IMPORTED_MODULE_0__[curveName] || defaultCurve + ); + }; + + var distance = function distance(p1, p2) { + return p1 && p2 + ? Math.sqrt( + Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2) + ) + : 0; + }; + + var traverseEdge = function traverseEdge(points) { + var prevPoint; + var totalDistance = 0; + points.forEach(function (point) { + totalDistance += distance(point, prevPoint); + prevPoint = point; + }); // Traverse half of total distance along points + + var distanceToLabel = totalDistance / 2; + var remainingDistance = distanceToLabel; + var center; + prevPoint = undefined; + points.forEach(function (point) { + if (prevPoint && !center) { + var vectorDistance = distance(point, prevPoint); + + if (vectorDistance < remainingDistance) { + remainingDistance -= vectorDistance; + } else { + // The point is remainingDistance from prevPoint in the vector between prevPoint and point + // Calculate the coordinates + var distanceRatio = + remainingDistance / vectorDistance; + if (distanceRatio <= 0) center = prevPoint; + if (distanceRatio >= 1) + center = { + x: point.x, + y: point.y, + }; + + if (distanceRatio > 0 && distanceRatio < 1) { + center = { + x: + (1 - distanceRatio) * prevPoint.x + + distanceRatio * point.x, + y: + (1 - distanceRatio) * prevPoint.y + + distanceRatio * point.y, + }; + } + } + } + + prevPoint = point; + }); + return center; + }; + + var calcLabelPosition = function calcLabelPosition(points) { + var p = traverseEdge(points); + return p; + }; + + var calcCardinalityPosition = function calcCardinalityPosition( + isRelationTypePresent, + points, + initialPosition + ) { + var prevPoint; + var totalDistance = 0; + + if (points[0] !== initialPosition) { + points = points.reverse(); + } + + points.forEach(function (point) { + totalDistance += distance(point, prevPoint); + prevPoint = point; + }); // Traverse only 25 total distance along points to find cardinality point + + var distanceToCardinalityPoint = 25; + var remainingDistance = distanceToCardinalityPoint; + var center; + prevPoint = undefined; + points.forEach(function (point) { + if (prevPoint && !center) { + var vectorDistance = distance(point, prevPoint); + + if (vectorDistance < remainingDistance) { + remainingDistance -= vectorDistance; + } else { + // The point is remainingDistance from prevPoint in the vector between prevPoint and point + // Calculate the coordinates + var distanceRatio = + remainingDistance / vectorDistance; + if (distanceRatio <= 0) center = prevPoint; + if (distanceRatio >= 1) + center = { + x: point.x, + y: point.y, + }; + + if (distanceRatio > 0 && distanceRatio < 1) { + center = { + x: + (1 - distanceRatio) * prevPoint.x + + distanceRatio * point.x, + y: + (1 - distanceRatio) * prevPoint.y + + distanceRatio * point.y, + }; + } + } + } + + prevPoint = point; + }); // If relation is present (Arrows will be added), change cardinality point off-set distance (d) + + var d = isRelationTypePresent ? 10 : 5; // Calculate Angle for x and y axis + + var angle = Math.atan2( + points[0].y - center.y, + points[0].x - center.x + ); + var cardinalityPosition = { + x: 0, + y: 0, + }; // Calculation cardinality position using angle, center point on the line/curve but pendicular and with offset-distance + + cardinalityPosition.x = + Math.sin(angle) * d + (points[0].x + center.x) / 2; + cardinalityPosition.y = + -Math.cos(angle) * d + (points[0].y + center.y) / 2; + return cardinalityPosition; + }; + + /* Harmony default export */ __webpack_exports__.default = { + detectType: detectType, + isSubstringInArray: isSubstringInArray, + interpolateToCurve: interpolateToCurve, + calcLabelPosition: calcLabelPosition, + calcCardinalityPosition: calcCardinalityPosition, + }; + + /***/ + }, + + /***/ 0: + /* !**********************!*\ + !*** util (ignored) ***! + \**********************/ + /* ! no static exports found */ + /***/ function (module, exports) { + /* (ignored) */ + /***/ + }, + + /***/ 1: + /* !**********************!*\ + !*** util (ignored) ***! + \**********************/ + /* ! no static exports found */ + /***/ function (module, exports) { + /* (ignored) */ + /***/ + }, + + /***/ 2: + /* !************************!*\ + !*** buffer (ignored) ***! + \************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + /* (ignored) */ + /***/ + }, + + /***/ 3: + /* !************************!*\ + !*** crypto (ignored) ***! + \************************/ + /* ! no static exports found */ + /***/ function (module, exports) { + /* (ignored) */ + /***/ + }, + + /** ****/ + } + ).default; +}); +// # sourceMappingURL=mermaid.js.map diff --git a/web_widget_mermaid/view/web_widget_mermaid_view.xml b/web_widget_mermaid/view/web_widget_mermaid_view.xml index f6f69b89b..d62b47643 100644 --- a/web_widget_mermaid/view/web_widget_mermaid_view.xml +++ b/web_widget_mermaid/view/web_widget_mermaid_view.xml @@ -8,7 +8,7 @@