X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/daf91662980dfeb6549c2f44c88c428cdcb001a7..81ce6a7de0be8ada90ebc587506d957d609babfa:/vendor/assets/iD/iD.js diff --git a/vendor/assets/iD/iD.js b/vendor/assets/iD/iD.js index 44f893227..ad4c20493 100644 --- a/vendor/assets/iD/iD.js +++ b/vendor/assets/iD/iD.js @@ -1,71066 +1,79786 @@ -(function(exports) { - - var bootstrap = (typeof exports.bootstrap === "object") ? - exports.bootstrap : - (exports.bootstrap = {}); - - bootstrap.tooltip = function() { - - var tooltip = function(selection) { - selection.each(setup); - }, - animation = d3.functor(false), - html = d3.functor(false), - title = function() { - var title = this.getAttribute("data-original-title"); - if (title) { - return title; - } else { - title = this.getAttribute("title"); - this.removeAttribute("title"); - this.setAttribute("data-original-title", title); +(() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod + )); + + // node_modules/diacritics/index.js + var require_diacritics = __commonJS({ + "node_modules/diacritics/index.js"(exports2) { + exports2.remove = removeDiacritics2; + var replacementList = [ + { + base: " ", + chars: "\xA0" + }, + { + base: "0", + chars: "\u07C0" + }, + { + base: "A", + chars: "\u24B6\uFF21\xC0\xC1\xC2\u1EA6\u1EA4\u1EAA\u1EA8\xC3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\xC4\u01DE\u1EA2\xC5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F" + }, + { + base: "AA", + chars: "\uA732" + }, + { + base: "AE", + chars: "\xC6\u01FC\u01E2" + }, + { + base: "AO", + chars: "\uA734" + }, + { + base: "AU", + chars: "\uA736" + }, + { + base: "AV", + chars: "\uA738\uA73A" + }, + { + base: "AY", + chars: "\uA73C" + }, + { + base: "B", + chars: "\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0181" + }, + { + base: "C", + chars: "\u24B8\uFF23\uA73E\u1E08\u0106C\u0108\u010A\u010C\xC7\u0187\u023B" + }, + { + base: "D", + chars: "\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018A\u0189\u1D05\uA779" + }, + { + base: "Dh", + chars: "\xD0" + }, + { + base: "DZ", + chars: "\u01F1\u01C4" + }, + { + base: "Dz", + chars: "\u01F2\u01C5" + }, + { + base: "E", + chars: "\u025B\u24BA\uFF25\xC8\xC9\xCA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\xCB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E\u1D07" + }, + { + base: "F", + chars: "\uA77C\u24BB\uFF26\u1E1E\u0191\uA77B" + }, + { + base: "G", + chars: "\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E\u0262" + }, + { + base: "H", + chars: "\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D" + }, + { + base: "I", + chars: "\u24BE\uFF29\xCC\xCD\xCE\u0128\u012A\u012C\u0130\xCF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197" + }, + { + base: "J", + chars: "\u24BF\uFF2A\u0134\u0248\u0237" + }, + { + base: "K", + chars: "\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2" + }, + { + base: "L", + chars: "\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780" + }, + { + base: "LJ", + chars: "\u01C7" + }, + { + base: "Lj", + chars: "\u01C8" + }, + { + base: "M", + chars: "\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C\u03FB" + }, + { + base: "N", + chars: "\uA7A4\u0220\u24C3\uFF2E\u01F8\u0143\xD1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u019D\uA790\u1D0E" + }, + { + base: "NJ", + chars: "\u01CA" + }, + { + base: "Nj", + chars: "\u01CB" + }, + { + base: "O", + chars: "\u24C4\uFF2F\xD2\xD3\xD4\u1ED2\u1ED0\u1ED6\u1ED4\xD5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\xD6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\xD8\u01FE\u0186\u019F\uA74A\uA74C" + }, + { + base: "OE", + chars: "\u0152" + }, + { + base: "OI", + chars: "\u01A2" + }, + { + base: "OO", + chars: "\uA74E" + }, + { + base: "OU", + chars: "\u0222" + }, + { + base: "P", + chars: "\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754" + }, + { + base: "Q", + chars: "\u24C6\uFF31\uA756\uA758\u024A" + }, + { + base: "R", + chars: "\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782" + }, + { + base: "S", + chars: "\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784" + }, + { + base: "T", + chars: "\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786" + }, + { + base: "Th", + chars: "\xDE" + }, + { + base: "TZ", + chars: "\uA728" + }, + { + base: "U", + chars: "\u24CA\uFF35\xD9\xDA\xDB\u0168\u1E78\u016A\u1E7A\u016C\xDC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244" + }, + { + base: "V", + chars: "\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245" + }, + { + base: "VY", + chars: "\uA760" + }, + { + base: "W", + chars: "\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72" + }, + { + base: "X", + chars: "\u24CD\uFF38\u1E8A\u1E8C" + }, + { + base: "Y", + chars: "\u24CE\uFF39\u1EF2\xDD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE" + }, + { + base: "Z", + chars: "\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762" + }, + { + base: "a", + chars: "\u24D0\uFF41\u1E9A\xE0\xE1\xE2\u1EA7\u1EA5\u1EAB\u1EA9\xE3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\xE4\u01DF\u1EA3\xE5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250\u0251" + }, + { + base: "aa", + chars: "\uA733" + }, + { + base: "ae", + chars: "\xE6\u01FD\u01E3" + }, + { + base: "ao", + chars: "\uA735" + }, + { + base: "au", + chars: "\uA737" + }, + { + base: "av", + chars: "\uA739\uA73B" + }, + { + base: "ay", + chars: "\uA73D" + }, + { + base: "b", + chars: "\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253\u0182" + }, + { + base: "c", + chars: "\uFF43\u24D2\u0107\u0109\u010B\u010D\xE7\u1E09\u0188\u023C\uA73F\u2184" + }, + { + base: "d", + chars: "\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\u018B\u13E7\u0501\uA7AA" + }, + { + base: "dh", + chars: "\xF0" + }, + { + base: "dz", + chars: "\u01F3\u01C6" + }, + { + base: "e", + chars: "\u24D4\uFF45\xE8\xE9\xEA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\xEB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u01DD" + }, + { + base: "f", + chars: "\u24D5\uFF46\u1E1F\u0192" + }, + { + base: "ff", + chars: "\uFB00" + }, + { + base: "fi", + chars: "\uFB01" + }, + { + base: "fl", + chars: "\uFB02" + }, + { + base: "ffi", + chars: "\uFB03" + }, + { + base: "ffl", + chars: "\uFB04" + }, + { + base: "g", + chars: "\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\uA77F\u1D79" + }, + { + base: "h", + chars: "\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265" + }, + { + base: "hv", + chars: "\u0195" + }, + { + base: "i", + chars: "\u24D8\uFF49\xEC\xED\xEE\u0129\u012B\u012D\xEF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131" + }, + { + base: "j", + chars: "\u24D9\uFF4A\u0135\u01F0\u0249" + }, + { + base: "k", + chars: "\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3" + }, + { + base: "l", + chars: "\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747\u026D" + }, + { + base: "lj", + chars: "\u01C9" + }, + { + base: "m", + chars: "\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F" + }, + { + base: "n", + chars: "\u24DD\uFF4E\u01F9\u0144\xF1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5\u043B\u0509" + }, + { + base: "nj", + chars: "\u01CC" + }, + { + base: "o", + chars: "\u24DE\uFF4F\xF2\xF3\xF4\u1ED3\u1ED1\u1ED7\u1ED5\xF5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\xF6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\xF8\u01FF\uA74B\uA74D\u0275\u0254\u1D11" + }, + { + base: "oe", + chars: "\u0153" + }, + { + base: "oi", + chars: "\u01A3" + }, + { + base: "oo", + chars: "\uA74F" + }, + { + base: "ou", + chars: "\u0223" + }, + { + base: "p", + chars: "\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755\u03C1" + }, + { + base: "q", + chars: "\u24E0\uFF51\u024B\uA757\uA759" + }, + { + base: "r", + chars: "\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783" + }, + { + base: "s", + chars: "\u24E2\uFF53\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B\u0282" + }, + { + base: "ss", + chars: "\xDF" + }, + { + base: "t", + chars: "\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787" + }, + { + base: "th", + chars: "\xFE" + }, + { + base: "tz", + chars: "\uA729" + }, + { + base: "u", + chars: "\u24E4\uFF55\xF9\xFA\xFB\u0169\u1E79\u016B\u1E7B\u016D\xFC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289" + }, + { + base: "v", + chars: "\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C" + }, + { + base: "vy", + chars: "\uA761" + }, + { + base: "w", + chars: "\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73" + }, + { + base: "x", + chars: "\u24E7\uFF58\u1E8B\u1E8D" + }, + { + base: "y", + chars: "\u24E8\uFF59\u1EF3\xFD\u0177\u1EF9\u0233\u1E8F\xFF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF" + }, + { + base: "z", + chars: "\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763" + } + ]; + var diacriticsMap = {}; + for (i2 = 0; i2 < replacementList.length; i2 += 1) { + chars = replacementList[i2].chars; + for (j2 = 0; j2 < chars.length; j2 += 1) { + diacriticsMap[chars[j2]] = replacementList[i2].base; } - return title; - }, - over = "mouseenter.tooltip", - out = "mouseleave.tooltip", - placements = "top left bottom right".split(" "), - placement = d3.functor("top"); - - tooltip.title = function(_) { - if (arguments.length) { - title = d3.functor(_); - return tooltip; - } else { - return title; } - }; - - tooltip.html = function(_) { - if (arguments.length) { - html = d3.functor(_); - return tooltip; - } else { - return html; + var chars; + var j2; + var i2; + function removeDiacritics2(str2) { + return str2.replace(/[^\u0000-\u007e]/g, function(c) { + return diacriticsMap[c] || c; + }); } - }; + exports2.replacementList = replacementList; + exports2.diacriticsMap = diacriticsMap; + } + }); - tooltip.placement = function(_) { - if (arguments.length) { - placement = d3.functor(_); - return tooltip; - } else { - return placement; + // node_modules/alif-toolkit/lib/isArabic.js + var require_isArabic = __commonJS({ + "node_modules/alif-toolkit/lib/isArabic.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var arabicBlocks = [ + [1536, 1791], + [1872, 1919], + [2208, 2303], + [64336, 65023], + [65136, 65279], + [69216, 69247], + [126064, 126143], + [126464, 126719] + // Mathematical Alphabetic symbols https://www.unicode.org/charts/PDF/U1EE00.pdf + ]; + function isArabic(char) { + if (char.length > 1) { + throw new Error("isArabic works on only one-character strings"); + } + let code = char.charCodeAt(0); + for (let i2 = 0; i2 < arabicBlocks.length; i2++) { + let block2 = arabicBlocks[i2]; + if (code >= block2[0] && code <= block2[1]) { + return true; + } + } + return false; } - }; - - tooltip.show = function(selection) { - selection.each(show); - }; - - tooltip.hide = function(selection) { - selection.each(hide); - }; - - tooltip.toggle = function(selection) { - selection.each(toggle); - }; - - tooltip.destroy = function(selection) { - selection - .on(over, null) - .on(out, null) - .attr("title", function() { - return this.getAttribute("data-original-title") || this.getAttribute("title"); - }) - .attr("data-original-title", null) - .select(".tooltip") - .remove(); - }; - - function setup() { - var root = d3.select(this), - animate = animation.apply(this, arguments), - tip = root.append("div") - .attr("class", "tooltip"); - - if (animate) { - tip.classed("fade", true); + exports2.isArabic = isArabic; + function isMath(char) { + if (char.length > 2) { + throw new Error("isMath works on only one-character strings"); + } + let code = char.charCodeAt(0); + return code >= 1632 && code <= 1644 || code >= 1776 && code <= 1785; } - - // TODO "inside" checks? - - tip.append("div") - .attr("class", "tooltip-arrow"); - tip.append("div") - .attr("class", "tooltip-inner"); - - var place = placement.apply(this, arguments); - tip.classed(place, true); - - root.on(over, show); - root.on(out, hide); + exports2.isMath = isMath; } + }); - function show() { - var root = d3.select(this), - content = title.apply(this, arguments), - tip = root.select(".tooltip") - .classed("in", true), - markup = html.apply(this, arguments), - innercontent = tip.select(".tooltip-inner")[markup ? "html" : "text"](content), - place = placement.apply(this, arguments), - outer = getPosition(root.node()), - inner = getPosition(tip.node()), - pos; - - switch (place) { - case "top": - pos = {x: outer.x + (outer.w - inner.w) / 2, y: outer.y - inner.h}; - break; - case "right": - pos = {x: outer.x + outer.w, y: outer.y + (outer.h - inner.h) / 2}; - break; - case "left": - pos = {x: outer.x - inner.w, y: outer.y + (outer.h - inner.h) / 2}; - break; - case "bottom": - pos = {x: Math.max(0, outer.x + (outer.w - inner.w) / 2), y: outer.y + outer.h}; - break; - } - - tip.style(pos ? - {left: ~~pos.x + "px", top: ~~pos.y + "px"} : - {left: null, top: null}); - - this.tooltipVisible = true; + // node_modules/alif-toolkit/lib/unicode-arabic.js + var require_unicode_arabic = __commonJS({ + "node_modules/alif-toolkit/lib/unicode-arabic.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var arabicReference = { + "alef": { + "normal": [ + "\u0627" + ], + "madda_above": { + "normal": [ + "\u0627\u0653", + "\u0622" + ], + "isolated": "\uFE81", + "final": "\uFE82" + }, + "hamza_above": { + "normal": [ + "\u0627\u0654", + "\u0623" + ], + "isolated": "\uFE83", + "final": "\uFE84" + }, + "hamza_below": { + "normal": [ + "\u0627\u0655", + "\u0625" + ], + "isolated": "\uFE87", + "final": "\uFE88" + }, + "wasla": { + "normal": "\u0671", + "isolated": "\uFB50", + "final": "\uFB51" + }, + "wavy_hamza_above": [ + "\u0672" + ], + "wavy_hamza_below": [ + "\u0627\u065F", + "\u0673" + ], + "high_hamza": [ + "\u0675", + "\u0627\u0674" + ], + "indic_two_above": [ + "\u0773" + ], + "indic_three_above": [ + "\u0774" + ], + "fathatan": { + "normal": [ + "\u0627\u064B" + ], + "final": "\uFD3C", + "isolated": "\uFD3D" + }, + "isolated": "\uFE8D", + "final": "\uFE8E" + }, + "beh": { + "normal": [ + "\u0628" + ], + "dotless": [ + "\u066E" + ], + "three_dots_horizontally_below": [ + "\u0750" + ], + "dot_below_three_dots_above": [ + "\u0751" + ], + "three_dots_pointing_upwards_below": [ + "\u0752" + ], + "three_dots_pointing_upwards_below_two_dots_above": [ + "\u0753" + ], + "two_dots_below_dot_above": [ + "\u0754" + ], + "inverted_small_v_below": [ + "\u0755" + ], + "small_v": [ + "\u0756" + ], + "small_v_below": [ + "\u08A0" + ], + "hamza_above": [ + "\u08A1" + ], + "small_meem_above": [ + "\u08B6" + ], + "isolated": "\uFE8F", + "final": "\uFE90", + "initial": "\uFE91", + "medial": "\uFE92" + }, + "teh marbuta": { + "normal": [ + "\u0629" + ], + "isolated": "\uFE93", + "final": "\uFE94" + }, + "teh": { + "normal": [ + "\u062A" + ], + "ring": [ + "\u067C" + ], + "three_dots_above_downwards": [ + "\u067D" + ], + "small_teh_above": [ + "\u08B8" + ], + "isolated": "\uFE95", + "final": "\uFE96", + "initial": "\uFE97", + "medial": "\uFE98" + }, + "theh": { + "normal": [ + "\u062B" + ], + "isolated": "\uFE99", + "final": "\uFE9A", + "initial": "\uFE9B", + "medial": "\uFE9C" + }, + "jeem": { + "normal": [ + "\u062C" + ], + "two_dots_above": [ + "\u08A2" + ], + "isolated": "\uFE9D", + "final": "\uFE9E", + "initial": "\uFE9F", + "medial": "\uFEA0" + }, + "hah": { + "normal": [ + "\u062D" + ], + "hamza_above": [ + "\u0681" + ], + "two_dots_vertical_above": [ + "\u0682" + ], + "three_dots_above": [ + "\u0685" + ], + "two_dots_above": [ + "\u0757" + ], + "three_dots_pointing_upwards_below": [ + "\u0758" + ], + "small_tah_below": [ + "\u076E" + ], + "small_tah_two_dots": [ + "\u076F" + ], + "small_tah_above": [ + "\u0772" + ], + "indic_four_below": [ + "\u077C" + ], + "isolated": "\uFEA1", + "final": "\uFEA2", + "initial": "\uFEA3", + "medial": "\uFEA4" + }, + "khah": { + "normal": [ + "\u062E" + ], + "isolated": "\uFEA5", + "final": "\uFEA6", + "initial": "\uFEA7", + "medial": "\uFEA8" + }, + "dal": { + "normal": [ + "\u062F" + ], + "ring": [ + "\u0689" + ], + "dot_below": [ + "\u068A" + ], + "dot_below_small_tah": [ + "\u068B" + ], + "three_dots_above_downwards": [ + "\u068F" + ], + "four_dots_above": [ + "\u0690" + ], + "inverted_v": [ + "\u06EE" + ], + "two_dots_vertically_below_small_tah": [ + "\u0759" + ], + "inverted_small_v_below": [ + "\u075A" + ], + "three_dots_below": [ + "\u08AE" + ], + "isolated": "\uFEA9", + "final": "\uFEAA" + }, + "thal": { + "normal": [ + "\u0630" + ], + "isolated": "\uFEAB", + "final": "\uFEAC" + }, + "reh": { + "normal": [ + "\u0631" + ], + "small_v": [ + "\u0692" + ], + "ring": [ + "\u0693" + ], + "dot_below": [ + "\u0694" + ], + "small_v_below": [ + "\u0695" + ], + "dot_below_dot_above": [ + "\u0696" + ], + "two_dots_above": [ + "\u0697" + ], + "four_dots_above": [ + "\u0699" + ], + "inverted_v": [ + "\u06EF" + ], + "stroke": [ + "\u075B" + ], + "two_dots_vertically_above": [ + "\u076B" + ], + "hamza_above": [ + "\u076C" + ], + "small_tah_two_dots": [ + "\u0771" + ], + "loop": [ + "\u08AA" + ], + "small_noon_above": [ + "\u08B9" + ], + "isolated": "\uFEAD", + "final": "\uFEAE" + }, + "zain": { + "normal": [ + "\u0632" + ], + "inverted_v_above": [ + "\u08B2" + ], + "isolated": "\uFEAF", + "final": "\uFEB0" + }, + "seen": { + "normal": [ + "\u0633" + ], + "dot_below_dot_above": [ + "\u069A" + ], + "three_dots_below": [ + "\u069B" + ], + "three_dots_below_three_dots_above": [ + "\u069C" + ], + "four_dots_above": [ + "\u075C" + ], + "two_dots_vertically_above": [ + "\u076D" + ], + "small_tah_two_dots": [ + "\u0770" + ], + "indic_four_above": [ + "\u077D" + ], + "inverted_v": [ + "\u077E" + ], + "isolated": "\uFEB1", + "final": "\uFEB2", + "initial": "\uFEB3", + "medial": "\uFEB4" + }, + "sheen": { + "normal": [ + "\u0634" + ], + "dot_below": [ + "\u06FA" + ], + "isolated": "\uFEB5", + "final": "\uFEB6", + "initial": "\uFEB7", + "medial": "\uFEB8" + }, + "sad": { + "normal": [ + "\u0635" + ], + "two_dots_below": [ + "\u069D" + ], + "three_dots_above": [ + "\u069E" + ], + "three_dots_below": [ + "\u08AF" + ], + "isolated": "\uFEB9", + "final": "\uFEBA", + "initial": "\uFEBB", + "medial": "\uFEBC" + }, + "dad": { + "normal": [ + "\u0636" + ], + "dot_below": [ + "\u06FB" + ], + "isolated": "\uFEBD", + "final": "\uFEBE", + "initial": "\uFEBF", + "medial": "\uFEC0" + }, + "tah": { + "normal": [ + "\u0637" + ], + "three_dots_above": [ + "\u069F" + ], + "two_dots_above": [ + "\u08A3" + ], + "isolated": "\uFEC1", + "final": "\uFEC2", + "initial": "\uFEC3", + "medial": "\uFEC4" + }, + "zah": { + "normal": [ + "\u0638" + ], + "isolated": "\uFEC5", + "final": "\uFEC6", + "initial": "\uFEC7", + "medial": "\uFEC8" + }, + "ain": { + "normal": [ + "\u0639" + ], + "three_dots_above": [ + "\u06A0" + ], + "two_dots_above": [ + "\u075D" + ], + "three_dots_pointing_downwards_above": [ + "\u075E" + ], + "two_dots_vertically_above": [ + "\u075F" + ], + "three_dots_below": [ + "\u08B3" + ], + "isolated": "\uFEC9", + "final": "\uFECA", + "initial": "\uFECB", + "medial": "\uFECC" + }, + "ghain": { + "normal": [ + "\u063A" + ], + "dot_below": [ + "\u06FC" + ], + "isolated": "\uFECD", + "final": "\uFECE", + "initial": "\uFECF", + "medial": "\uFED0" + }, + "feh": { + "normal": [ + "\u0641" + ], + "dotless": [ + "\u06A1" + ], + "dot_moved_below": [ + "\u06A2" + ], + "dot_below": [ + "\u06A3" + ], + "three_dots_below": [ + "\u06A5" + ], + "two_dots_below": [ + "\u0760" + ], + "three_dots_pointing_upwards_below": [ + "\u0761" + ], + "dot_below_three_dots_above": [ + "\u08A4" + ], + "isolated": "\uFED1", + "final": "\uFED2", + "initial": "\uFED3", + "medial": "\uFED4" + }, + "qaf": { + "normal": [ + "\u0642" + ], + "dotless": [ + "\u066F" + ], + "dot_above": [ + "\u06A7" + ], + "three_dots_above": [ + "\u06A8" + ], + "dot_below": [ + "\u08A5" + ], + "isolated": "\uFED5", + "final": "\uFED6", + "initial": "\uFED7", + "medial": "\uFED8" + }, + "kaf": { + "normal": [ + "\u0643" + ], + "swash": [ + "\u06AA" + ], + "ring": [ + "\u06AB" + ], + "dot_above": [ + "\u06AC" + ], + "three_dots_below": [ + "\u06AE" + ], + "two_dots_above": [ + "\u077F" + ], + "dot_below": [ + "\u08B4" + ], + "isolated": "\uFED9", + "final": "\uFEDA", + "initial": "\uFEDB", + "medial": "\uFEDC" + }, + "lam": { + "normal": [ + "\u0644" + ], + "small_v": [ + "\u06B5" + ], + "dot_above": [ + "\u06B6" + ], + "three_dots_above": [ + "\u06B7" + ], + "three_dots_below": [ + "\u06B8" + ], + "bar": [ + "\u076A" + ], + "double_bar": [ + "\u08A6" + ], + "isolated": "\uFEDD", + "final": "\uFEDE", + "initial": "\uFEDF", + "medial": "\uFEE0" + }, + "meem": { + "normal": [ + "\u0645" + ], + "dot_above": [ + "\u0765" + ], + "dot_below": [ + "\u0766" + ], + "three_dots_above": [ + "\u08A7" + ], + "isolated": "\uFEE1", + "final": "\uFEE2", + "initial": "\uFEE3", + "medial": "\uFEE4" + }, + "noon": { + "normal": [ + "\u0646" + ], + "dot_below": [ + "\u06B9" + ], + "ring": [ + "\u06BC" + ], + "three_dots_above": [ + "\u06BD" + ], + "two_dots_below": [ + "\u0767" + ], + "small_tah": [ + "\u0768" + ], + "small_v": [ + "\u0769" + ], + "isolated": "\uFEE5", + "final": "\uFEE6", + "initial": "\uFEE7", + "medial": "\uFEE8" + }, + "heh": { + "normal": [ + "\u0647" + ], + "isolated": "\uFEE9", + "final": "\uFEEA", + "initial": "\uFEEB", + "medial": "\uFEEC" + }, + "waw": { + "normal": [ + "\u0648" + ], + "hamza_above": { + "normal": [ + "\u0624", + "\u0648\u0654" + ], + "isolated": "\uFE85", + "final": "\uFE86" + }, + "high_hamza": [ + "\u0676", + "\u0648\u0674" + ], + "ring": [ + "\u06C4" + ], + "two_dots_above": [ + "\u06CA" + ], + "dot_above": [ + "\u06CF" + ], + "indic_two_above": [ + "\u0778" + ], + "indic_three_above": [ + "\u0779" + ], + "dot_within": [ + "\u08AB" + ], + "isolated": "\uFEED", + "final": "\uFEEE" + }, + "alef_maksura": { + "normal": [ + "\u0649" + ], + "hamza_above": [ + "\u0626", + "\u064A\u0654" + ], + "initial": "\uFBE8", + "medial": "\uFBE9", + "isolated": "\uFEEF", + "final": "\uFEF0" + }, + "yeh": { + "normal": [ + "\u064A" + ], + "hamza_above": { + "normal": [ + "\u0626", + "\u0649\u0654" + ], + "isolated": "\uFE89", + "final": "\uFE8A", + "initial": "\uFE8B", + "medial": "\uFE8C" + }, + "two_dots_below_hamza_above": [ + "\u08A8" + ], + "high_hamza": [ + "\u0678", + "\u064A\u0674" + ], + "tail": [ + "\u06CD" + ], + "small_v": [ + "\u06CE" + ], + "three_dots_below": [ + "\u06D1" + ], + "two_dots_below_dot_above": [ + "\u08A9" + ], + "two_dots_below_small_noon_above": [ + "\u08BA" + ], + "isolated": "\uFEF1", + "final": "\uFEF2", + "initial": "\uFEF3", + "medial": "\uFEF4" + }, + "tteh": { + "normal": [ + "\u0679" + ], + "isolated": "\uFB66", + "final": "\uFB67", + "initial": "\uFB68", + "medial": "\uFB69" + }, + "tteheh": { + "normal": [ + "\u067A" + ], + "isolated": "\uFB5E", + "final": "\uFB5F", + "initial": "\uFB60", + "medial": "\uFB61" + }, + "beeh": { + "normal": [ + "\u067B" + ], + "isolated": "\uFB52", + "final": "\uFB53", + "initial": "\uFB54", + "medial": "\uFB55" + }, + "peh": { + "normal": [ + "\u067E" + ], + "small_meem_above": [ + "\u08B7" + ], + "isolated": "\uFB56", + "final": "\uFB57", + "initial": "\uFB58", + "medial": "\uFB59" + }, + "teheh": { + "normal": [ + "\u067F" + ], + "isolated": "\uFB62", + "final": "\uFB63", + "initial": "\uFB64", + "medial": "\uFB65" + }, + "beheh": { + "normal": [ + "\u0680" + ], + "isolated": "\uFB5A", + "final": "\uFB5B", + "initial": "\uFB5C", + "medial": "\uFB5D" + }, + "nyeh": { + "normal": [ + "\u0683" + ], + "isolated": "\uFB76", + "final": "\uFB77", + "initial": "\uFB78", + "medial": "\uFB79" + }, + "dyeh": { + "normal": [ + "\u0684" + ], + "isolated": "\uFB72", + "final": "\uFB73", + "initial": "\uFB74", + "medial": "\uFB75" + }, + "tcheh": { + "normal": [ + "\u0686" + ], + "dot_above": [ + "\u06BF" + ], + "isolated": "\uFB7A", + "final": "\uFB7B", + "initial": "\uFB7C", + "medial": "\uFB7D" + }, + "tcheheh": { + "normal": [ + "\u0687" + ], + "isolated": "\uFB7E", + "final": "\uFB7F", + "initial": "\uFB80", + "medial": "\uFB81" + }, + "ddal": { + "normal": [ + "\u0688" + ], + "isolated": "\uFB88", + "final": "\uFB89" + }, + "dahal": { + "normal": [ + "\u068C" + ], + "isolated": "\uFB84", + "final": "\uFB85" + }, + "ddahal": { + "normal": [ + "\u068D" + ], + "isolated": "\uFB82", + "final": "\uFB83" + }, + "dul": { + "normal": [ + "\u068F", + "\u068E" + ], + "isolated": "\uFB86", + "final": "\uFB87" + }, + "rreh": { + "normal": [ + "\u0691" + ], + "isolated": "\uFB8C", + "final": "\uFB8D" + }, + "jeh": { + "normal": [ + "\u0698" + ], + "isolated": "\uFB8A", + "final": "\uFB8B" + }, + "veh": { + "normal": [ + "\u06A4" + ], + "isolated": "\uFB6A", + "final": "\uFB6B", + "initial": "\uFB6C", + "medial": "\uFB6D" + }, + "peheh": { + "normal": [ + "\u06A6" + ], + "isolated": "\uFB6E", + "final": "\uFB6F", + "initial": "\uFB70", + "medial": "\uFB71" + }, + "keheh": { + "normal": [ + "\u06A9" + ], + "dot_above": [ + "\u0762" + ], + "three_dots_above": [ + "\u0763" + ], + "three_dots_pointing_upwards_below": [ + "\u0764" + ], + "isolated": "\uFB8E", + "final": "\uFB8F", + "initial": "\uFB90", + "medial": "\uFB91" + }, + "ng": { + "normal": [ + "\u06AD" + ], + "isolated": "\uFBD3", + "final": "\uFBD4", + "initial": "\uFBD5", + "medial": "\uFBD6" + }, + "gaf": { + "normal": [ + "\u06AF" + ], + "ring": [ + "\u06B0" + ], + "two_dots_below": [ + "\u06B2" + ], + "three_dots_above": [ + "\u06B4" + ], + "inverted_stroke": [ + "\u08B0" + ], + "isolated": "\uFB92", + "final": "\uFB93", + "initial": "\uFB94", + "medial": "\uFB95" + }, + "ngoeh": { + "normal": [ + "\u06B1" + ], + "isolated": "\uFB9A", + "final": "\uFB9B", + "initial": "\uFB9C", + "medial": "\uFB9D" + }, + "gueh": { + "normal": [ + "\u06B3" + ], + "isolated": "\uFB96", + "final": "\uFB97", + "initial": "\uFB98", + "medial": "\uFB99" + }, + "noon ghunna": { + "normal": [ + "\u06BA" + ], + "isolated": "\uFB9E", + "final": "\uFB9F" + }, + "rnoon": { + "normal": [ + "\u06BB" + ], + "isolated": "\uFBA0", + "final": "\uFBA1", + "initial": "\uFBA2", + "medial": "\uFBA3" + }, + "heh doachashmee": { + "normal": [ + "\u06BE" + ], + "isolated": "\uFBAA", + "final": "\uFBAB", + "initial": "\uFBAC", + "medial": "\uFBAD" + }, + "heh goal": { + "normal": [ + "\u06C1" + ], + "hamza_above": [ + "\u06C1\u0654", + "\u06C2" + ], + "isolated": "\uFBA6", + "final": "\uFBA7", + "initial": "\uFBA8", + "medial": "\uFBA9" + }, + "teh marbuta goal": { + "normal": [ + "\u06C3" + ] + }, + "kirghiz oe": { + "normal": [ + "\u06C5" + ], + "isolated": "\uFBE0", + "final": "\uFBE1" + }, + "oe": { + "normal": [ + "\u06C6" + ], + "isolated": "\uFBD9", + "final": "\uFBDA" + }, + "u": { + "normal": [ + "\u06C7" + ], + "hamza_above": { + "normal": [ + "\u0677", + "\u06C7\u0674" + ], + "isolated": "\uFBDD" + }, + "isolated": "\uFBD7", + "final": "\uFBD8" + }, + "yu": { + "normal": [ + "\u06C8" + ], + "isolated": "\uFBDB", + "final": "\uFBDC" + }, + "kirghiz yu": { + "normal": [ + "\u06C9" + ], + "isolated": "\uFBE2", + "final": "\uFBE3" + }, + "ve": { + "normal": [ + "\u06CB" + ], + "isolated": "\uFBDE", + "final": "\uFBDF" + }, + "farsi yeh": { + "normal": [ + "\u06CC" + ], + "indic_two_above": [ + "\u0775" + ], + "indic_three_above": [ + "\u0776" + ], + "indic_four_above": [ + "\u0777" + ], + "isolated": "\uFBFC", + "final": "\uFBFD", + "initial": "\uFBFE", + "medial": "\uFBFF" + }, + "e": { + "normal": [ + "\u06D0" + ], + "isolated": "\uFBE4", + "final": "\uFBE5", + "initial": "\uFBE6", + "medial": "\uFBE7" + }, + "yeh barree": { + "normal": [ + "\u06D2" + ], + "hamza_above": { + "normal": [ + "\u06D2\u0654", + "\u06D3" + ], + "isolated": "\uFBB0", + "final": "\uFBB1" + }, + "indic_two_above": [ + "\u077A" + ], + "indic_three_above": [ + "\u077B" + ], + "isolated": "\uFBAE", + "final": "\uFBAF" + }, + "ae": { + "normal": [ + "\u06D5" + ], + "isolated": "\u06D5", + "final": "\uFEEA", + "yeh_above": { + "normal": [ + "\u06C0", + "\u06D5\u0654" + ], + "isolated": "\uFBA4", + "final": "\uFBA5" + } + }, + "rohingya yeh": { + "normal": [ + "\u08AC" + ] + }, + "low alef": { + "normal": [ + "\u08AD" + ] + }, + "straight waw": { + "normal": [ + "\u08B1" + ] + }, + "african feh": { + "normal": [ + "\u08BB" + ] + }, + "african qaf": { + "normal": [ + "\u08BC" + ] + }, + "african noon": { + "normal": [ + "\u08BD" + ] + } + }; + exports2.default = arabicReference; } + }); - function hide() { - d3.select(this).select(".tooltip") - .classed("in", false); - - this.tooltipVisible = false; + // node_modules/alif-toolkit/lib/unicode-ligatures.js + var require_unicode_ligatures = __commonJS({ + "node_modules/alif-toolkit/lib/unicode-ligatures.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var ligatureReference = { + "\u0626\u0627": { + "isolated": "\uFBEA", + "final": "\uFBEB" + }, + "\u0626\u06D5": { + "isolated": "\uFBEC", + "final": "\uFBED" + }, + "\u0626\u0648": { + "isolated": "\uFBEE", + "final": "\uFBEF" + }, + "\u0626\u06C7": { + "isolated": "\uFBF0", + "final": "\uFBF1" + }, + "\u0626\u06C6": { + "isolated": "\uFBF2", + "final": "\uFBF3" + }, + "\u0626\u06C8": { + "isolated": "\uFBF4", + "final": "\uFBF5" + }, + "\u0626\u06D0": { + "isolated": "\uFBF6", + "final": "\uFBF7", + "initial": "\uFBF8" + }, + "\u0626\u0649": { + "uighur_kirghiz": { + "isolated": "\uFBF9", + "final": "\uFBFA", + "initial": "\uFBFB" + }, + "isolated": "\uFC03", + "final": "\uFC68" + }, + "\u0626\u062C": { + "isolated": "\uFC00", + "initial": "\uFC97" + }, + "\u0626\u062D": { + "isolated": "\uFC01", + "initial": "\uFC98" + }, + "\u0626\u0645": { + "isolated": "\uFC02", + "final": "\uFC66", + "initial": "\uFC9A", + "medial": "\uFCDF" + }, + "\u0626\u064A": { + "isolated": "\uFC04", + "final": "\uFC69" + }, + "\u0628\u062C": { + "isolated": "\uFC05", + "initial": "\uFC9C" + }, + "\u0628\u062D": { + "isolated": "\uFC06", + "initial": "\uFC9D" + }, + "\u0628\u062E": { + "isolated": "\uFC07", + "initial": "\uFC9E" + }, + "\u0628\u0645": { + "isolated": "\uFC08", + "final": "\uFC6C", + "initial": "\uFC9F", + "medial": "\uFCE1" + }, + "\u0628\u0649": { + "isolated": "\uFC09", + "final": "\uFC6E" + }, + "\u0628\u064A": { + "isolated": "\uFC0A", + "final": "\uFC6F" + }, + "\u062A\u062C": { + "isolated": "\uFC0B", + "initial": "\uFCA1" + }, + "\u062A\u062D": { + "isolated": "\uFC0C", + "initial": "\uFCA2" + }, + "\u062A\u062E": { + "isolated": "\uFC0D", + "initial": "\uFCA3" + }, + "\u062A\u0645": { + "isolated": "\uFC0E", + "final": "\uFC72", + "initial": "\uFCA4", + "medial": "\uFCE3" + }, + "\u062A\u0649": { + "isolated": "\uFC0F", + "final": "\uFC74" + }, + "\u062A\u064A": { + "isolated": "\uFC10", + "final": "\uFC75" + }, + "\u062B\u062C": { + "isolated": "\uFC11" + }, + "\u062B\u0645": { + "isolated": "\uFC12", + "final": "\uFC78", + "initial": "\uFCA6", + "medial": "\uFCE5" + }, + "\u062B\u0649": { + "isolated": "\uFC13", + "final": "\uFC7A" + }, + "\u062B\u0648": { + "isolated": "\uFC14" + }, + "\u062C\u062D": { + "isolated": "\uFC15", + "initial": "\uFCA7" + }, + "\u062C\u0645": { + "isolated": "\uFC16", + "initial": "\uFCA8" + }, + "\u062D\u062C": { + "isolated": "\uFC17", + "initial": "\uFCA9" + }, + "\u062D\u0645": { + "isolated": "\uFC18", + "initial": "\uFCAA" + }, + "\u062E\u062C": { + "isolated": "\uFC19", + "initial": "\uFCAB" + }, + "\u062E\u062D": { + "isolated": "\uFC1A" + }, + "\u062E\u0645": { + "isolated": "\uFC1B", + "initial": "\uFCAC" + }, + "\u0633\u062C": { + "isolated": "\uFC1C", + "initial": "\uFCAD", + "medial": "\uFD34" + }, + "\u0633\u062D": { + "isolated": "\uFC1D", + "initial": "\uFCAE", + "medial": "\uFD35" + }, + "\u0633\u062E": { + "isolated": "\uFC1E", + "initial": "\uFCAF", + "medial": "\uFD36" + }, + "\u0633\u0645": { + "isolated": "\uFC1F", + "initial": "\uFCB0", + "medial": "\uFCE7" + }, + "\u0635\u062D": { + "isolated": "\uFC20", + "initial": "\uFCB1" + }, + "\u0635\u0645": { + "isolated": "\uFC21", + "initial": "\uFCB3" + }, + "\u0636\u062C": { + "isolated": "\uFC22", + "initial": "\uFCB4" + }, + "\u0636\u062D": { + "isolated": "\uFC23", + "initial": "\uFCB5" + }, + "\u0636\u062E": { + "isolated": "\uFC24", + "initial": "\uFCB6" + }, + "\u0636\u0645": { + "isolated": "\uFC25", + "initial": "\uFCB7" + }, + "\u0637\u062D": { + "isolated": "\uFC26", + "initial": "\uFCB8" + }, + "\u0637\u0645": { + "isolated": "\uFC27", + "initial": "\uFD33", + "medial": "\uFD3A" + }, + "\u0638\u0645": { + "isolated": "\uFC28", + "initial": "\uFCB9", + "medial": "\uFD3B" + }, + "\u0639\u062C": { + "isolated": "\uFC29", + "initial": "\uFCBA" + }, + "\u0639\u0645": { + "isolated": "\uFC2A", + "initial": "\uFCBB" + }, + "\u063A\u062C": { + "isolated": "\uFC2B", + "initial": "\uFCBC" + }, + "\u063A\u0645": { + "isolated": "\uFC2C", + "initial": "\uFCBD" + }, + "\u0641\u062C": { + "isolated": "\uFC2D", + "initial": "\uFCBE" + }, + "\u0641\u062D": { + "isolated": "\uFC2E", + "initial": "\uFCBF" + }, + "\u0641\u062E": { + "isolated": "\uFC2F", + "initial": "\uFCC0" + }, + "\u0641\u0645": { + "isolated": "\uFC30", + "initial": "\uFCC1" + }, + "\u0641\u0649": { + "isolated": "\uFC31", + "final": "\uFC7C" + }, + "\u0641\u064A": { + "isolated": "\uFC32", + "final": "\uFC7D" + }, + "\u0642\u062D": { + "isolated": "\uFC33", + "initial": "\uFCC2" + }, + "\u0642\u0645": { + "isolated": "\uFC34", + "initial": "\uFCC3" + }, + "\u0642\u0649": { + "isolated": "\uFC35", + "final": "\uFC7E" + }, + "\u0642\u064A": { + "isolated": "\uFC36", + "final": "\uFC7F" + }, + "\u0643\u0627": { + "isolated": "\uFC37", + "final": "\uFC80" + }, + "\u0643\u062C": { + "isolated": "\uFC38", + "initial": "\uFCC4" + }, + "\u0643\u062D": { + "isolated": "\uFC39", + "initial": "\uFCC5" + }, + "\u0643\u062E": { + "isolated": "\uFC3A", + "initial": "\uFCC6" + }, + "\u0643\u0644": { + "isolated": "\uFC3B", + "final": "\uFC81", + "initial": "\uFCC7", + "medial": "\uFCEB" + }, + "\u0643\u0645": { + "isolated": "\uFC3C", + "final": "\uFC82", + "initial": "\uFCC8", + "medial": "\uFCEC" + }, + "\u0643\u0649": { + "isolated": "\uFC3D", + "final": "\uFC83" + }, + "\u0643\u064A": { + "isolated": "\uFC3E", + "final": "\uFC84" + }, + "\u0644\u062C": { + "isolated": "\uFC3F", + "initial": "\uFCC9" + }, + "\u0644\u062D": { + "isolated": "\uFC40", + "initial": "\uFCCA" + }, + "\u0644\u062E": { + "isolated": "\uFC41", + "initial": "\uFCCB" + }, + "\u0644\u0645": { + "isolated": "\uFC42", + "final": "\uFC85", + "initial": "\uFCCC", + "medial": "\uFCED" + }, + "\u0644\u0649": { + "isolated": "\uFC43", + "final": "\uFC86" + }, + "\u0644\u064A": { + "isolated": "\uFC44", + "final": "\uFC87" + }, + "\u0645\u062C": { + "isolated": "\uFC45", + "initial": "\uFCCE" + }, + "\u0645\u062D": { + "isolated": "\uFC46", + "initial": "\uFCCF" + }, + "\u0645\u062E": { + "isolated": "\uFC47", + "initial": "\uFCD0" + }, + "\u0645\u0645": { + "isolated": "\uFC48", + "final": "\uFC89", + "initial": "\uFCD1" + }, + "\u0645\u0649": { + "isolated": "\uFC49" + }, + "\u0645\u064A": { + "isolated": "\uFC4A" + }, + "\u0646\u062C": { + "isolated": "\uFC4B", + "initial": "\uFCD2" + }, + "\u0646\u062D": { + "isolated": "\uFC4C", + "initial": "\uFCD3" + }, + "\u0646\u062E": { + "isolated": "\uFC4D", + "initial": "\uFCD4" + }, + "\u0646\u0645": { + "isolated": "\uFC4E", + "final": "\uFC8C", + "initial": "\uFCD5", + "medial": "\uFCEE" + }, + "\u0646\u0649": { + "isolated": "\uFC4F", + "final": "\uFC8E" + }, + "\u0646\u064A": { + "isolated": "\uFC50", + "final": "\uFC8F" + }, + "\u0647\u062C": { + "isolated": "\uFC51", + "initial": "\uFCD7" + }, + "\u0647\u0645": { + "isolated": "\uFC52", + "initial": "\uFCD8" + }, + "\u0647\u0649": { + "isolated": "\uFC53" + }, + "\u0647\u064A": { + "isolated": "\uFC54" + }, + "\u064A\u062C": { + "isolated": "\uFC55", + "initial": "\uFCDA" + }, + "\u064A\u062D": { + "isolated": "\uFC56", + "initial": "\uFCDB" + }, + "\u064A\u062E": { + "isolated": "\uFC57", + "initial": "\uFCDC" + }, + "\u064A\u0645": { + "isolated": "\uFC58", + "final": "\uFC93", + "initial": "\uFCDD", + "medial": "\uFCF0" + }, + "\u064A\u0649": { + "isolated": "\uFC59", + "final": "\uFC95" + }, + "\u064A\u064A": { + "isolated": "\uFC5A", + "final": "\uFC96" + }, + "\u0630\u0670": { + "isolated": "\uFC5B" + }, + "\u0631\u0670": { + "isolated": "\uFC5C" + }, + "\u0649\u0670": { + "isolated": "\uFC5D", + "final": "\uFC90" + }, + "\u064C\u0651": { + "isolated": "\uFC5E" + }, + "\u064D\u0651": { + "isolated": "\uFC5F" + }, + "\u064E\u0651": { + "isolated": "\uFC60" + }, + "\u064F\u0651": { + "isolated": "\uFC61" + }, + "\u0650\u0651": { + "isolated": "\uFC62" + }, + "\u0651\u0670": { + "isolated": "\uFC63" + }, + "\u0626\u0631": { + "final": "\uFC64" + }, + "\u0626\u0632": { + "final": "\uFC65" + }, + "\u0626\u0646": { + "final": "\uFC67" + }, + "\u0628\u0631": { + "final": "\uFC6A" + }, + "\u0628\u0632": { + "final": "\uFC6B" + }, + "\u0628\u0646": { + "final": "\uFC6D" + }, + "\u062A\u0631": { + "final": "\uFC70" + }, + "\u062A\u0632": { + "final": "\uFC71" + }, + "\u062A\u0646": { + "final": "\uFC73" + }, + "\u062B\u0631": { + "final": "\uFC76" + }, + "\u062B\u0632": { + "final": "\uFC77" + }, + "\u062B\u0646": { + "final": "\uFC79" + }, + "\u062B\u064A": { + "final": "\uFC7B" + }, + "\u0645\u0627": { + "final": "\uFC88" + }, + "\u0646\u0631": { + "final": "\uFC8A" + }, + "\u0646\u0632": { + "final": "\uFC8B" + }, + "\u0646\u0646": { + "final": "\uFC8D" + }, + "\u064A\u0631": { + "final": "\uFC91" + }, + "\u064A\u0632": { + "final": "\uFC92" + }, + "\u064A\u0646": { + "final": "\uFC94" + }, + "\u0626\u062E": { + "initial": "\uFC99" + }, + "\u0626\u0647": { + "initial": "\uFC9B", + "medial": "\uFCE0" + }, + "\u0628\u0647": { + "initial": "\uFCA0", + "medial": "\uFCE2" + }, + "\u062A\u0647": { + "initial": "\uFCA5", + "medial": "\uFCE4" + }, + "\u0635\u062E": { + "initial": "\uFCB2" + }, + "\u0644\u0647": { + "initial": "\uFCCD" + }, + "\u0646\u0647": { + "initial": "\uFCD6", + "medial": "\uFCEF" + }, + "\u0647\u0670": { + "initial": "\uFCD9" + }, + "\u064A\u0647": { + "initial": "\uFCDE", + "medial": "\uFCF1" + }, + "\u062B\u0647": { + "medial": "\uFCE6" + }, + "\u0633\u0647": { + "medial": "\uFCE8", + "initial": "\uFD31" + }, + "\u0634\u0645": { + "medial": "\uFCE9", + "isolated": "\uFD0C", + "final": "\uFD28", + "initial": "\uFD30" + }, + "\u0634\u0647": { + "medial": "\uFCEA", + "initial": "\uFD32" + }, + "\u0640\u064E\u0651": { + "medial": "\uFCF2" + }, + "\u0640\u064F\u0651": { + "medial": "\uFCF3" + }, + "\u0640\u0650\u0651": { + "medial": "\uFCF4" + }, + "\u0637\u0649": { + "isolated": "\uFCF5", + "final": "\uFD11" + }, + "\u0637\u064A": { + "isolated": "\uFCF6", + "final": "\uFD12" + }, + "\u0639\u0649": { + "isolated": "\uFCF7", + "final": "\uFD13" + }, + "\u0639\u064A": { + "isolated": "\uFCF8", + "final": "\uFD14" + }, + "\u063A\u0649": { + "isolated": "\uFCF9", + "final": "\uFD15" + }, + "\u063A\u064A": { + "isolated": "\uFCFA", + "final": "\uFD16" + }, + "\u0633\u0649": { + "isolated": "\uFCFB" + }, + "\u0633\u064A": { + "isolated": "\uFCFC", + "final": "\uFD18" + }, + "\u0634\u0649": { + "isolated": "\uFCFD", + "final": "\uFD19" + }, + "\u0634\u064A": { + "isolated": "\uFCFE", + "final": "\uFD1A" + }, + "\u062D\u0649": { + "isolated": "\uFCFF", + "final": "\uFD1B" + }, + "\u062D\u064A": { + "isolated": "\uFD00", + "final": "\uFD1C" + }, + "\u062C\u0649": { + "isolated": "\uFD01", + "final": "\uFD1D" + }, + "\u062C\u064A": { + "isolated": "\uFD02", + "final": "\uFD1E" + }, + "\u062E\u0649": { + "isolated": "\uFD03", + "final": "\uFD1F" + }, + "\u062E\u064A": { + "isolated": "\uFD04", + "final": "\uFD20" + }, + "\u0635\u0649": { + "isolated": "\uFD05", + "final": "\uFD21" + }, + "\u0635\u064A": { + "isolated": "\uFD06", + "final": "\uFD22" + }, + "\u0636\u0649": { + "isolated": "\uFD07", + "final": "\uFD23" + }, + "\u0636\u064A": { + "isolated": "\uFD08", + "final": "\uFD24" + }, + "\u0634\u062C": { + "isolated": "\uFD09", + "final": "\uFD25", + "initial": "\uFD2D", + "medial": "\uFD37" + }, + "\u0634\u062D": { + "isolated": "\uFD0A", + "final": "\uFD26", + "initial": "\uFD2E", + "medial": "\uFD38" + }, + "\u0634\u062E": { + "isolated": "\uFD0B", + "final": "\uFD27", + "initial": "\uFD2F", + "medial": "\uFD39" + }, + "\u0634\u0631": { + "isolated": "\uFD0D", + "final": "\uFD29" + }, + "\u0633\u0631": { + "isolated": "\uFD0E", + "final": "\uFD2A" + }, + "\u0635\u0631": { + "isolated": "\uFD0F", + "final": "\uFD2B" + }, + "\u0636\u0631": { + "isolated": "\uFD10", + "final": "\uFD2C" + }, + "\u0633\u0639": { + "final": "\uFD17" + }, + "\u062A\u062C\u0645": { + "initial": "\uFD50" + }, + "\u062A\u062D\u062C": { + "final": "\uFD51", + "initial": "\uFD52" + }, + "\u062A\u062D\u0645": { + "initial": "\uFD53" + }, + "\u062A\u062E\u0645": { + "initial": "\uFD54" + }, + "\u062A\u0645\u062C": { + "initial": "\uFD55" + }, + "\u062A\u0645\u062D": { + "initial": "\uFD56" + }, + "\u062A\u0645\u062E": { + "initial": "\uFD57" + }, + "\u062C\u0645\u062D": { + "final": "\uFD58", + "initial": "\uFD59" + }, + "\u062D\u0645\u064A": { + "final": "\uFD5A" + }, + "\u062D\u0645\u0649": { + "final": "\uFD5B" + }, + "\u0633\u062D\u062C": { + "initial": "\uFD5C" + }, + "\u0633\u062C\u062D": { + "initial": "\uFD5D" + }, + "\u0633\u062C\u0649": { + "final": "\uFD5E" + }, + "\u0633\u0645\u062D": { + "final": "\uFD5F", + "initial": "\uFD60" + }, + "\u0633\u0645\u062C": { + "initial": "\uFD61" + }, + "\u0633\u0645\u0645": { + "final": "\uFD62", + "initial": "\uFD63" + }, + "\u0635\u062D\u062D": { + "final": "\uFD64", + "initial": "\uFD65" + }, + "\u0635\u0645\u0645": { + "final": "\uFD66", + "initial": "\uFDC5" + }, + "\u0634\u062D\u0645": { + "final": "\uFD67", + "initial": "\uFD68" + }, + "\u0634\u062C\u064A": { + "final": "\uFD69" + }, + "\u0634\u0645\u062E": { + "final": "\uFD6A", + "initial": "\uFD6B" + }, + "\u0634\u0645\u0645": { + "final": "\uFD6C", + "initial": "\uFD6D" + }, + "\u0636\u062D\u0649": { + "final": "\uFD6E" + }, + "\u0636\u062E\u0645": { + "final": "\uFD6F", + "initial": "\uFD70" + }, + "\u0636\u0645\u062D": { + "final": "\uFD71" + }, + "\u0637\u0645\u062D": { + "initial": "\uFD72" + }, + "\u0637\u0645\u0645": { + "initial": "\uFD73" + }, + "\u0637\u0645\u064A": { + "final": "\uFD74" + }, + "\u0639\u062C\u0645": { + "final": "\uFD75", + "initial": "\uFDC4" + }, + "\u0639\u0645\u0645": { + "final": "\uFD76", + "initial": "\uFD77" + }, + "\u0639\u0645\u0649": { + "final": "\uFD78" + }, + "\u063A\u0645\u0645": { + "final": "\uFD79" + }, + "\u063A\u0645\u064A": { + "final": "\uFD7A" + }, + "\u063A\u0645\u0649": { + "final": "\uFD7B" + }, + "\u0641\u062E\u0645": { + "final": "\uFD7C", + "initial": "\uFD7D" + }, + "\u0642\u0645\u062D": { + "final": "\uFD7E", + "initial": "\uFDB4" + }, + "\u0642\u0645\u0645": { + "final": "\uFD7F" + }, + "\u0644\u062D\u0645": { + "final": "\uFD80", + "initial": "\uFDB5" + }, + "\u0644\u062D\u064A": { + "final": "\uFD81" + }, + "\u0644\u062D\u0649": { + "final": "\uFD82" + }, + "\u0644\u062C\u062C": { + "initial": "\uFD83", + "final": "\uFD84" + }, + "\u0644\u062E\u0645": { + "final": "\uFD85", + "initial": "\uFD86" + }, + "\u0644\u0645\u062D": { + "final": "\uFD87", + "initial": "\uFD88" + }, + "\u0645\u062D\u062C": { + "initial": "\uFD89" + }, + "\u0645\u062D\u0645": { + "initial": "\uFD8A" + }, + "\u0645\u062D\u064A": { + "final": "\uFD8B" + }, + "\u0645\u062C\u062D": { + "initial": "\uFD8C" + }, + "\u0645\u062C\u0645": { + "initial": "\uFD8D" + }, + "\u0645\u062E\u062C": { + "initial": "\uFD8E" + }, + "\u0645\u062E\u0645": { + "initial": "\uFD8F" + }, + "\u0645\u062C\u062E": { + "initial": "\uFD92" + }, + "\u0647\u0645\u062C": { + "initial": "\uFD93" + }, + "\u0647\u0645\u0645": { + "initial": "\uFD94" + }, + "\u0646\u062D\u0645": { + "initial": "\uFD95" + }, + "\u0646\u062D\u0649": { + "final": "\uFD96" + }, + "\u0646\u062C\u0645": { + "final": "\uFD97", + "initial": "\uFD98" + }, + "\u0646\u062C\u0649": { + "final": "\uFD99" + }, + "\u0646\u0645\u064A": { + "final": "\uFD9A" + }, + "\u0646\u0645\u0649": { + "final": "\uFD9B" + }, + "\u064A\u0645\u0645": { + "final": "\uFD9C", + "initial": "\uFD9D" + }, + "\u0628\u062E\u064A": { + "final": "\uFD9E" + }, + "\u062A\u062C\u064A": { + "final": "\uFD9F" + }, + "\u062A\u062C\u0649": { + "final": "\uFDA0" + }, + "\u062A\u062E\u064A": { + "final": "\uFDA1" + }, + "\u062A\u062E\u0649": { + "final": "\uFDA2" + }, + "\u062A\u0645\u064A": { + "final": "\uFDA3" + }, + "\u062A\u0645\u0649": { + "final": "\uFDA4" + }, + "\u062C\u0645\u064A": { + "final": "\uFDA5" + }, + "\u062C\u062D\u0649": { + "final": "\uFDA6" + }, + "\u062C\u0645\u0649": { + "final": "\uFDA7" + }, + "\u0633\u062E\u0649": { + "final": "\uFDA8" + }, + "\u0635\u062D\u064A": { + "final": "\uFDA9" + }, + "\u0634\u062D\u064A": { + "final": "\uFDAA" + }, + "\u0636\u062D\u064A": { + "final": "\uFDAB" + }, + "\u0644\u062C\u064A": { + "final": "\uFDAC" + }, + "\u0644\u0645\u064A": { + "final": "\uFDAD" + }, + "\u064A\u062D\u064A": { + "final": "\uFDAE" + }, + "\u064A\u062C\u064A": { + "final": "\uFDAF" + }, + "\u064A\u0645\u064A": { + "final": "\uFDB0" + }, + "\u0645\u0645\u064A": { + "final": "\uFDB1" + }, + "\u0642\u0645\u064A": { + "final": "\uFDB2" + }, + "\u0646\u062D\u064A": { + "final": "\uFDB3" + }, + "\u0639\u0645\u064A": { + "final": "\uFDB6" + }, + "\u0643\u0645\u064A": { + "final": "\uFDB7" + }, + "\u0646\u062C\u062D": { + "initial": "\uFDB8", + "final": "\uFDBD" + }, + "\u0645\u062E\u064A": { + "final": "\uFDB9" + }, + "\u0644\u062C\u0645": { + "initial": "\uFDBA", + "final": "\uFDBC" + }, + "\u0643\u0645\u0645": { + "final": "\uFDBB", + "initial": "\uFDC3" + }, + "\u062C\u062D\u064A": { + "final": "\uFDBE" + }, + "\u062D\u062C\u064A": { + "final": "\uFDBF" + }, + "\u0645\u062C\u064A": { + "final": "\uFDC0" + }, + "\u0641\u0645\u064A": { + "final": "\uFDC1" + }, + "\u0628\u062D\u064A": { + "final": "\uFDC2" + }, + "\u0633\u062E\u064A": { + "final": "\uFDC6" + }, + "\u0646\u062C\u064A": { + "final": "\uFDC7" + }, + "\u0644\u0622": { + "isolated": "\uFEF5", + "final": "\uFEF6" + }, + "\u0644\u0623": { + "isolated": "\uFEF7", + "final": "\uFEF8" + }, + "\u0644\u0625": { + "isolated": "\uFEF9", + "final": "\uFEFA" + }, + "\u0644\u0627": { + "isolated": "\uFEFB", + "final": "\uFEFC" + }, + "words": { + "\u0635\u0644\u06D2": "\uFDF0", + "\u0642\u0644\u06D2": "\uFDF1", + "\u0627\u0644\u0644\u0647": "\uFDF2", + "\u0627\u0643\u0628\u0631": "\uFDF3", + "\u0645\u062D\u0645\u062F": "\uFDF4", + "\u0635\u0644\u0639\u0645": "\uFDF5", + "\u0631\u0633\u0648\u0644": "\uFDF6", + "\u0639\u0644\u064A\u0647": "\uFDF7", + "\u0648\u0633\u0644\u0645": "\uFDF8", + "\u0635\u0644\u0649": "\uFDF9", + "\u0635\u0644\u0649\u0627\u0644\u0644\u0647\u0639\u0644\u064A\u0647\u0648\u0633\u0644\u0645": "\uFDFA", + "\u062C\u0644\u062C\u0644\u0627\u0644\u0647": "\uFDFB", + "\u0631\u06CC\u0627\u0644": "\uFDFC" + } + }; + exports2.default = ligatureReference; } + }); - function toggle() { - if (this.tooltipVisible) { - hide.apply(this, arguments); - } else { - show.apply(this, arguments); + // node_modules/alif-toolkit/lib/reference.js + var require_reference = __commonJS({ + "node_modules/alif-toolkit/lib/reference.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var unicode_arabic_1 = require_unicode_arabic(); + var unicode_ligatures_1 = require_unicode_ligatures(); + var letterList = Object.keys(unicode_arabic_1.default); + exports2.letterList = letterList; + var ligatureList = Object.keys(unicode_ligatures_1.default); + exports2.ligatureList = ligatureList; + var ligatureWordList = Object.keys(unicode_ligatures_1.default.words); + exports2.ligatureWordList = ligatureWordList; + var lams = "\u0644\u06B5\u06B6\u06B7\u06B8"; + exports2.lams = lams; + var alefs = "\u0627\u0622\u0623\u0625\u0671\u0672\u0673\u0675\u0773\u0774"; + exports2.alefs = alefs; + var tashkeel = "\u0605\u0640\u0670\u0674\u06DF\u06E7\u06E8"; + exports2.tashkeel = tashkeel; + function addToTashkeel(start2, finish) { + for (var i2 = start2; i2 <= finish; i2++) { + exports2.tashkeel = tashkeel += String.fromCharCode(i2); + } + } + addToTashkeel(1552, 1562); + addToTashkeel(1611, 1631); + addToTashkeel(1750, 1756); + addToTashkeel(1760, 1764); + addToTashkeel(1770, 1773); + addToTashkeel(2259, 2273); + addToTashkeel(2275, 2303); + addToTashkeel(65136, 65151); + var lineBreakers = "\u0627\u0629\u0648\u06C0\u06CF\u06FD\u06FE\u076B\u076C\u0771\u0773\u0774\u0778\u0779\u08E2\u08B1\u08B2\u08B9"; + exports2.lineBreakers = lineBreakers; + function addToLineBreakers(start2, finish) { + for (var i2 = start2; i2 <= finish; i2++) { + exports2.lineBreakers = lineBreakers += String.fromCharCode(i2); + } } + addToLineBreakers(1536, 1567); + addToLineBreakers(1569, 1573); + addToLineBreakers(1583, 1586); + addToLineBreakers(1632, 1645); + addToLineBreakers(1649, 1655); + addToLineBreakers(1672, 1689); + addToLineBreakers(1731, 1739); + addToLineBreakers(1746, 1785); + addToLineBreakers(1881, 1883); + addToLineBreakers(2218, 2222); + addToLineBreakers(64336, 65021); + addToLineBreakers(65152, 65276); + addToLineBreakers(69216, 69247); + addToLineBreakers(126064, 126143); + addToLineBreakers(126464, 126719); } + }); - return tooltip; - }; - - function getPosition(node) { - var mode = d3.select(node).style('position'); - if (mode === 'absolute' || mode === 'static') { - return { - x: node.offsetLeft, - y: node.offsetTop, - w: node.offsetWidth, - h: node.offsetHeight - }; - } else { - return { - x: 0, - y: 0, - w: node.offsetWidth, - h: node.offsetHeight - }; + // node_modules/alif-toolkit/lib/GlyphSplitter.js + var require_GlyphSplitter = __commonJS({ + "node_modules/alif-toolkit/lib/GlyphSplitter.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var isArabic_1 = require_isArabic(); + var reference_1 = require_reference(); + function GlyphSplitter(word) { + let letters = []; + let lastLetter = ""; + word.split("").forEach((letter) => { + if (isArabic_1.isArabic(letter)) { + if (reference_1.tashkeel.indexOf(letter) > -1) { + letters[letters.length - 1] += letter; + } else if (lastLetter.length && (reference_1.lams.indexOf(lastLetter) === 0 && reference_1.alefs.indexOf(letter) > -1 || reference_1.lams.indexOf(lastLetter) > 0 && reference_1.alefs.indexOf(letter) === 0)) { + letters[letters.length - 1] += letter; + } else { + letters.push(letter); + } + } else { + letters.push(letter); + } + if (reference_1.tashkeel.indexOf(letter) === -1) { + lastLetter = letter; + } + }); + return letters; + } + exports2.GlyphSplitter = GlyphSplitter; } - } + }); -})(this); -d3 = (function(){ - var d3 = {version: "3.1.4"}; // semver -d3.ascending = function(a, b) { - return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; -}; -d3.descending = function(a, b) { - return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; -}; -d3.min = function(array, f) { - var i = -1, - n = array.length, - a, - b; - if (arguments.length === 1) { - while (++i < n && ((a = array[i]) == null || a != a)) a = undefined; - while (++i < n) if ((b = array[i]) != null && a > b) a = b; - } else { - while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined; - while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b; - } - return a; -}; -d3.max = function(array, f) { - var i = -1, - n = array.length, - a, - b; - if (arguments.length === 1) { - while (++i < n && ((a = array[i]) == null || a != a)) a = undefined; - while (++i < n) if ((b = array[i]) != null && b > a) a = b; - } else { - while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined; - while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b; - } - return a; -}; -d3.extent = function(array, f) { - var i = -1, - n = array.length, - a, - b, - c; - if (arguments.length === 1) { - while (++i < n && ((a = c = array[i]) == null || a != a)) a = c = undefined; - while (++i < n) if ((b = array[i]) != null) { - if (a > b) a = b; - if (c < b) c = b; - } - } else { - while (++i < n && ((a = c = f.call(array, array[i], i)) == null || a != a)) a = undefined; - while (++i < n) if ((b = f.call(array, array[i], i)) != null) { - if (a > b) a = b; - if (c < b) c = b; - } - } - return [a, c]; -}; -d3.sum = function(array, f) { - var s = 0, - n = array.length, - a, - i = -1; - - if (arguments.length === 1) { - while (++i < n) if (!isNaN(a = +array[i])) s += a; - } else { - while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a; - } - - return s; -}; -function d3_number(x) { - return x != null && !isNaN(x); -} - -d3.mean = function(array, f) { - var n = array.length, - a, - m = 0, - i = -1, - j = 0; - if (arguments.length === 1) { - while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j; - } else { - while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j; - } - return j ? m : undefined; -}; -// R-7 per -d3.quantile = function(values, p) { - var H = (values.length - 1) * p + 1, - h = Math.floor(H), - v = +values[h - 1], - e = H - h; - return e ? v + e * (values[h] - v) : v; -}; - -d3.median = function(array, f) { - if (arguments.length > 1) array = array.map(f); - array = array.filter(d3_number); - return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined; -}; -d3.bisector = function(f) { - return { - left: function(a, x, lo, hi) { - if (arguments.length < 3) lo = 0; - if (arguments.length < 4) hi = a.length; - while (lo < hi) { - var mid = lo + hi >>> 1; - if (f.call(a, a[mid], mid) < x) lo = mid + 1; - else hi = mid; - } - return lo; - }, - right: function(a, x, lo, hi) { - if (arguments.length < 3) lo = 0; - if (arguments.length < 4) hi = a.length; - while (lo < hi) { - var mid = lo + hi >>> 1; - if (x < f.call(a, a[mid], mid)) hi = mid; - else lo = mid + 1; + // node_modules/alif-toolkit/lib/BaselineSplitter.js + var require_BaselineSplitter = __commonJS({ + "node_modules/alif-toolkit/lib/BaselineSplitter.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var isArabic_1 = require_isArabic(); + var reference_1 = require_reference(); + function BaselineSplitter(word) { + let letters = []; + let lastLetter = ""; + word.split("").forEach((letter) => { + if (isArabic_1.isArabic(letter) && isArabic_1.isArabic(lastLetter)) { + if (lastLetter.length && reference_1.tashkeel.indexOf(letter) > -1) { + letters[letters.length - 1] += letter; + } else if (reference_1.lineBreakers.indexOf(lastLetter) > -1) { + letters.push(letter); + } else { + letters[letters.length - 1] += letter; + } + } else { + letters.push(letter); + } + if (reference_1.tashkeel.indexOf(letter) === -1) { + lastLetter = letter; + } + }); + return letters; } - return lo; + exports2.BaselineSplitter = BaselineSplitter; } - }; -}; - -var d3_bisector = d3.bisector(function(d) { return d; }); -d3.bisectLeft = d3_bisector.left; -d3.bisect = d3.bisectRight = d3_bisector.right; -d3.shuffle = function(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; -}; -d3.permute = function(array, indexes) { - var permutes = [], - i = -1, - n = indexes.length; - while (++i < n) permutes[i] = array[indexes[i]]; - return permutes; -}; - -d3.zip = function() { - if (!(n = arguments.length)) return []; - for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) { - for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) { - zip[j] = arguments[j][i]; - } - } - return zips; -}; - -function d3_zipLength(d) { - return d.length; -} - -d3.transpose = function(matrix) { - return d3.zip.apply(d3, matrix); -}; -d3.keys = function(map) { - var keys = []; - for (var key in map) keys.push(key); - return keys; -}; -d3.values = function(map) { - var values = []; - for (var key in map) values.push(map[key]); - return values; -}; -d3.entries = function(map) { - var entries = []; - for (var key in map) entries.push({key: key, value: map[key]}); - return entries; -}; -d3.merge = function(arrays) { - return Array.prototype.concat.apply([], arrays); -}; -d3.range = function(start, stop, step) { - if (arguments.length < 3) { - step = 1; - if (arguments.length < 2) { - stop = start; - start = 0; - } - } - if ((stop - start) / step === Infinity) throw new Error("infinite range"); - var range = [], - k = d3_range_integerScale(Math.abs(step)), - i = -1, - j; - start *= k, stop *= k, step *= k; - if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); - else while ((j = start + step * ++i) < stop) range.push(j / k); - return range; -}; - -function d3_range_integerScale(x) { - var k = 1; - while (x * k % 1) k *= 10; - return k; -} -function d3_class(ctor, properties) { - try { - for (var key in properties) { - Object.defineProperty(ctor.prototype, key, { - value: properties[key], - enumerable: false - }); - } - } catch (e) { - ctor.prototype = properties; - } -} - -d3.map = function(object) { - var map = new d3_Map; - for (var key in object) map.set(key, object[key]); - return map; -}; - -function d3_Map() {} - -d3_class(d3_Map, { - has: function(key) { - return d3_map_prefix + key in this; - }, - get: function(key) { - return this[d3_map_prefix + key]; - }, - set: function(key, value) { - return this[d3_map_prefix + key] = value; - }, - remove: function(key) { - key = d3_map_prefix + key; - return key in this && delete this[key]; - }, - keys: function() { - var keys = []; - this.forEach(function(key) { keys.push(key); }); - return keys; - }, - values: function() { - var values = []; - this.forEach(function(key, value) { values.push(value); }); - return values; - }, - entries: function() { - var entries = []; - this.forEach(function(key, value) { entries.push({key: key, value: value}); }); - return entries; - }, - forEach: function(f) { - for (var key in this) { - if (key.charCodeAt(0) === d3_map_prefixCode) { - f.call(this, key.substring(1), this[key]); - } - } - } -}); - -var d3_map_prefix = "\0", // prevent collision with built-ins - d3_map_prefixCode = d3_map_prefix.charCodeAt(0); - -d3.nest = function() { - var nest = {}, - keys = [], - sortKeys = [], - sortValues, - rollup; - - function map(mapType, array, depth) { - if (depth >= keys.length) return rollup - ? rollup.call(nest, array) : (sortValues - ? array.sort(sortValues) - : array); - - var i = -1, - n = array.length, - key = keys[depth++], - keyValue, - object, - setter, - valuesByKey = new d3_Map, - values; - - while (++i < n) { - if (values = valuesByKey.get(keyValue = key(object = array[i]))) { - values.push(object); - } else { - valuesByKey.set(keyValue, [object]); - } - } - - if (mapType) { - object = mapType(); - setter = function(keyValue, values) { - object.set(keyValue, map(mapType, values, depth)); - }; - } else { - object = {}; - setter = function(keyValue, values) { - object[keyValue] = map(mapType, values, depth); - }; - } - - valuesByKey.forEach(setter); - return object; - } - - function entries(map, depth) { - if (depth >= keys.length) return map; - - var array = [], - sortKey = sortKeys[depth++]; - - map.forEach(function(key, keyMap) { - array.push({key: key, values: entries(keyMap, depth)}); - }); - - return sortKey - ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) - : array; - } - - nest.map = function(array, mapType) { - return map(mapType, array, 0); - }; - - nest.entries = function(array) { - return entries(map(d3.map, array, 0), 0); - }; - - nest.key = function(d) { - keys.push(d); - return nest; - }; - - // Specifies the order for the most-recently specified key. - // Note: only applies to entries. Map keys are unordered! - nest.sortKeys = function(order) { - sortKeys[keys.length - 1] = order; - return nest; - }; - - // Specifies the order for leaf values. - // Applies to both maps and entries array. - nest.sortValues = function(order) { - sortValues = order; - return nest; - }; - - nest.rollup = function(f) { - rollup = f; - return nest; - }; - - return nest; -}; - -d3.set = function(array) { - var set = new d3_Set(); - if (array) for (var i = 0; i < array.length; i++) set.add(array[i]); - return set; -}; - -function d3_Set() {} - -d3_class(d3_Set, { - has: function(value) { - return d3_map_prefix + value in this; - }, - add: function(value) { - this[d3_map_prefix + value] = true; - return value; - }, - remove: function(value) { - value = d3_map_prefix + value; - return value in this && delete this[value]; - }, - values: function() { - var values = []; - this.forEach(function(value) { - values.push(value); - }); - return values; - }, - forEach: function(f) { - for (var value in this) { - if (value.charCodeAt(0) === d3_map_prefixCode) { - f.call(this, value.substring(1)); - } - } - } -}); -d3.behavior = {}; -var d3_document = document, - d3_window = window; -// Copies a variable number of methods from source to target. -d3.rebind = function(target, source) { - var i = 1, n = arguments.length, method; - while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]); - return target; -}; - -// Method is assumed to be a standard D3 getter-setter: -// If passed with no arguments, gets the value. -// If passed with arguments, sets the value and returns the target. -function d3_rebind(target, source, method) { - return function() { - var value = method.apply(source, arguments); - return value === source ? target : value; - }; -} - -d3.dispatch = function() { - var dispatch = new d3_dispatch, - i = -1, - n = arguments.length; - while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch); - return dispatch; -}; - -function d3_dispatch() {} - -d3_dispatch.prototype.on = function(type, listener) { - var i = type.indexOf("."), - name = ""; - - // Extract optional namespace, e.g., "click.foo" - if (i >= 0) { - name = type.substring(i + 1); - type = type.substring(0, i); - } - - if (type) return arguments.length < 2 - ? this[type].on(name) - : this[type].on(name, listener); - - if (arguments.length === 2) { - if (listener == null) for (type in this) { - if (this.hasOwnProperty(type)) this[type].on(name, null); - } - return this; - } -}; - -function d3_dispatch_event(dispatch) { - var listeners = [], - listenerByName = new d3_Map; - - function event() { - var z = listeners, // defensive reference - i = -1, - n = z.length, - l; - while (++i < n) if (l = z[i].on) l.apply(this, arguments); - return dispatch; - } - - event.on = function(name, listener) { - var l = listenerByName.get(name), - i; - - // return the current listener, if any - if (arguments.length < 2) return l && l.on; - - // remove the old listener, if any (with copy-on-write) - if (l) { - l.on = null; - listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1)); - listenerByName.remove(name); - } - - // add the new listener, if any - if (listener) listeners.push(listenerByName.set(name, {on: listener})); - - return dispatch; - }; - - return event; -} - -d3.event = null; - -function d3_eventCancel() { - d3.event.stopPropagation(); - d3.event.preventDefault(); -} - -function d3_eventSource() { - var e = d3.event, s; - while (s = e.sourceEvent) e = s; - return e; -} - -// Like d3.dispatch, but for custom events abstracting native UI events. These -// events have a target component (such as a brush), a target element (such as -// the svg:g element containing the brush) and the standard arguments `d` (the -// target element's data) and `i` (the selection index of the target element). -function d3_eventDispatch(target) { - var dispatch = new d3_dispatch, - i = 0, - n = arguments.length; - - while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch); - - // Creates a dispatch context for the specified `thiz` (typically, the target - // DOM element that received the source event) and `argumentz` (typically, the - // data `d` and index `i` of the target element). The returned function can be - // used to dispatch an event to any registered listeners; the function takes a - // single argument as input, being the event to dispatch. The event must have - // a "type" attribute which corresponds to a type registered in the - // constructor. This context will automatically populate the "sourceEvent" and - // "target" attributes of the event, as well as setting the `d3.event` global - // for the duration of the notification. - dispatch.of = function(thiz, argumentz) { - return function(e1) { - try { - var e0 = - e1.sourceEvent = d3.event; - e1.target = target; - d3.event = e1; - dispatch[e1.type].apply(thiz, argumentz); - } finally { - d3.event = e0; - } - }; - }; - - return dispatch; -} - -d3.mouse = function(container) { - return d3_mousePoint(container, d3_eventSource()); -}; - -// https://bugs.webkit.org/show_bug.cgi?id=44083 -var d3_mouse_bug44083 = /WebKit/.test(d3_window.navigator.userAgent) ? -1 : 0; - -function d3_mousePoint(container, e) { - var svg = container.ownerSVGElement || container; - if (svg.createSVGPoint) { - var point = svg.createSVGPoint(); - if (d3_mouse_bug44083 < 0 && (d3_window.scrollX || d3_window.scrollY)) { - svg = d3.select(d3_document.body).append("svg") - .style("position", "absolute") - .style("top", 0) - .style("left", 0); - var ctm = svg[0][0].getScreenCTM(); - d3_mouse_bug44083 = !(ctm.f || ctm.e); - svg.remove(); - } - if (d3_mouse_bug44083) { - point.x = e.pageX; - point.y = e.pageY; - } else { - point.x = e.clientX; - point.y = e.clientY; - } - point = point.matrixTransform(container.getScreenCTM().inverse()); - return [point.x, point.y]; - } - var rect = container.getBoundingClientRect(); - return [e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop]; -}; - -var d3_array = d3_arraySlice; // conversion for NodeLists - -function d3_arrayCopy(pseudoarray) { - var i = -1, n = pseudoarray.length, array = []; - while (++i < n) array.push(pseudoarray[i]); - return array; -} - -function d3_arraySlice(pseudoarray) { - return Array.prototype.slice.call(pseudoarray); -} - -try { - d3_array(d3_document.documentElement.childNodes)[0].nodeType; -} catch(e) { - d3_array = d3_arrayCopy; -} - -var d3_arraySubclass = [].__proto__? - -// Until ECMAScript supports array subclassing, prototype injection works well. -function(array, prototype) { - array.__proto__ = prototype; -}: - -// And if your browser doesn't support __proto__, we'll use direct extension. -function(array, prototype) { - for (var property in prototype) array[property] = prototype[property]; -}; - -d3.touches = function(container, touches) { - if (arguments.length < 2) touches = d3_eventSource().touches; - return touches ? d3_array(touches).map(function(touch) { - var point = d3_mousePoint(container, touch); - point.identifier = touch.identifier; - return point; - }) : []; -}; - -function d3_selection(groups) { - d3_arraySubclass(groups, d3_selectionPrototype); - return groups; -} - -var d3_select = function(s, n) { return n.querySelector(s); }, - d3_selectAll = function(s, n) { return n.querySelectorAll(s); }, - d3_selectRoot = d3_document.documentElement, - d3_selectMatcher = d3_selectRoot.matchesSelector || d3_selectRoot.webkitMatchesSelector || d3_selectRoot.mozMatchesSelector || d3_selectRoot.msMatchesSelector || d3_selectRoot.oMatchesSelector, - d3_selectMatches = function(n, s) { return d3_selectMatcher.call(n, s); }; - -// Prefer Sizzle, if available. -if (typeof Sizzle === "function") { - d3_select = function(s, n) { return Sizzle(s, n)[0] || null; }; - d3_selectAll = function(s, n) { return Sizzle.uniqueSort(Sizzle(s, n)); }; - d3_selectMatches = Sizzle.matchesSelector; -} - -var d3_selectionPrototype = []; - -d3.selection = function() { - return d3_selectionRoot; -}; - -d3.selection.prototype = d3_selectionPrototype; - - -d3_selectionPrototype.select = function(selector) { - var subgroups = [], - subgroup, - subnode, - group, - node; - - if (typeof selector !== "function") selector = d3_selection_selector(selector); - - for (var j = -1, m = this.length; ++j < m;) { - subgroups.push(subgroup = []); - subgroup.parentNode = (group = this[j]).parentNode; - for (var i = -1, n = group.length; ++i < n;) { - if (node = group[i]) { - subgroup.push(subnode = selector.call(node, node.__data__, i)); - if (subnode && "__data__" in node) subnode.__data__ = node.__data__; - } else { - subgroup.push(null); - } - } - } - - return d3_selection(subgroups); -}; - -function d3_selection_selector(selector) { - return function() { - return d3_select(selector, this); - }; -} - -d3_selectionPrototype.selectAll = function(selector) { - var subgroups = [], - subgroup, - node; - - if (typeof selector !== "function") selector = d3_selection_selectorAll(selector); + }); - for (var j = -1, m = this.length; ++j < m;) { - for (var group = this[j], i = -1, n = group.length; ++i < n;) { - if (node = group[i]) { - subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i))); - subgroup.parentNode = node; + // node_modules/alif-toolkit/lib/Normalization.js + var require_Normalization = __commonJS({ + "node_modules/alif-toolkit/lib/Normalization.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var unicode_arabic_1 = require_unicode_arabic(); + var unicode_ligatures_1 = require_unicode_ligatures(); + var isArabic_1 = require_isArabic(); + var reference_1 = require_reference(); + function Normal(word, breakPresentationForm) { + if (typeof breakPresentationForm === "undefined") { + breakPresentationForm = true; + } + let returnable = ""; + word.split("").forEach((letter) => { + if (!isArabic_1.isArabic(letter)) { + returnable += letter; + return; + } + for (let w = 0; w < reference_1.letterList.length; w++) { + let letterForms = unicode_arabic_1.default[reference_1.letterList[w]]; + let versions = Object.keys(letterForms); + for (let v = 0; v < versions.length; v++) { + let localVersion = letterForms[versions[v]]; + if (typeof localVersion === "object" && typeof localVersion.indexOf === "undefined") { + let embeddedForms = Object.keys(localVersion); + for (let ef = 0; ef < embeddedForms.length; ef++) { + let form = localVersion[embeddedForms[ef]]; + if (form === letter || typeof form === "object" && form.indexOf && form.indexOf(letter) > -1) { + if (form === letter) { + if (breakPresentationForm && localVersion["normal"] && ["isolated", "initial", "medial", "final"].indexOf(embeddedForms[ef]) > -1) { + if (typeof localVersion["normal"] === "object") { + returnable += localVersion["normal"][0]; + } else { + returnable += localVersion["normal"]; + } + return; + } + returnable += letter; + return; + } else if (typeof form === "object" && form.indexOf && form.indexOf(letter) > -1) { + returnable += form[0]; + return; + } + } + } + } else if (localVersion === letter) { + if (breakPresentationForm && letterForms["normal"] && ["isolated", "initial", "medial", "final"].indexOf(versions[v]) > -1) { + if (typeof letterForms["normal"] === "object") { + returnable += letterForms["normal"][0]; + } else { + returnable += letterForms["normal"]; + } + return; + } + returnable += letter; + return; + } else if (typeof localVersion === "object" && localVersion.indexOf && localVersion.indexOf(letter) > -1) { + returnable += localVersion[0]; + return; + } + } + } + for (let v2 = 0; v2 < reference_1.ligatureList.length; v2++) { + let normalForm = reference_1.ligatureList[v2]; + if (normalForm !== "words") { + let ligForms = Object.keys(unicode_ligatures_1.default[normalForm]); + for (let f2 = 0; f2 < ligForms.length; f2++) { + if (unicode_ligatures_1.default[normalForm][ligForms[f2]] === letter) { + returnable += normalForm; + return; + } + } + } + } + for (let v3 = 0; v3 < reference_1.ligatureWordList.length; v3++) { + let normalForm = reference_1.ligatureWordList[v3]; + if (unicode_ligatures_1.default.words[normalForm] === letter) { + returnable += normalForm; + return; + } + } + returnable += letter; + }); + return returnable; } + exports2.Normal = Normal; } - } - - return d3_selection(subgroups); -}; - -function d3_selection_selectorAll(selector) { - return function() { - return d3_selectAll(selector, this); - }; -} -var d3_nsPrefix = { - svg: "http://www.w3.org/2000/svg", - xhtml: "http://www.w3.org/1999/xhtml", - xlink: "http://www.w3.org/1999/xlink", - xml: "http://www.w3.org/XML/1998/namespace", - xmlns: "http://www.w3.org/2000/xmlns/" -}; - -d3.ns = { - prefix: d3_nsPrefix, - qualify: function(name) { - var i = name.indexOf(":"), - prefix = name; - if (i >= 0) { - prefix = name.substring(0, i); - name = name.substring(i + 1); - } - return d3_nsPrefix.hasOwnProperty(prefix) - ? {space: d3_nsPrefix[prefix], local: name} - : name; - } -}; - -d3_selectionPrototype.attr = function(name, value) { - if (arguments.length < 2) { - - // For attr(string), return the attribute value for the first node. - if (typeof name === "string") { - var node = this.node(); - name = d3.ns.qualify(name); - return name.local - ? node.getAttributeNS(name.space, name.local) - : node.getAttribute(name); - } - - // For attr(object), the object specifies the names and values of the - // attributes to set or remove. The values may be functions that are - // evaluated for each element. - for (value in name) this.each(d3_selection_attr(value, name[value])); - return this; - } - - return this.each(d3_selection_attr(name, value)); -}; - -function d3_selection_attr(name, value) { - name = d3.ns.qualify(name); - - // For attr(string, null), remove the attribute with the specified name. - function attrNull() { - this.removeAttribute(name); - } - function attrNullNS() { - this.removeAttributeNS(name.space, name.local); - } - - // For attr(string, string), set the attribute with the specified name. - function attrConstant() { - this.setAttribute(name, value); - } - function attrConstantNS() { - this.setAttributeNS(name.space, name.local, value); - } - - // For attr(string, function), evaluate the function for each element, and set - // or remove the attribute as appropriate. - function attrFunction() { - var x = value.apply(this, arguments); - if (x == null) this.removeAttribute(name); - else this.setAttribute(name, x); - } - function attrFunctionNS() { - var x = value.apply(this, arguments); - if (x == null) this.removeAttributeNS(name.space, name.local); - else this.setAttributeNS(name.space, name.local, x); - } - - return value == null - ? (name.local ? attrNullNS : attrNull) : (typeof value === "function" - ? (name.local ? attrFunctionNS : attrFunction) - : (name.local ? attrConstantNS : attrConstant)); -} -function d3_collapse(s) { - return s.trim().replace(/\s+/g, " "); -} -d3.requote = function(s) { - return s.replace(d3_requote_re, "\\$&"); -}; - -var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g; - -d3_selectionPrototype.classed = function(name, value) { - if (arguments.length < 2) { + }); - // For classed(string), return true only if the first node has the specified - // class or classes. Note that even if the browser supports DOMTokenList, it - // probably doesn't support it on SVG elements (which can be animated). - if (typeof name === "string") { - var node = this.node(), - n = (name = name.trim().split(/^|\s+/g)).length, - i = -1; - if (value = node.classList) { - while (++i < n) if (!value.contains(name[i])) return false; - } else { - value = node.getAttribute("class"); - while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false; + // node_modules/alif-toolkit/lib/CharShaper.js + var require_CharShaper = __commonJS({ + "node_modules/alif-toolkit/lib/CharShaper.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var unicode_arabic_1 = require_unicode_arabic(); + var isArabic_1 = require_isArabic(); + var reference_1 = require_reference(); + function CharShaper(letter, form) { + if (!isArabic_1.isArabic(letter)) { + throw new Error("Not Arabic"); + } + if (letter === "\u0621") { + return "\u0621"; + } + for (let w = 0; w < reference_1.letterList.length; w++) { + let letterForms = unicode_arabic_1.default[reference_1.letterList[w]]; + let versions = Object.keys(letterForms); + for (let v = 0; v < versions.length; v++) { + let localVersion = letterForms[versions[v]]; + if (localVersion === letter || typeof localVersion === "object" && localVersion.indexOf && localVersion.indexOf(letter) > -1) { + if (versions.indexOf(form) > -1) { + return letterForms[form]; + } + } else if (typeof localVersion === "object" && typeof localVersion.indexOf === "undefined") { + let embeddedVersions = Object.keys(localVersion); + for (let ev = 0; ev < embeddedVersions.length; ev++) { + if (localVersion[embeddedVersions[ev]] === letter || typeof localVersion[embeddedVersions[ev]] === "object" && localVersion[embeddedVersions[ev]].indexOf && localVersion[embeddedVersions[ev]].indexOf(letter) > -1) { + if (embeddedVersions.indexOf(form) > -1) { + return localVersion[form]; + } + } + } + } + } + } } - return true; - } - - // For classed(object), the object specifies the names of classes to add or - // remove. The values may be functions that are evaluated for each element. - for (value in name) this.each(d3_selection_classed(value, name[value])); - return this; - } - - // Otherwise, both a name and a value are specified, and are handled as below. - return this.each(d3_selection_classed(name, value)); -}; - -function d3_selection_classedRe(name) { - return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g"); -} - -// Multiple class names are allowed (e.g., "foo bar"). -function d3_selection_classed(name, value) { - name = name.trim().split(/\s+/).map(d3_selection_classedName); - var n = name.length; - - function classedConstant() { - var i = -1; - while (++i < n) name[i](this, value); - } - - // When the value is a function, the function is still evaluated only once per - // element even if there are multiple class names. - function classedFunction() { - var i = -1, x = value.apply(this, arguments); - while (++i < n) name[i](this, x); - } - - return typeof value === "function" - ? classedFunction - : classedConstant; -} - -function d3_selection_classedName(name) { - var re = d3_selection_classedRe(name); - return function(node, value) { - if (c = node.classList) return value ? c.add(name) : c.remove(name); - var c = node.getAttribute("class") || ""; - if (value) { - re.lastIndex = 0; - if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name)); - } else { - node.setAttribute("class", d3_collapse(c.replace(re, " "))); - } - }; -} - -d3_selectionPrototype.style = function(name, value, priority) { - var n = arguments.length; - if (n < 3) { - - // For style(object) or style(object, string), the object specifies the - // names and values of the attributes to set or remove. The values may be - // functions that are evaluated for each element. The optional string - // specifies the priority. - if (typeof name !== "string") { - if (n < 2) value = ""; - for (priority in name) this.each(d3_selection_style(priority, name[priority], value)); - return this; + exports2.CharShaper = CharShaper; } - - // For style(string), return the computed style value for the first node. - if (n < 2) return d3_window.getComputedStyle(this.node(), null).getPropertyValue(name); - - // For style(string, string) or style(string, function), use the default - // priority. The priority is ignored for style(string, null). - priority = ""; - } - - // Otherwise, a name, value and priority are specified, and handled as below. - return this.each(d3_selection_style(name, value, priority)); -}; - -function d3_selection_style(name, value, priority) { - - // For style(name, null) or style(name, null, priority), remove the style - // property with the specified name. The priority is ignored. - function styleNull() { - this.style.removeProperty(name); - } - - // For style(name, string) or style(name, string, priority), set the style - // property with the specified name, using the specified priority. - function styleConstant() { - this.style.setProperty(name, value, priority); - } - - // For style(name, function) or style(name, function, priority), evaluate the - // function for each element, and set or remove the style property as - // appropriate. When setting, use the specified priority. - function styleFunction() { - var x = value.apply(this, arguments); - if (x == null) this.style.removeProperty(name); - else this.style.setProperty(name, x, priority); - } - - return value == null - ? styleNull : (typeof value === "function" - ? styleFunction : styleConstant); -} - -d3_selectionPrototype.property = function(name, value) { - if (arguments.length < 2) { - - // For property(string), return the property value for the first node. - if (typeof name === "string") return this.node()[name]; - - // For property(object), the object specifies the names and values of the - // properties to set or remove. The values may be functions that are - // evaluated for each element. - for (value in name) this.each(d3_selection_property(value, name[value])); - return this; - } - - // Otherwise, both a name and a value are specified, and are handled as below. - return this.each(d3_selection_property(name, value)); -}; - -function d3_selection_property(name, value) { - - // For property(name, null), remove the property with the specified name. - function propertyNull() { - delete this[name]; - } - - // For property(name, string), set the property with the specified name. - function propertyConstant() { - this[name] = value; - } - - // For property(name, function), evaluate the function for each element, and - // set or remove the property as appropriate. - function propertyFunction() { - var x = value.apply(this, arguments); - if (x == null) delete this[name]; - else this[name] = x; - } - - return value == null - ? propertyNull : (typeof value === "function" - ? propertyFunction : propertyConstant); -} - -d3_selectionPrototype.text = function(value) { - return arguments.length - ? this.each(typeof value === "function" - ? function() { var v = value.apply(this, arguments); this.textContent = v == null ? "" : v; } : value == null - ? function() { this.textContent = ""; } - : function() { this.textContent = value; }) - : this.node().textContent; -}; - -d3_selectionPrototype.html = function(value) { - return arguments.length - ? this.each(typeof value === "function" - ? function() { var v = value.apply(this, arguments); this.innerHTML = v == null ? "" : v; } : value == null - ? function() { this.innerHTML = ""; } - : function() { this.innerHTML = value; }) - : this.node().innerHTML; -}; - -// TODO append(node)? -// TODO append(function)? -d3_selectionPrototype.append = function(name) { - name = d3.ns.qualify(name); - - function append() { - return this.appendChild(d3_document.createElementNS(this.namespaceURI, name)); - } - - function appendNS() { - return this.appendChild(d3_document.createElementNS(name.space, name.local)); - } - - return this.select(name.local ? appendNS : append); -}; - -d3_selectionPrototype.insert = function(name, before) { - name = d3.ns.qualify(name); - - if (typeof before !== "function") before = d3_selection_selector(before); - - function insert(d, i) { - return this.insertBefore( - d3_document.createElementNS(this.namespaceURI, name), - before.call(this, d, i)); - } - - function insertNS(d, i) { - return this.insertBefore( - d3_document.createElementNS(name.space, name.local), - before.call(this, d, i)); - } - - return this.select(name.local ? insertNS : insert); -}; - -// TODO remove(selector)? -// TODO remove(node)? -// TODO remove(function)? -d3_selectionPrototype.remove = function() { - return this.each(function() { - var parent = this.parentNode; - if (parent) parent.removeChild(this); }); -}; - -d3_selectionPrototype.data = function(value, key) { - var i = -1, - n = this.length, - group, - node; - // If no value is specified, return the first value. - if (!arguments.length) { - value = new Array(n = (group = this[0]).length); - while (++i < n) { - if (node = group[i]) { - value[i] = node.__data__; + // node_modules/alif-toolkit/lib/WordShaper.js + var require_WordShaper = __commonJS({ + "node_modules/alif-toolkit/lib/WordShaper.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var isArabic_1 = require_isArabic(); + var reference_1 = require_reference(); + var CharShaper_1 = require_CharShaper(); + var unicode_ligatures_1 = require_unicode_ligatures(); + function WordShaper2(word) { + let state = "initial"; + let output = ""; + for (let w = 0; w < word.length; w++) { + let nextLetter = " "; + for (let nxw = w + 1; nxw < word.length; nxw++) { + if (!isArabic_1.isArabic(word[nxw])) { + break; + } + if (reference_1.tashkeel.indexOf(word[nxw]) === -1) { + nextLetter = word[nxw]; + break; + } + } + if (!isArabic_1.isArabic(word[w]) || isArabic_1.isMath(word[w])) { + output += word[w]; + state = "initial"; + } else if (reference_1.tashkeel.indexOf(word[w]) > -1) { + output += word[w]; + } else if (nextLetter === " " || reference_1.lineBreakers.indexOf(word[w]) > -1) { + output += CharShaper_1.CharShaper(word[w], state === "initial" ? "isolated" : "final"); + state = "initial"; + } else if (reference_1.lams.indexOf(word[w]) > -1 && reference_1.alefs.indexOf(nextLetter) > -1) { + output += unicode_ligatures_1.default[word[w] + nextLetter][state === "initial" ? "isolated" : "final"]; + while (word[w] !== nextLetter) { + w++; + } + state = "initial"; + } else { + output += CharShaper_1.CharShaper(word[w], state); + state = "medial"; + } + } + return output; } + exports2.WordShaper = WordShaper2; } - return value; - } + }); - function bind(group, groupData) { - var i, - n = group.length, - m = groupData.length, - n0 = Math.min(n, m), - updateNodes = new Array(m), - enterNodes = new Array(m), - exitNodes = new Array(n), - node, - nodeData; - - if (key) { - var nodeByKeyValue = new d3_Map, - dataByKeyValue = new d3_Map, - keyValues = [], - keyValue; - - for (i = -1; ++i < n;) { - keyValue = key.call(node = group[i], node.__data__, i); - if (nodeByKeyValue.has(keyValue)) { - exitNodes[i] = node; // duplicate selection key - } else { - nodeByKeyValue.set(keyValue, node); + // node_modules/alif-toolkit/lib/ParentLetter.js + var require_ParentLetter = __commonJS({ + "node_modules/alif-toolkit/lib/ParentLetter.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var unicode_arabic_1 = require_unicode_arabic(); + var isArabic_1 = require_isArabic(); + var reference_1 = require_reference(); + function ParentLetter(letter) { + if (!isArabic_1.isArabic(letter)) { + throw new Error("Not an Arabic letter"); } - keyValues.push(keyValue); - } - - for (i = -1; ++i < m;) { - keyValue = key.call(groupData, nodeData = groupData[i], i); - if (node = nodeByKeyValue.get(keyValue)) { - updateNodes[i] = node; - node.__data__ = nodeData; - } else if (!dataByKeyValue.has(keyValue)) { // no duplicate data key - enterNodes[i] = d3_selection_dataNode(nodeData); + for (let w = 0; w < reference_1.letterList.length; w++) { + let letterForms = unicode_arabic_1.default[reference_1.letterList[w]]; + let versions = Object.keys(letterForms); + for (let v = 0; v < versions.length; v++) { + let localVersion = letterForms[versions[v]]; + if (typeof localVersion === "object" && typeof localVersion.indexOf === "undefined") { + let embeddedForms = Object.keys(localVersion); + for (let ef = 0; ef < embeddedForms.length; ef++) { + let form = localVersion[embeddedForms[ef]]; + if (form === letter || typeof form === "object" && form.indexOf && form.indexOf(letter) > -1) { + return localVersion; + } + } + } else if (localVersion === letter || typeof localVersion === "object" && localVersion.indexOf && localVersion.indexOf(letter) > -1) { + return letterForms; + } + } + return null; } - dataByKeyValue.set(keyValue, nodeData); - nodeByKeyValue.remove(keyValue); } - - for (i = -1; ++i < n;) { - if (nodeByKeyValue.has(keyValues[i])) { - exitNodes[i] = group[i]; + exports2.ParentLetter = ParentLetter; + function GrandparentLetter(letter) { + if (!isArabic_1.isArabic(letter)) { + throw new Error("Not an Arabic letter"); } - } - } else { - for (i = -1; ++i < n0;) { - node = group[i]; - nodeData = groupData[i]; - if (node) { - node.__data__ = nodeData; - updateNodes[i] = node; - } else { - enterNodes[i] = d3_selection_dataNode(nodeData); + for (let w = 0; w < reference_1.letterList.length; w++) { + let letterForms = unicode_arabic_1.default[reference_1.letterList[w]]; + let versions = Object.keys(letterForms); + for (let v = 0; v < versions.length; v++) { + let localVersion = letterForms[versions[v]]; + if (typeof localVersion === "object" && typeof localVersion.indexOf === "undefined") { + let embeddedForms = Object.keys(localVersion); + for (let ef = 0; ef < embeddedForms.length; ef++) { + let form = localVersion[embeddedForms[ef]]; + if (form === letter || typeof form === "object" && form.indexOf && form.indexOf(letter) > -1) { + return letterForms; + } + } + } else if (localVersion === letter || typeof localVersion === "object" && localVersion.indexOf && localVersion.indexOf(letter) > -1) { + return letterForms; + } + } + return null; } } - for (; i < m; ++i) { - enterNodes[i] = d3_selection_dataNode(groupData[i]); - } - for (; i < n; ++i) { - exitNodes[i] = group[i]; - } + exports2.GrandparentLetter = GrandparentLetter; } + }); - enterNodes.update - = updateNodes; - - enterNodes.parentNode - = updateNodes.parentNode - = exitNodes.parentNode - = group.parentNode; - - enter.push(enterNodes); - update.push(updateNodes); - exit.push(exitNodes); - } - - var enter = d3_selection_enter([]), - update = d3_selection([]), - exit = d3_selection([]); - - if (typeof value === "function") { - while (++i < n) { - bind(group = this[i], value.call(group, group.parentNode.__data__, i)); - } - } else { - while (++i < n) { - bind(group = this[i], value); + // node_modules/alif-toolkit/lib/index.js + var require_lib = __commonJS({ + "node_modules/alif-toolkit/lib/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var isArabic_1 = require_isArabic(); + exports2.isArabic = isArabic_1.isArabic; + var GlyphSplitter_1 = require_GlyphSplitter(); + exports2.GlyphSplitter = GlyphSplitter_1.GlyphSplitter; + var BaselineSplitter_1 = require_BaselineSplitter(); + exports2.BaselineSplitter = BaselineSplitter_1.BaselineSplitter; + var Normalization_1 = require_Normalization(); + exports2.Normal = Normalization_1.Normal; + var CharShaper_1 = require_CharShaper(); + exports2.CharShaper = CharShaper_1.CharShaper; + var WordShaper_1 = require_WordShaper(); + exports2.WordShaper = WordShaper_1.WordShaper; + var ParentLetter_1 = require_ParentLetter(); + exports2.ParentLetter = ParentLetter_1.ParentLetter; + exports2.GrandparentLetter = ParentLetter_1.GrandparentLetter; } - } - - update.enter = function() { return enter; }; - update.exit = function() { return exit; }; - return update; -}; - -function d3_selection_dataNode(data) { - return {__data__: data}; -} - -d3_selectionPrototype.datum = function(value) { - return arguments.length - ? this.property("__data__", value) - : this.property("__data__"); -}; - -d3_selectionPrototype.filter = function(filter) { - var subgroups = [], - subgroup, - group, - node; - - if (typeof filter !== "function") filter = d3_selection_filter(filter); + }); - for (var j = 0, m = this.length; j < m; j++) { - subgroups.push(subgroup = []); - subgroup.parentNode = (group = this[j]).parentNode; - for (var i = 0, n = group.length; i < n; i++) { - if ((node = group[i]) && filter.call(node, node.__data__, i)) { - subgroup.push(node); - } + // node_modules/vparse/index.js + var require_vparse = __commonJS({ + "node_modules/vparse/index.js"(exports2, module2) { + (function(window2) { + "use strict"; + function parseVersion3(v) { + var m = v.replace(/[^0-9.]/g, "").match(/[0-9]*\.|[0-9]+/g) || []; + v = { + major: +m[0] || 0, + minor: +m[1] || 0, + patch: +m[2] || 0, + build: +m[3] || 0 + }; + v.isEmpty = !v.major && !v.minor && !v.patch && !v.build; + v.parsed = [v.major, v.minor, v.patch, v.build]; + v.text = v.parsed.join("."); + v.compare = compare; + return v; + } + function compare(v) { + if (typeof v === "string") { + v = parseVersion3(v); + } + for (var i2 = 0; i2 < 4; i2++) { + if (this.parsed[i2] !== v.parsed[i2]) { + return this.parsed[i2] > v.parsed[i2] ? 1 : -1; + } + } + return 0; + } + if (typeof module2 === "object" && module2 && typeof module2.exports === "object") { + module2.exports = parseVersion3; + } else { + window2.parseVersion = parseVersion3; + } + })(exports2); } - } - - return d3_selection(subgroups); -}; + }); -function d3_selection_filter(selector) { - return function() { - return d3_selectMatches(this, selector); - }; -} - -d3_selectionPrototype.order = function() { - for (var j = -1, m = this.length; ++j < m;) { - for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0;) { - if (node = group[i]) { - if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); - next = node; - } + // node_modules/which-polygon/node_modules/quickselect/quickselect.js + var require_quickselect = __commonJS({ + "node_modules/which-polygon/node_modules/quickselect/quickselect.js"(exports2, module2) { + (function(global3, factory) { + typeof exports2 === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : global3.quickselect = factory(); + })(exports2, function() { + "use strict"; + function quickselect2(arr, k, left, right, compare) { + quickselectStep(arr, k, left || 0, right || arr.length - 1, compare || defaultCompare); + } + function quickselectStep(arr, k, left, right, compare) { + while (right > left) { + if (right - left > 600) { + var n2 = right - left + 1; + var m = k - left + 1; + var z = Math.log(n2); + var s = 0.5 * Math.exp(2 * z / 3); + var sd = 0.5 * Math.sqrt(z * s * (n2 - s) / n2) * (m - n2 / 2 < 0 ? -1 : 1); + var newLeft = Math.max(left, Math.floor(k - m * s / n2 + sd)); + var newRight = Math.min(right, Math.floor(k + (n2 - m) * s / n2 + sd)); + quickselectStep(arr, k, newLeft, newRight, compare); + } + var t = arr[k]; + var i2 = left; + var j2 = right; + swap2(arr, left, k); + if (compare(arr[right], t) > 0) + swap2(arr, left, right); + while (i2 < j2) { + swap2(arr, i2, j2); + i2++; + j2--; + while (compare(arr[i2], t) < 0) + i2++; + while (compare(arr[j2], t) > 0) + j2--; + } + if (compare(arr[left], t) === 0) + swap2(arr, left, j2); + else { + j2++; + swap2(arr, j2, right); + } + if (j2 <= k) + left = j2 + 1; + if (k <= j2) + right = j2 - 1; + } + } + function swap2(arr, i2, j2) { + var tmp = arr[i2]; + arr[i2] = arr[j2]; + arr[j2] = tmp; + } + function defaultCompare(a, b) { + return a < b ? -1 : a > b ? 1 : 0; + } + return quickselect2; + }); } - } - return this; -}; - -d3_selectionPrototype.sort = function(comparator) { - comparator = d3_selection_sortComparator.apply(this, arguments); - for (var j = -1, m = this.length; ++j < m;) this[j].sort(comparator); - return this.order(); -}; + }); -function d3_selection_sortComparator(comparator) { - if (!arguments.length) comparator = d3.ascending; - return function(a, b) { - return (!a - !b) || comparator(a.__data__, b.__data__); - }; -} -function d3_noop() {} - -d3_selectionPrototype.on = function(type, listener, capture) { - var n = arguments.length; - if (n < 3) { - - // For on(object) or on(object, boolean), the object specifies the event - // types and listeners to add or remove. The optional boolean specifies - // whether the listener captures events. - if (typeof type !== "string") { - if (n < 2) listener = false; - for (capture in type) this.each(d3_selection_on(capture, type[capture], listener)); - return this; + // node_modules/which-polygon/node_modules/rbush/index.js + var require_rbush = __commonJS({ + "node_modules/which-polygon/node_modules/rbush/index.js"(exports2, module2) { + "use strict"; + module2.exports = rbush; + module2.exports.default = rbush; + var quickselect2 = require_quickselect(); + function rbush(maxEntries, format2) { + if (!(this instanceof rbush)) + return new rbush(maxEntries, format2); + this._maxEntries = Math.max(4, maxEntries || 9); + this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4)); + if (format2) { + this._initFormat(format2); + } + this.clear(); + } + rbush.prototype = { + all: function() { + return this._all(this.data, []); + }, + search: function(bbox2) { + var node = this.data, result = [], toBBox = this.toBBox; + if (!intersects(bbox2, node)) + return result; + var nodesToSearch = [], i2, len, child, childBBox; + while (node) { + for (i2 = 0, len = node.children.length; i2 < len; i2++) { + child = node.children[i2]; + childBBox = node.leaf ? toBBox(child) : child; + if (intersects(bbox2, childBBox)) { + if (node.leaf) + result.push(child); + else if (contains(bbox2, childBBox)) + this._all(child, result); + else + nodesToSearch.push(child); + } + } + node = nodesToSearch.pop(); + } + return result; + }, + collides: function(bbox2) { + var node = this.data, toBBox = this.toBBox; + if (!intersects(bbox2, node)) + return false; + var nodesToSearch = [], i2, len, child, childBBox; + while (node) { + for (i2 = 0, len = node.children.length; i2 < len; i2++) { + child = node.children[i2]; + childBBox = node.leaf ? toBBox(child) : child; + if (intersects(bbox2, childBBox)) { + if (node.leaf || contains(bbox2, childBBox)) + return true; + nodesToSearch.push(child); + } + } + node = nodesToSearch.pop(); + } + return false; + }, + load: function(data) { + if (!(data && data.length)) + return this; + if (data.length < this._minEntries) { + for (var i2 = 0, len = data.length; i2 < len; i2++) { + this.insert(data[i2]); + } + return this; + } + var node = this._build(data.slice(), 0, data.length - 1, 0); + if (!this.data.children.length) { + this.data = node; + } else if (this.data.height === node.height) { + this._splitRoot(this.data, node); + } else { + if (this.data.height < node.height) { + var tmpNode = this.data; + this.data = node; + node = tmpNode; + } + this._insert(node, this.data.height - node.height - 1, true); + } + return this; + }, + insert: function(item) { + if (item) + this._insert(item, this.data.height - 1); + return this; + }, + clear: function() { + this.data = createNode([]); + return this; + }, + remove: function(item, equalsFn) { + if (!item) + return this; + var node = this.data, bbox2 = this.toBBox(item), path = [], indexes = [], i2, parent, index, goingUp; + while (node || path.length) { + if (!node) { + node = path.pop(); + parent = path[path.length - 1]; + i2 = indexes.pop(); + goingUp = true; + } + if (node.leaf) { + index = findItem(item, node.children, equalsFn); + if (index !== -1) { + node.children.splice(index, 1); + path.push(node); + this._condense(path); + return this; + } + } + if (!goingUp && !node.leaf && contains(node, bbox2)) { + path.push(node); + indexes.push(i2); + i2 = 0; + parent = node; + node = node.children[0]; + } else if (parent) { + i2++; + node = parent.children[i2]; + goingUp = false; + } else + node = null; + } + return this; + }, + toBBox: function(item) { + return item; + }, + compareMinX: compareNodeMinX, + compareMinY: compareNodeMinY, + toJSON: function() { + return this.data; + }, + fromJSON: function(data) { + this.data = data; + return this; + }, + _all: function(node, result) { + var nodesToSearch = []; + while (node) { + if (node.leaf) + result.push.apply(result, node.children); + else + nodesToSearch.push.apply(nodesToSearch, node.children); + node = nodesToSearch.pop(); + } + return result; + }, + _build: function(items, left, right, height) { + var N = right - left + 1, M = this._maxEntries, node; + if (N <= M) { + node = createNode(items.slice(left, right + 1)); + calcBBox(node, this.toBBox); + return node; + } + if (!height) { + height = Math.ceil(Math.log(N) / Math.log(M)); + M = Math.ceil(N / Math.pow(M, height - 1)); + } + node = createNode([]); + node.leaf = false; + node.height = height; + var N2 = Math.ceil(N / M), N1 = N2 * Math.ceil(Math.sqrt(M)), i2, j2, right2, right3; + multiSelect(items, left, right, N1, this.compareMinX); + for (i2 = left; i2 <= right; i2 += N1) { + right2 = Math.min(i2 + N1 - 1, right); + multiSelect(items, i2, right2, N2, this.compareMinY); + for (j2 = i2; j2 <= right2; j2 += N2) { + right3 = Math.min(j2 + N2 - 1, right2); + node.children.push(this._build(items, j2, right3, height - 1)); + } + } + calcBBox(node, this.toBBox); + return node; + }, + _chooseSubtree: function(bbox2, node, level, path) { + var i2, len, child, targetNode, area, enlargement, minArea, minEnlargement; + while (true) { + path.push(node); + if (node.leaf || path.length - 1 === level) + break; + minArea = minEnlargement = Infinity; + for (i2 = 0, len = node.children.length; i2 < len; i2++) { + child = node.children[i2]; + area = bboxArea(child); + enlargement = enlargedArea(bbox2, child) - area; + if (enlargement < minEnlargement) { + minEnlargement = enlargement; + minArea = area < minArea ? area : minArea; + targetNode = child; + } else if (enlargement === minEnlargement) { + if (area < minArea) { + minArea = area; + targetNode = child; + } + } + } + node = targetNode || node.children[0]; + } + return node; + }, + _insert: function(item, level, isNode) { + var toBBox = this.toBBox, bbox2 = isNode ? item : toBBox(item), insertPath = []; + var node = this._chooseSubtree(bbox2, this.data, level, insertPath); + node.children.push(item); + extend2(node, bbox2); + while (level >= 0) { + if (insertPath[level].children.length > this._maxEntries) { + this._split(insertPath, level); + level--; + } else + break; + } + this._adjustParentBBoxes(bbox2, insertPath, level); + }, + // split overflowed node into two + _split: function(insertPath, level) { + var node = insertPath[level], M = node.children.length, m = this._minEntries; + this._chooseSplitAxis(node, m, M); + var splitIndex = this._chooseSplitIndex(node, m, M); + var newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex)); + newNode.height = node.height; + newNode.leaf = node.leaf; + calcBBox(node, this.toBBox); + calcBBox(newNode, this.toBBox); + if (level) + insertPath[level - 1].children.push(newNode); + else + this._splitRoot(node, newNode); + }, + _splitRoot: function(node, newNode) { + this.data = createNode([node, newNode]); + this.data.height = node.height + 1; + this.data.leaf = false; + calcBBox(this.data, this.toBBox); + }, + _chooseSplitIndex: function(node, m, M) { + var i2, bbox1, bbox2, overlap, area, minOverlap, minArea, index; + minOverlap = minArea = Infinity; + for (i2 = m; i2 <= M - m; i2++) { + bbox1 = distBBox(node, 0, i2, this.toBBox); + bbox2 = distBBox(node, i2, M, this.toBBox); + overlap = intersectionArea(bbox1, bbox2); + area = bboxArea(bbox1) + bboxArea(bbox2); + if (overlap < minOverlap) { + minOverlap = overlap; + index = i2; + minArea = area < minArea ? area : minArea; + } else if (overlap === minOverlap) { + if (area < minArea) { + minArea = area; + index = i2; + } + } + } + return index; + }, + // sorts node children by the best axis for split + _chooseSplitAxis: function(node, m, M) { + var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX, compareMinY = node.leaf ? this.compareMinY : compareNodeMinY, xMargin = this._allDistMargin(node, m, M, compareMinX), yMargin = this._allDistMargin(node, m, M, compareMinY); + if (xMargin < yMargin) + node.children.sort(compareMinX); + }, + // total margin of all possible split distributions where each node is at least m full + _allDistMargin: function(node, m, M, compare) { + node.children.sort(compare); + var toBBox = this.toBBox, leftBBox = distBBox(node, 0, m, toBBox), rightBBox = distBBox(node, M - m, M, toBBox), margin = bboxMargin(leftBBox) + bboxMargin(rightBBox), i2, child; + for (i2 = m; i2 < M - m; i2++) { + child = node.children[i2]; + extend2(leftBBox, node.leaf ? toBBox(child) : child); + margin += bboxMargin(leftBBox); + } + for (i2 = M - m - 1; i2 >= m; i2--) { + child = node.children[i2]; + extend2(rightBBox, node.leaf ? toBBox(child) : child); + margin += bboxMargin(rightBBox); + } + return margin; + }, + _adjustParentBBoxes: function(bbox2, path, level) { + for (var i2 = level; i2 >= 0; i2--) { + extend2(path[i2], bbox2); + } + }, + _condense: function(path) { + for (var i2 = path.length - 1, siblings; i2 >= 0; i2--) { + if (path[i2].children.length === 0) { + if (i2 > 0) { + siblings = path[i2 - 1].children; + siblings.splice(siblings.indexOf(path[i2]), 1); + } else + this.clear(); + } else + calcBBox(path[i2], this.toBBox); + } + }, + _initFormat: function(format2) { + var compareArr = ["return a", " - b", ";"]; + this.compareMinX = new Function("a", "b", compareArr.join(format2[0])); + this.compareMinY = new Function("a", "b", compareArr.join(format2[1])); + this.toBBox = new Function( + "a", + "return {minX: a" + format2[0] + ", minY: a" + format2[1] + ", maxX: a" + format2[2] + ", maxY: a" + format2[3] + "};" + ); + } + }; + function findItem(item, items, equalsFn) { + if (!equalsFn) + return items.indexOf(item); + for (var i2 = 0; i2 < items.length; i2++) { + if (equalsFn(item, items[i2])) + return i2; + } + return -1; + } + function calcBBox(node, toBBox) { + distBBox(node, 0, node.children.length, toBBox, node); + } + function distBBox(node, k, p, toBBox, destNode) { + if (!destNode) + destNode = createNode(null); + destNode.minX = Infinity; + destNode.minY = Infinity; + destNode.maxX = -Infinity; + destNode.maxY = -Infinity; + for (var i2 = k, child; i2 < p; i2++) { + child = node.children[i2]; + extend2(destNode, node.leaf ? toBBox(child) : child); + } + return destNode; + } + function extend2(a, b) { + a.minX = Math.min(a.minX, b.minX); + a.minY = Math.min(a.minY, b.minY); + a.maxX = Math.max(a.maxX, b.maxX); + a.maxY = Math.max(a.maxY, b.maxY); + return a; + } + function compareNodeMinX(a, b) { + return a.minX - b.minX; + } + function compareNodeMinY(a, b) { + return a.minY - b.minY; + } + function bboxArea(a) { + return (a.maxX - a.minX) * (a.maxY - a.minY); + } + function bboxMargin(a) { + return a.maxX - a.minX + (a.maxY - a.minY); + } + function enlargedArea(a, b) { + return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) * (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY)); + } + function intersectionArea(a, b) { + var minX = Math.max(a.minX, b.minX), minY = Math.max(a.minY, b.minY), maxX = Math.min(a.maxX, b.maxX), maxY = Math.min(a.maxY, b.maxY); + return Math.max(0, maxX - minX) * Math.max(0, maxY - minY); + } + function contains(a, b) { + return a.minX <= b.minX && a.minY <= b.minY && b.maxX <= a.maxX && b.maxY <= a.maxY; + } + function intersects(a, b) { + return b.minX <= a.maxX && b.minY <= a.maxY && b.maxX >= a.minX && b.maxY >= a.minY; + } + function createNode(children2) { + return { + children: children2, + height: 1, + leaf: true, + minX: Infinity, + minY: Infinity, + maxX: -Infinity, + maxY: -Infinity + }; + } + function multiSelect(arr, left, right, n2, compare) { + var stack = [left, right], mid; + while (stack.length) { + right = stack.pop(); + left = stack.pop(); + if (right - left <= n2) + continue; + mid = left + Math.ceil((right - left) / n2 / 2) * n2; + quickselect2(arr, mid, left, right, compare); + stack.push(left, mid, mid, right); + } + } } + }); - // For on(string), return the listener for the first node. - if (n < 2) return (n = this.node()["__on" + type]) && n._; - - // For on(string, function), use the default capture. - capture = false; - } - - // Otherwise, a type, listener and capture are specified, and handled as below. - return this.each(d3_selection_on(type, listener, capture)); -}; - -function d3_selection_on(type, listener, capture) { - var name = "__on" + type, - i = type.indexOf("."), - wrap = d3_selection_onListener; - - if (i > 0) type = type.substring(0, i); - var filter = d3_selection_onFilters.get(type); - if (filter) type = filter, wrap = d3_selection_onFilter; - - function onRemove() { - var l = this[name]; - if (l) { - this.removeEventListener(type, l, l.$); - delete this[name]; + // node_modules/lineclip/index.js + var require_lineclip = __commonJS({ + "node_modules/lineclip/index.js"(exports2, module2) { + "use strict"; + module2.exports = lineclip2; + lineclip2.polyline = lineclip2; + lineclip2.polygon = polygonclip2; + function lineclip2(points, bbox2, result) { + var len = points.length, codeA = bitCode2(points[0], bbox2), part = [], i2, a, b, codeB, lastCode; + if (!result) + result = []; + for (i2 = 1; i2 < len; i2++) { + a = points[i2 - 1]; + b = points[i2]; + codeB = lastCode = bitCode2(b, bbox2); + while (true) { + if (!(codeA | codeB)) { + part.push(a); + if (codeB !== lastCode) { + part.push(b); + if (i2 < len - 1) { + result.push(part); + part = []; + } + } else if (i2 === len - 1) { + part.push(b); + } + break; + } else if (codeA & codeB) { + break; + } else if (codeA) { + a = intersect2(a, b, codeA, bbox2); + codeA = bitCode2(a, bbox2); + } else { + b = intersect2(a, b, codeB, bbox2); + codeB = bitCode2(b, bbox2); + } + } + codeA = lastCode; + } + if (part.length) + result.push(part); + return result; + } + function polygonclip2(points, bbox2) { + var result, edge, prev, prevInside, i2, p, inside; + for (edge = 1; edge <= 8; edge *= 2) { + result = []; + prev = points[points.length - 1]; + prevInside = !(bitCode2(prev, bbox2) & edge); + for (i2 = 0; i2 < points.length; i2++) { + p = points[i2]; + inside = !(bitCode2(p, bbox2) & edge); + if (inside !== prevInside) + result.push(intersect2(prev, p, edge, bbox2)); + if (inside) + result.push(p); + prev = p; + prevInside = inside; + } + points = result; + if (!points.length) + break; + } + return result; + } + function intersect2(a, b, edge, bbox2) { + return edge & 8 ? [a[0] + (b[0] - a[0]) * (bbox2[3] - a[1]) / (b[1] - a[1]), bbox2[3]] : ( + // top + edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox2[1] - a[1]) / (b[1] - a[1]), bbox2[1]] : ( + // bottom + edge & 2 ? [bbox2[2], a[1] + (b[1] - a[1]) * (bbox2[2] - a[0]) / (b[0] - a[0])] : ( + // right + edge & 1 ? [bbox2[0], a[1] + (b[1] - a[1]) * (bbox2[0] - a[0]) / (b[0] - a[0])] : ( + // left + null + ) + ) + ) + ); + } + function bitCode2(p, bbox2) { + var code = 0; + if (p[0] < bbox2[0]) + code |= 1; + else if (p[0] > bbox2[2]) + code |= 2; + if (p[1] < bbox2[1]) + code |= 4; + else if (p[1] > bbox2[3]) + code |= 8; + return code; + } } - } - - function onAdd() { - var l = wrap(listener, d3_array(arguments)); - if (typeof Raven !== 'undefined') l = Raven.wrap(l); - onRemove.call(this); - this.addEventListener(type, this[name] = l, l.$ = capture); - l._ = listener; - } + }); - function removeAll() { - var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), - match; - for (var name in this) { - if (match = name.match(re)) { - var l = this[name]; - this.removeEventListener(match[1], l, l.$); - delete this[name]; + // node_modules/which-polygon/index.js + var require_which_polygon = __commonJS({ + "node_modules/which-polygon/index.js"(exports2, module2) { + "use strict"; + var rbush = require_rbush(); + var lineclip2 = require_lineclip(); + module2.exports = whichPolygon5; + function whichPolygon5(data) { + var bboxes = []; + for (var i2 = 0; i2 < data.features.length; i2++) { + var feature3 = data.features[i2]; + if (!feature3.geometry) + continue; + var coords = feature3.geometry.coordinates; + if (feature3.geometry.type === "Polygon") { + bboxes.push(treeItem(coords, feature3.properties)); + } else if (feature3.geometry.type === "MultiPolygon") { + for (var j2 = 0; j2 < coords.length; j2++) { + bboxes.push(treeItem(coords[j2], feature3.properties)); + } + } + } + var tree = rbush().load(bboxes); + function query(p, multi) { + var output = [], result = tree.search({ + minX: p[0], + minY: p[1], + maxX: p[0], + maxY: p[1] + }); + for (var i3 = 0; i3 < result.length; i3++) { + if (insidePolygon(result[i3].coords, p)) { + if (multi) + output.push(result[i3].props); + else + return result[i3].props; + } + } + return multi && output.length ? output : null; + } + query.tree = tree; + query.bbox = function queryBBox(bbox2) { + var output = []; + var result = tree.search({ + minX: bbox2[0], + minY: bbox2[1], + maxX: bbox2[2], + maxY: bbox2[3] + }); + for (var i3 = 0; i3 < result.length; i3++) { + if (polygonIntersectsBBox(result[i3].coords, bbox2)) { + output.push(result[i3].props); + } + } + return output; + }; + return query; + } + function polygonIntersectsBBox(polygon2, bbox2) { + var bboxCenter = [ + (bbox2[0] + bbox2[2]) / 2, + (bbox2[1] + bbox2[3]) / 2 + ]; + if (insidePolygon(polygon2, bboxCenter)) + return true; + for (var i2 = 0; i2 < polygon2.length; i2++) { + if (lineclip2(polygon2[i2], bbox2).length > 0) + return true; + } + return false; + } + function insidePolygon(rings, p) { + var inside = false; + for (var i2 = 0, len = rings.length; i2 < len; i2++) { + var ring = rings[i2]; + for (var j2 = 0, len2 = ring.length, k = len2 - 1; j2 < len2; k = j2++) { + if (rayIntersect(p, ring[j2], ring[k])) + inside = !inside; + } + } + return inside; + } + function rayIntersect(p, p1, p2) { + return p1[1] > p[1] !== p2[1] > p[1] && p[0] < (p2[0] - p1[0]) * (p[1] - p1[1]) / (p2[1] - p1[1]) + p1[0]; + } + function treeItem(coords, props) { + var item = { + minX: Infinity, + minY: Infinity, + maxX: -Infinity, + maxY: -Infinity, + coords, + props + }; + for (var i2 = 0; i2 < coords[0].length; i2++) { + var p = coords[0][i2]; + item.minX = Math.min(item.minX, p[0]); + item.minY = Math.min(item.minY, p[1]); + item.maxX = Math.max(item.maxX, p[0]); + item.maxY = Math.max(item.maxY, p[1]); + } + return item; } } - } - - return i - ? listener ? onAdd : onRemove - : listener ? d3_noop : removeAll; -} - -var d3_selection_onFilters = d3.map({ - mouseenter: "mouseover", - mouseleave: "mouseout" -}); - -d3_selection_onFilters.forEach(function(k) { - if ("on" + k in d3_document) d3_selection_onFilters.remove(k); -}); + }); -function d3_selection_onListener(listener, argumentz) { - return function(e) { - var o = d3.event; // Events can be reentrant (e.g., focus). - d3.event = e; - argumentz[0] = this.__data__; - try { - listener.apply(this, argumentz); - } finally { - d3.event = o; + // node_modules/wgs84/index.js + var require_wgs84 = __commonJS({ + "node_modules/wgs84/index.js"(exports2, module2) { + module2.exports.RADIUS = 6378137; + module2.exports.FLATTENING = 1 / 298.257223563; + module2.exports.POLAR_RADIUS = 63567523142e-4; } - }; -} + }); -function d3_selection_onFilter(listener, argumentz) { - var l = d3_selection_onListener(listener, argumentz); - return function(e) { - var target = this, related = e.relatedTarget; - if (!related || (related !== target && !(related.compareDocumentPosition(target) & 8))) { - l.call(target, e); + // node_modules/@mapbox/geojson-area/index.js + var require_geojson_area = __commonJS({ + "node_modules/@mapbox/geojson-area/index.js"(exports2, module2) { + var wgs84 = require_wgs84(); + module2.exports.geometry = geometry; + module2.exports.ring = ringArea; + function geometry(_) { + var area = 0, i2; + switch (_.type) { + case "Polygon": + return polygonArea(_.coordinates); + case "MultiPolygon": + for (i2 = 0; i2 < _.coordinates.length; i2++) { + area += polygonArea(_.coordinates[i2]); + } + return area; + case "Point": + case "MultiPoint": + case "LineString": + case "MultiLineString": + return 0; + case "GeometryCollection": + for (i2 = 0; i2 < _.geometries.length; i2++) { + area += geometry(_.geometries[i2]); + } + return area; + } + } + function polygonArea(coords) { + var area = 0; + if (coords && coords.length > 0) { + area += Math.abs(ringArea(coords[0])); + for (var i2 = 1; i2 < coords.length; i2++) { + area -= Math.abs(ringArea(coords[i2])); + } + } + return area; + } + function ringArea(coords) { + var p1, p2, p3, lowerIndex, middleIndex, upperIndex, i2, area = 0, coordsLength = coords.length; + if (coordsLength > 2) { + for (i2 = 0; i2 < coordsLength; i2++) { + if (i2 === coordsLength - 2) { + lowerIndex = coordsLength - 2; + middleIndex = coordsLength - 1; + upperIndex = 0; + } else if (i2 === coordsLength - 1) { + lowerIndex = coordsLength - 1; + middleIndex = 0; + upperIndex = 1; + } else { + lowerIndex = i2; + middleIndex = i2 + 1; + upperIndex = i2 + 2; + } + p1 = coords[lowerIndex]; + p2 = coords[middleIndex]; + p3 = coords[upperIndex]; + area += (rad(p3[0]) - rad(p1[0])) * Math.sin(rad(p2[1])); + } + area = area * wgs84.RADIUS * wgs84.RADIUS / 2; + } + return area; + } + function rad(_) { + return _ * Math.PI / 180; + } } - }; -} - -d3_selectionPrototype.each = function(callback) { - return d3_selection_each(this, function(node, i, j) { - callback.call(node, node.__data__, i, j); }); -}; -function d3_selection_each(groups, callback) { - for (var 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(node, i, j); + // node_modules/circle-to-polygon/input-validation/validateCenter.js + var require_validateCenter = __commonJS({ + "node_modules/circle-to-polygon/input-validation/validateCenter.js"(exports2) { + exports2.validateCenter = function validateCenter(center) { + var validCenterLengths = [2, 3]; + if (!Array.isArray(center) || !validCenterLengths.includes(center.length)) { + throw new Error("ERROR! Center has to be an array of length two or three"); + } + var [lng, lat] = center; + if (typeof lng !== "number" || typeof lat !== "number") { + throw new Error( + `ERROR! Longitude and Latitude has to be numbers but where ${typeof lng} and ${typeof lat}` + ); + } + if (lng > 180 || lng < -180) { + throw new Error(`ERROR! Longitude has to be between -180 and 180 but was ${lng}`); + } + if (lat > 90 || lat < -90) { + throw new Error(`ERROR! Latitude has to be between -90 and 90 but was ${lat}`); + } + }; } - } - return groups; -} - -d3_selectionPrototype.call = function(callback) { - var args = d3_array(arguments); - callback.apply(args[0] = this, args); - return this; -}; - -d3_selectionPrototype.empty = function() { - return !this.node(); -}; + }); -d3_selectionPrototype.node = function() { - for (var j = 0, m = this.length; j < m; j++) { - for (var group = this[j], i = 0, n = group.length; i < n; i++) { - var node = group[i]; - if (node) return node; + // node_modules/circle-to-polygon/input-validation/validateRadius.js + var require_validateRadius = __commonJS({ + "node_modules/circle-to-polygon/input-validation/validateRadius.js"(exports2) { + exports2.validateRadius = function validateRadius(radius) { + if (typeof radius !== "number") { + throw new Error(`ERROR! Radius has to be a positive number but was: ${typeof radius}`); + } + if (radius <= 0) { + throw new Error(`ERROR! Radius has to be a positive number but was: ${radius}`); + } + }; } - } - return null; -}; - -function d3_selection_enter(selection) { - d3_arraySubclass(selection, d3_selection_enterPrototype); - return selection; -} - -var d3_selection_enterPrototype = []; - -d3.selection.enter = d3_selection_enter; -d3.selection.enter.prototype = d3_selection_enterPrototype; - -d3_selection_enterPrototype.append = d3_selectionPrototype.append; -d3_selection_enterPrototype.insert = d3_selectionPrototype.insert; -d3_selection_enterPrototype.empty = d3_selectionPrototype.empty; -d3_selection_enterPrototype.node = d3_selectionPrototype.node; - + }); -d3_selection_enterPrototype.select = function(selector) { - var subgroups = [], - subgroup, - subnode, - upgroup, - group, - node; - - for (var j = -1, m = this.length; ++j < m;) { - upgroup = (group = this[j]).update; - subgroups.push(subgroup = []); - subgroup.parentNode = group.parentNode; - for (var i = -1, n = group.length; ++i < n;) { - if (node = group[i]) { - subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i)); - subnode.__data__ = node.__data__; - } else { - subgroup.push(null); - } + // node_modules/circle-to-polygon/input-validation/validateNumberOfEdges.js + var require_validateNumberOfEdges = __commonJS({ + "node_modules/circle-to-polygon/input-validation/validateNumberOfEdges.js"(exports2) { + exports2.validateNumberOfEdges = function validateNumberOfEdges(numberOfEdges) { + if (typeof numberOfEdges !== "number") { + const ARGUMENT_TYPE = Array.isArray(numberOfEdges) ? "array" : typeof numberOfEdges; + throw new Error(`ERROR! Number of edges has to be a number but was: ${ARGUMENT_TYPE}`); + } + if (numberOfEdges < 3) { + throw new Error(`ERROR! Number of edges has to be at least 3 but was: ${numberOfEdges}`); + } + }; } - } - - return d3_selection(subgroups); -}; - -d3_selectionPrototype.transition = function() { - var id = d3_transitionInheritId || ++d3_transitionId, - subgroups = [], - subgroup, - node, - transition = Object.create(d3_transitionInherit); - - transition.time = Date.now(); + }); - for (var j = -1, m = this.length; ++j < m;) { - subgroups.push(subgroup = []); - for (var group = this[j], i = -1, n = group.length; ++i < n;) { - if (node = group[i]) d3_transitionNode(node, i, id, transition); - subgroup.push(node); + // node_modules/circle-to-polygon/input-validation/validateEarthRadius.js + var require_validateEarthRadius = __commonJS({ + "node_modules/circle-to-polygon/input-validation/validateEarthRadius.js"(exports2) { + exports2.validateEarthRadius = function validateEarthRadius(earthRadius2) { + if (typeof earthRadius2 !== "number") { + const ARGUMENT_TYPE = Array.isArray(earthRadius2) ? "array" : typeof earthRadius2; + throw new Error(`ERROR! Earth radius has to be a number but was: ${ARGUMENT_TYPE}`); + } + if (earthRadius2 <= 0) { + throw new Error(`ERROR! Earth radius has to be a positive number but was: ${earthRadius2}`); + } + }; } - } - - return d3_transition(subgroups, id); -}; - -var d3_selectionRoot = d3_selection([[d3_document]]); - -d3_selectionRoot[0].parentNode = d3_selectRoot; - -// TODO fast singleton implementation! -// TODO select(function) -d3.select = function(selector) { - return typeof selector === "string" - ? d3_selectionRoot.select(selector) - : d3_selection([[selector]]); // assume node -}; - -// TODO selectAll(function) -d3.selectAll = function(selector) { - return typeof selector === "string" - ? d3_selectionRoot.selectAll(selector) - : d3_selection([d3_array(selector)]); // assume node[] -}; - -d3.behavior.zoom = function() { - var translate = [0, 0], - translate0, // translate when we started zooming (to avoid drift) - scale = 1, - scale0, // scale when we started touching - scaleExtent = d3_behavior_zoomInfinity, - event = d3_eventDispatch(zoom, "zoom"), - x0, - x1, - y0, - y1, - touchtime; // time of last touchstart (to detect double-tap) - - function zoom() { - this.on("mousedown.zoom", mousedown) - .on("mousemove.zoom", mousemove) - .on(d3_behavior_zoomWheel + ".zoom", mousewheel) - .on("dblclick.zoom", dblclick) - .on("touchstart.zoom", touchstart) - .on("touchmove.zoom", touchmove) - .on("touchend.zoom", touchstart); - } - - zoom.translate = function(x) { - if (!arguments.length) return translate; - translate = x.map(Number); - rescale(); - return zoom; - }; - - zoom.scale = function(x) { - if (!arguments.length) return scale; - scale = +x; - rescale(); - return zoom; - }; - - zoom.scaleExtent = function(x) { - if (!arguments.length) return scaleExtent; - scaleExtent = x == null ? d3_behavior_zoomInfinity : x.map(Number); - return zoom; - }; - - zoom.x = function(z) { - if (!arguments.length) return x1; - x1 = z; - x0 = z.copy(); - translate = [0, 0]; - scale = 1; - return zoom; - }; - - zoom.y = function(z) { - if (!arguments.length) return y1; - y1 = z; - y0 = z.copy(); - translate = [0, 0]; - scale = 1; - return zoom; - }; - - function location(p) { - return [(p[0] - translate[0]) / scale, (p[1] - translate[1]) / scale]; - } - - function point(l) { - return [l[0] * scale + translate[0], l[1] * scale + translate[1]]; - } - - function scaleTo(s) { - scale = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s)); - } - - function translateTo(p, l) { - l = point(l); - translate[0] += p[0] - l[0]; - translate[1] += p[1] - l[1]; - } - - function rescale() { - if (x1) x1.domain(x0.range().map(function(x) { return (x - translate[0]) / scale; }).map(x0.invert)); - if (y1) y1.domain(y0.range().map(function(y) { return (y - translate[1]) / scale; }).map(y0.invert)); - } - - function dispatch(event) { - rescale(); - d3.event.preventDefault(); - event({type: "zoom", scale: scale, translate: translate}); - } - - function mousedown() { - var target = this, - event_ = event.of(target, arguments), - eventTarget = d3.event.target, - moved = 0, - w = d3.select(d3_window).on("mousemove.zoom", mousemove).on("mouseup.zoom", mouseup), - l = location(d3.mouse(target)); - - d3_window.focus(); - d3_eventCancel(); + }); - function mousemove() { - moved = 1; - translateTo(d3.mouse(target), l); - dispatch(event_); + // node_modules/circle-to-polygon/input-validation/validateBearing.js + var require_validateBearing = __commonJS({ + "node_modules/circle-to-polygon/input-validation/validateBearing.js"(exports2) { + exports2.validateBearing = function validateBearing(bearing) { + if (typeof bearing !== "number") { + const ARGUMENT_TYPE = Array.isArray(bearing) ? "array" : typeof bearing; + throw new Error(`ERROR! Bearing has to be a number but was: ${ARGUMENT_TYPE}`); + } + }; } + }); - function mouseup() { - if (moved) d3_eventCancel(); - w.on("mousemove.zoom", null).on("mouseup.zoom", null); - if (moved && d3.event.target === eventTarget) { - w.on("click.zoom", click, true); - window.setTimeout(function() { - // Remove click block if click didn't fire - w.on("click.zoom", null); - }, 0); + // node_modules/circle-to-polygon/input-validation/index.js + var require_input_validation = __commonJS({ + "node_modules/circle-to-polygon/input-validation/index.js"(exports2) { + var validateCenter = require_validateCenter().validateCenter; + var validateRadius = require_validateRadius().validateRadius; + var validateNumberOfEdges = require_validateNumberOfEdges().validateNumberOfEdges; + var validateEarthRadius = require_validateEarthRadius().validateEarthRadius; + var validateBearing = require_validateBearing().validateBearing; + function validateInput({ center, radius, numberOfEdges, earthRadius: earthRadius2, bearing }) { + validateCenter(center); + validateRadius(radius); + validateNumberOfEdges(numberOfEdges); + validateEarthRadius(earthRadius2); + validateBearing(bearing); } + exports2.validateCenter = validateCenter; + exports2.validateRadius = validateRadius; + exports2.validateNumberOfEdges = validateNumberOfEdges; + exports2.validateEarthRadius = validateEarthRadius; + exports2.validateBearing = validateBearing; + exports2.validateInput = validateInput; } + }); - function click() { - d3_eventCancel(); - w.on("click.zoom", null); - } - } - - function mousewheel() { - if (!translate0) translate0 = location(d3.mouse(this)); - scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * scale); - translateTo(d3.mouse(this), translate0); - dispatch(event.of(this, arguments)); - } - - function mousemove() { - translate0 = null; - } - - function dblclick() { - var p = d3.mouse(this), l = location(p), k = Math.log(scale) / Math.LN2; - scaleTo(Math.pow(2, d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1)); - translateTo(p, l); - dispatch(event.of(this, arguments)); - } - - function touchstart() { - var touches = d3.touches(this), - now = Date.now(); - - scale0 = scale; - translate0 = {}; - touches.forEach(function(t) { translate0[t.identifier] = location(t); }); - d3_eventCancel(); - - if (touches.length === 1) { - if (now - touchtime < 500) { // dbltap - var p = touches[0], l = location(touches[0]); - scaleTo(scale * 2); - translateTo(p, l); - dispatch(event.of(this, arguments)); + // node_modules/circle-to-polygon/index.js + var require_circle_to_polygon = __commonJS({ + "node_modules/circle-to-polygon/index.js"(exports2, module2) { + "use strict"; + var { validateInput } = require_input_validation(); + var defaultEarthRadius = 6378137; + function toRadians(angleInDegrees) { + return angleInDegrees * Math.PI / 180; } - touchtime = now; - } - } - - function touchmove() { - var touches = d3.touches(this), - p0 = touches[0], - l0 = translate0[p0.identifier]; - if (p1 = touches[1]) { - var p1, l1 = translate0[p1.identifier]; - p0 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2]; - l0 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2]; - scaleTo(d3.event.scale * scale0); - } - translateTo(p0, l0); - touchtime = null; - dispatch(event.of(this, arguments)); - } - - return d3.rebind(zoom, event, "on"); -}; - -var d3_behavior_zoomInfinity = [0, Infinity]; // default scale extent - -// https://developer.mozilla.org/en-US/docs/Mozilla_event_reference/wheel -var d3_behavior_zoomDelta, d3_behavior_zoomWheel - = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() { return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1); }, "wheel") - : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() { return d3.event.wheelDelta; }, "mousewheel") - : (d3_behavior_zoomDelta = function() { return -d3.event.detail; }, "MozMousePixelScroll"); -function d3_functor(v) { - return typeof v === "function" ? v : function() { return v; }; -} - -d3.functor = d3_functor; - -var d3_timer_id = 0, - d3_timer_byId = {}, - d3_timer_queue = null, - d3_timer_interval, // is an interval (or frame) active? - d3_timer_timeout; // is a timeout active? - -// The timer will continue to fire until callback returns true. -d3.timer = function(callback, delay, then) { - if (arguments.length < 3) { - if (arguments.length < 2) delay = 0; - else if (!isFinite(delay)) return; - then = Date.now(); - } - - // If the callback's already in the queue, update it. - var timer = d3_timer_byId[callback.id]; - if (timer && timer.callback === callback) { - timer.then = then; - timer.delay = delay; - } - - // Otherwise, add the callback to the queue. - else d3_timer_byId[callback.id = ++d3_timer_id] = d3_timer_queue = { - callback: callback, - then: then, - delay: delay, - next: d3_timer_queue - }; - - // Start animatin'! - if (!d3_timer_interval) { - d3_timer_timeout = clearTimeout(d3_timer_timeout); - d3_timer_interval = 1; - d3_timer_frame(d3_timer_step); - } -}; - -function d3_timer_step() { - var elapsed, - now = Date.now(), - t1 = d3_timer_queue; - - while (t1) { - elapsed = now - t1.then; - if (elapsed >= t1.delay) t1.flush = t1.callback(elapsed); - t1 = t1.next; - } - - var delay = d3_timer_flush() - now; - if (delay > 24) { - if (isFinite(delay)) { - clearTimeout(d3_timer_timeout); - d3_timer_timeout = setTimeout(d3_timer_step, delay); - } - d3_timer_interval = 0; - } else { - d3_timer_interval = 1; - d3_timer_frame(d3_timer_step); - } -} - -d3.timer.flush = function() { - var elapsed, - now = Date.now(), - t1 = d3_timer_queue; - - while (t1) { - elapsed = now - t1.then; - if (!t1.delay) t1.flush = t1.callback(elapsed); - t1 = t1.next; - } - - d3_timer_flush(); -}; - -// Flush after callbacks to avoid concurrent queue modification. -function d3_timer_flush() { - var t0 = null, - t1 = d3_timer_queue, - then = Infinity; - while (t1) { - if (t1.flush) { - delete d3_timer_byId[t1.callback.id]; - t1 = t0 ? t0.next = t1.next : d3_timer_queue = t1.next; - } else { - then = Math.min(then, t1.then + t1.delay); - t1 = (t0 = t1).next; - } - } - return then; -} - -var d3_timer_frame = d3_window.requestAnimationFrame - || d3_window.webkitRequestAnimationFrame - || d3_window.mozRequestAnimationFrame - || d3_window.oRequestAnimationFrame - || d3_window.msRequestAnimationFrame - || function(callback) { setTimeout(callback, 17); }; -var π = Math.PI, - ε = 1e-6, - d3_radians = π / 180, - d3_degrees = 180 / π; - -function d3_sgn(x) { - return x > 0 ? 1 : x < 0 ? -1 : 0; -} - -function d3_acos(x) { - return Math.acos(Math.max(-1, Math.min(1, x))); -} - -function d3_asin(x) { - return x > 1 ? π / 2 : x < -1 ? -π / 2 : Math.asin(x); -} - -function d3_sinh(x) { - return (Math.exp(x) - Math.exp(-x)) / 2; -} - -function d3_cosh(x) { - return (Math.exp(x) + Math.exp(-x)) / 2; -} - -function d3_haversin(x) { - return (x = Math.sin(x / 2)) * x; -} -d3.geo = {}; -function d3_identity(d) { - return d; -} -function d3_true() { - return true; -} - -function d3_geo_spherical(cartesian) { - return [ - Math.atan2(cartesian[1], cartesian[0]), - Math.asin(Math.max(-1, Math.min(1, cartesian[2]))) - ]; -} - -function d3_geo_sphericalEqual(a, b) { - return Math.abs(a[0] - b[0]) < ε && Math.abs(a[1] - b[1]) < ε; -} - -// General spherical polygon clipping algorithm: takes a polygon, cuts it into -// visible line segments and rejoins the segments by interpolating along the -// clip edge. -function d3_geo_clipPolygon(segments, compare, inside, interpolate, listener) { - var subject = [], - clip = []; - - segments.forEach(function(segment) { - if ((n = segment.length - 1) <= 0) return; - var n, p0 = segment[0], p1 = segment[n]; - - // 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 (d3_geo_sphericalEqual(p0, p1)) { - listener.lineStart(); - for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]); - listener.lineEnd(); - return; - } - - var a = {point: p0, points: segment, other: null, visited: false, entry: true, subject: true}, - b = {point: p0, points: [p0], other: a, visited: false, entry: false, subject: false}; - a.other = b; - subject.push(a); - clip.push(b); - a = {point: p1, points: [p1], other: null, visited: false, entry: false, subject: true}; - b = {point: p1, points: [p1], other: a, visited: false, entry: true, subject: false}; - a.other = b; - subject.push(a); - clip.push(b); - }); - clip.sort(compare); - d3_geo_clipPolygonLinkCircular(subject); - d3_geo_clipPolygonLinkCircular(clip); - if (!subject.length) return; - - if (inside) for (var i = 1, e = !inside(clip[0].point), n = clip.length; i < n; ++i) { - clip[i].entry = (e = !e); - } - - var start = subject[0], - current, - points, - point; - while (1) { - // Find first unvisited intersection. - current = start; - while (current.visited) if ((current = current.next) === start) return; - points = current.points; - listener.lineStart(); - do { - current.visited = current.other.visited = true; - if (current.entry) { - if (current.subject) { - for (var i = 0; i < points.length; i++) listener.point((point = points[i])[0], point[1]); - } else { - interpolate(current.point, current.next.point, 1, listener); + function toDegrees(angleInRadians) { + return angleInRadians * 180 / Math.PI; + } + function offset(c1, distance, earthRadius2, bearing) { + var lat1 = toRadians(c1[1]); + var lon1 = toRadians(c1[0]); + var dByR = distance / earthRadius2; + var lat = Math.asin( + Math.sin(lat1) * Math.cos(dByR) + Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing) + ); + var lon = lon1 + Math.atan2( + Math.sin(bearing) * Math.sin(dByR) * Math.cos(lat1), + Math.cos(dByR) - Math.sin(lat1) * Math.sin(lat) + ); + return [toDegrees(lon), toDegrees(lat)]; + } + module2.exports = function circleToPolygon2(center, radius, options2) { + var n2 = getNumberOfEdges(options2); + var earthRadius2 = getEarthRadius(options2); + var bearing = getBearing(options2); + var direction = getDirection(options2); + validateInput({ center, radius, numberOfEdges: n2, earthRadius: earthRadius2, bearing }); + var start2 = toRadians(bearing); + var coordinates = []; + for (var i2 = 0; i2 < n2; ++i2) { + coordinates.push( + offset( + center, + radius, + earthRadius2, + start2 + direction * 2 * Math.PI * -i2 / n2 + ) + ); } - current = current.next; - } else { - if (current.subject) { - points = current.prev.points; - for (var i = points.length; --i >= 0;) listener.point((point = points[i])[0], point[1]); - } else { - interpolate(current.point, current.prev.point, -1, listener); - } - current = current.prev; - } - current = current.other; - points = current.points; - } while (!current.visited); - listener.lineEnd(); - } -} - -function d3_geo_clipPolygonLinkCircular(array) { - if (!(n = array.length)) return; - var n, - i = 0, - a = array[0], - b; - while (++i < n) { - a.next = b = array[i]; - b.prev = a; - a = b; - } - a.next = b = array[0]; - b.prev = a; -} - -function d3_geo_clip(pointVisible, clipLine, interpolate) { - return function(listener) { - var line = clipLine(listener); - - var clip = { - point: point, - lineStart: lineStart, - lineEnd: lineEnd, - polygonStart: function() { - clip.point = pointRing; - clip.lineStart = ringStart; - clip.lineEnd = ringEnd; - invisible = false; - invisibleArea = visibleArea = 0; - segments = []; - listener.polygonStart(); - }, - polygonEnd: function() { - clip.point = point; - clip.lineStart = lineStart; - clip.lineEnd = lineEnd; - - segments = d3.merge(segments); - if (segments.length) { - d3_geo_clipPolygon(segments, d3_geo_clipSort, null, interpolate, listener); - } else if (visibleArea < -ε || invisible && invisibleArea < -ε) { - listener.lineStart(); - interpolate(null, null, 1, listener); - listener.lineEnd(); - } - listener.polygonEnd(); - segments = null; - }, - sphere: function() { - listener.polygonStart(); - listener.lineStart(); - interpolate(null, null, 1, listener); - listener.lineEnd(); - listener.polygonEnd(); + coordinates.push(coordinates[0]); + return { + type: "Polygon", + coordinates: [coordinates] + }; + }; + function getNumberOfEdges(options2) { + if (isUndefinedOrNull(options2)) { + return 32; + } else if (isObjectNotArray(options2)) { + var numberOfEdges = options2.numberOfEdges; + return numberOfEdges === void 0 ? 32 : numberOfEdges; + } + return options2; } - }; - - function point(λ, φ) { if (pointVisible(λ, φ)) listener.point(λ, φ); } - function pointLine(λ, φ) { line.point(λ, φ); } - function lineStart() { clip.point = pointLine; line.lineStart(); } - function lineEnd() { clip.point = point; line.lineEnd(); } - - var segments, - visibleArea, - invisibleArea, - invisible; - - var buffer = d3_geo_clipBufferListener(), - ringListener = clipLine(buffer), - ring; - - function pointRing(λ, φ) { - ringListener.point(λ, φ); - ring.push([λ, φ]); - } - - function ringStart() { - ringListener.lineStart(); - ring = []; - } - - function ringEnd() { - pointRing(ring[0][0], ring[0][1]); - ringListener.lineEnd(); - - var clean = ringListener.clean(), - ringSegments = buffer.buffer(), - segment, - n = ringSegments.length; - - // TODO compute on-the-fly? - if (!n) { - invisible = true; - invisibleArea += d3_geo_clipAreaRing(ring, -1); - ring = null; - return; + function getEarthRadius(options2) { + if (isUndefinedOrNull(options2)) { + return defaultEarthRadius; + } else if (isObjectNotArray(options2)) { + var earthRadius2 = options2.earthRadius; + return earthRadius2 === void 0 ? defaultEarthRadius : earthRadius2; + } + return defaultEarthRadius; } - ring = null; - - // No intersections. - // TODO compute on-the-fly? - if (clean & 1) { - segment = ringSegments[0]; - visibleArea += d3_geo_clipAreaRing(segment, 1); - var n = segment.length - 1, - i = -1, - point; - listener.lineStart(); - while (++i < n) listener.point((point = segment[i])[0], point[1]); - listener.lineEnd(); - return; + function getDirection(options2) { + if (isObjectNotArray(options2) && options2.rightHandRule) { + return -1; + } + return 1; } - - // Rejoin connected segments. - // TODO reuse bufferListener.rejoin()? - if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift())); - - segments.push(ringSegments.filter(d3_geo_clipSegmentLength1)); - } - - return clip; - }; -} - -function d3_geo_clipSegmentLength1(segment) { - return segment.length > 1; -} - -function d3_geo_clipBufferListener() { - var lines = [], - line; - return { - lineStart: function() { lines.push(line = []); }, - point: function(λ, φ) { line.push([λ, φ]); }, - lineEnd: d3_noop, - buffer: function() { - var buffer = lines; - lines = []; - line = null; - return buffer; - }, - rejoin: function() { - if (lines.length > 1) lines.push(lines.pop().concat(lines.shift())); - } - }; -} - -// Approximate polygon ring area (×2, since we only need the sign). -// For an invisible polygon ring, we rotate longitudinally by 180°. -// The invisible parameter should be 1, or -1 to rotate longitudinally. -// Based on Robert. G. Chamberlain and William H. Duquette, -// “Some Algorithms for Polygons on a Sphere”, -// http://trs-new.jpl.nasa.gov/dspace/handle/2014/40409 -function d3_geo_clipAreaRing(ring, invisible) { - if (!(n = ring.length)) return 0; - var n, - i = 0, - area = 0, - p = ring[0], - λ = p[0], - φ = p[1], - cosφ = Math.cos(φ), - x0 = Math.atan2(invisible * Math.sin(λ) * cosφ, Math.sin(φ)), - y0 = 1 - invisible * Math.cos(λ) * cosφ, - x1 = x0, - x, // λ'; λ rotated to south pole. - y; // φ' = 1 + sin(φ); φ rotated to south pole. - while (++i < n) { - p = ring[i]; - cosφ = Math.cos(φ = p[1]); - x = Math.atan2(invisible * Math.sin(λ = p[0]) * cosφ, Math.sin(φ)); - y = 1 - invisible * Math.cos(λ) * cosφ; - - // If both the current point and the previous point are at the north pole, - // skip this point. - if (Math.abs(y0 - 2) < ε && Math.abs(y - 2) < ε) continue; - - // If this or the previous point is at the south pole, or if this segment - // goes through the south pole, the area is 0. - if (Math.abs(y) < ε || Math.abs(y0) < ε) {} - - // If this segment goes through either pole… - else if (Math.abs(Math.abs(x - x0) - π) < ε) { - // For the north pole, compute lune area. - if (y + y0 > 2) area += 4 * (x - x0); - // For the south pole, the area is zero. - } - - // If the previous point is at the north pole, then compute lune area. - else if (Math.abs(y0 - 2) < ε) area += 4 * (x - x1); - - // Otherwise, the spherical triangle area is approximately - // δλ * (1 + sinφ0 + 1 + sinφ) / 2. - else area += ((3 * π + x - x0) % (2 * π) - π) * (y0 + y); - - x1 = x0, x0 = x, y0 = y; - } - return area; -} - -// Intersection points are sorted along the clip edge. For both antimeridian -// cutting and circle clipping, the same comparison is used. -function d3_geo_clipSort(a, b) { - return ((a = a.point)[0] < 0 ? a[1] - π / 2 - ε : π / 2 - a[1]) - - ((b = b.point)[0] < 0 ? b[1] - π / 2 - ε : π / 2 - b[1]); -} - -var d3_geo_clipAntimeridian = d3_geo_clip(d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate); - -// 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 d3_geo_clipAntimeridianLine(listener) { - var λ0 = NaN, - φ0 = NaN, - sλ0 = NaN, - clean; // no intersections - - return { - lineStart: function() { - listener.lineStart(); - clean = 1; - }, - point: function(λ1, φ1) { - var sλ1 = λ1 > 0 ? π : -π, - dλ = Math.abs(λ1 - λ0); - if (Math.abs(dλ - π) < ε) { // line crosses a pole - listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? π / 2 : -π / 2); - listener.point(sλ0, φ0); - listener.lineEnd(); - listener.lineStart(); - listener.point(sλ1, φ0); - listener.point( λ1, φ0); - clean = 0; - } else if (sλ0 !== sλ1 && dλ >= π) { // line crosses antimeridian - // handle degeneracies - if (Math.abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε; - if (Math.abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε; - φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1); - listener.point(sλ0, φ0); - listener.lineEnd(); - listener.lineStart(); - listener.point(sλ1, φ0); - clean = 0; - } - listener.point(λ0 = λ1, φ0 = φ1); - sλ0 = sλ1; - }, - lineEnd: function() { - listener.lineEnd(); - λ0 = φ0 = NaN; - }, - // if there are intersections, we always rejoin the first and last segments. - clean: function() { return 2 - clean; } - }; -} - -function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) { - var cosφ0, - cosφ1, - sinλ0_λ1 = Math.sin(λ0 - λ1); - return Math.abs(sinλ0_λ1) > ε - ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) - / (cosφ0 * cosφ1 * sinλ0_λ1)) - : (φ0 + φ1) / 2; -} - -function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) { - var φ; - if (from == null) { - φ = direction * π / 2; - listener.point(-π, φ); - listener.point( 0, φ); - listener.point( π, φ); - listener.point( π, 0); - listener.point( π, -φ); - listener.point( 0, -φ); - listener.point(-π, -φ); - listener.point(-π, 0); - listener.point(-π, φ); - } else if (Math.abs(from[0] - to[0]) > ε) { - var s = (from[0] < to[0] ? 1 : -1) * π; - φ = direction * s / 2; - listener.point(-s, φ); - listener.point( 0, φ); - listener.point( s, φ); - } else { - listener.point(to[0], to[1]); - } -} -// TODO -// cross and scale return new vectors, -// whereas add and normalize operate in-place - -function d3_geo_cartesian(spherical) { - var λ = spherical[0], - φ = spherical[1], - cosφ = Math.cos(φ); - return [ - cosφ * Math.cos(λ), - cosφ * Math.sin(λ), - Math.sin(φ) - ]; -} - -function d3_geo_cartesianDot(a, b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; -} - -function d3_geo_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] - ]; -} - -function d3_geo_cartesianAdd(a, b) { - a[0] += b[0]; - a[1] += b[1]; - a[2] += b[2]; -} - -function d3_geo_cartesianScale(vector, k) { - return [ - vector[0] * k, - vector[1] * k, - vector[2] * k - ]; -} - -function d3_geo_cartesianNormalize(d) { - var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]); - d[0] /= l; - d[1] /= l; - d[2] /= l; -} - -function d3_geo_equirectangular(λ, φ) { - return [λ, φ]; -} - -(d3.geo.equirectangular = function() { - return d3_geo_projection(d3_geo_equirectangular); -}).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular; - -d3.geo.rotation = function(rotate) { - rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0); - - function forward(coordinates) { - coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians); - return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates; - } - - forward.invert = function(coordinates) { - coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians); - return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates; - }; - - return forward; -}; - -// Note: |δλ| must be < 2π -function d3_geo_rotation(δλ, δφ, δγ) { - return δλ ? (δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ)) - : d3_geo_rotationλ(δλ)) - : (δφ || δγ ? d3_geo_rotationφγ(δφ, δγ) - : d3_geo_equirectangular); -} - -function d3_geo_forwardRotationλ(δλ) { - return function(λ, φ) { - return λ += δλ, [λ > π ? λ - 2 * π : λ < -π ? λ + 2 * π : λ, φ]; - }; -} - -function d3_geo_rotationλ(δλ) { - var rotation = d3_geo_forwardRotationλ(δλ); - rotation.invert = d3_geo_forwardRotationλ(-δλ); - return rotation; -} - -function d3_geo_rotationφγ(δφ, δγ) { - var cosδφ = Math.cos(δφ), - sinδφ = Math.sin(δφ), - cosδγ = Math.cos(δγ), - sinδγ = Math.sin(δγ); - - function rotation(λ, φ) { - var cosφ = Math.cos(φ), - x = Math.cos(λ) * cosφ, - y = Math.sin(λ) * cosφ, - z = Math.sin(φ), - k = z * cosδφ + x * sinδφ; - return [ - Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ), - Math.asin(Math.max(-1, Math.min(1, k * cosδγ + y * sinδγ))) - ]; - } - - rotation.invert = function(λ, φ) { - var cosφ = Math.cos(φ), - x = Math.cos(λ) * cosφ, - y = Math.sin(λ) * cosφ, - z = Math.sin(φ), - k = z * cosδγ - y * sinδγ; - return [ - Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ), - Math.asin(Math.max(-1, Math.min(1, k * cosδφ - x * sinδφ))) - ]; - }; - - return rotation; -} - -d3.geo.circle = function() { - var origin = [0, 0], - angle, - precision = 6, - interpolate; - - function circle() { - var center = typeof origin === "function" ? origin.apply(this, arguments) : origin, - rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert, - ring = []; - - interpolate(null, null, 1, { - point: function(x, y) { - ring.push(x = rotate(x, y)); - x[0] *= d3_degrees, x[1] *= d3_degrees; + function getBearing(options2) { + if (isUndefinedOrNull(options2)) { + return 0; + } else if (isObjectNotArray(options2)) { + var bearing = options2.bearing; + return bearing === void 0 ? 0 : bearing; + } + return 0; + } + function isObjectNotArray(argument) { + return argument !== null && typeof argument === "object" && !Array.isArray(argument); + } + function isUndefinedOrNull(argument) { + return argument === null || argument === void 0; } - }); - - return {type: "Polygon", coordinates: [ring]}; - } - - circle.origin = function(x) { - if (!arguments.length) return origin; - origin = x; - return circle; - }; - - circle.angle = function(x) { - if (!arguments.length) return angle; - interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians); - return circle; - }; - - circle.precision = function(_) { - if (!arguments.length) return precision; - interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians); - return circle; - }; - - return circle.angle(90); -}; - -// Interpolates along a circle centered at [0°, 0°], with a given radius and -// precision. -function d3_geo_circleInterpolate(radius, precision) { - var cr = Math.cos(radius), - sr = Math.sin(radius); - return function(from, to, direction, listener) { - if (from != null) { - from = d3_geo_circleAngle(cr, from); - to = d3_geo_circleAngle(cr, to); - if (direction > 0 ? from < to: from > to) from += direction * 2 * π; - } else { - from = radius + direction * 2 * π; - to = radius; - } - var point; - for (var step = direction * precision, t = from; direction > 0 ? t > to : t < to; t -= step) { - listener.point((point = d3_geo_spherical([ - cr, - -sr * Math.cos(t), - -sr * Math.sin(t) - ]))[0], point[1]); } - }; -} - -// Signed angle of a cartesian point relative to [cr, 0, 0]. -function d3_geo_circleAngle(cr, point) { - var a = d3_geo_cartesian(point); - a[0] -= cr; - d3_geo_cartesianNormalize(a); - var angle = d3_acos(-a[1]); - return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI); -} - -// Clip features against a small circle centered at [0°, 0°]. -function d3_geo_clipCircle(radius) { - var cr = Math.cos(radius), - smallRadius = cr > 0, - notHemisphere = Math.abs(cr) > ε, // TODO optimise for this common case - interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians); - - return d3_geo_clip(visible, clipLine, interpolate); - - function visible(λ, φ) { - return Math.cos(λ) * Math.cos(φ) > 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(listener) { - 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() { - v00 = v0 = false; - clean = 1; - }, - point: function(λ, φ) { - var point1 = [λ, φ], - point2, - v = visible(λ, φ), - c = smallRadius - ? v ? 0 : code(λ, φ) - : v ? code(λ + (λ < 0 ? π : -π), φ) : 0; - if (!point0 && (v00 = v0 = v)) listener.lineStart(); - // Handle degeneracies. - // TODO ignore if not clipping polygons. - if (v !== v0) { - point2 = intersect(point0, point1); - if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) { - point1[0] += ε; - point1[1] += ε; - v = visible(point1[0], point1[1]); - } - } - if (v !== v0) { - clean = 0; + }); + + // node_modules/polygon-clipping/dist/polygon-clipping.umd.js + var require_polygon_clipping_umd = __commonJS({ + "node_modules/polygon-clipping/dist/polygon-clipping.umd.js"(exports2, module2) { + (function(global3, factory) { + typeof exports2 === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global3 = typeof globalThis !== "undefined" ? globalThis : global3 || self, global3.polygonClipping = factory()); + })(exports2, function() { + "use strict"; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i2 = 0; i2 < props.length; i2++) { + var descriptor = props[i2]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) + descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) + _defineProperties(Constructor.prototype, protoProps); + if (staticProps) + _defineProperties(Constructor, staticProps); + return Constructor; + } + var Node = ( + /** @class */ + function() { + function Node2(key, data) { + this.next = null; + this.key = key; + this.data = data; + this.left = null; + this.right = null; + } + return Node2; + }() + ); + function DEFAULT_COMPARE(a, b) { + return a > b ? 1 : a < b ? -1 : 0; + } + function splay(i2, t, comparator) { + var N = new Node(null, null); + var l = N; + var r = N; + while (true) { + var cmp2 = comparator(i2, t.key); + if (cmp2 < 0) { + if (t.left === null) + break; + if (comparator(i2, t.left.key) < 0) { + var y = t.left; + t.left = y.right; + y.right = t; + t = y; + if (t.left === null) + break; + } + r.left = t; + r = t; + t = t.left; + } else if (cmp2 > 0) { + if (t.right === null) + break; + if (comparator(i2, t.right.key) > 0) { + var y = t.right; + t.right = y.left; + y.left = t; + t = y; + if (t.right === null) + break; + } + l.right = t; + l = t; + t = t.right; + } else + break; + } + l.right = t.left; + r.left = t.right; + t.left = N.right; + t.right = N.left; + return t; + } + function insert(i2, data, t, comparator) { + var node = new Node(i2, data); + if (t === null) { + node.left = node.right = null; + return node; + } + t = splay(i2, t, comparator); + var cmp2 = comparator(i2, t.key); + if (cmp2 < 0) { + node.left = t.left; + node.right = t; + t.left = null; + } else if (cmp2 >= 0) { + node.right = t.right; + node.left = t; + t.right = null; + } + return node; + } + function split(key, v, comparator) { + var left = null; + var right = null; if (v) { - // outside going in - listener.lineStart(); - point2 = intersect(point1, point0); - listener.point(point2[0], point2[1]); - } else { - // inside going out - point2 = intersect(point0, point1); - listener.point(point2[0], point2[1]); - listener.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) { - listener.lineStart(); - listener.point(t[0][0], t[0][1]); - listener.point(t[1][0], t[1][1]); - listener.lineEnd(); + v = splay(key, v, comparator); + var cmp2 = comparator(v.key, key); + if (cmp2 === 0) { + left = v.left; + right = v.right; + } else if (cmp2 < 0) { + right = v.right; + v.right = null; + left = v; } else { - listener.point(t[1][0], t[1][1]); - listener.lineEnd(); - listener.lineStart(); - listener.point(t[0][0], t[0][1]); + left = v.left; + v.left = null; + right = v; } } + return { + left, + right + }; } - if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) { - listener.point(point1[0], point1[1]); + function merge2(left, right, comparator) { + if (right === null) + return left; + if (left === null) + return right; + right = splay(left.key, right, comparator); + right.left = left; + return right; } - point0 = point1, v0 = v, c0 = c; - }, - lineEnd: function() { - if (v0) listener.lineEnd(); - point0 = null; - }, - // Rejoin first and last segments if there were intersections and the first - // and last points were visible. - clean: function() { return clean | ((v00 && v0) << 1); } - }; - } - - // Intersects the great circle between a and b with the clip circle. - function intersect(a, b, two) { - var pa = d3_geo_cartesian(a), - pb = d3_geo_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 = d3_geo_cartesianCross(pa, pb), - n2n2 = d3_geo_cartesianDot(n2, n2), - n1n2 = n2[0], // d3_geo_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 = d3_geo_cartesianCross(n1, n2), - A = d3_geo_cartesianScale(n1, c1), - B = d3_geo_cartesianScale(n2, c2); - d3_geo_cartesianAdd(A, B); - - // Solve |p(t)|^2 = 1. - var u = n1xn2, - w = d3_geo_cartesianDot(A, u), - uu = d3_geo_cartesianDot(u, u), - t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1); - - if (t2 < 0) return; - - var t = Math.sqrt(t2), - q = d3_geo_cartesianScale(u, (-w - t) / uu); - d3_geo_cartesianAdd(q, A); - q = d3_geo_spherical(q); - if (!two) return q; - - // Two intersection points. - var λ0 = a[0], - λ1 = b[0], - φ0 = a[1], - φ1 = b[1], - z; - if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z; - var δλ = λ1 - λ0, - polar = Math.abs(δλ - π) < ε, - meridian = polar || δλ < ε; - - if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z; - - // Check that the first point is between a and b. - if (meridian - ? polar - ? φ0 + φ1 > 0 ^ q[1] < (Math.abs(q[0] - λ0) < ε ? φ0 : φ1) - : φ0 <= q[1] && q[1] <= φ1 - : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) { - var q1 = d3_geo_cartesianScale(u, (-w + t) / uu); - d3_geo_cartesianAdd(q1, A); - return [q, d3_geo_spherical(q1)]; - } - } - - // Generates a 4-bit vector representing the location of a point relative to - // the small circle's bounding box. - function code(λ, φ) { - var r = smallRadius ? radius : π - radius, - code = 0; - if (λ < -r) code |= 1; // left - else if (λ > r) code |= 2; // right - if (φ < -r) code |= 4; // below - else if (φ > r) code |= 8; // above - return code; - } -} - -var d3_geo_clipViewMAX = 1e9; - -function d3_geo_clipView(x0, y0, x1, y1) { - return function(listener) { - var listener_ = listener, - bufferListener = d3_geo_clipBufferListener(), - segments, - polygon, - ring; - - var clip = { - point: point, - lineStart: lineStart, - lineEnd: lineEnd, - polygonStart: function() { - listener = bufferListener; - segments = []; - polygon = []; - }, - polygonEnd: function() { - listener = listener_; - if ((segments = d3.merge(segments)).length) { - listener.polygonStart(); - d3_geo_clipPolygon(segments, compare, inside, interpolate, listener); - listener.polygonEnd(); - } else if (insidePolygon([x0, y0])) { - listener.polygonStart(), listener.lineStart(); - interpolate(null, null, 1, listener); - listener.lineEnd(), listener.polygonEnd(); + function printRow(root3, prefix, isTail, out, printNode) { + if (root3) { + out("" + prefix + (isTail ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ") + printNode(root3) + "\n"); + var indent2 = prefix + (isTail ? " " : "\u2502 "); + if (root3.left) + printRow(root3.left, indent2, false, out, printNode); + if (root3.right) + printRow(root3.right, indent2, true, out, printNode); + } } - segments = polygon = ring = null; - } - }; - - function inside(point) { - var a = corner(point, -1), - i = insidePolygon([a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0]); - return i; - } - - function insidePolygon(p) { - var wn = 0, // the winding number counter - n = polygon.length, - y = p[1]; - - for (var i = 0; i < n; ++i) { - for (var j = 1, v = polygon[i], m = v.length, a = v[0]; j < m; ++j) { - b = v[j]; - if (a[1] <= y) { - if (b[1] > y && isLeft(a, b, p) > 0) ++wn; - } else { - if (b[1] <= y && isLeft(a, b, p) < 0) --wn; + var Tree = ( + /** @class */ + function() { + function Tree2(comparator) { + if (comparator === void 0) { + comparator = DEFAULT_COMPARE; + } + this._root = null; + this._size = 0; + this._comparator = comparator; + } + Tree2.prototype.insert = function(key, data) { + this._size++; + return this._root = insert(key, data, this._root, this._comparator); + }; + Tree2.prototype.add = function(key, data) { + var node = new Node(key, data); + if (this._root === null) { + node.left = node.right = null; + this._size++; + this._root = node; + } + var comparator = this._comparator; + var t = splay(key, this._root, comparator); + var cmp2 = comparator(key, t.key); + if (cmp2 === 0) + this._root = t; + else { + if (cmp2 < 0) { + node.left = t.left; + node.right = t; + t.left = null; + } else if (cmp2 > 0) { + node.right = t.right; + node.left = t; + t.right = null; + } + this._size++; + this._root = node; + } + return this._root; + }; + Tree2.prototype.remove = function(key) { + this._root = this._remove(key, this._root, this._comparator); + }; + Tree2.prototype._remove = function(i2, t, comparator) { + var x; + if (t === null) + return null; + t = splay(i2, t, comparator); + var cmp2 = comparator(i2, t.key); + if (cmp2 === 0) { + if (t.left === null) { + x = t.right; + } else { + x = splay(i2, t.left, comparator); + x.right = t.right; + } + this._size--; + return x; + } + return t; + }; + Tree2.prototype.pop = function() { + var node = this._root; + if (node) { + while (node.left) { + node = node.left; + } + this._root = splay(node.key, this._root, this._comparator); + this._root = this._remove(node.key, this._root, this._comparator); + return { + key: node.key, + data: node.data + }; + } + return null; + }; + Tree2.prototype.findStatic = function(key) { + var current = this._root; + var compare = this._comparator; + while (current) { + var cmp2 = compare(key, current.key); + if (cmp2 === 0) + return current; + else if (cmp2 < 0) + current = current.left; + else + current = current.right; + } + return null; + }; + Tree2.prototype.find = function(key) { + if (this._root) { + this._root = splay(key, this._root, this._comparator); + if (this._comparator(key, this._root.key) !== 0) + return null; + } + return this._root; + }; + Tree2.prototype.contains = function(key) { + var current = this._root; + var compare = this._comparator; + while (current) { + var cmp2 = compare(key, current.key); + if (cmp2 === 0) + return true; + else if (cmp2 < 0) + current = current.left; + else + current = current.right; + } + return false; + }; + Tree2.prototype.forEach = function(visitor, ctx) { + var current = this._root; + var Q = []; + var done = false; + while (!done) { + if (current !== null) { + Q.push(current); + current = current.left; + } else { + if (Q.length !== 0) { + current = Q.pop(); + visitor.call(ctx, current); + current = current.right; + } else + done = true; + } + } + return this; + }; + Tree2.prototype.range = function(low, high, fn, ctx) { + var Q = []; + var compare = this._comparator; + var node = this._root; + var cmp2; + while (Q.length !== 0 || node) { + if (node) { + Q.push(node); + node = node.left; + } else { + node = Q.pop(); + cmp2 = compare(node.key, high); + if (cmp2 > 0) { + break; + } else if (compare(node.key, low) >= 0) { + if (fn.call(ctx, node)) + return this; + } + node = node.right; + } + } + return this; + }; + Tree2.prototype.keys = function() { + var keys2 = []; + this.forEach(function(_a) { + var key = _a.key; + return keys2.push(key); + }); + return keys2; + }; + Tree2.prototype.values = function() { + var values = []; + this.forEach(function(_a) { + var data = _a.data; + return values.push(data); + }); + return values; + }; + Tree2.prototype.min = function() { + if (this._root) + return this.minNode(this._root).key; + return null; + }; + Tree2.prototype.max = function() { + if (this._root) + return this.maxNode(this._root).key; + return null; + }; + Tree2.prototype.minNode = function(t) { + if (t === void 0) { + t = this._root; + } + if (t) + while (t.left) { + t = t.left; + } + return t; + }; + Tree2.prototype.maxNode = function(t) { + if (t === void 0) { + t = this._root; + } + if (t) + while (t.right) { + t = t.right; + } + return t; + }; + Tree2.prototype.at = function(index2) { + var current = this._root; + var done = false; + var i2 = 0; + var Q = []; + while (!done) { + if (current) { + Q.push(current); + current = current.left; + } else { + if (Q.length > 0) { + current = Q.pop(); + if (i2 === index2) + return current; + i2++; + current = current.right; + } else + done = true; + } + } + return null; + }; + Tree2.prototype.next = function(d) { + var root3 = this._root; + var successor = null; + if (d.right) { + successor = d.right; + while (successor.left) { + successor = successor.left; + } + return successor; + } + var comparator = this._comparator; + while (root3) { + var cmp2 = comparator(d.key, root3.key); + if (cmp2 === 0) + break; + else if (cmp2 < 0) { + successor = root3; + root3 = root3.left; + } else + root3 = root3.right; + } + return successor; + }; + Tree2.prototype.prev = function(d) { + var root3 = this._root; + var predecessor = null; + if (d.left !== null) { + predecessor = d.left; + while (predecessor.right) { + predecessor = predecessor.right; + } + return predecessor; + } + var comparator = this._comparator; + while (root3) { + var cmp2 = comparator(d.key, root3.key); + if (cmp2 === 0) + break; + else if (cmp2 < 0) + root3 = root3.left; + else { + predecessor = root3; + root3 = root3.right; + } + } + return predecessor; + }; + Tree2.prototype.clear = function() { + this._root = null; + this._size = 0; + return this; + }; + Tree2.prototype.toList = function() { + return toList(this._root); + }; + Tree2.prototype.load = function(keys2, values, presort) { + if (values === void 0) { + values = []; + } + if (presort === void 0) { + presort = false; + } + var size = keys2.length; + var comparator = this._comparator; + if (presort) + sort(keys2, values, 0, size - 1, comparator); + if (this._root === null) { + this._root = loadRecursive(keys2, values, 0, size); + this._size = size; + } else { + var mergedList = mergeLists(this.toList(), createList(keys2, values), comparator); + size = this._size + size; + this._root = sortedListToBST({ + head: mergedList + }, 0, size); + } + return this; + }; + Tree2.prototype.isEmpty = function() { + return this._root === null; + }; + Object.defineProperty(Tree2.prototype, "size", { + get: function get4() { + return this._size; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Tree2.prototype, "root", { + get: function get4() { + return this._root; + }, + enumerable: true, + configurable: true + }); + Tree2.prototype.toString = function(printNode) { + if (printNode === void 0) { + printNode = function printNode2(n2) { + return String(n2.key); + }; + } + var out = []; + printRow(this._root, "", true, function(v) { + return out.push(v); + }, printNode); + return out.join(""); + }; + Tree2.prototype.update = function(key, newKey, newData) { + var comparator = this._comparator; + var _a = split(key, this._root, comparator), left = _a.left, right = _a.right; + if (comparator(key, newKey) < 0) { + right = insert(newKey, newData, right, comparator); + } else { + left = insert(newKey, newData, left, comparator); + } + this._root = merge2(left, right, comparator); + }; + Tree2.prototype.split = function(key) { + return split(key, this._root, this._comparator); + }; + return Tree2; + }() + ); + function loadRecursive(keys2, values, start2, end) { + var size = end - start2; + if (size > 0) { + var middle = start2 + Math.floor(size / 2); + var key = keys2[middle]; + var data = values[middle]; + var node = new Node(key, data); + node.left = loadRecursive(keys2, values, start2, middle); + node.right = loadRecursive(keys2, values, middle + 1, end); + return node; } - a = b; + return null; } - } - return wn !== 0; - } - - function isLeft(a, b, c) { - return (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]); - } - - function interpolate(from, to, direction, listener) { - var a = 0, a1 = 0; - if (from == null || - (a = corner(from, direction)) !== (a1 = corner(to, direction)) || - comparePoints(from, to) < 0 ^ direction > 0) { - do { - listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0); - } while ((a = (a + direction + 4) % 4) !== a1); - } else { - listener.point(to[0], to[1]); - } - } - - function visible(x, y) { - return x0 <= x && x <= x1 && y0 <= y && y <= y1; - } - - function point(x, y) { - if (visible(x, y)) listener.point(x, y); - } - - var x__, y__, v__, // first point - x_, y_, v_, // previous point - first; - - function lineStart() { - clip.point = linePoint; - if (polygon) polygon.push(ring = []); - first = true; - v_ = false; - x_ = y_ = NaN; - } - - function lineEnd() { - // TODO rather than special-case polygons, simply handle them separately. - // Ideally, coincident intersection points should be jittered to avoid - // clipping issues. - if (segments) { - linePoint(x__, y__); - if (v__ && v_) bufferListener.rejoin(); - segments.push(bufferListener.buffer()); - } - clip.point = point; - if (v_) listener.lineEnd(); - } - - function linePoint(x, y) { - x = Math.max(-d3_geo_clipViewMAX, Math.min(d3_geo_clipViewMAX, x)); - y = Math.max(-d3_geo_clipViewMAX, Math.min(d3_geo_clipViewMAX, y)); - var v = visible(x, y); - if (polygon) ring.push([x, y]); - if (first) { - x__ = x, y__ = y, v__ = v; - first = false; - if (v) { - listener.lineStart(); - listener.point(x, y); + function createList(keys2, values) { + var head = new Node(null, null); + var p = head; + for (var i2 = 0; i2 < keys2.length; i2++) { + p = p.next = new Node(keys2[i2], values[i2]); + } + p.next = null; + return head.next; } - } else { - if (v && v_) listener.point(x, y); - else { - var a = [x_, y_], - b = [x, y]; - if (clipLine(a, b)) { - if (!v_) { - listener.lineStart(); - listener.point(a[0], a[1]); - } - listener.point(b[0], b[1]); - if (!v) listener.lineEnd(); - } else { - listener.lineStart(); - listener.point(x, y); + function toList(root3) { + var current = root3; + var Q = []; + var done = false; + var head = new Node(null, null); + var p = head; + while (!done) { + if (current) { + Q.push(current); + current = current.left; + } else { + if (Q.length > 0) { + current = p = p.next = Q.pop(); + current = current.right; + } else + done = true; + } } + p.next = null; + return head.next; } - } - x_ = x, y_ = y, v_ = v; - } - - return clip; - }; - - function corner(p, direction) { - return Math.abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 - : Math.abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 - : Math.abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 - : direction > 0 ? 3 : 2; // Math.abs(p[1] - y1) < ε - } - - function compare(a, b) { - return comparePoints(a.point, b.point); - } - - function comparePoints(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]; - } - - // Liang–Barsky line clipping. - function clipLine(a, b) { - var dx = b[0] - a[0], - dy = b[1] - a[1], - t = [0, 1]; - - if (Math.abs(dx) < ε && Math.abs(dy) < ε) return x0 <= a[0] && a[0] <= x1 && y0 <= a[1] && a[1] <= y1; - - if (d3_geo_clipViewT(x0 - a[0], dx, t) && - d3_geo_clipViewT(a[0] - x1, -dx, t) && - d3_geo_clipViewT(y0 - a[1], dy, t) && - d3_geo_clipViewT(a[1] - y1, -dy, t)) { - if (t[1] < 1) { - b[0] = a[0] + t[1] * dx; - b[1] = a[1] + t[1] * dy; - } - if (t[0] > 0) { - a[0] += t[0] * dx; - a[1] += t[0] * dy; - } - return true; - } - - return false; - } -} - -function d3_geo_clipViewT(num, denominator, t) { - if (Math.abs(denominator) < ε) return num <= 0; - - var u = num / denominator; - - if (denominator > 0) { - if (u > t[1]) return false; - if (u > t[0]) t[0] = u; - } else { - if (u < t[0]) return false; - if (u < t[1]) t[1] = u; - } - return true; -} -function d3_geo_compose(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; -} - -d3.geo.stream = function(object, listener) { - if (d3_geo_streamObjectType.hasOwnProperty(object.type)) { - d3_geo_streamObjectType[object.type](object, listener); - } else { - d3_geo_streamGeometry(object, listener); - } -}; - -function d3_geo_streamGeometry(geometry, listener) { - if (d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) { - d3_geo_streamGeometryType[geometry.type](geometry, listener); - } -} - -var d3_geo_streamObjectType = { - Feature: function(feature, listener) { - d3_geo_streamGeometry(feature.geometry, listener); - }, - FeatureCollection: function(object, listener) { - var features = object.features, i = -1, n = features.length; - while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener); - } -}; - -var d3_geo_streamGeometryType = { - Sphere: function(object, listener) { - listener.sphere(); - }, - Point: function(object, listener) { - var coordinate = object.coordinates; - listener.point(coordinate[0], coordinate[1]); - }, - MultiPoint: function(object, listener) { - var coordinates = object.coordinates, i = -1, n = coordinates.length, coordinate; - while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1]); - }, - LineString: function(object, listener) { - d3_geo_streamLine(object.coordinates, listener, 0); - }, - MultiLineString: function(object, listener) { - var coordinates = object.coordinates, i = -1, n = coordinates.length; - while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0); - }, - Polygon: function(object, listener) { - d3_geo_streamPolygon(object.coordinates, listener); - }, - MultiPolygon: function(object, listener) { - var coordinates = object.coordinates, i = -1, n = coordinates.length; - while (++i < n) d3_geo_streamPolygon(coordinates[i], listener); - }, - GeometryCollection: function(object, listener) { - var geometries = object.geometries, i = -1, n = geometries.length; - while (++i < n) d3_geo_streamGeometry(geometries[i], listener); - } -}; - -function d3_geo_streamLine(coordinates, listener, closed) { - var i = -1, n = coordinates.length - closed, coordinate; - listener.lineStart(); - while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1]); - listener.lineEnd(); -} - -function d3_geo_streamPolygon(coordinates, listener) { - var i = -1, n = coordinates.length; - listener.polygonStart(); - while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1); - listener.polygonEnd(); -} - -function d3_geo_resample(project) { - var δ2 = .5, // precision, px² - maxDepth = 16; - - function resample(stream) { - var λ0, x0, y0, a0, b0, c0; // previous point - - var resample = { - point: point, - lineStart: lineStart, - lineEnd: lineEnd, - polygonStart: function() { stream.polygonStart(); resample.lineStart = polygonLineStart; }, - polygonEnd: function() { stream.polygonEnd(); resample.lineStart = lineStart; } - }; - - function point(x, y) { - x = project(x, y); - stream.point(x[0], x[1]); - } - - function lineStart() { - x0 = NaN; - resample.point = linePoint; - stream.lineStart(); - } - - function linePoint(λ, φ) { - var c = d3_geo_cartesian([λ, φ]), p = project(λ, φ); - resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream); - stream.point(x0, y0); - } - - function lineEnd() { - resample.point = point; - stream.lineEnd(); + function sortedListToBST(list, start2, end) { + var size = end - start2; + if (size > 0) { + var middle = start2 + Math.floor(size / 2); + var left = sortedListToBST(list, start2, middle); + var root3 = list.head; + root3.left = left; + list.head = list.head.next; + root3.right = sortedListToBST(list, middle + 1, end); + return root3; + } + return null; + } + function mergeLists(l1, l2, compare) { + var head = new Node(null, null); + var p = head; + var p1 = l1; + var p2 = l2; + while (p1 !== null && p2 !== null) { + if (compare(p1.key, p2.key) < 0) { + p.next = p1; + p1 = p1.next; + } else { + p.next = p2; + p2 = p2.next; + } + p = p.next; + } + if (p1 !== null) { + p.next = p1; + } else if (p2 !== null) { + p.next = p2; + } + return head.next; + } + function sort(keys2, values, left, right, compare) { + if (left >= right) + return; + var pivot = keys2[left + right >> 1]; + var i2 = left - 1; + var j2 = right + 1; + while (true) { + do { + i2++; + } while (compare(keys2[i2], pivot) < 0); + do { + j2--; + } while (compare(keys2[j2], pivot) > 0); + if (i2 >= j2) + break; + var tmp = keys2[i2]; + keys2[i2] = keys2[j2]; + keys2[j2] = tmp; + tmp = values[i2]; + values[i2] = values[j2]; + values[j2] = tmp; + } + sort(keys2, values, left, j2, compare); + sort(keys2, values, j2 + 1, right, compare); + } + var isInBbox = function isInBbox2(bbox2, point2) { + return bbox2.ll.x <= point2.x && point2.x <= bbox2.ur.x && bbox2.ll.y <= point2.y && point2.y <= bbox2.ur.y; + }; + var getBboxOverlap = function getBboxOverlap2(b1, b2) { + if (b2.ur.x < b1.ll.x || b1.ur.x < b2.ll.x || b2.ur.y < b1.ll.y || b1.ur.y < b2.ll.y) + return null; + var lowerX = b1.ll.x < b2.ll.x ? b2.ll.x : b1.ll.x; + var upperX = b1.ur.x < b2.ur.x ? b1.ur.x : b2.ur.x; + var lowerY = b1.ll.y < b2.ll.y ? b2.ll.y : b1.ll.y; + var upperY = b1.ur.y < b2.ur.y ? b1.ur.y : b2.ur.y; + return { + ll: { + x: lowerX, + y: lowerY + }, + ur: { + x: upperX, + y: upperY + } + }; + }; + var epsilon3 = Number.EPSILON; + if (epsilon3 === void 0) + epsilon3 = Math.pow(2, -52); + var EPSILON_SQ = epsilon3 * epsilon3; + var cmp = function cmp2(a, b) { + if (-epsilon3 < a && a < epsilon3) { + if (-epsilon3 < b && b < epsilon3) { + return 0; + } + } + var ab = a - b; + if (ab * ab < EPSILON_SQ * a * b) { + return 0; + } + return a < b ? -1 : 1; + }; + var PtRounder = /* @__PURE__ */ function() { + function PtRounder2() { + _classCallCheck(this, PtRounder2); + this.reset(); + } + _createClass(PtRounder2, [{ + key: "reset", + value: function reset() { + this.xRounder = new CoordRounder(); + this.yRounder = new CoordRounder(); + } + }, { + key: "round", + value: function round(x, y) { + return { + x: this.xRounder.round(x), + y: this.yRounder.round(y) + }; + } + }]); + return PtRounder2; + }(); + var CoordRounder = /* @__PURE__ */ function() { + function CoordRounder2() { + _classCallCheck(this, CoordRounder2); + this.tree = new Tree(); + this.round(0); + } + _createClass(CoordRounder2, [{ + key: "round", + value: function round(coord2) { + var node = this.tree.add(coord2); + var prevNode = this.tree.prev(node); + if (prevNode !== null && cmp(node.key, prevNode.key) === 0) { + this.tree.remove(coord2); + return prevNode.key; + } + var nextNode = this.tree.next(node); + if (nextNode !== null && cmp(node.key, nextNode.key) === 0) { + this.tree.remove(coord2); + return nextNode.key; + } + return coord2; + } + }]); + return CoordRounder2; + }(); + var rounder = new PtRounder(); + var crossProduct = function crossProduct2(a, b) { + return a.x * b.y - a.y * b.x; + }; + var dotProduct = function dotProduct2(a, b) { + return a.x * b.x + a.y * b.y; + }; + var compareVectorAngles = function compareVectorAngles2(basePt, endPt1, endPt2) { + var v1 = { + x: endPt1.x - basePt.x, + y: endPt1.y - basePt.y + }; + var v2 = { + x: endPt2.x - basePt.x, + y: endPt2.y - basePt.y + }; + var kross = crossProduct(v1, v2); + return cmp(kross, 0); + }; + var length = function length2(v) { + return Math.sqrt(dotProduct(v, v)); + }; + var sineOfAngle = function sineOfAngle2(pShared, pBase, pAngle) { + var vBase = { + x: pBase.x - pShared.x, + y: pBase.y - pShared.y + }; + var vAngle = { + x: pAngle.x - pShared.x, + y: pAngle.y - pShared.y + }; + return crossProduct(vAngle, vBase) / length(vAngle) / length(vBase); + }; + var cosineOfAngle = function cosineOfAngle2(pShared, pBase, pAngle) { + var vBase = { + x: pBase.x - pShared.x, + y: pBase.y - pShared.y + }; + var vAngle = { + x: pAngle.x - pShared.x, + y: pAngle.y - pShared.y + }; + return dotProduct(vAngle, vBase) / length(vAngle) / length(vBase); + }; + var horizontalIntersection = function horizontalIntersection2(pt, v, y) { + if (v.y === 0) + return null; + return { + x: pt.x + v.x / v.y * (y - pt.y), + y + }; + }; + var verticalIntersection = function verticalIntersection2(pt, v, x) { + if (v.x === 0) + return null; + return { + x, + y: pt.y + v.y / v.x * (x - pt.x) + }; + }; + var intersection = function intersection2(pt1, v1, pt2, v2) { + if (v1.x === 0) + return verticalIntersection(pt2, v2, pt1.x); + if (v2.x === 0) + return verticalIntersection(pt1, v1, pt2.x); + if (v1.y === 0) + return horizontalIntersection(pt2, v2, pt1.y); + if (v2.y === 0) + return horizontalIntersection(pt1, v1, pt2.y); + var kross = crossProduct(v1, v2); + if (kross == 0) + return null; + var ve = { + x: pt2.x - pt1.x, + y: pt2.y - pt1.y + }; + var d1 = crossProduct(ve, v1) / kross; + var d2 = crossProduct(ve, v2) / kross; + var x12 = pt1.x + d2 * v1.x, x2 = pt2.x + d1 * v2.x; + var y12 = pt1.y + d2 * v1.y, y2 = pt2.y + d1 * v2.y; + var x = (x12 + x2) / 2; + var y = (y12 + y2) / 2; + return { + x, + y + }; + }; + var SweepEvent = /* @__PURE__ */ function() { + _createClass(SweepEvent2, null, [{ + key: "compare", + // for ordering sweep events in the sweep event queue + value: function compare(a, b) { + var ptCmp = SweepEvent2.comparePoints(a.point, b.point); + if (ptCmp !== 0) + return ptCmp; + if (a.point !== b.point) + a.link(b); + if (a.isLeft !== b.isLeft) + return a.isLeft ? 1 : -1; + return Segment.compare(a.segment, b.segment); + } + // for ordering points in sweep line order + }, { + key: "comparePoints", + value: function comparePoints(aPt, bPt) { + if (aPt.x < bPt.x) + return -1; + if (aPt.x > bPt.x) + return 1; + if (aPt.y < bPt.y) + return -1; + if (aPt.y > bPt.y) + return 1; + return 0; + } + // Warning: 'point' input will be modified and re-used (for performance) + }]); + function SweepEvent2(point2, isLeft) { + _classCallCheck(this, SweepEvent2); + if (point2.events === void 0) + point2.events = [this]; + else + point2.events.push(this); + this.point = point2; + this.isLeft = isLeft; + } + _createClass(SweepEvent2, [{ + key: "link", + value: function link2(other) { + if (other.point === this.point) { + throw new Error("Tried to link already linked events"); + } + var otherEvents = other.point.events; + for (var i2 = 0, iMax = otherEvents.length; i2 < iMax; i2++) { + var evt = otherEvents[i2]; + this.point.events.push(evt); + evt.point = this.point; + } + this.checkForConsuming(); + } + /* Do a pass over our linked events and check to see if any pair + * of segments match, and should be consumed. */ + }, { + key: "checkForConsuming", + value: function checkForConsuming() { + var numEvents = this.point.events.length; + for (var i2 = 0; i2 < numEvents; i2++) { + var evt1 = this.point.events[i2]; + if (evt1.segment.consumedBy !== void 0) + continue; + for (var j2 = i2 + 1; j2 < numEvents; j2++) { + var evt2 = this.point.events[j2]; + if (evt2.consumedBy !== void 0) + continue; + if (evt1.otherSE.point.events !== evt2.otherSE.point.events) + continue; + evt1.segment.consume(evt2.segment); + } + } + } + }, { + key: "getAvailableLinkedEvents", + value: function getAvailableLinkedEvents() { + var events = []; + for (var i2 = 0, iMax = this.point.events.length; i2 < iMax; i2++) { + var evt = this.point.events[i2]; + if (evt !== this && !evt.segment.ringOut && evt.segment.isInResult()) { + events.push(evt); + } + } + return events; + } + /** + * Returns a comparator function for sorting linked events that will + * favor the event that will give us the smallest left-side angle. + * All ring construction starts as low as possible heading to the right, + * so by always turning left as sharp as possible we'll get polygons + * without uncessary loops & holes. + * + * The comparator function has a compute cache such that it avoids + * re-computing already-computed values. + */ + }, { + key: "getLeftmostComparator", + value: function getLeftmostComparator(baseEvent) { + var _this = this; + var cache = /* @__PURE__ */ new Map(); + var fillCache = function fillCache2(linkedEvent) { + var nextEvent = linkedEvent.otherSE; + cache.set(linkedEvent, { + sine: sineOfAngle(_this.point, baseEvent.point, nextEvent.point), + cosine: cosineOfAngle(_this.point, baseEvent.point, nextEvent.point) + }); + }; + return function(a, b) { + if (!cache.has(a)) + fillCache(a); + if (!cache.has(b)) + fillCache(b); + var _cache$get = cache.get(a), asine = _cache$get.sine, acosine = _cache$get.cosine; + var _cache$get2 = cache.get(b), bsine = _cache$get2.sine, bcosine = _cache$get2.cosine; + if (asine >= 0 && bsine >= 0) { + if (acosine < bcosine) + return 1; + if (acosine > bcosine) + return -1; + return 0; + } + if (asine < 0 && bsine < 0) { + if (acosine < bcosine) + return -1; + if (acosine > bcosine) + return 1; + return 0; + } + if (bsine < asine) + return -1; + if (bsine > asine) + return 1; + return 0; + }; + } + }]); + return SweepEvent2; + }(); + var segmentId = 0; + var Segment = /* @__PURE__ */ function() { + _createClass(Segment2, null, [{ + key: "compare", + /* This compare() function is for ordering segments in the sweep + * line tree, and does so according to the following criteria: + * + * Consider the vertical line that lies an infinestimal step to the + * right of the right-more of the two left endpoints of the input + * segments. Imagine slowly moving a point up from negative infinity + * in the increasing y direction. Which of the two segments will that + * point intersect first? That segment comes 'before' the other one. + * + * If neither segment would be intersected by such a line, (if one + * or more of the segments are vertical) then the line to be considered + * is directly on the right-more of the two left inputs. + */ + value: function compare(a, b) { + var alx = a.leftSE.point.x; + var blx = b.leftSE.point.x; + var arx = a.rightSE.point.x; + var brx = b.rightSE.point.x; + if (brx < alx) + return 1; + if (arx < blx) + return -1; + var aly = a.leftSE.point.y; + var bly = b.leftSE.point.y; + var ary = a.rightSE.point.y; + var bry = b.rightSE.point.y; + if (alx < blx) { + if (bly < aly && bly < ary) + return 1; + if (bly > aly && bly > ary) + return -1; + var aCmpBLeft = a.comparePoint(b.leftSE.point); + if (aCmpBLeft < 0) + return 1; + if (aCmpBLeft > 0) + return -1; + var bCmpARight = b.comparePoint(a.rightSE.point); + if (bCmpARight !== 0) + return bCmpARight; + return -1; + } + if (alx > blx) { + if (aly < bly && aly < bry) + return -1; + if (aly > bly && aly > bry) + return 1; + var bCmpALeft = b.comparePoint(a.leftSE.point); + if (bCmpALeft !== 0) + return bCmpALeft; + var aCmpBRight = a.comparePoint(b.rightSE.point); + if (aCmpBRight < 0) + return 1; + if (aCmpBRight > 0) + return -1; + return 1; + } + if (aly < bly) + return -1; + if (aly > bly) + return 1; + if (arx < brx) { + var _bCmpARight = b.comparePoint(a.rightSE.point); + if (_bCmpARight !== 0) + return _bCmpARight; + } + if (arx > brx) { + var _aCmpBRight = a.comparePoint(b.rightSE.point); + if (_aCmpBRight < 0) + return 1; + if (_aCmpBRight > 0) + return -1; + } + if (arx !== brx) { + var ay = ary - aly; + var ax = arx - alx; + var by = bry - bly; + var bx = brx - blx; + if (ay > ax && by < bx) + return 1; + if (ay < ax && by > bx) + return -1; + } + if (arx > brx) + return 1; + if (arx < brx) + return -1; + if (ary < bry) + return -1; + if (ary > bry) + return 1; + if (a.id < b.id) + return -1; + if (a.id > b.id) + return 1; + return 0; + } + /* Warning: a reference to ringWindings input will be stored, + * and possibly will be later modified */ + }]); + function Segment2(leftSE, rightSE, rings, windings) { + _classCallCheck(this, Segment2); + this.id = ++segmentId; + this.leftSE = leftSE; + leftSE.segment = this; + leftSE.otherSE = rightSE; + this.rightSE = rightSE; + rightSE.segment = this; + rightSE.otherSE = leftSE; + this.rings = rings; + this.windings = windings; + } + _createClass(Segment2, [{ + key: "replaceRightSE", + /* When a segment is split, the rightSE is replaced with a new sweep event */ + value: function replaceRightSE(newRightSE) { + this.rightSE = newRightSE; + this.rightSE.segment = this; + this.rightSE.otherSE = this.leftSE; + this.leftSE.otherSE = this.rightSE; + } + }, { + key: "bbox", + value: function bbox2() { + var y12 = this.leftSE.point.y; + var y2 = this.rightSE.point.y; + return { + ll: { + x: this.leftSE.point.x, + y: y12 < y2 ? y12 : y2 + }, + ur: { + x: this.rightSE.point.x, + y: y12 > y2 ? y12 : y2 + } + }; + } + /* A vector from the left point to the right */ + }, { + key: "vector", + value: function vector() { + return { + x: this.rightSE.point.x - this.leftSE.point.x, + y: this.rightSE.point.y - this.leftSE.point.y + }; + } + }, { + key: "isAnEndpoint", + value: function isAnEndpoint(pt) { + return pt.x === this.leftSE.point.x && pt.y === this.leftSE.point.y || pt.x === this.rightSE.point.x && pt.y === this.rightSE.point.y; + } + /* Compare this segment with a point. + * + * A point P is considered to be colinear to a segment if there + * exists a distance D such that if we travel along the segment + * from one * endpoint towards the other a distance D, we find + * ourselves at point P. + * + * Return value indicates: + * + * 1: point lies above the segment (to the left of vertical) + * 0: point is colinear to segment + * -1: point lies below the segment (to the right of vertical) + */ + }, { + key: "comparePoint", + value: function comparePoint(point2) { + if (this.isAnEndpoint(point2)) + return 0; + var lPt = this.leftSE.point; + var rPt = this.rightSE.point; + var v = this.vector(); + if (lPt.x === rPt.x) { + if (point2.x === lPt.x) + return 0; + return point2.x < lPt.x ? 1 : -1; + } + var yDist = (point2.y - lPt.y) / v.y; + var xFromYDist = lPt.x + yDist * v.x; + if (point2.x === xFromYDist) + return 0; + var xDist = (point2.x - lPt.x) / v.x; + var yFromXDist = lPt.y + xDist * v.y; + if (point2.y === yFromXDist) + return 0; + return point2.y < yFromXDist ? -1 : 1; + } + /** + * Given another segment, returns the first non-trivial intersection + * between the two segments (in terms of sweep line ordering), if it exists. + * + * A 'non-trivial' intersection is one that will cause one or both of the + * segments to be split(). As such, 'trivial' vs. 'non-trivial' intersection: + * + * * endpoint of segA with endpoint of segB --> trivial + * * endpoint of segA with point along segB --> non-trivial + * * endpoint of segB with point along segA --> non-trivial + * * point along segA with point along segB --> non-trivial + * + * If no non-trivial intersection exists, return null + * Else, return null. + */ + }, { + key: "getIntersection", + value: function getIntersection(other) { + var tBbox = this.bbox(); + var oBbox = other.bbox(); + var bboxOverlap = getBboxOverlap(tBbox, oBbox); + if (bboxOverlap === null) + return null; + var tlp = this.leftSE.point; + var trp = this.rightSE.point; + var olp = other.leftSE.point; + var orp = other.rightSE.point; + var touchesOtherLSE = isInBbox(tBbox, olp) && this.comparePoint(olp) === 0; + var touchesThisLSE = isInBbox(oBbox, tlp) && other.comparePoint(tlp) === 0; + var touchesOtherRSE = isInBbox(tBbox, orp) && this.comparePoint(orp) === 0; + var touchesThisRSE = isInBbox(oBbox, trp) && other.comparePoint(trp) === 0; + if (touchesThisLSE && touchesOtherLSE) { + if (touchesThisRSE && !touchesOtherRSE) + return trp; + if (!touchesThisRSE && touchesOtherRSE) + return orp; + return null; + } + if (touchesThisLSE) { + if (touchesOtherRSE) { + if (tlp.x === orp.x && tlp.y === orp.y) + return null; + } + return tlp; + } + if (touchesOtherLSE) { + if (touchesThisRSE) { + if (trp.x === olp.x && trp.y === olp.y) + return null; + } + return olp; + } + if (touchesThisRSE && touchesOtherRSE) + return null; + if (touchesThisRSE) + return trp; + if (touchesOtherRSE) + return orp; + var pt = intersection(tlp, this.vector(), olp, other.vector()); + if (pt === null) + return null; + if (!isInBbox(bboxOverlap, pt)) + return null; + return rounder.round(pt.x, pt.y); + } + /** + * Split the given segment into multiple segments on the given points. + * * Each existing segment will retain its leftSE and a new rightSE will be + * generated for it. + * * A new segment will be generated which will adopt the original segment's + * rightSE, and a new leftSE will be generated for it. + * * If there are more than two points given to split on, new segments + * in the middle will be generated with new leftSE and rightSE's. + * * An array of the newly generated SweepEvents will be returned. + * + * Warning: input array of points is modified + */ + }, { + key: "split", + value: function split2(point2) { + var newEvents = []; + var alreadyLinked = point2.events !== void 0; + var newLeftSE = new SweepEvent(point2, true); + var newRightSE = new SweepEvent(point2, false); + var oldRightSE = this.rightSE; + this.replaceRightSE(newRightSE); + newEvents.push(newRightSE); + newEvents.push(newLeftSE); + var newSeg = new Segment2(newLeftSE, oldRightSE, this.rings.slice(), this.windings.slice()); + if (SweepEvent.comparePoints(newSeg.leftSE.point, newSeg.rightSE.point) > 0) { + newSeg.swapEvents(); + } + if (SweepEvent.comparePoints(this.leftSE.point, this.rightSE.point) > 0) { + this.swapEvents(); + } + if (alreadyLinked) { + newLeftSE.checkForConsuming(); + newRightSE.checkForConsuming(); + } + return newEvents; + } + /* Swap which event is left and right */ + }, { + key: "swapEvents", + value: function swapEvents() { + var tmpEvt = this.rightSE; + this.rightSE = this.leftSE; + this.leftSE = tmpEvt; + this.leftSE.isLeft = true; + this.rightSE.isLeft = false; + for (var i2 = 0, iMax = this.windings.length; i2 < iMax; i2++) { + this.windings[i2] *= -1; + } + } + /* Consume another segment. We take their rings under our wing + * and mark them as consumed. Use for perfectly overlapping segments */ + }, { + key: "consume", + value: function consume(other) { + var consumer = this; + var consumee = other; + while (consumer.consumedBy) { + consumer = consumer.consumedBy; + } + while (consumee.consumedBy) { + consumee = consumee.consumedBy; + } + var cmp2 = Segment2.compare(consumer, consumee); + if (cmp2 === 0) + return; + if (cmp2 > 0) { + var tmp = consumer; + consumer = consumee; + consumee = tmp; + } + if (consumer.prev === consumee) { + var _tmp = consumer; + consumer = consumee; + consumee = _tmp; + } + for (var i2 = 0, iMax = consumee.rings.length; i2 < iMax; i2++) { + var ring = consumee.rings[i2]; + var winding = consumee.windings[i2]; + var index2 = consumer.rings.indexOf(ring); + if (index2 === -1) { + consumer.rings.push(ring); + consumer.windings.push(winding); + } else + consumer.windings[index2] += winding; + } + consumee.rings = null; + consumee.windings = null; + consumee.consumedBy = consumer; + consumee.leftSE.consumedBy = consumer.leftSE; + consumee.rightSE.consumedBy = consumer.rightSE; + } + /* The first segment previous segment chain that is in the result */ + }, { + key: "prevInResult", + value: function prevInResult() { + if (this._prevInResult !== void 0) + return this._prevInResult; + if (!this.prev) + this._prevInResult = null; + else if (this.prev.isInResult()) + this._prevInResult = this.prev; + else + this._prevInResult = this.prev.prevInResult(); + return this._prevInResult; + } + }, { + key: "beforeState", + value: function beforeState() { + if (this._beforeState !== void 0) + return this._beforeState; + if (!this.prev) + this._beforeState = { + rings: [], + windings: [], + multiPolys: [] + }; + else { + var seg = this.prev.consumedBy || this.prev; + this._beforeState = seg.afterState(); + } + return this._beforeState; + } + }, { + key: "afterState", + value: function afterState() { + if (this._afterState !== void 0) + return this._afterState; + var beforeState = this.beforeState(); + this._afterState = { + rings: beforeState.rings.slice(0), + windings: beforeState.windings.slice(0), + multiPolys: [] + }; + var ringsAfter = this._afterState.rings; + var windingsAfter = this._afterState.windings; + var mpsAfter = this._afterState.multiPolys; + for (var i2 = 0, iMax = this.rings.length; i2 < iMax; i2++) { + var ring = this.rings[i2]; + var winding = this.windings[i2]; + var index2 = ringsAfter.indexOf(ring); + if (index2 === -1) { + ringsAfter.push(ring); + windingsAfter.push(winding); + } else + windingsAfter[index2] += winding; + } + var polysAfter = []; + var polysExclude = []; + for (var _i = 0, _iMax = ringsAfter.length; _i < _iMax; _i++) { + if (windingsAfter[_i] === 0) + continue; + var _ring = ringsAfter[_i]; + var poly = _ring.poly; + if (polysExclude.indexOf(poly) !== -1) + continue; + if (_ring.isExterior) + polysAfter.push(poly); + else { + if (polysExclude.indexOf(poly) === -1) + polysExclude.push(poly); + var _index = polysAfter.indexOf(_ring.poly); + if (_index !== -1) + polysAfter.splice(_index, 1); + } + } + for (var _i2 = 0, _iMax2 = polysAfter.length; _i2 < _iMax2; _i2++) { + var mp = polysAfter[_i2].multiPoly; + if (mpsAfter.indexOf(mp) === -1) + mpsAfter.push(mp); + } + return this._afterState; + } + /* Is this segment part of the final result? */ + }, { + key: "isInResult", + value: function isInResult() { + if (this.consumedBy) + return false; + if (this._isInResult !== void 0) + return this._isInResult; + var mpsBefore = this.beforeState().multiPolys; + var mpsAfter = this.afterState().multiPolys; + switch (operation.type) { + case "union": { + var noBefores = mpsBefore.length === 0; + var noAfters = mpsAfter.length === 0; + this._isInResult = noBefores !== noAfters; + break; + } + case "intersection": { + var least; + var most; + if (mpsBefore.length < mpsAfter.length) { + least = mpsBefore.length; + most = mpsAfter.length; + } else { + least = mpsAfter.length; + most = mpsBefore.length; + } + this._isInResult = most === operation.numMultiPolys && least < most; + break; + } + case "xor": { + var diff = Math.abs(mpsBefore.length - mpsAfter.length); + this._isInResult = diff % 2 === 1; + break; + } + case "difference": { + var isJustSubject = function isJustSubject2(mps) { + return mps.length === 1 && mps[0].isSubject; + }; + this._isInResult = isJustSubject(mpsBefore) !== isJustSubject(mpsAfter); + break; + } + default: + throw new Error("Unrecognized operation type found ".concat(operation.type)); + } + return this._isInResult; + } + }], [{ + key: "fromRing", + value: function fromRing(pt1, pt2, ring) { + var leftPt, rightPt, winding; + var cmpPts = SweepEvent.comparePoints(pt1, pt2); + if (cmpPts < 0) { + leftPt = pt1; + rightPt = pt2; + winding = 1; + } else if (cmpPts > 0) { + leftPt = pt2; + rightPt = pt1; + winding = -1; + } else + throw new Error("Tried to create degenerate segment at [".concat(pt1.x, ", ").concat(pt1.y, "]")); + var leftSE = new SweepEvent(leftPt, true); + var rightSE = new SweepEvent(rightPt, false); + return new Segment2(leftSE, rightSE, [ring], [winding]); + } + }]); + return Segment2; + }(); + var RingIn = /* @__PURE__ */ function() { + function RingIn2(geomRing, poly, isExterior) { + _classCallCheck(this, RingIn2); + if (!Array.isArray(geomRing) || geomRing.length === 0) { + throw new Error("Input geometry is not a valid Polygon or MultiPolygon"); + } + this.poly = poly; + this.isExterior = isExterior; + this.segments = []; + if (typeof geomRing[0][0] !== "number" || typeof geomRing[0][1] !== "number") { + throw new Error("Input geometry is not a valid Polygon or MultiPolygon"); + } + var firstPoint = rounder.round(geomRing[0][0], geomRing[0][1]); + this.bbox = { + ll: { + x: firstPoint.x, + y: firstPoint.y + }, + ur: { + x: firstPoint.x, + y: firstPoint.y + } + }; + var prevPoint = firstPoint; + for (var i2 = 1, iMax = geomRing.length; i2 < iMax; i2++) { + if (typeof geomRing[i2][0] !== "number" || typeof geomRing[i2][1] !== "number") { + throw new Error("Input geometry is not a valid Polygon or MultiPolygon"); + } + var point2 = rounder.round(geomRing[i2][0], geomRing[i2][1]); + if (point2.x === prevPoint.x && point2.y === prevPoint.y) + continue; + this.segments.push(Segment.fromRing(prevPoint, point2, this)); + if (point2.x < this.bbox.ll.x) + this.bbox.ll.x = point2.x; + if (point2.y < this.bbox.ll.y) + this.bbox.ll.y = point2.y; + if (point2.x > this.bbox.ur.x) + this.bbox.ur.x = point2.x; + if (point2.y > this.bbox.ur.y) + this.bbox.ur.y = point2.y; + prevPoint = point2; + } + if (firstPoint.x !== prevPoint.x || firstPoint.y !== prevPoint.y) { + this.segments.push(Segment.fromRing(prevPoint, firstPoint, this)); + } + } + _createClass(RingIn2, [{ + key: "getSweepEvents", + value: function getSweepEvents() { + var sweepEvents = []; + for (var i2 = 0, iMax = this.segments.length; i2 < iMax; i2++) { + var segment = this.segments[i2]; + sweepEvents.push(segment.leftSE); + sweepEvents.push(segment.rightSE); + } + return sweepEvents; + } + }]); + return RingIn2; + }(); + var PolyIn = /* @__PURE__ */ function() { + function PolyIn2(geomPoly, multiPoly) { + _classCallCheck(this, PolyIn2); + if (!Array.isArray(geomPoly)) { + throw new Error("Input geometry is not a valid Polygon or MultiPolygon"); + } + this.exteriorRing = new RingIn(geomPoly[0], this, true); + this.bbox = { + ll: { + x: this.exteriorRing.bbox.ll.x, + y: this.exteriorRing.bbox.ll.y + }, + ur: { + x: this.exteriorRing.bbox.ur.x, + y: this.exteriorRing.bbox.ur.y + } + }; + this.interiorRings = []; + for (var i2 = 1, iMax = geomPoly.length; i2 < iMax; i2++) { + var ring = new RingIn(geomPoly[i2], this, false); + if (ring.bbox.ll.x < this.bbox.ll.x) + this.bbox.ll.x = ring.bbox.ll.x; + if (ring.bbox.ll.y < this.bbox.ll.y) + this.bbox.ll.y = ring.bbox.ll.y; + if (ring.bbox.ur.x > this.bbox.ur.x) + this.bbox.ur.x = ring.bbox.ur.x; + if (ring.bbox.ur.y > this.bbox.ur.y) + this.bbox.ur.y = ring.bbox.ur.y; + this.interiorRings.push(ring); + } + this.multiPoly = multiPoly; + } + _createClass(PolyIn2, [{ + key: "getSweepEvents", + value: function getSweepEvents() { + var sweepEvents = this.exteriorRing.getSweepEvents(); + for (var i2 = 0, iMax = this.interiorRings.length; i2 < iMax; i2++) { + var ringSweepEvents = this.interiorRings[i2].getSweepEvents(); + for (var j2 = 0, jMax = ringSweepEvents.length; j2 < jMax; j2++) { + sweepEvents.push(ringSweepEvents[j2]); + } + } + return sweepEvents; + } + }]); + return PolyIn2; + }(); + var MultiPolyIn = /* @__PURE__ */ function() { + function MultiPolyIn2(geom, isSubject) { + _classCallCheck(this, MultiPolyIn2); + if (!Array.isArray(geom)) { + throw new Error("Input geometry is not a valid Polygon or MultiPolygon"); + } + try { + if (typeof geom[0][0][0] === "number") + geom = [geom]; + } catch (ex) { + } + this.polys = []; + this.bbox = { + ll: { + x: Number.POSITIVE_INFINITY, + y: Number.POSITIVE_INFINITY + }, + ur: { + x: Number.NEGATIVE_INFINITY, + y: Number.NEGATIVE_INFINITY + } + }; + for (var i2 = 0, iMax = geom.length; i2 < iMax; i2++) { + var poly = new PolyIn(geom[i2], this); + if (poly.bbox.ll.x < this.bbox.ll.x) + this.bbox.ll.x = poly.bbox.ll.x; + if (poly.bbox.ll.y < this.bbox.ll.y) + this.bbox.ll.y = poly.bbox.ll.y; + if (poly.bbox.ur.x > this.bbox.ur.x) + this.bbox.ur.x = poly.bbox.ur.x; + if (poly.bbox.ur.y > this.bbox.ur.y) + this.bbox.ur.y = poly.bbox.ur.y; + this.polys.push(poly); + } + this.isSubject = isSubject; + } + _createClass(MultiPolyIn2, [{ + key: "getSweepEvents", + value: function getSweepEvents() { + var sweepEvents = []; + for (var i2 = 0, iMax = this.polys.length; i2 < iMax; i2++) { + var polySweepEvents = this.polys[i2].getSweepEvents(); + for (var j2 = 0, jMax = polySweepEvents.length; j2 < jMax; j2++) { + sweepEvents.push(polySweepEvents[j2]); + } + } + return sweepEvents; + } + }]); + return MultiPolyIn2; + }(); + var RingOut = /* @__PURE__ */ function() { + _createClass(RingOut2, null, [{ + key: "factory", + /* Given the segments from the sweep line pass, compute & return a series + * of closed rings from all the segments marked to be part of the result */ + value: function factory(allSegments) { + var ringsOut = []; + for (var i2 = 0, iMax = allSegments.length; i2 < iMax; i2++) { + var segment = allSegments[i2]; + if (!segment.isInResult() || segment.ringOut) + continue; + var prevEvent = null; + var event = segment.leftSE; + var nextEvent = segment.rightSE; + var events = [event]; + var startingPoint = event.point; + var intersectionLEs = []; + while (true) { + prevEvent = event; + event = nextEvent; + events.push(event); + if (event.point === startingPoint) + break; + while (true) { + var availableLEs = event.getAvailableLinkedEvents(); + if (availableLEs.length === 0) { + var firstPt = events[0].point; + var lastPt = events[events.length - 1].point; + throw new Error("Unable to complete output ring starting at [".concat(firstPt.x, ",") + " ".concat(firstPt.y, "]. Last matching segment found ends at") + " [".concat(lastPt.x, ", ").concat(lastPt.y, "].")); + } + if (availableLEs.length === 1) { + nextEvent = availableLEs[0].otherSE; + break; + } + var indexLE = null; + for (var j2 = 0, jMax = intersectionLEs.length; j2 < jMax; j2++) { + if (intersectionLEs[j2].point === event.point) { + indexLE = j2; + break; + } + } + if (indexLE !== null) { + var intersectionLE = intersectionLEs.splice(indexLE)[0]; + var ringEvents = events.splice(intersectionLE.index); + ringEvents.unshift(ringEvents[0].otherSE); + ringsOut.push(new RingOut2(ringEvents.reverse())); + continue; + } + intersectionLEs.push({ + index: events.length, + point: event.point + }); + var comparator = event.getLeftmostComparator(prevEvent); + nextEvent = availableLEs.sort(comparator)[0].otherSE; + break; + } + } + ringsOut.push(new RingOut2(events)); + } + return ringsOut; + } + }]); + function RingOut2(events) { + _classCallCheck(this, RingOut2); + this.events = events; + for (var i2 = 0, iMax = events.length; i2 < iMax; i2++) { + events[i2].segment.ringOut = this; + } + this.poly = null; + } + _createClass(RingOut2, [{ + key: "getGeom", + value: function getGeom2() { + var prevPt = this.events[0].point; + var points = [prevPt]; + for (var i2 = 1, iMax = this.events.length - 1; i2 < iMax; i2++) { + var _pt = this.events[i2].point; + var _nextPt = this.events[i2 + 1].point; + if (compareVectorAngles(_pt, prevPt, _nextPt) === 0) + continue; + points.push(_pt); + prevPt = _pt; + } + if (points.length === 1) + return null; + var pt = points[0]; + var nextPt = points[1]; + if (compareVectorAngles(pt, prevPt, nextPt) === 0) + points.shift(); + points.push(points[0]); + var step = this.isExteriorRing() ? 1 : -1; + var iStart = this.isExteriorRing() ? 0 : points.length - 1; + var iEnd = this.isExteriorRing() ? points.length : -1; + var orderedPoints = []; + for (var _i = iStart; _i != iEnd; _i += step) { + orderedPoints.push([points[_i].x, points[_i].y]); + } + return orderedPoints; + } + }, { + key: "isExteriorRing", + value: function isExteriorRing() { + if (this._isExteriorRing === void 0) { + var enclosing = this.enclosingRing(); + this._isExteriorRing = enclosing ? !enclosing.isExteriorRing() : true; + } + return this._isExteriorRing; + } + }, { + key: "enclosingRing", + value: function enclosingRing() { + if (this._enclosingRing === void 0) { + this._enclosingRing = this._calcEnclosingRing(); + } + return this._enclosingRing; + } + /* Returns the ring that encloses this one, if any */ + }, { + key: "_calcEnclosingRing", + value: function _calcEnclosingRing() { + var leftMostEvt = this.events[0]; + for (var i2 = 1, iMax = this.events.length; i2 < iMax; i2++) { + var evt = this.events[i2]; + if (SweepEvent.compare(leftMostEvt, evt) > 0) + leftMostEvt = evt; + } + var prevSeg = leftMostEvt.segment.prevInResult(); + var prevPrevSeg = prevSeg ? prevSeg.prevInResult() : null; + while (true) { + if (!prevSeg) + return null; + if (!prevPrevSeg) + return prevSeg.ringOut; + if (prevPrevSeg.ringOut !== prevSeg.ringOut) { + if (prevPrevSeg.ringOut.enclosingRing() !== prevSeg.ringOut) { + return prevSeg.ringOut; + } else + return prevSeg.ringOut.enclosingRing(); + } + prevSeg = prevPrevSeg.prevInResult(); + prevPrevSeg = prevSeg ? prevSeg.prevInResult() : null; + } + } + }]); + return RingOut2; + }(); + var PolyOut = /* @__PURE__ */ function() { + function PolyOut2(exteriorRing) { + _classCallCheck(this, PolyOut2); + this.exteriorRing = exteriorRing; + exteriorRing.poly = this; + this.interiorRings = []; + } + _createClass(PolyOut2, [{ + key: "addInterior", + value: function addInterior(ring) { + this.interiorRings.push(ring); + ring.poly = this; + } + }, { + key: "getGeom", + value: function getGeom2() { + var geom = [this.exteriorRing.getGeom()]; + if (geom[0] === null) + return null; + for (var i2 = 0, iMax = this.interiorRings.length; i2 < iMax; i2++) { + var ringGeom = this.interiorRings[i2].getGeom(); + if (ringGeom === null) + continue; + geom.push(ringGeom); + } + return geom; + } + }]); + return PolyOut2; + }(); + var MultiPolyOut = /* @__PURE__ */ function() { + function MultiPolyOut2(rings) { + _classCallCheck(this, MultiPolyOut2); + this.rings = rings; + this.polys = this._composePolys(rings); + } + _createClass(MultiPolyOut2, [{ + key: "getGeom", + value: function getGeom2() { + var geom = []; + for (var i2 = 0, iMax = this.polys.length; i2 < iMax; i2++) { + var polyGeom = this.polys[i2].getGeom(); + if (polyGeom === null) + continue; + geom.push(polyGeom); + } + return geom; + } + }, { + key: "_composePolys", + value: function _composePolys(rings) { + var polys = []; + for (var i2 = 0, iMax = rings.length; i2 < iMax; i2++) { + var ring = rings[i2]; + if (ring.poly) + continue; + if (ring.isExteriorRing()) + polys.push(new PolyOut(ring)); + else { + var enclosingRing = ring.enclosingRing(); + if (!enclosingRing.poly) + polys.push(new PolyOut(enclosingRing)); + enclosingRing.poly.addInterior(ring); + } + } + return polys; + } + }]); + return MultiPolyOut2; + }(); + var SweepLine = /* @__PURE__ */ function() { + function SweepLine2(queue) { + var comparator = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Segment.compare; + _classCallCheck(this, SweepLine2); + this.queue = queue; + this.tree = new Tree(comparator); + this.segments = []; + } + _createClass(SweepLine2, [{ + key: "process", + value: function process2(event) { + var segment = event.segment; + var newEvents = []; + if (event.consumedBy) { + if (event.isLeft) + this.queue.remove(event.otherSE); + else + this.tree.remove(segment); + return newEvents; + } + var node = event.isLeft ? this.tree.insert(segment) : this.tree.find(segment); + if (!node) + throw new Error("Unable to find segment #".concat(segment.id, " ") + "[".concat(segment.leftSE.point.x, ", ").concat(segment.leftSE.point.y, "] -> ") + "[".concat(segment.rightSE.point.x, ", ").concat(segment.rightSE.point.y, "] ") + "in SweepLine tree. Please submit a bug report."); + var prevNode = node; + var nextNode = node; + var prevSeg = void 0; + var nextSeg = void 0; + while (prevSeg === void 0) { + prevNode = this.tree.prev(prevNode); + if (prevNode === null) + prevSeg = null; + else if (prevNode.key.consumedBy === void 0) + prevSeg = prevNode.key; + } + while (nextSeg === void 0) { + nextNode = this.tree.next(nextNode); + if (nextNode === null) + nextSeg = null; + else if (nextNode.key.consumedBy === void 0) + nextSeg = nextNode.key; + } + if (event.isLeft) { + var prevMySplitter = null; + if (prevSeg) { + var prevInter = prevSeg.getIntersection(segment); + if (prevInter !== null) { + if (!segment.isAnEndpoint(prevInter)) + prevMySplitter = prevInter; + if (!prevSeg.isAnEndpoint(prevInter)) { + var newEventsFromSplit = this._splitSafely(prevSeg, prevInter); + for (var i2 = 0, iMax = newEventsFromSplit.length; i2 < iMax; i2++) { + newEvents.push(newEventsFromSplit[i2]); + } + } + } + } + var nextMySplitter = null; + if (nextSeg) { + var nextInter = nextSeg.getIntersection(segment); + if (nextInter !== null) { + if (!segment.isAnEndpoint(nextInter)) + nextMySplitter = nextInter; + if (!nextSeg.isAnEndpoint(nextInter)) { + var _newEventsFromSplit = this._splitSafely(nextSeg, nextInter); + for (var _i = 0, _iMax = _newEventsFromSplit.length; _i < _iMax; _i++) { + newEvents.push(_newEventsFromSplit[_i]); + } + } + } + } + if (prevMySplitter !== null || nextMySplitter !== null) { + var mySplitter = null; + if (prevMySplitter === null) + mySplitter = nextMySplitter; + else if (nextMySplitter === null) + mySplitter = prevMySplitter; + else { + var cmpSplitters = SweepEvent.comparePoints(prevMySplitter, nextMySplitter); + mySplitter = cmpSplitters <= 0 ? prevMySplitter : nextMySplitter; + } + this.queue.remove(segment.rightSE); + newEvents.push(segment.rightSE); + var _newEventsFromSplit2 = segment.split(mySplitter); + for (var _i2 = 0, _iMax2 = _newEventsFromSplit2.length; _i2 < _iMax2; _i2++) { + newEvents.push(_newEventsFromSplit2[_i2]); + } + } + if (newEvents.length > 0) { + this.tree.remove(segment); + newEvents.push(event); + } else { + this.segments.push(segment); + segment.prev = prevSeg; + } + } else { + if (prevSeg && nextSeg) { + var inter = prevSeg.getIntersection(nextSeg); + if (inter !== null) { + if (!prevSeg.isAnEndpoint(inter)) { + var _newEventsFromSplit3 = this._splitSafely(prevSeg, inter); + for (var _i3 = 0, _iMax3 = _newEventsFromSplit3.length; _i3 < _iMax3; _i3++) { + newEvents.push(_newEventsFromSplit3[_i3]); + } + } + if (!nextSeg.isAnEndpoint(inter)) { + var _newEventsFromSplit4 = this._splitSafely(nextSeg, inter); + for (var _i4 = 0, _iMax4 = _newEventsFromSplit4.length; _i4 < _iMax4; _i4++) { + newEvents.push(_newEventsFromSplit4[_i4]); + } + } + } + } + this.tree.remove(segment); + } + return newEvents; + } + /* Safely split a segment that is currently in the datastructures + * IE - a segment other than the one that is currently being processed. */ + }, { + key: "_splitSafely", + value: function _splitSafely(seg, pt) { + this.tree.remove(seg); + var rightSE = seg.rightSE; + this.queue.remove(rightSE); + var newEvents = seg.split(pt); + newEvents.push(rightSE); + if (seg.consumedBy === void 0) + this.tree.insert(seg); + return newEvents; + } + }]); + return SweepLine2; + }(); + var POLYGON_CLIPPING_MAX_QUEUE_SIZE = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_QUEUE_SIZE || 1e6; + var POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS || 1e6; + var Operation = /* @__PURE__ */ function() { + function Operation2() { + _classCallCheck(this, Operation2); + } + _createClass(Operation2, [{ + key: "run", + value: function run(type2, geom, moreGeoms) { + operation.type = type2; + rounder.reset(); + var multipolys = [new MultiPolyIn(geom, true)]; + for (var i2 = 0, iMax = moreGeoms.length; i2 < iMax; i2++) { + multipolys.push(new MultiPolyIn(moreGeoms[i2], false)); + } + operation.numMultiPolys = multipolys.length; + if (operation.type === "difference") { + var subject = multipolys[0]; + var _i = 1; + while (_i < multipolys.length) { + if (getBboxOverlap(multipolys[_i].bbox, subject.bbox) !== null) + _i++; + else + multipolys.splice(_i, 1); + } + } + if (operation.type === "intersection") { + for (var _i2 = 0, _iMax = multipolys.length; _i2 < _iMax; _i2++) { + var mpA = multipolys[_i2]; + for (var j2 = _i2 + 1, jMax = multipolys.length; j2 < jMax; j2++) { + if (getBboxOverlap(mpA.bbox, multipolys[j2].bbox) === null) + return []; + } + } + } + var queue = new Tree(SweepEvent.compare); + for (var _i3 = 0, _iMax2 = multipolys.length; _i3 < _iMax2; _i3++) { + var sweepEvents = multipolys[_i3].getSweepEvents(); + for (var _j = 0, _jMax = sweepEvents.length; _j < _jMax; _j++) { + queue.insert(sweepEvents[_j]); + if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) { + throw new Error("Infinite loop when putting segment endpoints in a priority queue (queue size too big). Please file a bug report."); + } + } + } + var sweepLine = new SweepLine(queue); + var prevQueueSize = queue.size; + var node = queue.pop(); + while (node) { + var evt = node.key; + if (queue.size === prevQueueSize) { + var seg = evt.segment; + throw new Error("Unable to pop() ".concat(evt.isLeft ? "left" : "right", " SweepEvent ") + "[".concat(evt.point.x, ", ").concat(evt.point.y, "] from segment #").concat(seg.id, " ") + "[".concat(seg.leftSE.point.x, ", ").concat(seg.leftSE.point.y, "] -> ") + "[".concat(seg.rightSE.point.x, ", ").concat(seg.rightSE.point.y, "] from queue. ") + "Please file a bug report."); + } + if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) { + throw new Error("Infinite loop when passing sweep line over endpoints (queue size too big). Please file a bug report."); + } + if (sweepLine.segments.length > POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS) { + throw new Error("Infinite loop when passing sweep line over endpoints (too many sweep line segments). Please file a bug report."); + } + var newEvents = sweepLine.process(evt); + for (var _i4 = 0, _iMax3 = newEvents.length; _i4 < _iMax3; _i4++) { + var _evt = newEvents[_i4]; + if (_evt.consumedBy === void 0) + queue.insert(_evt); + } + prevQueueSize = queue.size; + node = queue.pop(); + } + rounder.reset(); + var ringsOut = RingOut.factory(sweepLine.segments); + var result = new MultiPolyOut(ringsOut); + return result.getGeom(); + } + }]); + return Operation2; + }(); + var operation = new Operation(); + var union = function union2(geom) { + for (var _len = arguments.length, moreGeoms = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + moreGeoms[_key - 1] = arguments[_key]; + } + return operation.run("union", geom, moreGeoms); + }; + var intersection$1 = function intersection2(geom) { + for (var _len2 = arguments.length, moreGeoms = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + moreGeoms[_key2 - 1] = arguments[_key2]; + } + return operation.run("intersection", geom, moreGeoms); + }; + var xor = function xor2(geom) { + for (var _len3 = arguments.length, moreGeoms = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) { + moreGeoms[_key3 - 1] = arguments[_key3]; + } + return operation.run("xor", geom, moreGeoms); + }; + var difference = function difference2(subjectGeom) { + for (var _len4 = arguments.length, clippingGeoms = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { + clippingGeoms[_key4 - 1] = arguments[_key4]; + } + return operation.run("difference", subjectGeom, clippingGeoms); + }; + var index = { + union, + intersection: intersection$1, + xor, + difference + }; + return index; + }); } + }); - function polygonLineStart() { - var λ00, φ00, x00, y00, a00, b00, c00; // first point - - lineStart(); - - resample.point = function(λ, φ) { - linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0; - resample.point = linePoint; - }; - - resample.lineEnd = function() { - resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream); - resample.lineEnd = lineEnd; - lineEnd(); - }; + // node_modules/geojson-precision/index.js + var require_geojson_precision = __commonJS({ + "node_modules/geojson-precision/index.js"(exports2, module2) { + (function() { + function parse(t, coordinatePrecision, extrasPrecision) { + function point2(p) { + return p.map(function(e, index) { + if (index < 2) { + return 1 * e.toFixed(coordinatePrecision); + } else { + return 1 * e.toFixed(extrasPrecision); + } + }); + } + function multi(l) { + return l.map(point2); + } + function poly(p) { + return p.map(multi); + } + function multiPoly(m) { + return m.map(poly); + } + function geometry(obj) { + if (!obj) { + return {}; + } + switch (obj.type) { + case "Point": + obj.coordinates = point2(obj.coordinates); + return obj; + case "LineString": + case "MultiPoint": + obj.coordinates = multi(obj.coordinates); + return obj; + case "Polygon": + case "MultiLineString": + obj.coordinates = poly(obj.coordinates); + return obj; + case "MultiPolygon": + obj.coordinates = multiPoly(obj.coordinates); + return obj; + case "GeometryCollection": + obj.geometries = obj.geometries.map(geometry); + return obj; + default: + return {}; + } + } + function feature3(obj) { + obj.geometry = geometry(obj.geometry); + return obj; + } + function featureCollection(f2) { + f2.features = f2.features.map(feature3); + return f2; + } + function geometryCollection(g) { + g.geometries = g.geometries.map(geometry); + return g; + } + if (!t) { + return t; + } + switch (t.type) { + case "Feature": + return feature3(t); + case "GeometryCollection": + return geometryCollection(t); + case "FeatureCollection": + return featureCollection(t); + case "Point": + case "LineString": + case "Polygon": + case "MultiPoint": + case "MultiPolygon": + case "MultiLineString": + return geometry(t); + default: + return t; + } + } + module2.exports = parse; + module2.exports.parse = parse; + })(); } + }); - return resample; - } - - function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) { - var dx = x1 - x0, - dy = y1 - y0, - d2 = dx * dx + dy * dy; - if (d2 > 4 * δ2 && depth--) { - var a = a0 + a1, - b = b0 + b1, - c = c0 + c1, - m = Math.sqrt(a * a + b * b + c * c), - φ2 = Math.asin(c /= m), - λ2 = Math.abs(Math.abs(c) - 1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), - p = project(λ2, φ2), - x2 = p[0], - y2 = p[1], - dx2 = x2 - x0, - dy2 = y2 - y0, - dz = dy * dx2 - dx * dy2; - if (dz * dz / d2 > δ2 || Math.abs((dx * dx2 + dy * dy2) / d2 - .5) > .3) { - resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream); - stream.point(x2, y2); - resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream); + // node_modules/@aitodotai/json-stringify-pretty-compact/index.js + var require_json_stringify_pretty_compact = __commonJS({ + "node_modules/@aitodotai/json-stringify-pretty-compact/index.js"(exports2, module2) { + function isObject3(obj) { + return typeof obj === "object" && obj !== null; + } + function forEach(obj, cb) { + if (Array.isArray(obj)) { + obj.forEach(cb); + } else if (isObject3(obj)) { + Object.keys(obj).forEach(function(key) { + var val = obj[key]; + cb(val, key); + }); + } + } + function getTreeDepth(obj) { + var depth = 0; + if (Array.isArray(obj) || isObject3(obj)) { + forEach(obj, function(val) { + if (Array.isArray(val) || isObject3(val)) { + var tmpDepth = getTreeDepth(val); + if (tmpDepth > depth) { + depth = tmpDepth; + } + } + }); + return depth + 1; + } + return depth; + } + function stringify3(obj, options2) { + options2 = options2 || {}; + var indent2 = JSON.stringify([1], null, get4(options2, "indent", 2)).slice(2, -3); + var addMargin = get4(options2, "margins", false); + var addArrayMargin = get4(options2, "arrayMargins", false); + var addObjectMargin = get4(options2, "objectMargins", false); + var maxLength = indent2 === "" ? Infinity : get4(options2, "maxLength", 80); + var maxNesting = get4(options2, "maxNesting", Infinity); + return function _stringify(obj2, currentIndent, reserved) { + if (obj2 && typeof obj2.toJSON === "function") { + obj2 = obj2.toJSON(); + } + var string = JSON.stringify(obj2); + if (string === void 0) { + return string; + } + var length = maxLength - currentIndent.length - reserved; + var treeDepth = getTreeDepth(obj2); + if (treeDepth <= maxNesting && string.length <= length) { + var prettified = prettify(string, { + addMargin, + addArrayMargin, + addObjectMargin + }); + if (prettified.length <= length) { + return prettified; + } + } + if (isObject3(obj2)) { + var nextIndent = currentIndent + indent2; + var items = []; + var delimiters; + var comma = function(array2, index2) { + return index2 === array2.length - 1 ? 0 : 1; + }; + if (Array.isArray(obj2)) { + for (var index = 0; index < obj2.length; index++) { + items.push( + _stringify(obj2[index], nextIndent, comma(obj2, index)) || "null" + ); + } + delimiters = "[]"; + } else { + Object.keys(obj2).forEach(function(key, index2, array2) { + var keyPart = JSON.stringify(key) + ": "; + var value = _stringify( + obj2[key], + nextIndent, + keyPart.length + comma(array2, index2) + ); + if (value !== void 0) { + items.push(keyPart + value); + } + }); + delimiters = "{}"; + } + if (items.length > 0) { + return [ + delimiters[0], + indent2 + items.join(",\n" + nextIndent), + delimiters[1] + ].join("\n" + currentIndent); + } + } + return string; + }(obj, "", 0); + } + var stringOrChar = /("(?:[^\\"]|\\.)*")|[:,\][}{]/g; + function prettify(string, options2) { + options2 = options2 || {}; + var tokens = { + "{": "{", + "}": "}", + "[": "[", + "]": "]", + ",": ", ", + ":": ": " + }; + if (options2.addMargin || options2.addObjectMargin) { + tokens["{"] = "{ "; + tokens["}"] = " }"; + } + if (options2.addMargin || options2.addArrayMargin) { + tokens["["] = "[ "; + tokens["]"] = " ]"; + } + return string.replace(stringOrChar, function(match, string2) { + return string2 ? match : tokens[match]; + }); } + function get4(options2, name, defaultValue) { + return name in options2 ? options2[name] : defaultValue; + } + module2.exports = stringify3; } - } - - resample.precision = function(_) { - if (!arguments.length) return Math.sqrt(δ2); - maxDepth = (δ2 = _ * _) > 0 && 16; - return resample; - }; - - return resample; -} - -d3.geo.projection = d3_geo_projection; -d3.geo.projectionMutator = d3_geo_projectionMutator; - -function d3_geo_projection(project) { - return d3_geo_projectionMutator(function() { return project; })(); -} - -function d3_geo_projectionMutator(projectAt) { - var project, - rotate, - projectRotate, - projectResample = d3_geo_resample(function(x, y) { x = project(x, y); return [x[0] * k + δx, δy - x[1] * k]; }), - k = 150, // scale - x = 480, y = 250, // translate - λ = 0, φ = 0, // center - δλ = 0, δφ = 0, δγ = 0, // rotate - δx, δy, // center - preclip = d3_geo_clipAntimeridian, - postclip = d3_identity, - clipAngle = null, - clipExtent = null; - - function projection(point) { - point = projectRotate(point[0] * d3_radians, point[1] * d3_radians); - return [point[0] * k + δx, δy - point[1] * k]; - } - - function invert(point) { - point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k); - return point && [point[0] * d3_degrees, point[1] * d3_degrees]; - } - - projection.stream = function(stream) { - return d3_geo_projectionRadiansRotate(rotate, preclip(projectResample(postclip(stream)))); - }; - - projection.clipAngle = function(_) { - if (!arguments.length) return clipAngle; - preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians); - return projection; - }; - - projection.clipExtent = function(_) { - if (!arguments.length) return clipExtent; - clipExtent = _; - postclip = _ == null ? d3_identity : d3_geo_clipView(_[0][0], _[0][1], _[1][0], _[1][1]); - return projection; - }; - - projection.scale = function(_) { - if (!arguments.length) return k; - k = +_; - return reset(); - }; - - projection.translate = function(_) { - if (!arguments.length) return [x, y]; - x = +_[0]; - y = +_[1]; - return reset(); - }; - - projection.center = function(_) { - if (!arguments.length) return [λ * d3_degrees, φ * d3_degrees]; - λ = _[0] % 360 * d3_radians; - φ = _[1] % 360 * d3_radians; - return reset(); - }; - - projection.rotate = function(_) { - if (!arguments.length) return [δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees]; - δλ = _[0] % 360 * d3_radians; - δφ = _[1] % 360 * d3_radians; - δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0; - return reset(); - }; - - d3.rebind(projection, projectResample, "precision"); + }); - function reset() { - projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project); - var center = project(λ, φ); - δx = x - center[0] * k; - δy = y + center[1] * k; - return projection; - } - - return function() { - project = projectAt.apply(this, arguments); - projection.invert = project.invert && invert; - return reset(); - }; -} - -function d3_geo_projectionRadiansRotate(rotate, stream) { - return { - point: function(x, y) { - y = rotate(x * d3_radians, y * d3_radians), x = y[0]; - stream.point(x > π ? x - 2 * π : x < -π ? x + 2 * π : x, y[1]); - }, - sphere: function() { stream.sphere(); }, - lineStart: function() { stream.lineStart(); }, - lineEnd: function() { stream.lineEnd(); }, - polygonStart: function() { stream.polygonStart(); }, - polygonEnd: function() { stream.polygonEnd(); } - }; -} - -function d3_geo_mercator(λ, φ) { - return [λ, Math.log(Math.tan(π / 4 + φ / 2))]; -} - -d3_geo_mercator.invert = function(x, y) { - return [x, 2 * Math.atan(Math.exp(y)) - π / 2]; -}; - -function d3_geo_mercatorProjection(project) { - var m = d3_geo_projection(project), - scale = m.scale, - translate = m.translate, - clipExtent = m.clipExtent, - clipAuto; - - m.scale = function() { - var v = scale.apply(m, arguments); - return v === m ? (clipAuto ? m.clipExtent(null) : m) : v; - }; - - m.translate = function() { - var v = translate.apply(m, arguments); - return v === m ? (clipAuto ? m.clipExtent(null) : m) : v; - }; - - m.clipExtent = function(_) { - var v = clipExtent.apply(m, arguments); - if (v === m) { - if (clipAuto = _ == null) { - var k = π * scale(), t = translate(); - clipExtent([[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]]); - } - } else if (clipAuto) { - v = null; - } - return v; - }; - - return m.clipExtent(null); -} - -(d3.geo.mercator = function() { - return d3_geo_mercatorProjection(d3_geo_mercator); -}).raw = d3_geo_mercator; - -function d3_geo_conic(projectAt) { - var φ0 = 0, - φ1 = π / 3, - m = d3_geo_projectionMutator(projectAt), - p = m(φ0, φ1); - - p.parallels = function(_) { - if (!arguments.length) return [φ0 / π * 180, φ1 / π * 180]; - return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180); - }; - - return p; -} - -function d3_geo_conicEqualArea(φ0, φ1) { - var sinφ0 = Math.sin(φ0), - n = (sinφ0 + Math.sin(φ1)) / 2, - C = 1 + sinφ0 * (2 * n - sinφ0), - ρ0 = Math.sqrt(C) / n; - - function forward(λ, φ) { - var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n; - return [ - ρ * Math.sin(λ *= n), - ρ0 - ρ * Math.cos(λ) - ]; - } - - forward.invert = function(x, y) { - var ρ0_y = ρ0 - y; - return [ - Math.atan2(x, ρ0_y) / n, - Math.asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n)) - ]; - }; - - return forward; -} - -(d3.geo.conicEqualArea = function() { - return d3_geo_conic(d3_geo_conicEqualArea); -}).raw = d3_geo_conicEqualArea; - -// A composite projection for the United States, 960×500. 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 -d3.geo.albersUsa = function() { - var lower48 = d3.geo.conicEqualArea() - .rotate([98, 0]) - .center([0, 38]) - .parallels([29.5, 45.5]); - - var alaska = d3.geo.conicEqualArea() - .rotate([160, 0]) - .center([0, 60]) - .parallels([55, 65]); - - var hawaii = d3.geo.conicEqualArea() - .rotate([160, 0]) - .center([0, 20]) - .parallels([8, 18]); - - var puertoRico = d3.geo.conicEqualArea() - .rotate([60, 0]) - .center([0, 10]) - .parallels([8, 18]); - - var alaskaInvert, - hawaiiInvert, - puertoRicoInvert; - - function albersUsa(coordinates) { - return projection(coordinates)(coordinates); - } - - function projection(point) { - var lon = point[0], - lat = point[1]; - return lat > 50 ? alaska - : lon < -140 ? hawaii - : lat < 21 ? puertoRico - : lower48; - } - - albersUsa.invert = function(coordinates) { - return alaskaInvert(coordinates) || hawaiiInvert(coordinates) || puertoRicoInvert(coordinates) || lower48.invert(coordinates); - }; - - albersUsa.scale = function(x) { - if (!arguments.length) return lower48.scale(); - lower48.scale(x); - alaska.scale(x * .6); - hawaii.scale(x); - puertoRico.scale(x * 1.5); - return albersUsa.translate(lower48.translate()); - }; - - albersUsa.translate = function(x) { - if (!arguments.length) return lower48.translate(); - var dz = lower48.scale(), - dx = x[0], - dy = x[1]; - lower48.translate(x); - alaska.translate([dx - .40 * dz, dy + .17 * dz]); - hawaii.translate([dx - .19 * dz, dy + .20 * dz]); - puertoRico.translate([dx + .58 * dz, dy + .43 * dz]); - - alaskaInvert = d3_geo_albersUsaInvert(alaska, [[-180, 50], [-130, 72]]); - hawaiiInvert = d3_geo_albersUsaInvert(hawaii, [[-164, 18], [-154, 24]]); - puertoRicoInvert = d3_geo_albersUsaInvert(puertoRico, [[-67.5, 17.5], [-65, 19]]); - - return albersUsa; - }; - - return albersUsa.scale(1000); -}; - -function d3_geo_albersUsaInvert(projection, extent) { - var a = projection(extent[0]), - b = projection([.5 * (extent[0][0] + extent[1][0]), extent[0][1]]), - c = projection([extent[1][0], extent[0][1]]), - d = projection(extent[1]); - - var dya = b[1]- a[1], - dxa = b[0]- a[0], - dyb = c[1]- b[1], - dxb = c[0]- b[0]; - - var ma = dya / dxa, - mb = dyb / dxb; - - // Find center of circle going through points [a, b, c]. - var cx = .5 * (ma * mb * (a[1] - c[1]) + mb * (a[0] + b[0]) - ma * (b[0] + c[0])) / (mb - ma), - cy = (.5 * (a[0] + b[0]) - cx) / ma + .5 * (a[1] + b[1]); - - // Radial distance² from center. - var dx0 = d[0] - cx, - dy0 = d[1] - cy, - dx1 = a[0] - cx, - dy1 = a[1] - cy, - r0 = dx0 * dx0 + dy0 * dy0, - r1 = dx1 * dx1 + dy1 * dy1; - - // Angular extent. - var a0 = Math.atan2(dy0, dx0), - a1 = Math.atan2(dy1, dx1); - - return function(coordinates) { - var dx = coordinates[0] - cx, - dy = coordinates[1] - cy, - r = dx * dx + dy * dy, - a = Math.atan2(dy, dx); - if (r0 < r && r < r1 && a0 < a && a < a1) return projection.invert(coordinates); - }; -} - -d3.geo.area = function(object) { - d3_geo_areaSum = 0; - d3.geo.stream(object, d3_geo_area); - return d3_geo_areaSum; -}; - -var d3_geo_areaSum, - d3_geo_areaRingU, - d3_geo_areaRingV; - -var d3_geo_area = { - sphere: function() { d3_geo_areaSum += 4 * π; }, - point: d3_noop, - lineStart: d3_noop, - lineEnd: d3_noop, - - // Only count area for polygon rings. - polygonStart: function() { - d3_geo_areaRingU = 1, d3_geo_areaRingV = 0; - d3_geo_area.lineStart = d3_geo_areaRingStart; - }, - polygonEnd: function() { - var area = 2 * Math.atan2(d3_geo_areaRingV, d3_geo_areaRingU); - d3_geo_areaSum += area < 0 ? 4 * π + area : area; - d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop; - } -}; - -function d3_geo_areaRingStart() { - var λ00, φ00, λ0, cosφ0, sinφ0; // start point and two previous points - - // For the first point, … - d3_geo_area.point = function(λ, φ) { - d3_geo_area.point = nextPoint; - λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), sinφ0 = Math.sin(φ); - }; - - // For subsequent points, … - function nextPoint(λ, φ) { - λ *= d3_radians; - φ = φ * d3_radians / 2 + π / 4; // 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 dλ = λ - λ0, - cosφ = Math.cos(φ), - sinφ = Math.sin(φ), - k = sinφ0 * sinφ, - u0 = d3_geo_areaRingU, - v0 = d3_geo_areaRingV, - u = cosφ0 * cosφ + k * Math.cos(dλ), - v = k * Math.sin(dλ); - // ∑ arg(z) = arg(∏ z), where z = u + iv. - d3_geo_areaRingU = u0 * u - v0 * v; - d3_geo_areaRingV = v0 * u + u0 * v; - - // Advance the previous points. - λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ; - } - - // For the last point, return to the start. - d3_geo_area.lineEnd = function() { - nextPoint(λ00, φ00); - }; -} - -d3.geo.bounds = d3_geo_bounds(d3_identity); - -function d3_geo_bounds(projectStream) { - var x0, y0, x1, y1; - - var bound = { - point: boundPoint, - lineStart: d3_noop, - lineEnd: d3_noop, - - // While inside a polygon, ignore points in holes. - polygonStart: function() { bound.lineEnd = boundPolygonLineEnd; }, - polygonEnd: function() { bound.point = boundPoint; } - }; - - function boundPoint(x, y) { - if (x < x0) x0 = x; - if (x > x1) x1 = x; - if (y < y0) y0 = y; - if (y > y1) y1 = y; - } - - function boundPolygonLineEnd() { - bound.point = bound.lineEnd = d3_noop; - } - - return function(feature) { - y1 = x1 = -(x0 = y0 = Infinity); - d3.geo.stream(feature, projectStream(bound)); - return [[x0, y0], [x1, y1]]; - }; -} - -d3.geo.centroid = function(object) { - d3_geo_centroidDimension = d3_geo_centroidW = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0; - d3.geo.stream(object, d3_geo_centroid); - var m; - if (d3_geo_centroidW && - Math.abs(m = Math.sqrt(d3_geo_centroidX * d3_geo_centroidX + d3_geo_centroidY * d3_geo_centroidY + d3_geo_centroidZ * d3_geo_centroidZ)) > ε) { - return [ - Math.atan2(d3_geo_centroidY, d3_geo_centroidX) * d3_degrees, - Math.asin(Math.max(-1, Math.min(1, d3_geo_centroidZ / m))) * d3_degrees - ]; - } -}; - -var d3_geo_centroidDimension, - d3_geo_centroidW, - d3_geo_centroidX, - d3_geo_centroidY, - d3_geo_centroidZ; - -var d3_geo_centroid = { - sphere: function() { - if (d3_geo_centroidDimension < 2) { - d3_geo_centroidDimension = 2; - d3_geo_centroidW = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0; - } - }, - point: d3_geo_centroidPoint, - lineStart: d3_geo_centroidLineStart, - lineEnd: d3_geo_centroidLineEnd, - polygonStart: function() { - if (d3_geo_centroidDimension < 2) { - d3_geo_centroidDimension = 2; - d3_geo_centroidW = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0; - } - d3_geo_centroid.lineStart = d3_geo_centroidRingStart; - }, - polygonEnd: function() { - d3_geo_centroid.lineStart = d3_geo_centroidLineStart; - } -}; - -// Arithmetic mean of Cartesian vectors. -function d3_geo_centroidPoint(λ, φ) { - if (d3_geo_centroidDimension) return; - ++d3_geo_centroidW; - λ *= d3_radians; - var cosφ = Math.cos(φ *= d3_radians); - d3_geo_centroidX += (cosφ * Math.cos(λ) - d3_geo_centroidX) / d3_geo_centroidW; - d3_geo_centroidY += (cosφ * Math.sin(λ) - d3_geo_centroidY) / d3_geo_centroidW; - d3_geo_centroidZ += (Math.sin(φ) - d3_geo_centroidZ) / d3_geo_centroidW; -} - -function d3_geo_centroidRingStart() { - var λ00, φ00; // first point - - d3_geo_centroidDimension = 1; - d3_geo_centroidLineStart(); - d3_geo_centroidDimension = 2; - - var linePoint = d3_geo_centroid.point; - d3_geo_centroid.point = function(λ, φ) { - linePoint(λ00 = λ, φ00 = φ); - }; - d3_geo_centroid.lineEnd = function() { - d3_geo_centroid.point(λ00, φ00); - d3_geo_centroidLineEnd(); - d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd; - }; -} - -function d3_geo_centroidLineStart() { - var x0, y0, z0; // previous point - - if (d3_geo_centroidDimension > 1) return; - if (d3_geo_centroidDimension < 1) { - d3_geo_centroidDimension = 1; - d3_geo_centroidW = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0; - } - - d3_geo_centroid.point = function(λ, φ) { - λ *= d3_radians; - var cosφ = Math.cos(φ *= d3_radians); - x0 = cosφ * Math.cos(λ); - y0 = cosφ * Math.sin(λ); - z0 = Math.sin(φ); - d3_geo_centroid.point = nextPoint; - }; - - function nextPoint(λ, φ) { - λ *= d3_radians; - var cosφ = Math.cos(φ *= d3_radians), - x = cosφ * Math.cos(λ), - y = cosφ * Math.sin(λ), - z = Math.sin(φ), - w = Math.atan2( - Math.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); - d3_geo_centroidW += w; - d3_geo_centroidX += w * (x0 + (x0 = x)); - d3_geo_centroidY += w * (y0 + (y0 = y)); - d3_geo_centroidZ += w * (z0 + (z0 = z)); - } -} - -function d3_geo_centroidLineEnd() { - d3_geo_centroid.point = d3_geo_centroidPoint; -} - -// TODO Unify this code with d3.geom.polygon area? - -var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = { - point: d3_noop, - lineStart: d3_noop, - lineEnd: d3_noop, - - // Only count area for polygon rings. - polygonStart: function() { - d3_geo_pathAreaPolygon = 0; - d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart; - }, - polygonEnd: function() { - d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop; - d3_geo_pathAreaSum += Math.abs(d3_geo_pathAreaPolygon / 2); - } -}; - -function d3_geo_pathAreaRingStart() { - var x00, y00, x0, y0; - - // For the first point, … - d3_geo_pathArea.point = function(x, y) { - d3_geo_pathArea.point = nextPoint; - x00 = x0 = x, y00 = y0 = y; - }; - - // For subsequent points, … - function nextPoint(x, y) { - d3_geo_pathAreaPolygon += y0 * x - x0 * y; - x0 = x, y0 = y; - } - - // For the last point, return to the start. - d3_geo_pathArea.lineEnd = function() { - nextPoint(x00, y00); - }; -} -function d3_geo_pathBuffer() { - var pointCircle = d3_geo_pathCircle(4.5), - buffer = []; - - var stream = { - point: point, - - // While inside a line, override point to moveTo then lineTo. - lineStart: function() { stream.point = pointLineStart; }, - lineEnd: lineEnd, - - // While inside a polygon, override lineEnd to closePath. - polygonStart: function() { stream.lineEnd = lineEndPolygon; }, - polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; }, - - pointRadius: function(_) { - pointCircle = d3_geo_pathCircle(_); - return stream; - }, - - result: function() { - if (buffer.length) { - var result = buffer.join(""); - buffer = []; - return result; - } + // node_modules/aes-js/index.js + var require_aes_js = __commonJS({ + "node_modules/aes-js/index.js"(exports2, module2) { + (function(root3) { + "use strict"; + function checkInt(value) { + return parseInt(value) === value; + } + function checkInts(arrayish) { + if (!checkInt(arrayish.length)) { + return false; + } + for (var i2 = 0; i2 < arrayish.length; i2++) { + if (!checkInt(arrayish[i2]) || arrayish[i2] < 0 || arrayish[i2] > 255) { + return false; + } + } + return true; + } + function coerceArray(arg, copy2) { + if (arg.buffer && arg.name === "Uint8Array") { + if (copy2) { + if (arg.slice) { + arg = arg.slice(); + } else { + arg = Array.prototype.slice.call(arg); + } + } + return arg; + } + if (Array.isArray(arg)) { + if (!checkInts(arg)) { + throw new Error("Array contains invalid value: " + arg); + } + return new Uint8Array(arg); + } + if (checkInt(arg.length) && checkInts(arg)) { + return new Uint8Array(arg); + } + throw new Error("unsupported array-like object"); + } + function createArray(length) { + return new Uint8Array(length); + } + function copyArray(sourceArray, targetArray, targetStart, sourceStart, sourceEnd) { + if (sourceStart != null || sourceEnd != null) { + if (sourceArray.slice) { + sourceArray = sourceArray.slice(sourceStart, sourceEnd); + } else { + sourceArray = Array.prototype.slice.call(sourceArray, sourceStart, sourceEnd); + } + } + targetArray.set(sourceArray, targetStart); + } + var convertUtf8 = function() { + function toBytes(text2) { + var result = [], i2 = 0; + text2 = encodeURI(text2); + while (i2 < text2.length) { + var c = text2.charCodeAt(i2++); + if (c === 37) { + result.push(parseInt(text2.substr(i2, 2), 16)); + i2 += 2; + } else { + result.push(c); + } + } + return coerceArray(result); + } + function fromBytes(bytes) { + var result = [], i2 = 0; + while (i2 < bytes.length) { + var c = bytes[i2]; + if (c < 128) { + result.push(String.fromCharCode(c)); + i2++; + } else if (c > 191 && c < 224) { + result.push(String.fromCharCode((c & 31) << 6 | bytes[i2 + 1] & 63)); + i2 += 2; + } else { + result.push(String.fromCharCode((c & 15) << 12 | (bytes[i2 + 1] & 63) << 6 | bytes[i2 + 2] & 63)); + i2 += 3; + } + } + return result.join(""); + } + return { + toBytes, + fromBytes + }; + }(); + var convertHex = function() { + function toBytes(text2) { + var result = []; + for (var i2 = 0; i2 < text2.length; i2 += 2) { + result.push(parseInt(text2.substr(i2, 2), 16)); + } + return result; + } + var Hex = "0123456789abcdef"; + function fromBytes(bytes) { + var result = []; + for (var i2 = 0; i2 < bytes.length; i2++) { + var v = bytes[i2]; + result.push(Hex[(v & 240) >> 4] + Hex[v & 15]); + } + return result.join(""); + } + return { + toBytes, + fromBytes + }; + }(); + var numberOfRounds = { 16: 10, 24: 12, 32: 14 }; + var rcon = [1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154, 47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145]; + var S = [99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22]; + var Si = [82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66, 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125]; + var T1 = [3328402341, 4168907908, 4000806809, 4135287693, 4294111757, 3597364157, 3731845041, 2445657428, 1613770832, 33620227, 3462883241, 1445669757, 3892248089, 3050821474, 1303096294, 3967186586, 2412431941, 528646813, 2311702848, 4202528135, 4026202645, 2992200171, 2387036105, 4226871307, 1101901292, 3017069671, 1604494077, 1169141738, 597466303, 1403299063, 3832705686, 2613100635, 1974974402, 3791519004, 1033081774, 1277568618, 1815492186, 2118074177, 4126668546, 2211236943, 1748251740, 1369810420, 3521504564, 4193382664, 3799085459, 2883115123, 1647391059, 706024767, 134480908, 2512897874, 1176707941, 2646852446, 806885416, 932615841, 168101135, 798661301, 235341577, 605164086, 461406363, 3756188221, 3454790438, 1311188841, 2142417613, 3933566367, 302582043, 495158174, 1479289972, 874125870, 907746093, 3698224818, 3025820398, 1537253627, 2756858614, 1983593293, 3084310113, 2108928974, 1378429307, 3722699582, 1580150641, 327451799, 2790478837, 3117535592, 0, 3253595436, 1075847264, 3825007647, 2041688520, 3059440621, 3563743934, 2378943302, 1740553945, 1916352843, 2487896798, 2555137236, 2958579944, 2244988746, 3151024235, 3320835882, 1336584933, 3992714006, 2252555205, 2588757463, 1714631509, 293963156, 2319795663, 3925473552, 67240454, 4269768577, 2689618160, 2017213508, 631218106, 1269344483, 2723238387, 1571005438, 2151694528, 93294474, 1066570413, 563977660, 1882732616, 4059428100, 1673313503, 2008463041, 2950355573, 1109467491, 537923632, 3858759450, 4260623118, 3218264685, 2177748300, 403442708, 638784309, 3287084079, 3193921505, 899127202, 2286175436, 773265209, 2479146071, 1437050866, 4236148354, 2050833735, 3362022572, 3126681063, 840505643, 3866325909, 3227541664, 427917720, 2655997905, 2749160575, 1143087718, 1412049534, 999329963, 193497219, 2353415882, 3354324521, 1807268051, 672404540, 2816401017, 3160301282, 369822493, 2916866934, 3688947771, 1681011286, 1949973070, 336202270, 2454276571, 201721354, 1210328172, 3093060836, 2680341085, 3184776046, 1135389935, 3294782118, 965841320, 831886756, 3554993207, 4068047243, 3588745010, 2345191491, 1849112409, 3664604599, 26054028, 2983581028, 2622377682, 1235855840, 3630984372, 2891339514, 4092916743, 3488279077, 3395642799, 4101667470, 1202630377, 268961816, 1874508501, 4034427016, 1243948399, 1546530418, 941366308, 1470539505, 1941222599, 2546386513, 3421038627, 2715671932, 3899946140, 1042226977, 2521517021, 1639824860, 227249030, 260737669, 3765465232, 2084453954, 1907733956, 3429263018, 2420656344, 100860677, 4160157185, 470683154, 3261161891, 1781871967, 2924959737, 1773779408, 394692241, 2579611992, 974986535, 664706745, 3655459128, 3958962195, 731420851, 571543859, 3530123707, 2849626480, 126783113, 865375399, 765172662, 1008606754, 361203602, 3387549984, 2278477385, 2857719295, 1344809080, 2782912378, 59542671, 1503764984, 160008576, 437062935, 1707065306, 3622233649, 2218934982, 3496503480, 2185314755, 697932208, 1512910199, 504303377, 2075177163, 2824099068, 1841019862, 739644986]; + var T2 = [2781242211, 2230877308, 2582542199, 2381740923, 234877682, 3184946027, 2984144751, 1418839493, 1348481072, 50462977, 2848876391, 2102799147, 434634494, 1656084439, 3863849899, 2599188086, 1167051466, 2636087938, 1082771913, 2281340285, 368048890, 3954334041, 3381544775, 201060592, 3963727277, 1739838676, 4250903202, 3930435503, 3206782108, 4149453988, 2531553906, 1536934080, 3262494647, 484572669, 2923271059, 1783375398, 1517041206, 1098792767, 49674231, 1334037708, 1550332980, 4098991525, 886171109, 150598129, 2481090929, 1940642008, 1398944049, 1059722517, 201851908, 1385547719, 1699095331, 1587397571, 674240536, 2704774806, 252314885, 3039795866, 151914247, 908333586, 2602270848, 1038082786, 651029483, 1766729511, 3447698098, 2682942837, 454166793, 2652734339, 1951935532, 775166490, 758520603, 3000790638, 4004797018, 4217086112, 4137964114, 1299594043, 1639438038, 3464344499, 2068982057, 1054729187, 1901997871, 2534638724, 4121318227, 1757008337, 0, 750906861, 1614815264, 535035132, 3363418545, 3988151131, 3201591914, 1183697867, 3647454910, 1265776953, 3734260298, 3566750796, 3903871064, 1250283471, 1807470800, 717615087, 3847203498, 384695291, 3313910595, 3617213773, 1432761139, 2484176261, 3481945413, 283769337, 100925954, 2180939647, 4037038160, 1148730428, 3123027871, 3813386408, 4087501137, 4267549603, 3229630528, 2315620239, 2906624658, 3156319645, 1215313976, 82966005, 3747855548, 3245848246, 1974459098, 1665278241, 807407632, 451280895, 251524083, 1841287890, 1283575245, 337120268, 891687699, 801369324, 3787349855, 2721421207, 3431482436, 959321879, 1469301956, 4065699751, 2197585534, 1199193405, 2898814052, 3887750493, 724703513, 2514908019, 2696962144, 2551808385, 3516813135, 2141445340, 1715741218, 2119445034, 2872807568, 2198571144, 3398190662, 700968686, 3547052216, 1009259540, 2041044702, 3803995742, 487983883, 1991105499, 1004265696, 1449407026, 1316239930, 504629770, 3683797321, 168560134, 1816667172, 3837287516, 1570751170, 1857934291, 4014189740, 2797888098, 2822345105, 2754712981, 936633572, 2347923833, 852879335, 1133234376, 1500395319, 3084545389, 2348912013, 1689376213, 3533459022, 3762923945, 3034082412, 4205598294, 133428468, 634383082, 2949277029, 2398386810, 3913789102, 403703816, 3580869306, 2297460856, 1867130149, 1918643758, 607656988, 4049053350, 3346248884, 1368901318, 600565992, 2090982877, 2632479860, 557719327, 3717614411, 3697393085, 2249034635, 2232388234, 2430627952, 1115438654, 3295786421, 2865522278, 3633334344, 84280067, 33027830, 303828494, 2747425121, 1600795957, 4188952407, 3496589753, 2434238086, 1486471617, 658119965, 3106381470, 953803233, 334231800, 3005978776, 857870609, 3151128937, 1890179545, 2298973838, 2805175444, 3056442267, 574365214, 2450884487, 550103529, 1233637070, 4289353045, 2018519080, 2057691103, 2399374476, 4166623649, 2148108681, 387583245, 3664101311, 836232934, 3330556482, 3100665960, 3280093505, 2955516313, 2002398509, 287182607, 3413881008, 4238890068, 3597515707, 975967766]; + var T3 = [1671808611, 2089089148, 2006576759, 2072901243, 4061003762, 1807603307, 1873927791, 3310653893, 810573872, 16974337, 1739181671, 729634347, 4263110654, 3613570519, 2883997099, 1989864566, 3393556426, 2191335298, 3376449993, 2106063485, 4195741690, 1508618841, 1204391495, 4027317232, 2917941677, 3563566036, 2734514082, 2951366063, 2629772188, 2767672228, 1922491506, 3227229120, 3082974647, 4246528509, 2477669779, 644500518, 911895606, 1061256767, 4144166391, 3427763148, 878471220, 2784252325, 3845444069, 4043897329, 1905517169, 3631459288, 827548209, 356461077, 67897348, 3344078279, 593839651, 3277757891, 405286936, 2527147926, 84871685, 2595565466, 118033927, 305538066, 2157648768, 3795705826, 3945188843, 661212711, 2999812018, 1973414517, 152769033, 2208177539, 745822252, 439235610, 455947803, 1857215598, 1525593178, 2700827552, 1391895634, 994932283, 3596728278, 3016654259, 695947817, 3812548067, 795958831, 2224493444, 1408607827, 3513301457, 0, 3979133421, 543178784, 4229948412, 2982705585, 1542305371, 1790891114, 3410398667, 3201918910, 961245753, 1256100938, 1289001036, 1491644504, 3477767631, 3496721360, 4012557807, 2867154858, 4212583931, 1137018435, 1305975373, 861234739, 2241073541, 1171229253, 4178635257, 33948674, 2139225727, 1357946960, 1011120188, 2679776671, 2833468328, 1374921297, 2751356323, 1086357568, 2408187279, 2460827538, 2646352285, 944271416, 4110742005, 3168756668, 3066132406, 3665145818, 560153121, 271589392, 4279952895, 4077846003, 3530407890, 3444343245, 202643468, 322250259, 3962553324, 1608629855, 2543990167, 1154254916, 389623319, 3294073796, 2817676711, 2122513534, 1028094525, 1689045092, 1575467613, 422261273, 1939203699, 1621147744, 2174228865, 1339137615, 3699352540, 577127458, 712922154, 2427141008, 2290289544, 1187679302, 3995715566, 3100863416, 339486740, 3732514782, 1591917662, 186455563, 3681988059, 3762019296, 844522546, 978220090, 169743370, 1239126601, 101321734, 611076132, 1558493276, 3260915650, 3547250131, 2901361580, 1655096418, 2443721105, 2510565781, 3828863972, 2039214713, 3878868455, 3359869896, 928607799, 1840765549, 2374762893, 3580146133, 1322425422, 2850048425, 1823791212, 1459268694, 4094161908, 3928346602, 1706019429, 2056189050, 2934523822, 135794696, 3134549946, 2022240376, 628050469, 779246638, 472135708, 2800834470, 3032970164, 3327236038, 3894660072, 3715932637, 1956440180, 522272287, 1272813131, 3185336765, 2340818315, 2323976074, 1888542832, 1044544574, 3049550261, 1722469478, 1222152264, 50660867, 4127324150, 236067854, 1638122081, 895445557, 1475980887, 3117443513, 2257655686, 3243809217, 489110045, 2662934430, 3778599393, 4162055160, 2561878936, 288563729, 1773916777, 3648039385, 2391345038, 2493985684, 2612407707, 505560094, 2274497927, 3911240169, 3460925390, 1442818645, 678973480, 3749357023, 2358182796, 2717407649, 2306869641, 219617805, 3218761151, 3862026214, 1120306242, 1756942440, 1103331905, 2578459033, 762796589, 252780047, 2966125488, 1425844308, 3151392187, 372911126]; + var T4 = [1667474886, 2088535288, 2004326894, 2071694838, 4075949567, 1802223062, 1869591006, 3318043793, 808472672, 16843522, 1734846926, 724270422, 4278065639, 3621216949, 2880169549, 1987484396, 3402253711, 2189597983, 3385409673, 2105378810, 4210693615, 1499065266, 1195886990, 4042263547, 2913856577, 3570689971, 2728590687, 2947541573, 2627518243, 2762274643, 1920112356, 3233831835, 3082273397, 4261223649, 2475929149, 640051788, 909531756, 1061110142, 4160160501, 3435941763, 875846760, 2779116625, 3857003729, 4059105529, 1903268834, 3638064043, 825316194, 353713962, 67374088, 3351728789, 589522246, 3284360861, 404236336, 2526454071, 84217610, 2593830191, 117901582, 303183396, 2155911963, 3806477791, 3958056653, 656894286, 2998062463, 1970642922, 151591698, 2206440989, 741110872, 437923380, 454765878, 1852748508, 1515908788, 2694904667, 1381168804, 993742198, 3604373943, 3014905469, 690584402, 3823320797, 791638366, 2223281939, 1398011302, 3520161977, 0, 3991743681, 538992704, 4244381667, 2981218425, 1532751286, 1785380564, 3419096717, 3200178535, 960056178, 1246420628, 1280103576, 1482221744, 3486468741, 3503319995, 4025428677, 2863326543, 4227536621, 1128514950, 1296947098, 859002214, 2240123921, 1162203018, 4193849577, 33687044, 2139062782, 1347481760, 1010582648, 2678045221, 2829640523, 1364325282, 2745433693, 1077985408, 2408548869, 2459086143, 2644360225, 943212656, 4126475505, 3166494563, 3065430391, 3671750063, 555836226, 269496352, 4294908645, 4092792573, 3537006015, 3452783745, 202118168, 320025894, 3974901699, 1600119230, 2543297077, 1145359496, 387397934, 3301201811, 2812801621, 2122220284, 1027426170, 1684319432, 1566435258, 421079858, 1936954854, 1616945344, 2172753945, 1330631070, 3705438115, 572679748, 707427924, 2425400123, 2290647819, 1179044492, 4008585671, 3099120491, 336870440, 3739122087, 1583276732, 185277718, 3688593069, 3772791771, 842159716, 976899700, 168435220, 1229577106, 101059084, 606366792, 1549591736, 3267517855, 3553849021, 2897014595, 1650632388, 2442242105, 2509612081, 3840161747, 2038008818, 3890688725, 3368567691, 926374254, 1835907034, 2374863873, 3587531953, 1313788572, 2846482505, 1819063512, 1448540844, 4109633523, 3941213647, 1701162954, 2054852340, 2930698567, 134748176, 3132806511, 2021165296, 623210314, 774795868, 471606328, 2795958615, 3031746419, 3334885783, 3907527627, 3722280097, 1953799400, 522133822, 1263263126, 3183336545, 2341176845, 2324333839, 1886425312, 1044267644, 3048588401, 1718004428, 1212733584, 50529542, 4143317495, 235803164, 1633788866, 892690282, 1465383342, 3115962473, 2256965911, 3250673817, 488449850, 2661202215, 3789633753, 4177007595, 2560144171, 286339874, 1768537042, 3654906025, 2391705863, 2492770099, 2610673197, 505291324, 2273808917, 3924369609, 3469625735, 1431699370, 673740880, 3755965093, 2358021891, 2711746649, 2307489801, 218961690, 3217021541, 3873845719, 1111672452, 1751693520, 1094828930, 2576986153, 757954394, 252645662, 2964376443, 1414855848, 3149649517, 370555436]; + var T5 = [1374988112, 2118214995, 437757123, 975658646, 1001089995, 530400753, 2902087851, 1273168787, 540080725, 2910219766, 2295101073, 4110568485, 1340463100, 3307916247, 641025152, 3043140495, 3736164937, 632953703, 1172967064, 1576976609, 3274667266, 2169303058, 2370213795, 1809054150, 59727847, 361929877, 3211623147, 2505202138, 3569255213, 1484005843, 1239443753, 2395588676, 1975683434, 4102977912, 2572697195, 666464733, 3202437046, 4035489047, 3374361702, 2110667444, 1675577880, 3843699074, 2538681184, 1649639237, 2976151520, 3144396420, 4269907996, 4178062228, 1883793496, 2403728665, 2497604743, 1383856311, 2876494627, 1917518562, 3810496343, 1716890410, 3001755655, 800440835, 2261089178, 3543599269, 807962610, 599762354, 33778362, 3977675356, 2328828971, 2809771154, 4077384432, 1315562145, 1708848333, 101039829, 3509871135, 3299278474, 875451293, 2733856160, 92987698, 2767645557, 193195065, 1080094634, 1584504582, 3178106961, 1042385657, 2531067453, 3711829422, 1306967366, 2438237621, 1908694277, 67556463, 1615861247, 429456164, 3602770327, 2302690252, 1742315127, 2968011453, 126454664, 3877198648, 2043211483, 2709260871, 2084704233, 4169408201, 0, 159417987, 841739592, 504459436, 1817866830, 4245618683, 260388950, 1034867998, 908933415, 168810852, 1750902305, 2606453969, 607530554, 202008497, 2472011535, 3035535058, 463180190, 2160117071, 1641816226, 1517767529, 470948374, 3801332234, 3231722213, 1008918595, 303765277, 235474187, 4069246893, 766945465, 337553864, 1475418501, 2943682380, 4003061179, 2743034109, 4144047775, 1551037884, 1147550661, 1543208500, 2336434550, 3408119516, 3069049960, 3102011747, 3610369226, 1113818384, 328671808, 2227573024, 2236228733, 3535486456, 2935566865, 3341394285, 496906059, 3702665459, 226906860, 2009195472, 733156972, 2842737049, 294930682, 1206477858, 2835123396, 2700099354, 1451044056, 573804783, 2269728455, 3644379585, 2362090238, 2564033334, 2801107407, 2776292904, 3669462566, 1068351396, 742039012, 1350078989, 1784663195, 1417561698, 4136440770, 2430122216, 775550814, 2193862645, 2673705150, 1775276924, 1876241833, 3475313331, 3366754619, 270040487, 3902563182, 3678124923, 3441850377, 1851332852, 3969562369, 2203032232, 3868552805, 2868897406, 566021896, 4011190502, 3135740889, 1248802510, 3936291284, 699432150, 832877231, 708780849, 3332740144, 899835584, 1951317047, 4236429990, 3767586992, 866637845, 4043610186, 1106041591, 2144161806, 395441711, 1984812685, 1139781709, 3433712980, 3835036895, 2664543715, 1282050075, 3240894392, 1181045119, 2640243204, 25965917, 4203181171, 4211818798, 3009879386, 2463879762, 3910161971, 1842759443, 2597806476, 933301370, 1509430414, 3943906441, 3467192302, 3076639029, 3776767469, 2051518780, 2631065433, 1441952575, 404016761, 1942435775, 1408749034, 1610459739, 3745345300, 2017778566, 3400528769, 3110650942, 941896748, 3265478751, 371049330, 3168937228, 675039627, 4279080257, 967311729, 135050206, 3635733660, 1683407248, 2076935265, 3576870512, 1215061108, 3501741890]; + var T6 = [1347548327, 1400783205, 3273267108, 2520393566, 3409685355, 4045380933, 2880240216, 2471224067, 1428173050, 4138563181, 2441661558, 636813900, 4233094615, 3620022987, 2149987652, 2411029155, 1239331162, 1730525723, 2554718734, 3781033664, 46346101, 310463728, 2743944855, 3328955385, 3875770207, 2501218972, 3955191162, 3667219033, 768917123, 3545789473, 692707433, 1150208456, 1786102409, 2029293177, 1805211710, 3710368113, 3065962831, 401639597, 1724457132, 3028143674, 409198410, 2196052529, 1620529459, 1164071807, 3769721975, 2226875310, 486441376, 2499348523, 1483753576, 428819965, 2274680428, 3075636216, 598438867, 3799141122, 1474502543, 711349675, 129166120, 53458370, 2592523643, 2782082824, 4063242375, 2988687269, 3120694122, 1559041666, 730517276, 2460449204, 4042459122, 2706270690, 3446004468, 3573941694, 533804130, 2328143614, 2637442643, 2695033685, 839224033, 1973745387, 957055980, 2856345839, 106852767, 1371368976, 4181598602, 1033297158, 2933734917, 1179510461, 3046200461, 91341917, 1862534868, 4284502037, 605657339, 2547432937, 3431546947, 2003294622, 3182487618, 2282195339, 954669403, 3682191598, 1201765386, 3917234703, 3388507166, 0, 2198438022, 1211247597, 2887651696, 1315723890, 4227665663, 1443857720, 507358933, 657861945, 1678381017, 560487590, 3516619604, 975451694, 2970356327, 261314535, 3535072918, 2652609425, 1333838021, 2724322336, 1767536459, 370938394, 182621114, 3854606378, 1128014560, 487725847, 185469197, 2918353863, 3106780840, 3356761769, 2237133081, 1286567175, 3152976349, 4255350624, 2683765030, 3160175349, 3309594171, 878443390, 1988838185, 3704300486, 1756818940, 1673061617, 3403100636, 272786309, 1075025698, 545572369, 2105887268, 4174560061, 296679730, 1841768865, 1260232239, 4091327024, 3960309330, 3497509347, 1814803222, 2578018489, 4195456072, 575138148, 3299409036, 446754879, 3629546796, 4011996048, 3347532110, 3252238545, 4270639778, 915985419, 3483825537, 681933534, 651868046, 2755636671, 3828103837, 223377554, 2607439820, 1649704518, 3270937875, 3901806776, 1580087799, 4118987695, 3198115200, 2087309459, 2842678573, 3016697106, 1003007129, 2802849917, 1860738147, 2077965243, 164439672, 4100872472, 32283319, 2827177882, 1709610350, 2125135846, 136428751, 3874428392, 3652904859, 3460984630, 3572145929, 3593056380, 2939266226, 824852259, 818324884, 3224740454, 930369212, 2801566410, 2967507152, 355706840, 1257309336, 4148292826, 243256656, 790073846, 2373340630, 1296297904, 1422699085, 3756299780, 3818836405, 457992840, 3099667487, 2135319889, 77422314, 1560382517, 1945798516, 788204353, 1521706781, 1385356242, 870912086, 325965383, 2358957921, 2050466060, 2388260884, 2313884476, 4006521127, 901210569, 3990953189, 1014646705, 1503449823, 1062597235, 2031621326, 3212035895, 3931371469, 1533017514, 350174575, 2256028891, 2177544179, 1052338372, 741876788, 1606591296, 1914052035, 213705253, 2334669897, 1107234197, 1899603969, 3725069491, 2631447780, 2422494913, 1635502980, 1893020342, 1950903388, 1120974935]; + var T7 = [2807058932, 1699970625, 2764249623, 1586903591, 1808481195, 1173430173, 1487645946, 59984867, 4199882800, 1844882806, 1989249228, 1277555970, 3623636965, 3419915562, 1149249077, 2744104290, 1514790577, 459744698, 244860394, 3235995134, 1963115311, 4027744588, 2544078150, 4190530515, 1608975247, 2627016082, 2062270317, 1507497298, 2200818878, 567498868, 1764313568, 3359936201, 2305455554, 2037970062, 1047239e3, 1910319033, 1337376481, 2904027272, 2892417312, 984907214, 1243112415, 830661914, 861968209, 2135253587, 2011214180, 2927934315, 2686254721, 731183368, 1750626376, 4246310725, 1820824798, 4172763771, 3542330227, 48394827, 2404901663, 2871682645, 671593195, 3254988725, 2073724613, 145085239, 2280796200, 2779915199, 1790575107, 2187128086, 472615631, 3029510009, 4075877127, 3802222185, 4107101658, 3201631749, 1646252340, 4270507174, 1402811438, 1436590835, 3778151818, 3950355702, 3963161475, 4020912224, 2667994737, 273792366, 2331590177, 104699613, 95345982, 3175501286, 2377486676, 1560637892, 3564045318, 369057872, 4213447064, 3919042237, 1137477952, 2658625497, 1119727848, 2340947849, 1530455833, 4007360968, 172466556, 266959938, 516552836, 0, 2256734592, 3980931627, 1890328081, 1917742170, 4294704398, 945164165, 3575528878, 958871085, 3647212047, 2787207260, 1423022939, 775562294, 1739656202, 3876557655, 2530391278, 2443058075, 3310321856, 547512796, 1265195639, 437656594, 3121275539, 719700128, 3762502690, 387781147, 218828297, 3350065803, 2830708150, 2848461854, 428169201, 122466165, 3720081049, 1627235199, 648017665, 4122762354, 1002783846, 2117360635, 695634755, 3336358691, 4234721005, 4049844452, 3704280881, 2232435299, 574624663, 287343814, 612205898, 1039717051, 840019705, 2708326185, 793451934, 821288114, 1391201670, 3822090177, 376187827, 3113855344, 1224348052, 1679968233, 2361698556, 1058709744, 752375421, 2431590963, 1321699145, 3519142200, 2734591178, 188127444, 2177869557, 3727205754, 2384911031, 3215212461, 2648976442, 2450346104, 3432737375, 1180849278, 331544205, 3102249176, 4150144569, 2952102595, 2159976285, 2474404304, 766078933, 313773861, 2570832044, 2108100632, 1668212892, 3145456443, 2013908262, 418672217, 3070356634, 2594734927, 1852171925, 3867060991, 3473416636, 3907448597, 2614737639, 919489135, 164948639, 2094410160, 2997825956, 590424639, 2486224549, 1723872674, 3157750862, 3399941250, 3501252752, 3625268135, 2555048196, 3673637356, 1343127501, 4130281361, 3599595085, 2957853679, 1297403050, 81781910, 3051593425, 2283490410, 532201772, 1367295589, 3926170974, 895287692, 1953757831, 1093597963, 492483431, 3528626907, 1446242576, 1192455638, 1636604631, 209336225, 344873464, 1015671571, 669961897, 3375740769, 3857572124, 2973530695, 3747192018, 1933530610, 3464042516, 935293895, 3454686199, 2858115069, 1863638845, 3683022916, 4085369519, 3292445032, 875313188, 1080017571, 3279033885, 621591778, 1233856572, 2504130317, 24197544, 3017672716, 3835484340, 3247465558, 2220981195, 3060847922, 1551124588, 1463996600]; + var T8 = [4104605777, 1097159550, 396673818, 660510266, 2875968315, 2638606623, 4200115116, 3808662347, 821712160, 1986918061, 3430322568, 38544885, 3856137295, 718002117, 893681702, 1654886325, 2975484382, 3122358053, 3926825029, 4274053469, 796197571, 1290801793, 1184342925, 3556361835, 2405426947, 2459735317, 1836772287, 1381620373, 3196267988, 1948373848, 3764988233, 3385345166, 3263785589, 2390325492, 1480485785, 3111247143, 3780097726, 2293045232, 548169417, 3459953789, 3746175075, 439452389, 1362321559, 1400849762, 1685577905, 1806599355, 2174754046, 137073913, 1214797936, 1174215055, 3731654548, 2079897426, 1943217067, 1258480242, 529487843, 1437280870, 3945269170, 3049390895, 3313212038, 923313619, 679998e3, 3215307299, 57326082, 377642221, 3474729866, 2041877159, 133361907, 1776460110, 3673476453, 96392454, 878845905, 2801699524, 777231668, 4082475170, 2330014213, 4142626212, 2213296395, 1626319424, 1906247262, 1846563261, 562755902, 3708173718, 1040559837, 3871163981, 1418573201, 3294430577, 114585348, 1343618912, 2566595609, 3186202582, 1078185097, 3651041127, 3896688048, 2307622919, 425408743, 3371096953, 2081048481, 1108339068, 2216610296, 0, 2156299017, 736970802, 292596766, 1517440620, 251657213, 2235061775, 2933202493, 758720310, 265905162, 1554391400, 1532285339, 908999204, 174567692, 1474760595, 4002861748, 2610011675, 3234156416, 3693126241, 2001430874, 303699484, 2478443234, 2687165888, 585122620, 454499602, 151849742, 2345119218, 3064510765, 514443284, 4044981591, 1963412655, 2581445614, 2137062819, 19308535, 1928707164, 1715193156, 4219352155, 1126790795, 600235211, 3992742070, 3841024952, 836553431, 1669664834, 2535604243, 3323011204, 1243905413, 3141400786, 4180808110, 698445255, 2653899549, 2989552604, 2253581325, 3252932727, 3004591147, 1891211689, 2487810577, 3915653703, 4237083816, 4030667424, 2100090966, 865136418, 1229899655, 953270745, 3399679628, 3557504664, 4118925222, 2061379749, 3079546586, 2915017791, 983426092, 2022837584, 1607244650, 2118541908, 2366882550, 3635996816, 972512814, 3283088770, 1568718495, 3499326569, 3576539503, 621982671, 2895723464, 410887952, 2623762152, 1002142683, 645401037, 1494807662, 2595684844, 1335535747, 2507040230, 4293295786, 3167684641, 367585007, 3885750714, 1865862730, 2668221674, 2960971305, 2763173681, 1059270954, 2777952454, 2724642869, 1320957812, 2194319100, 2429595872, 2815956275, 77089521, 3973773121, 3444575871, 2448830231, 1305906550, 4021308739, 2857194700, 2516901860, 3518358430, 1787304780, 740276417, 1699839814, 1592394909, 2352307457, 2272556026, 188821243, 1729977011, 3687994002, 274084841, 3594982253, 3613494426, 2701949495, 4162096729, 322734571, 2837966542, 1640576439, 484830689, 1202797690, 3537852828, 4067639125, 349075736, 3342319475, 4157467219, 4255800159, 1030690015, 1155237496, 2951971274, 1757691577, 607398968, 2738905026, 499347990, 3794078908, 1011452712, 227885567, 2818666809, 213114376, 3034881240, 1455525988, 3414450555, 850817237, 1817998408, 3092726480]; + var U1 = [0, 235474187, 470948374, 303765277, 941896748, 908933415, 607530554, 708780849, 1883793496, 2118214995, 1817866830, 1649639237, 1215061108, 1181045119, 1417561698, 1517767529, 3767586992, 4003061179, 4236429990, 4069246893, 3635733660, 3602770327, 3299278474, 3400528769, 2430122216, 2664543715, 2362090238, 2193862645, 2835123396, 2801107407, 3035535058, 3135740889, 3678124923, 3576870512, 3341394285, 3374361702, 3810496343, 3977675356, 4279080257, 4043610186, 2876494627, 2776292904, 3076639029, 3110650942, 2472011535, 2640243204, 2403728665, 2169303058, 1001089995, 899835584, 666464733, 699432150, 59727847, 226906860, 530400753, 294930682, 1273168787, 1172967064, 1475418501, 1509430414, 1942435775, 2110667444, 1876241833, 1641816226, 2910219766, 2743034109, 2976151520, 3211623147, 2505202138, 2606453969, 2302690252, 2269728455, 3711829422, 3543599269, 3240894392, 3475313331, 3843699074, 3943906441, 4178062228, 4144047775, 1306967366, 1139781709, 1374988112, 1610459739, 1975683434, 2076935265, 1775276924, 1742315127, 1034867998, 866637845, 566021896, 800440835, 92987698, 193195065, 429456164, 395441711, 1984812685, 2017778566, 1784663195, 1683407248, 1315562145, 1080094634, 1383856311, 1551037884, 101039829, 135050206, 437757123, 337553864, 1042385657, 807962610, 573804783, 742039012, 2531067453, 2564033334, 2328828971, 2227573024, 2935566865, 2700099354, 3001755655, 3168937228, 3868552805, 3902563182, 4203181171, 4102977912, 3736164937, 3501741890, 3265478751, 3433712980, 1106041591, 1340463100, 1576976609, 1408749034, 2043211483, 2009195472, 1708848333, 1809054150, 832877231, 1068351396, 766945465, 599762354, 159417987, 126454664, 361929877, 463180190, 2709260871, 2943682380, 3178106961, 3009879386, 2572697195, 2538681184, 2236228733, 2336434550, 3509871135, 3745345300, 3441850377, 3274667266, 3910161971, 3877198648, 4110568485, 4211818798, 2597806476, 2497604743, 2261089178, 2295101073, 2733856160, 2902087851, 3202437046, 2968011453, 3936291284, 3835036895, 4136440770, 4169408201, 3535486456, 3702665459, 3467192302, 3231722213, 2051518780, 1951317047, 1716890410, 1750902305, 1113818384, 1282050075, 1584504582, 1350078989, 168810852, 67556463, 371049330, 404016761, 841739592, 1008918595, 775550814, 540080725, 3969562369, 3801332234, 4035489047, 4269907996, 3569255213, 3669462566, 3366754619, 3332740144, 2631065433, 2463879762, 2160117071, 2395588676, 2767645557, 2868897406, 3102011747, 3069049960, 202008497, 33778362, 270040487, 504459436, 875451293, 975658646, 675039627, 641025152, 2084704233, 1917518562, 1615861247, 1851332852, 1147550661, 1248802510, 1484005843, 1451044056, 933301370, 967311729, 733156972, 632953703, 260388950, 25965917, 328671808, 496906059, 1206477858, 1239443753, 1543208500, 1441952575, 2144161806, 1908694277, 1675577880, 1842759443, 3610369226, 3644379585, 3408119516, 3307916247, 4011190502, 3776767469, 4077384432, 4245618683, 2809771154, 2842737049, 3144396420, 3043140495, 2673705150, 2438237621, 2203032232, 2370213795]; + var U2 = [0, 185469197, 370938394, 487725847, 741876788, 657861945, 975451694, 824852259, 1483753576, 1400783205, 1315723890, 1164071807, 1950903388, 2135319889, 1649704518, 1767536459, 2967507152, 3152976349, 2801566410, 2918353863, 2631447780, 2547432937, 2328143614, 2177544179, 3901806776, 3818836405, 4270639778, 4118987695, 3299409036, 3483825537, 3535072918, 3652904859, 2077965243, 1893020342, 1841768865, 1724457132, 1474502543, 1559041666, 1107234197, 1257309336, 598438867, 681933534, 901210569, 1052338372, 261314535, 77422314, 428819965, 310463728, 3409685355, 3224740454, 3710368113, 3593056380, 3875770207, 3960309330, 4045380933, 4195456072, 2471224067, 2554718734, 2237133081, 2388260884, 3212035895, 3028143674, 2842678573, 2724322336, 4138563181, 4255350624, 3769721975, 3955191162, 3667219033, 3516619604, 3431546947, 3347532110, 2933734917, 2782082824, 3099667487, 3016697106, 2196052529, 2313884476, 2499348523, 2683765030, 1179510461, 1296297904, 1347548327, 1533017514, 1786102409, 1635502980, 2087309459, 2003294622, 507358933, 355706840, 136428751, 53458370, 839224033, 957055980, 605657339, 790073846, 2373340630, 2256028891, 2607439820, 2422494913, 2706270690, 2856345839, 3075636216, 3160175349, 3573941694, 3725069491, 3273267108, 3356761769, 4181598602, 4063242375, 4011996048, 3828103837, 1033297158, 915985419, 730517276, 545572369, 296679730, 446754879, 129166120, 213705253, 1709610350, 1860738147, 1945798516, 2029293177, 1239331162, 1120974935, 1606591296, 1422699085, 4148292826, 4233094615, 3781033664, 3931371469, 3682191598, 3497509347, 3446004468, 3328955385, 2939266226, 2755636671, 3106780840, 2988687269, 2198438022, 2282195339, 2501218972, 2652609425, 1201765386, 1286567175, 1371368976, 1521706781, 1805211710, 1620529459, 2105887268, 1988838185, 533804130, 350174575, 164439672, 46346101, 870912086, 954669403, 636813900, 788204353, 2358957921, 2274680428, 2592523643, 2441661558, 2695033685, 2880240216, 3065962831, 3182487618, 3572145929, 3756299780, 3270937875, 3388507166, 4174560061, 4091327024, 4006521127, 3854606378, 1014646705, 930369212, 711349675, 560487590, 272786309, 457992840, 106852767, 223377554, 1678381017, 1862534868, 1914052035, 2031621326, 1211247597, 1128014560, 1580087799, 1428173050, 32283319, 182621114, 401639597, 486441376, 768917123, 651868046, 1003007129, 818324884, 1503449823, 1385356242, 1333838021, 1150208456, 1973745387, 2125135846, 1673061617, 1756818940, 2970356327, 3120694122, 2802849917, 2887651696, 2637442643, 2520393566, 2334669897, 2149987652, 3917234703, 3799141122, 4284502037, 4100872472, 3309594171, 3460984630, 3545789473, 3629546796, 2050466060, 1899603969, 1814803222, 1730525723, 1443857720, 1560382517, 1075025698, 1260232239, 575138148, 692707433, 878443390, 1062597235, 243256656, 91341917, 409198410, 325965383, 3403100636, 3252238545, 3704300486, 3620022987, 3874428392, 3990953189, 4042459122, 4227665663, 2460449204, 2578018489, 2226875310, 2411029155, 3198115200, 3046200461, 2827177882, 2743944855]; + var U3 = [0, 218828297, 437656594, 387781147, 875313188, 958871085, 775562294, 590424639, 1750626376, 1699970625, 1917742170, 2135253587, 1551124588, 1367295589, 1180849278, 1265195639, 3501252752, 3720081049, 3399941250, 3350065803, 3835484340, 3919042237, 4270507174, 4085369519, 3102249176, 3051593425, 2734591178, 2952102595, 2361698556, 2177869557, 2530391278, 2614737639, 3145456443, 3060847922, 2708326185, 2892417312, 2404901663, 2187128086, 2504130317, 2555048196, 3542330227, 3727205754, 3375740769, 3292445032, 3876557655, 3926170974, 4246310725, 4027744588, 1808481195, 1723872674, 1910319033, 2094410160, 1608975247, 1391201670, 1173430173, 1224348052, 59984867, 244860394, 428169201, 344873464, 935293895, 984907214, 766078933, 547512796, 1844882806, 1627235199, 2011214180, 2062270317, 1507497298, 1423022939, 1137477952, 1321699145, 95345982, 145085239, 532201772, 313773861, 830661914, 1015671571, 731183368, 648017665, 3175501286, 2957853679, 2807058932, 2858115069, 2305455554, 2220981195, 2474404304, 2658625497, 3575528878, 3625268135, 3473416636, 3254988725, 3778151818, 3963161475, 4213447064, 4130281361, 3599595085, 3683022916, 3432737375, 3247465558, 3802222185, 4020912224, 4172763771, 4122762354, 3201631749, 3017672716, 2764249623, 2848461854, 2331590177, 2280796200, 2431590963, 2648976442, 104699613, 188127444, 472615631, 287343814, 840019705, 1058709744, 671593195, 621591778, 1852171925, 1668212892, 1953757831, 2037970062, 1514790577, 1463996600, 1080017571, 1297403050, 3673637356, 3623636965, 3235995134, 3454686199, 4007360968, 3822090177, 4107101658, 4190530515, 2997825956, 3215212461, 2830708150, 2779915199, 2256734592, 2340947849, 2627016082, 2443058075, 172466556, 122466165, 273792366, 492483431, 1047239e3, 861968209, 612205898, 695634755, 1646252340, 1863638845, 2013908262, 1963115311, 1446242576, 1530455833, 1277555970, 1093597963, 1636604631, 1820824798, 2073724613, 1989249228, 1436590835, 1487645946, 1337376481, 1119727848, 164948639, 81781910, 331544205, 516552836, 1039717051, 821288114, 669961897, 719700128, 2973530695, 3157750862, 2871682645, 2787207260, 2232435299, 2283490410, 2667994737, 2450346104, 3647212047, 3564045318, 3279033885, 3464042516, 3980931627, 3762502690, 4150144569, 4199882800, 3070356634, 3121275539, 2904027272, 2686254721, 2200818878, 2384911031, 2570832044, 2486224549, 3747192018, 3528626907, 3310321856, 3359936201, 3950355702, 3867060991, 4049844452, 4234721005, 1739656202, 1790575107, 2108100632, 1890328081, 1402811438, 1586903591, 1233856572, 1149249077, 266959938, 48394827, 369057872, 418672217, 1002783846, 919489135, 567498868, 752375421, 209336225, 24197544, 376187827, 459744698, 945164165, 895287692, 574624663, 793451934, 1679968233, 1764313568, 2117360635, 1933530610, 1343127501, 1560637892, 1243112415, 1192455638, 3704280881, 3519142200, 3336358691, 3419915562, 3907448597, 3857572124, 4075877127, 4294704398, 3029510009, 3113855344, 2927934315, 2744104290, 2159976285, 2377486676, 2594734927, 2544078150]; + var U4 = [0, 151849742, 303699484, 454499602, 607398968, 758720310, 908999204, 1059270954, 1214797936, 1097159550, 1517440620, 1400849762, 1817998408, 1699839814, 2118541908, 2001430874, 2429595872, 2581445614, 2194319100, 2345119218, 3034881240, 3186202582, 2801699524, 2951971274, 3635996816, 3518358430, 3399679628, 3283088770, 4237083816, 4118925222, 4002861748, 3885750714, 1002142683, 850817237, 698445255, 548169417, 529487843, 377642221, 227885567, 77089521, 1943217067, 2061379749, 1640576439, 1757691577, 1474760595, 1592394909, 1174215055, 1290801793, 2875968315, 2724642869, 3111247143, 2960971305, 2405426947, 2253581325, 2638606623, 2487810577, 3808662347, 3926825029, 4044981591, 4162096729, 3342319475, 3459953789, 3576539503, 3693126241, 1986918061, 2137062819, 1685577905, 1836772287, 1381620373, 1532285339, 1078185097, 1229899655, 1040559837, 923313619, 740276417, 621982671, 439452389, 322734571, 137073913, 19308535, 3871163981, 4021308739, 4104605777, 4255800159, 3263785589, 3414450555, 3499326569, 3651041127, 2933202493, 2815956275, 3167684641, 3049390895, 2330014213, 2213296395, 2566595609, 2448830231, 1305906550, 1155237496, 1607244650, 1455525988, 1776460110, 1626319424, 2079897426, 1928707164, 96392454, 213114376, 396673818, 514443284, 562755902, 679998e3, 865136418, 983426092, 3708173718, 3557504664, 3474729866, 3323011204, 4180808110, 4030667424, 3945269170, 3794078908, 2507040230, 2623762152, 2272556026, 2390325492, 2975484382, 3092726480, 2738905026, 2857194700, 3973773121, 3856137295, 4274053469, 4157467219, 3371096953, 3252932727, 3673476453, 3556361835, 2763173681, 2915017791, 3064510765, 3215307299, 2156299017, 2307622919, 2459735317, 2610011675, 2081048481, 1963412655, 1846563261, 1729977011, 1480485785, 1362321559, 1243905413, 1126790795, 878845905, 1030690015, 645401037, 796197571, 274084841, 425408743, 38544885, 188821243, 3613494426, 3731654548, 3313212038, 3430322568, 4082475170, 4200115116, 3780097726, 3896688048, 2668221674, 2516901860, 2366882550, 2216610296, 3141400786, 2989552604, 2837966542, 2687165888, 1202797690, 1320957812, 1437280870, 1554391400, 1669664834, 1787304780, 1906247262, 2022837584, 265905162, 114585348, 499347990, 349075736, 736970802, 585122620, 972512814, 821712160, 2595684844, 2478443234, 2293045232, 2174754046, 3196267988, 3079546586, 2895723464, 2777952454, 3537852828, 3687994002, 3234156416, 3385345166, 4142626212, 4293295786, 3841024952, 3992742070, 174567692, 57326082, 410887952, 292596766, 777231668, 660510266, 1011452712, 893681702, 1108339068, 1258480242, 1343618912, 1494807662, 1715193156, 1865862730, 1948373848, 2100090966, 2701949495, 2818666809, 3004591147, 3122358053, 2235061775, 2352307457, 2535604243, 2653899549, 3915653703, 3764988233, 4219352155, 4067639125, 3444575871, 3294430577, 3746175075, 3594982253, 836553431, 953270745, 600235211, 718002117, 367585007, 484830689, 133361907, 251657213, 2041877159, 1891211689, 1806599355, 1654886325, 1568718495, 1418573201, 1335535747, 1184342925]; + function convertToInt32(bytes) { + var result = []; + for (var i2 = 0; i2 < bytes.length; i2 += 4) { + result.push( + bytes[i2] << 24 | bytes[i2 + 1] << 16 | bytes[i2 + 2] << 8 | bytes[i2 + 3] + ); + } + return result; + } + var AES = function(key) { + if (!(this instanceof AES)) { + throw Error("AES must be instanitated with `new`"); + } + Object.defineProperty(this, "key", { + value: coerceArray(key, true) + }); + this._prepare(); + }; + AES.prototype._prepare = function() { + var rounds = numberOfRounds[this.key.length]; + if (rounds == null) { + throw new Error("invalid key size (must be 16, 24 or 32 bytes)"); + } + this._Ke = []; + this._Kd = []; + for (var i2 = 0; i2 <= rounds; i2++) { + this._Ke.push([0, 0, 0, 0]); + this._Kd.push([0, 0, 0, 0]); + } + var roundKeyCount = (rounds + 1) * 4; + var KC = this.key.length / 4; + var tk = convertToInt32(this.key); + var index; + for (var i2 = 0; i2 < KC; i2++) { + index = i2 >> 2; + this._Ke[index][i2 % 4] = tk[i2]; + this._Kd[rounds - index][i2 % 4] = tk[i2]; + } + var rconpointer = 0; + var t = KC, tt; + while (t < roundKeyCount) { + tt = tk[KC - 1]; + tk[0] ^= S[tt >> 16 & 255] << 24 ^ S[tt >> 8 & 255] << 16 ^ S[tt & 255] << 8 ^ S[tt >> 24 & 255] ^ rcon[rconpointer] << 24; + rconpointer += 1; + if (KC != 8) { + for (var i2 = 1; i2 < KC; i2++) { + tk[i2] ^= tk[i2 - 1]; + } + } else { + for (var i2 = 1; i2 < KC / 2; i2++) { + tk[i2] ^= tk[i2 - 1]; + } + tt = tk[KC / 2 - 1]; + tk[KC / 2] ^= S[tt & 255] ^ S[tt >> 8 & 255] << 8 ^ S[tt >> 16 & 255] << 16 ^ S[tt >> 24 & 255] << 24; + for (var i2 = KC / 2 + 1; i2 < KC; i2++) { + tk[i2] ^= tk[i2 - 1]; + } + } + var i2 = 0, r, c; + while (i2 < KC && t < roundKeyCount) { + r = t >> 2; + c = t % 4; + this._Ke[r][c] = tk[i2]; + this._Kd[rounds - r][c] = tk[i2++]; + t++; + } + } + for (var r = 1; r < rounds; r++) { + for (var c = 0; c < 4; c++) { + tt = this._Kd[r][c]; + this._Kd[r][c] = U1[tt >> 24 & 255] ^ U2[tt >> 16 & 255] ^ U3[tt >> 8 & 255] ^ U4[tt & 255]; + } + } + }; + AES.prototype.encrypt = function(plaintext) { + if (plaintext.length != 16) { + throw new Error("invalid plaintext size (must be 16 bytes)"); + } + var rounds = this._Ke.length - 1; + var a = [0, 0, 0, 0]; + var t = convertToInt32(plaintext); + for (var i2 = 0; i2 < 4; i2++) { + t[i2] ^= this._Ke[0][i2]; + } + for (var r = 1; r < rounds; r++) { + for (var i2 = 0; i2 < 4; i2++) { + a[i2] = T1[t[i2] >> 24 & 255] ^ T2[t[(i2 + 1) % 4] >> 16 & 255] ^ T3[t[(i2 + 2) % 4] >> 8 & 255] ^ T4[t[(i2 + 3) % 4] & 255] ^ this._Ke[r][i2]; + } + t = a.slice(); + } + var result = createArray(16), tt; + for (var i2 = 0; i2 < 4; i2++) { + tt = this._Ke[rounds][i2]; + result[4 * i2] = (S[t[i2] >> 24 & 255] ^ tt >> 24) & 255; + result[4 * i2 + 1] = (S[t[(i2 + 1) % 4] >> 16 & 255] ^ tt >> 16) & 255; + result[4 * i2 + 2] = (S[t[(i2 + 2) % 4] >> 8 & 255] ^ tt >> 8) & 255; + result[4 * i2 + 3] = (S[t[(i2 + 3) % 4] & 255] ^ tt) & 255; + } + return result; + }; + AES.prototype.decrypt = function(ciphertext) { + if (ciphertext.length != 16) { + throw new Error("invalid ciphertext size (must be 16 bytes)"); + } + var rounds = this._Kd.length - 1; + var a = [0, 0, 0, 0]; + var t = convertToInt32(ciphertext); + for (var i2 = 0; i2 < 4; i2++) { + t[i2] ^= this._Kd[0][i2]; + } + for (var r = 1; r < rounds; r++) { + for (var i2 = 0; i2 < 4; i2++) { + a[i2] = T5[t[i2] >> 24 & 255] ^ T6[t[(i2 + 3) % 4] >> 16 & 255] ^ T7[t[(i2 + 2) % 4] >> 8 & 255] ^ T8[t[(i2 + 1) % 4] & 255] ^ this._Kd[r][i2]; + } + t = a.slice(); + } + var result = createArray(16), tt; + for (var i2 = 0; i2 < 4; i2++) { + tt = this._Kd[rounds][i2]; + result[4 * i2] = (Si[t[i2] >> 24 & 255] ^ tt >> 24) & 255; + result[4 * i2 + 1] = (Si[t[(i2 + 3) % 4] >> 16 & 255] ^ tt >> 16) & 255; + result[4 * i2 + 2] = (Si[t[(i2 + 2) % 4] >> 8 & 255] ^ tt >> 8) & 255; + result[4 * i2 + 3] = (Si[t[(i2 + 1) % 4] & 255] ^ tt) & 255; + } + return result; + }; + var ModeOfOperationECB = function(key) { + if (!(this instanceof ModeOfOperationECB)) { + throw Error("AES must be instanitated with `new`"); + } + this.description = "Electronic Code Block"; + this.name = "ecb"; + this._aes = new AES(key); + }; + ModeOfOperationECB.prototype.encrypt = function(plaintext) { + plaintext = coerceArray(plaintext); + if (plaintext.length % 16 !== 0) { + throw new Error("invalid plaintext size (must be multiple of 16 bytes)"); + } + var ciphertext = createArray(plaintext.length); + var block2 = createArray(16); + for (var i2 = 0; i2 < plaintext.length; i2 += 16) { + copyArray(plaintext, block2, 0, i2, i2 + 16); + block2 = this._aes.encrypt(block2); + copyArray(block2, ciphertext, i2); + } + return ciphertext; + }; + ModeOfOperationECB.prototype.decrypt = function(ciphertext) { + ciphertext = coerceArray(ciphertext); + if (ciphertext.length % 16 !== 0) { + throw new Error("invalid ciphertext size (must be multiple of 16 bytes)"); + } + var plaintext = createArray(ciphertext.length); + var block2 = createArray(16); + for (var i2 = 0; i2 < ciphertext.length; i2 += 16) { + copyArray(ciphertext, block2, 0, i2, i2 + 16); + block2 = this._aes.decrypt(block2); + copyArray(block2, plaintext, i2); + } + return plaintext; + }; + var ModeOfOperationCBC = function(key, iv) { + if (!(this instanceof ModeOfOperationCBC)) { + throw Error("AES must be instanitated with `new`"); + } + this.description = "Cipher Block Chaining"; + this.name = "cbc"; + if (!iv) { + iv = createArray(16); + } else if (iv.length != 16) { + throw new Error("invalid initialation vector size (must be 16 bytes)"); + } + this._lastCipherblock = coerceArray(iv, true); + this._aes = new AES(key); + }; + ModeOfOperationCBC.prototype.encrypt = function(plaintext) { + plaintext = coerceArray(plaintext); + if (plaintext.length % 16 !== 0) { + throw new Error("invalid plaintext size (must be multiple of 16 bytes)"); + } + var ciphertext = createArray(plaintext.length); + var block2 = createArray(16); + for (var i2 = 0; i2 < plaintext.length; i2 += 16) { + copyArray(plaintext, block2, 0, i2, i2 + 16); + for (var j2 = 0; j2 < 16; j2++) { + block2[j2] ^= this._lastCipherblock[j2]; + } + this._lastCipherblock = this._aes.encrypt(block2); + copyArray(this._lastCipherblock, ciphertext, i2); + } + return ciphertext; + }; + ModeOfOperationCBC.prototype.decrypt = function(ciphertext) { + ciphertext = coerceArray(ciphertext); + if (ciphertext.length % 16 !== 0) { + throw new Error("invalid ciphertext size (must be multiple of 16 bytes)"); + } + var plaintext = createArray(ciphertext.length); + var block2 = createArray(16); + for (var i2 = 0; i2 < ciphertext.length; i2 += 16) { + copyArray(ciphertext, block2, 0, i2, i2 + 16); + block2 = this._aes.decrypt(block2); + for (var j2 = 0; j2 < 16; j2++) { + plaintext[i2 + j2] = block2[j2] ^ this._lastCipherblock[j2]; + } + copyArray(ciphertext, this._lastCipherblock, 0, i2, i2 + 16); + } + return plaintext; + }; + var ModeOfOperationCFB = function(key, iv, segmentSize) { + if (!(this instanceof ModeOfOperationCFB)) { + throw Error("AES must be instanitated with `new`"); + } + this.description = "Cipher Feedback"; + this.name = "cfb"; + if (!iv) { + iv = createArray(16); + } else if (iv.length != 16) { + throw new Error("invalid initialation vector size (must be 16 size)"); + } + if (!segmentSize) { + segmentSize = 1; + } + this.segmentSize = segmentSize; + this._shiftRegister = coerceArray(iv, true); + this._aes = new AES(key); + }; + ModeOfOperationCFB.prototype.encrypt = function(plaintext) { + if (plaintext.length % this.segmentSize != 0) { + throw new Error("invalid plaintext size (must be segmentSize bytes)"); + } + var encrypted = coerceArray(plaintext, true); + var xorSegment; + for (var i2 = 0; i2 < encrypted.length; i2 += this.segmentSize) { + xorSegment = this._aes.encrypt(this._shiftRegister); + for (var j2 = 0; j2 < this.segmentSize; j2++) { + encrypted[i2 + j2] ^= xorSegment[j2]; + } + copyArray(this._shiftRegister, this._shiftRegister, 0, this.segmentSize); + copyArray(encrypted, this._shiftRegister, 16 - this.segmentSize, i2, i2 + this.segmentSize); + } + return encrypted; + }; + ModeOfOperationCFB.prototype.decrypt = function(ciphertext) { + if (ciphertext.length % this.segmentSize != 0) { + throw new Error("invalid ciphertext size (must be segmentSize bytes)"); + } + var plaintext = coerceArray(ciphertext, true); + var xorSegment; + for (var i2 = 0; i2 < plaintext.length; i2 += this.segmentSize) { + xorSegment = this._aes.encrypt(this._shiftRegister); + for (var j2 = 0; j2 < this.segmentSize; j2++) { + plaintext[i2 + j2] ^= xorSegment[j2]; + } + copyArray(this._shiftRegister, this._shiftRegister, 0, this.segmentSize); + copyArray(ciphertext, this._shiftRegister, 16 - this.segmentSize, i2, i2 + this.segmentSize); + } + return plaintext; + }; + var ModeOfOperationOFB = function(key, iv) { + if (!(this instanceof ModeOfOperationOFB)) { + throw Error("AES must be instanitated with `new`"); + } + this.description = "Output Feedback"; + this.name = "ofb"; + if (!iv) { + iv = createArray(16); + } else if (iv.length != 16) { + throw new Error("invalid initialation vector size (must be 16 bytes)"); + } + this._lastPrecipher = coerceArray(iv, true); + this._lastPrecipherIndex = 16; + this._aes = new AES(key); + }; + ModeOfOperationOFB.prototype.encrypt = function(plaintext) { + var encrypted = coerceArray(plaintext, true); + for (var i2 = 0; i2 < encrypted.length; i2++) { + if (this._lastPrecipherIndex === 16) { + this._lastPrecipher = this._aes.encrypt(this._lastPrecipher); + this._lastPrecipherIndex = 0; + } + encrypted[i2] ^= this._lastPrecipher[this._lastPrecipherIndex++]; + } + return encrypted; + }; + ModeOfOperationOFB.prototype.decrypt = ModeOfOperationOFB.prototype.encrypt; + var Counter = function(initialValue) { + if (!(this instanceof Counter)) { + throw Error("Counter must be instanitated with `new`"); + } + if (initialValue !== 0 && !initialValue) { + initialValue = 1; + } + if (typeof initialValue === "number") { + this._counter = createArray(16); + this.setValue(initialValue); + } else { + this.setBytes(initialValue); + } + }; + Counter.prototype.setValue = function(value) { + if (typeof value !== "number" || parseInt(value) != value) { + throw new Error("invalid counter value (must be an integer)"); + } + if (value > Number.MAX_SAFE_INTEGER) { + throw new Error("integer value out of safe range"); + } + for (var index = 15; index >= 0; --index) { + this._counter[index] = value % 256; + value = parseInt(value / 256); + } + }; + Counter.prototype.setBytes = function(bytes) { + bytes = coerceArray(bytes, true); + if (bytes.length != 16) { + throw new Error("invalid counter bytes size (must be 16 bytes)"); + } + this._counter = bytes; + }; + Counter.prototype.increment = function() { + for (var i2 = 15; i2 >= 0; i2--) { + if (this._counter[i2] === 255) { + this._counter[i2] = 0; + } else { + this._counter[i2]++; + break; + } + } + }; + var ModeOfOperationCTR = function(key, counter) { + if (!(this instanceof ModeOfOperationCTR)) { + throw Error("AES must be instanitated with `new`"); + } + this.description = "Counter"; + this.name = "ctr"; + if (!(counter instanceof Counter)) { + counter = new Counter(counter); + } + this._counter = counter; + this._remainingCounter = null; + this._remainingCounterIndex = 16; + this._aes = new AES(key); + }; + ModeOfOperationCTR.prototype.encrypt = function(plaintext) { + var encrypted = coerceArray(plaintext, true); + for (var i2 = 0; i2 < encrypted.length; i2++) { + if (this._remainingCounterIndex === 16) { + this._remainingCounter = this._aes.encrypt(this._counter._counter); + this._remainingCounterIndex = 0; + this._counter.increment(); + } + encrypted[i2] ^= this._remainingCounter[this._remainingCounterIndex++]; + } + return encrypted; + }; + ModeOfOperationCTR.prototype.decrypt = ModeOfOperationCTR.prototype.encrypt; + function pkcs7pad(data) { + data = coerceArray(data, true); + var padder = 16 - data.length % 16; + var result = createArray(data.length + padder); + copyArray(data, result); + for (var i2 = data.length; i2 < result.length; i2++) { + result[i2] = padder; + } + return result; + } + function pkcs7strip(data) { + data = coerceArray(data, true); + if (data.length < 16) { + throw new Error("PKCS#7 invalid length"); + } + var padder = data[data.length - 1]; + if (padder > 16) { + throw new Error("PKCS#7 padding byte out of range"); + } + var length = data.length - padder; + for (var i2 = 0; i2 < padder; i2++) { + if (data[length + i2] !== padder) { + throw new Error("PKCS#7 invalid padding byte"); + } + } + var result = createArray(length); + copyArray(data, result, 0, 0, length); + return result; + } + var aesjs2 = { + AES, + Counter, + ModeOfOperation: { + ecb: ModeOfOperationECB, + cbc: ModeOfOperationCBC, + cfb: ModeOfOperationCFB, + ofb: ModeOfOperationOFB, + ctr: ModeOfOperationCTR + }, + utils: { + hex: convertHex, + utf8: convertUtf8 + }, + padding: { + pkcs7: { + pad: pkcs7pad, + strip: pkcs7strip + } + }, + _arrayTest: { + coerceArray, + createArray, + copyArray + } + }; + if (typeof exports2 !== "undefined") { + module2.exports = aesjs2; + } else if (typeof define === "function" && define.amd) { + define([], function() { + return aesjs2; + }); + } else { + if (root3.aesjs) { + aesjs2._aesjs = root3.aesjs; + } + root3.aesjs = aesjs2; + } + })(exports2); } - }; - - function point(x, y) { - buffer.push("M", x, ",", y, pointCircle); - } - - function pointLineStart(x, y) { - buffer.push("M", x, ",", y); - stream.point = pointLine; - } - - function pointLine(x, y) { - buffer.push("L", x, ",", y); - } - - function lineEnd() { - stream.point = point; - } - - function lineEndPolygon() { - buffer.push("Z"); - } - - return stream; -} - -// TODO Unify this code with d3.geom.polygon centroid? -// TODO Enforce positive area for exterior, negative area for interior? - -var d3_geo_pathCentroid = { - point: d3_geo_pathCentroidPoint, - - // For lines, weight by length. - lineStart: d3_geo_pathCentroidLineStart, - lineEnd: d3_geo_pathCentroidLineEnd, - - // For polygons, weight by area. - polygonStart: function() { - d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart; - }, - polygonEnd: function() { - d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint; - d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart; - d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd; - } -}; - -function d3_geo_pathCentroidPoint(x, y) { - if (d3_geo_centroidDimension) return; - d3_geo_centroidX += x; - d3_geo_centroidY += y; - ++d3_geo_centroidZ; -} - -function d3_geo_pathCentroidLineStart() { - var x0, y0; - - if (d3_geo_centroidDimension !== 1) { - if (d3_geo_centroidDimension < 1) { - d3_geo_centroidDimension = 1; - d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0; - } else return; - } - - d3_geo_pathCentroid.point = function(x, y) { - d3_geo_pathCentroid.point = nextPoint; - x0 = x, y0 = y; - }; - - function nextPoint(x, y) { - var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy); - d3_geo_centroidX += z * (x0 + x) / 2; - d3_geo_centroidY += z * (y0 + y) / 2; - d3_geo_centroidZ += z; - x0 = x, y0 = y; - } -} - -function d3_geo_pathCentroidLineEnd() { - d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint; -} - -function d3_geo_pathCentroidRingStart() { - var x00, y00, x0, y0; - - if (d3_geo_centroidDimension < 2) { - d3_geo_centroidDimension = 2; - d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0; - } - - // For the first point, … - d3_geo_pathCentroid.point = function(x, y) { - d3_geo_pathCentroid.point = nextPoint; - x00 = x0 = x, y00 = y0 = y; - }; - - // For subsequent points, … - function nextPoint(x, y) { - var z = y0 * x - x0 * y; - d3_geo_centroidX += z * (x0 + x); - d3_geo_centroidY += z * (y0 + y); - d3_geo_centroidZ += z * 3; - x0 = x, y0 = y; - } - - // For the last point, return to the start. - d3_geo_pathCentroid.lineEnd = function() { - nextPoint(x00, y00); - }; -} - -function d3_geo_pathContext(context) { - var pointRadius = 4.5; - - var stream = { - point: point, + }); - // While inside a line, override point to moveTo then lineTo. - lineStart: function() { stream.point = pointLineStart; }, - lineEnd: lineEnd, - - // While inside a polygon, override lineEnd to closePath. - polygonStart: function() { stream.lineEnd = lineEndPolygon; }, - polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; }, - - pointRadius: function(_) { - pointRadius = _; - return stream; - }, - - result: d3_noop - }; - - function point(x, y) { - context.moveTo(x, y); - context.arc(x, y, pointRadius, 0, 2 * π); - } - - function pointLineStart(x, y) { - context.moveTo(x, y); - stream.point = pointLine; - } - - function pointLine(x, y) { - context.lineTo(x, y); - } - - function lineEnd() { - stream.point = point; - } - - function lineEndPolygon() { - context.closePath(); - } - - return stream; -} - -d3.geo.path = function() { - var pointRadius = 4.5, - projection, - context, - projectStream, - contextStream; - - function path(object) { - if (object) d3.geo.stream(object, projectStream( - contextStream.pointRadius(typeof pointRadius === "function" - ? +pointRadius.apply(this, arguments) - : pointRadius))); - return contextStream.result(); - } - - path.area = function(object) { - d3_geo_pathAreaSum = 0; - d3.geo.stream(object, projectStream(d3_geo_pathArea)); - return d3_geo_pathAreaSum; - }; - - path.centroid = function(object) { - d3_geo_centroidDimension = d3_geo_centroidX = d3_geo_centroidY = d3_geo_centroidZ = 0; - d3.geo.stream(object, projectStream(d3_geo_pathCentroid)); - return d3_geo_centroidZ ? [d3_geo_centroidX / d3_geo_centroidZ, d3_geo_centroidY / d3_geo_centroidZ] : undefined; - }; - - path.bounds = function(object) { - return d3_geo_bounds(projectStream)(object); - }; - - path.projection = function(_) { - if (!arguments.length) return projection; - projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity; - return path; - }; - - path.context = function(_) { - if (!arguments.length) return context; - contextStream = (context = _) == null ? new d3_geo_pathBuffer : new d3_geo_pathContext(_); - return path; - }; - - path.pointRadius = function(_) { - if (!arguments.length) return pointRadius; - pointRadius = typeof _ === "function" ? _ : +_; - return path; - }; - - return path.projection(d3.geo.albersUsa()).context(null); -}; - -function d3_geo_pathCircle(radius) { - return "m0," + radius - + "a" + radius + "," + radius + " 0 1,1 0," + (-2 * radius) - + "a" + radius + "," + radius + " 0 1,1 0," + (+2 * radius) - + "z"; -} - -function d3_geo_pathProjectStream(project) { - var resample = d3_geo_resample(function(λ, φ) { return project([λ * d3_degrees, φ * d3_degrees]); }); - return function(stream) { - stream = resample(stream); - return { - point: function(λ, φ) { stream.point(λ * d3_radians, φ * d3_radians); }, - sphere: function() { stream.sphere(); }, - lineStart: function() { stream.lineStart(); }, - lineEnd: function() { stream.lineEnd(); }, - polygonStart: function() { stream.polygonStart(); }, - polygonEnd: function() { stream.polygonEnd(); } - }; - }; -} -d3.geom = {}; - -d3.geom.polygon = function(coordinates) { - - coordinates.area = function() { - var i = 0, - n = coordinates.length, - area = coordinates[n - 1][1] * coordinates[0][0] - coordinates[n - 1][0] * coordinates[0][1]; - while (++i < n) { - area += coordinates[i - 1][1] * coordinates[i][0] - coordinates[i - 1][0] * coordinates[i][1]; - } - return area * .5; - }; - - coordinates.centroid = function(k) { - var i = -1, - n = coordinates.length, - x = 0, - y = 0, - a, - b = coordinates[n - 1], - c; - if (!arguments.length) k = -1 / (6 * coordinates.area()); - while (++i < n) { - a = b; - b = coordinates[i]; - c = a[0] * b[1] - b[0] * a[1]; - x += (a[0] + b[0]) * c; - y += (a[1] + b[1]) * c; - } - return [x * k, y * k]; - }; - - // The Sutherland-Hodgman clipping algorithm. - // Note: requires the clip polygon to be counterclockwise and convex. - coordinates.clip = function(subject) { - var input, - i = -1, - n = coordinates.length, - j, - m, - a = coordinates[n - 1], - b, - c, - d; - while (++i < n) { - input = subject.slice(); - subject.length = 0; - b = coordinates[i]; - c = input[(m = input.length) - 1]; - j = -1; - while (++j < m) { - d = input[j]; - if (d3_geom_polygonInside(d, a, b)) { - if (!d3_geom_polygonInside(c, a, b)) { - subject.push(d3_geom_polygonIntersect(c, d, a, b)); - } - subject.push(d); - } else if (d3_geom_polygonInside(c, a, b)) { - subject.push(d3_geom_polygonIntersect(c, d, a, b)); - } - c = d; - } - a = b; - } - return subject; - }; - - return coordinates; -}; - -function d3_geom_polygonInside(p, a, b) { - return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]); -} - -// Intersect two infinite lines cd and ab. -function d3_geom_polygonIntersect(c, d, a, b) { - var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3, - y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3, - ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21); - return [x1 + ua * x21, y1 + ua * y21]; -} - -var d3_ease_default = function() { return d3_identity; }; - -var d3_ease = d3.map({ - linear: d3_ease_default, - poly: d3_ease_poly, - quad: function() { return d3_ease_quad; }, - cubic: function() { return d3_ease_cubic; }, - sin: function() { return d3_ease_sin; }, - exp: function() { return d3_ease_exp; }, - circle: function() { return d3_ease_circle; }, - elastic: d3_ease_elastic, - back: d3_ease_back, - bounce: function() { return d3_ease_bounce; } -}); - -var d3_ease_mode = d3.map({ - "in": d3_identity, - "out": d3_ease_reverse, - "in-out": d3_ease_reflect, - "out-in": function(f) { return d3_ease_reflect(d3_ease_reverse(f)); } -}); - -d3.ease = function(name) { - var i = name.indexOf("-"), - t = i >= 0 ? name.substring(0, i) : name, - m = i >= 0 ? name.substring(i + 1) : "in"; - t = d3_ease.get(t) || d3_ease_default; - m = d3_ease_mode.get(m) || d3_identity; - return d3_ease_clamp(m(t.apply(null, Array.prototype.slice.call(arguments, 1)))); -}; - -function d3_ease_clamp(f) { - return function(t) { - return t <= 0 ? 0 : t >= 1 ? 1 : f(t); - }; -} - -function d3_ease_reverse(f) { - return function(t) { - return 1 - f(1 - t); - }; -} - -function d3_ease_reflect(f) { - return function(t) { - return .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t))); - }; -} - -function d3_ease_quad(t) { - return t * t; -} - -function d3_ease_cubic(t) { - return t * t * t; -} - -// Optimized clamp(reflect(poly(3))). -function d3_ease_cubicInOut(t) { - if (t <= 0) return 0; - if (t >= 1) return 1; - var t2 = t * t, t3 = t2 * t; - return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75); -} - -function d3_ease_poly(e) { - return function(t) { - return Math.pow(t, e); - }; -} - -function d3_ease_sin(t) { - return 1 - Math.cos(t * π / 2); -} - -function d3_ease_exp(t) { - return Math.pow(2, 10 * (t - 1)); -} - -function d3_ease_circle(t) { - return 1 - Math.sqrt(1 - t * t); -} - -function d3_ease_elastic(a, p) { - var s; - if (arguments.length < 2) p = 0.45; - if (arguments.length) s = p / (2 * π) * Math.asin(1 / a); - else a = 1, s = p / 4; - return function(t) { - return 1 + a * Math.pow(2, 10 * -t) * Math.sin((t - s) * 2 * π / p); - }; -} - -function d3_ease_back(s) { - if (!s) s = 1.70158; - return function(t) { - return t * t * ((s + 1) * t - s); - }; -} - -function d3_ease_bounce(t) { - return t < 1 / 2.75 ? 7.5625 * t * t - : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 - : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 - : 7.5625 * (t -= 2.625 / 2.75) * t + .984375; -} - -function d3_transition(groups, id) { - d3_arraySubclass(groups, d3_transitionPrototype); - - groups.id = id; // Note: read-only! - - return groups; -} - -var d3_transitionPrototype = [], - d3_transitionId = 0, - d3_transitionInheritId, - d3_transitionInherit = {ease: d3_ease_cubicInOut, delay: 0, duration: 250}; - -d3_transitionPrototype.call = d3_selectionPrototype.call; -d3_transitionPrototype.empty = d3_selectionPrototype.empty; -d3_transitionPrototype.node = d3_selectionPrototype.node; - -d3.transition = function(selection) { - return arguments.length - ? (d3_transitionInheritId ? selection.transition() : selection) - : d3_selectionRoot.transition(); -}; - -d3.transition.prototype = d3_transitionPrototype; - - -d3_transitionPrototype.select = function(selector) { - var id = this.id, - subgroups = [], - subgroup, - subnode, - node; - - if (typeof selector !== "function") selector = d3_selection_selector(selector); - - for (var j = -1, m = this.length; ++j < m;) { - subgroups.push(subgroup = []); - for (var group = this[j], i = -1, n = group.length; ++i < n;) { - if ((node = group[i]) && (subnode = selector.call(node, node.__data__, i))) { - if ("__data__" in node) subnode.__data__ = node.__data__; - d3_transitionNode(subnode, i, id, node.__transition__[id]); - subgroup.push(subnode); - } else { - subgroup.push(null); - } - } - } - - return d3_transition(subgroups, id); -}; - -d3_transitionPrototype.selectAll = function(selector) { - var id = this.id, - subgroups = [], - subgroup, - subnodes, - node, - subnode, - transition; - - if (typeof selector !== "function") selector = d3_selection_selectorAll(selector); - - for (var j = -1, m = this.length; ++j < m;) { - for (var group = this[j], i = -1, n = group.length; ++i < n;) { - if (node = group[i]) { - transition = node.__transition__[id]; - subnodes = selector.call(node, node.__data__, i); - subgroups.push(subgroup = []); - for (var k = -1, o = subnodes.length; ++k < o;) { - d3_transitionNode(subnode = subnodes[k], k, id, transition); - subgroup.push(subnode); + // node_modules/lodash/lodash.js + var require_lodash = __commonJS({ + "node_modules/lodash/lodash.js"(exports2, module2) { + (function() { + var undefined2; + var VERSION = "4.17.21"; + var LARGE_ARRAY_SIZE2 = 200; + var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT3 = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`"; + var HASH_UNDEFINED4 = "__lodash_hash_undefined__"; + var MAX_MEMOIZE_SIZE = 500; + var PLACEHOLDER = "__lodash_placeholder__"; + var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4; + var COMPARE_PARTIAL_FLAG5 = 1, COMPARE_UNORDERED_FLAG3 = 2; + 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; + var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = "..."; + var HOT_COUNT = 800, HOT_SPAN = 16; + var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2, LAZY_WHILE_FLAG = 3; + var INFINITY2 = 1 / 0, MAX_SAFE_INTEGER3 = 9007199254740991, MAX_INTEGER = 17976931348623157e292, NAN2 = 0 / 0; + var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; + 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] + ]; + var argsTag4 = "[object Arguments]", arrayTag3 = "[object Array]", asyncTag2 = "[object AsyncFunction]", boolTag3 = "[object Boolean]", dateTag3 = "[object Date]", domExcTag = "[object DOMException]", errorTag3 = "[object Error]", funcTag3 = "[object Function]", genTag2 = "[object GeneratorFunction]", mapTag4 = "[object Map]", numberTag3 = "[object Number]", nullTag2 = "[object Null]", objectTag4 = "[object Object]", promiseTag2 = "[object Promise]", proxyTag2 = "[object Proxy]", regexpTag3 = "[object RegExp]", setTag4 = "[object Set]", stringTag3 = "[object String]", symbolTag3 = "[object Symbol]", undefinedTag2 = "[object Undefined]", weakMapTag3 = "[object WeakMap]", weakSetTag = "[object WeakSet]"; + var arrayBufferTag3 = "[object ArrayBuffer]", dataViewTag4 = "[object DataView]", float32Tag2 = "[object Float32Array]", float64Tag2 = "[object Float64Array]", int8Tag2 = "[object Int8Array]", int16Tag2 = "[object Int16Array]", int32Tag2 = "[object Int32Array]", uint8Tag2 = "[object Uint8Array]", uint8ClampedTag2 = "[object Uint8ClampedArray]", uint16Tag2 = "[object Uint16Array]", uint32Tag2 = "[object Uint32Array]"; + var reEmptyStringLeading = /\b__p \+= '';/g, reEmptyStringMiddle = /\b(__p \+=) '' \+/g, reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; + var reEscapedHtml2 = /&(?:amp|lt|gt|quot|#39);/g, reUnescapedHtml2 = /[&<>"']/g, reHasEscapedHtml2 = RegExp(reEscapedHtml2.source), reHasUnescapedHtml2 = RegExp(reUnescapedHtml2.source); + var reEscape = /<%-([\s\S]+?)%>/g, reEvaluate = /<%([\s\S]+?)%>/g, reInterpolate = /<%=([\s\S]+?)%>/g; + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + var reRegExpChar2 = /[\\^$.*+?()[\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar2.source); + var reTrimStart2 = /^\s+/; + var reWhitespace2 = /\s/; + var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, reSplitDetails = /,? & /; + var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/; + var reEscapeChar = /\\(\\)?/g; + var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; + var reFlags = /\w*$/; + var reIsBadHex2 = /^[-+]0x[0-9a-f]+$/i; + var reIsBinary2 = /^0b[01]+$/i; + var reIsHostCtor2 = /^\[object .+?Constructor\]$/; + var reIsOctal2 = /^0o[0-7]+$/i; + var reIsUint2 = /^(?:0|[1-9]\d*)$/; + var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + var reNoMatch = /($^)/; + var reUnescapedString = /['\n\r\u2028\u2029\\]/g; + 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; + 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"; + 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("|") + ")"; + var reApos = RegExp(rsApos, "g"); + var reComboMark = RegExp(rsCombo, "g"); + var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g"); + 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"); + var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]"); + 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 ]/; + 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" + ]; + var templateCounter = -1; + var typedArrayTags2 = {}; + typedArrayTags2[float32Tag2] = typedArrayTags2[float64Tag2] = typedArrayTags2[int8Tag2] = typedArrayTags2[int16Tag2] = typedArrayTags2[int32Tag2] = typedArrayTags2[uint8Tag2] = typedArrayTags2[uint8ClampedTag2] = typedArrayTags2[uint16Tag2] = typedArrayTags2[uint32Tag2] = true; + typedArrayTags2[argsTag4] = typedArrayTags2[arrayTag3] = typedArrayTags2[arrayBufferTag3] = typedArrayTags2[boolTag3] = typedArrayTags2[dataViewTag4] = typedArrayTags2[dateTag3] = typedArrayTags2[errorTag3] = typedArrayTags2[funcTag3] = typedArrayTags2[mapTag4] = typedArrayTags2[numberTag3] = typedArrayTags2[objectTag4] = typedArrayTags2[regexpTag3] = typedArrayTags2[setTag4] = typedArrayTags2[stringTag3] = typedArrayTags2[weakMapTag3] = false; + var cloneableTags = {}; + cloneableTags[argsTag4] = cloneableTags[arrayTag3] = cloneableTags[arrayBufferTag3] = cloneableTags[dataViewTag4] = cloneableTags[boolTag3] = cloneableTags[dateTag3] = cloneableTags[float32Tag2] = cloneableTags[float64Tag2] = cloneableTags[int8Tag2] = cloneableTags[int16Tag2] = cloneableTags[int32Tag2] = cloneableTags[mapTag4] = cloneableTags[numberTag3] = cloneableTags[objectTag4] = cloneableTags[regexpTag3] = cloneableTags[setTag4] = cloneableTags[stringTag3] = cloneableTags[symbolTag3] = cloneableTags[uint8Tag2] = cloneableTags[uint8ClampedTag2] = cloneableTags[uint16Tag2] = cloneableTags[uint32Tag2] = true; + cloneableTags[errorTag3] = cloneableTags[funcTag3] = cloneableTags[weakMapTag3] = false; + 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" + }; + var htmlEscapes2 = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'" + }; + var htmlUnescapes2 = { + "&": "&", + "<": "<", + ">": ">", + """: '"', + "'": "'" + }; + var stringEscapes = { + "\\": "\\", + "'": "'", + "\n": "n", + "\r": "r", + "\u2028": "u2028", + "\u2029": "u2029" + }; + var freeParseFloat = parseFloat, freeParseInt2 = parseInt; + var freeGlobal2 = typeof global == "object" && global && global.Object === Object && global; + var freeSelf2 = typeof self == "object" && self && self.Object === Object && self; + var root3 = freeGlobal2 || freeSelf2 || Function("return this")(); + var freeExports3 = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2; + var freeModule3 = freeExports3 && typeof module2 == "object" && module2 && !module2.nodeType && module2; + var moduleExports3 = freeModule3 && freeModule3.exports === freeExports3; + var freeProcess2 = moduleExports3 && freeGlobal2.process; + var nodeUtil2 = function() { + try { + var types = freeModule3 && freeModule3.require && freeModule3.require("util").types; + if (types) { + return types; + } + return freeProcess2 && freeProcess2.binding && freeProcess2.binding("util"); + } catch (e) { + } + }(); + var nodeIsArrayBuffer = nodeUtil2 && nodeUtil2.isArrayBuffer, nodeIsDate = nodeUtil2 && nodeUtil2.isDate, nodeIsMap = nodeUtil2 && nodeUtil2.isMap, nodeIsRegExp = nodeUtil2 && nodeUtil2.isRegExp, nodeIsSet = nodeUtil2 && nodeUtil2.isSet, nodeIsTypedArray2 = nodeUtil2 && nodeUtil2.isTypedArray; + 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); } - } - } - } - - return d3_transition(subgroups, id); -}; - -d3_transitionPrototype.filter = function(filter) { - var subgroups = [], - subgroup, - group, - node; - - if (typeof filter !== "function") filter = d3_selection_filter(filter); - - for (var j = 0, m = this.length; j < m; j++) { - subgroups.push(subgroup = []); - for (var group = this[j], i = 0, n = group.length; i < n; i++) { - if ((node = group[i]) && filter.call(node, node.__data__, i)) { - subgroup.push(node); - } - } - } - - return d3_transition(subgroups, this.id, this.time).ease(this.ease()); -}; -function d3_Color() {} - -d3_Color.prototype.toString = function() { - return this.rgb() + ""; -}; - -d3.hsl = function(h, s, l) { - return arguments.length === 1 - ? (h instanceof d3_Hsl ? d3_hsl(h.h, h.s, h.l) - : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl)) - : d3_hsl(+h, +s, +l); -}; - -function d3_hsl(h, s, l) { - return new d3_Hsl(h, s, l); -} - -function d3_Hsl(h, s, l) { - this.h = h; - this.s = s; - this.l = l; -} - -var d3_hslPrototype = d3_Hsl.prototype = new d3_Color; - -d3_hslPrototype.brighter = function(k) { - k = Math.pow(0.7, arguments.length ? k : 1); - return d3_hsl(this.h, this.s, this.l / k); -}; - -d3_hslPrototype.darker = function(k) { - k = Math.pow(0.7, arguments.length ? k : 1); - return d3_hsl(this.h, this.s, k * this.l); -}; - -d3_hslPrototype.rgb = function() { - return d3_hsl_rgb(this.h, this.s, this.l); -}; - -function d3_hsl_rgb(h, s, l) { - var m1, - m2; - - /* Some simple corrections for h, s and l. */ - h = h % 360; if (h < 0) h += 360; - s = s < 0 ? 0 : s > 1 ? 1 : s; - l = l < 0 ? 0 : l > 1 ? 1 : l; - - /* From FvD 13.37, CSS Color Module Level 3 */ - m2 = l <= .5 ? l * (1 + s) : l + s - l * s; - m1 = 2 * l - m2; - - function v(h) { - if (h > 360) h -= 360; - else if (h < 0) h += 360; - if (h < 60) return m1 + (m2 - m1) * h / 60; - if (h < 180) return m2; - if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60; - return m1; - } - - function vv(h) { - return Math.round(v(h) * 255); - } - - return d3_rgb(vv(h + 120), vv(h), vv(h - 120)); -} - -d3.hcl = function(h, c, l) { - return arguments.length === 1 - ? (h instanceof d3_Hcl ? d3_hcl(h.h, h.c, h.l) - : (h instanceof d3_Lab ? d3_lab_hcl(h.l, h.a, h.b) - : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b))) - : d3_hcl(+h, +c, +l); -}; - -function d3_hcl(h, c, l) { - return new d3_Hcl(h, c, l); -} - -function d3_Hcl(h, c, l) { - this.h = h; - this.c = c; - this.l = l; -} - -var d3_hclPrototype = d3_Hcl.prototype = new d3_Color; - -d3_hclPrototype.brighter = function(k) { - return d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1))); -}; - -d3_hclPrototype.darker = function(k) { - return d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1))); -}; - -d3_hclPrototype.rgb = function() { - return d3_hcl_lab(this.h, this.c, this.l).rgb(); -}; - -function d3_hcl_lab(h, c, l) { - return d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c); -} - -d3.lab = function(l, a, b) { - return arguments.length === 1 - ? (l instanceof d3_Lab ? d3_lab(l.l, l.a, l.b) - : (l instanceof d3_Hcl ? d3_hcl_lab(l.l, l.c, l.h) - : d3_rgb_lab((l = d3.rgb(l)).r, l.g, l.b))) - : d3_lab(+l, +a, +b); -}; - -function d3_lab(l, a, b) { - return new d3_Lab(l, a, b); -} - -function d3_Lab(l, a, b) { - this.l = l; - this.a = a; - this.b = b; -} - -// Corresponds roughly to RGB brighter/darker -var d3_lab_K = 18; - -// D65 standard referent -var d3_lab_X = 0.950470, - d3_lab_Y = 1, - d3_lab_Z = 1.088830; - -var d3_labPrototype = d3_Lab.prototype = new d3_Color; - -d3_labPrototype.brighter = function(k) { - return d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b); -}; - -d3_labPrototype.darker = function(k) { - return d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b); -}; - -d3_labPrototype.rgb = function() { - return d3_lab_rgb(this.l, this.a, this.b); -}; - -function d3_lab_rgb(l, a, b) { - var y = (l + 16) / 116, - x = y + a / 500, - z = y - b / 200; - x = d3_lab_xyz(x) * d3_lab_X; - y = d3_lab_xyz(y) * d3_lab_Y; - z = d3_lab_xyz(z) * d3_lab_Z; - return d3_rgb( - d3_xyz_rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), - d3_xyz_rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z), - d3_xyz_rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z) - ); -} - -function d3_lab_hcl(l, a, b) { - return d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l); -} - -function d3_lab_xyz(x) { - return x > 0.206893034 ? x * x * x : (x - 4 / 29) / 7.787037; -} -function d3_xyz_lab(x) { - return x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29; -} - -function d3_xyz_rgb(r) { - return Math.round(255 * (r <= 0.00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - 0.055)); -} - -d3.rgb = function(r, g, b) { - return arguments.length === 1 - ? (r instanceof d3_Rgb ? d3_rgb(r.r, r.g, r.b) - : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb)) - : d3_rgb(~~r, ~~g, ~~b); -}; - -function d3_rgb(r, g, b) { - return new d3_Rgb(r, g, b); -} - -function d3_Rgb(r, g, b) { - this.r = r; - this.g = g; - this.b = b; -} - -var d3_rgbPrototype = d3_Rgb.prototype = new d3_Color; - -d3_rgbPrototype.brighter = function(k) { - k = Math.pow(0.7, arguments.length ? k : 1); - var r = this.r, - g = this.g, - b = this.b, - i = 30; - if (!r && !g && !b) return d3_rgb(i, i, i); - if (r && r < i) r = i; - if (g && g < i) g = i; - if (b && b < i) b = i; - return d3_rgb( - Math.min(255, Math.floor(r / k)), - Math.min(255, Math.floor(g / k)), - Math.min(255, Math.floor(b / k))); -}; - -d3_rgbPrototype.darker = function(k) { - k = Math.pow(0.7, arguments.length ? k : 1); - return d3_rgb( - Math.floor(k * this.r), - Math.floor(k * this.g), - Math.floor(k * this.b)); -}; - -d3_rgbPrototype.hsl = function() { - return d3_rgb_hsl(this.r, this.g, this.b); -}; - -d3_rgbPrototype.toString = function() { - return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b); -}; - -function d3_rgb_hex(v) { - return v < 0x10 - ? "0" + Math.max(0, v).toString(16) - : Math.min(255, v).toString(16); -} - -function d3_rgb_parse(format, rgb, hsl) { - var r = 0, // red channel; int in [0, 255] - g = 0, // green channel; int in [0, 255] - b = 0, // blue channel; int in [0, 255] - m1, // CSS color specification match - m2, // CSS color specification type (e.g., rgb) - name; - - /* Handle hsl, rgb. */ - m1 = /([a-z]+)\((.*)\)/i.exec(format); - if (m1) { - m2 = m1[2].split(","); - switch (m1[1]) { - case "hsl": { - return hsl( - parseFloat(m2[0]), // degrees - parseFloat(m2[1]) / 100, // percentage - parseFloat(m2[2]) / 100 // percentage - ); - } - case "rgb": { - return rgb( - d3_rgb_parseNumber(m2[0]), - d3_rgb_parseNumber(m2[1]), - d3_rgb_parseNumber(m2[2]) - ); - } - } - } - - /* Named colors. */ - if (name = d3_rgb_names.get(format)) return rgb(name.r, name.g, name.b); - - /* Hexadecimal colors: #rgb and #rrggbb. */ - if (format != null && format.charAt(0) === "#") { - if (format.length === 4) { - r = format.charAt(1); r += r; - g = format.charAt(2); g += g; - b = format.charAt(3); b += b; - } else if (format.length === 7) { - r = format.substring(1, 3); - g = format.substring(3, 5); - b = format.substring(5, 7); - } - r = parseInt(r, 16); - g = parseInt(g, 16); - b = parseInt(b, 16); - } - - return rgb(r, g, b); -} - -function d3_rgb_hsl(r, g, b) { - var min = Math.min(r /= 255, g /= 255, b /= 255), - max = Math.max(r, g, b), - d = max - min, - h, - s, - l = (max + min) / 2; - if (d) { - s = l < .5 ? d / (max + min) : d / (2 - max - min); - if (r == max) h = (g - b) / d + (g < b ? 6 : 0); - else if (g == max) h = (b - r) / d + 2; - else h = (r - g) / d + 4; - h *= 60; - } else { - s = h = 0; - } - return d3_hsl(h, s, l); -} - -function d3_rgb_lab(r, g, b) { - r = d3_rgb_xyz(r); - g = d3_rgb_xyz(g); - b = d3_rgb_xyz(b); - var x = d3_xyz_lab((0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / d3_lab_X), - y = d3_xyz_lab((0.2126729 * r + 0.7151522 * g + 0.0721750 * b) / d3_lab_Y), - z = d3_xyz_lab((0.0193339 * r + 0.1191920 * g + 0.9503041 * b) / d3_lab_Z); - return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z)); -} - -function d3_rgb_xyz(r) { - return (r /= 255) <= 0.04045 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4); -} - -function d3_rgb_parseNumber(c) { // either integer or percentage - var f = parseFloat(c); - return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f; -} - -var d3_rgb_names = d3.map({ - aliceblue: "#f0f8ff", - antiquewhite: "#faebd7", - aqua: "#00ffff", - aquamarine: "#7fffd4", - azure: "#f0ffff", - beige: "#f5f5dc", - bisque: "#ffe4c4", - black: "#000000", - blanchedalmond: "#ffebcd", - blue: "#0000ff", - blueviolet: "#8a2be2", - brown: "#a52a2a", - burlywood: "#deb887", - cadetblue: "#5f9ea0", - chartreuse: "#7fff00", - chocolate: "#d2691e", - coral: "#ff7f50", - cornflowerblue: "#6495ed", - cornsilk: "#fff8dc", - crimson: "#dc143c", - cyan: "#00ffff", - darkblue: "#00008b", - darkcyan: "#008b8b", - darkgoldenrod: "#b8860b", - darkgray: "#a9a9a9", - darkgreen: "#006400", - darkgrey: "#a9a9a9", - darkkhaki: "#bdb76b", - darkmagenta: "#8b008b", - darkolivegreen: "#556b2f", - darkorange: "#ff8c00", - darkorchid: "#9932cc", - darkred: "#8b0000", - darksalmon: "#e9967a", - darkseagreen: "#8fbc8f", - darkslateblue: "#483d8b", - darkslategray: "#2f4f4f", - darkslategrey: "#2f4f4f", - darkturquoise: "#00ced1", - darkviolet: "#9400d3", - deeppink: "#ff1493", - deepskyblue: "#00bfff", - dimgray: "#696969", - dimgrey: "#696969", - dodgerblue: "#1e90ff", - firebrick: "#b22222", - floralwhite: "#fffaf0", - forestgreen: "#228b22", - fuchsia: "#ff00ff", - gainsboro: "#dcdcdc", - ghostwhite: "#f8f8ff", - gold: "#ffd700", - goldenrod: "#daa520", - gray: "#808080", - green: "#008000", - greenyellow: "#adff2f", - grey: "#808080", - honeydew: "#f0fff0", - hotpink: "#ff69b4", - indianred: "#cd5c5c", - indigo: "#4b0082", - ivory: "#fffff0", - khaki: "#f0e68c", - lavender: "#e6e6fa", - lavenderblush: "#fff0f5", - lawngreen: "#7cfc00", - lemonchiffon: "#fffacd", - lightblue: "#add8e6", - lightcoral: "#f08080", - lightcyan: "#e0ffff", - lightgoldenrodyellow: "#fafad2", - lightgray: "#d3d3d3", - lightgreen: "#90ee90", - lightgrey: "#d3d3d3", - lightpink: "#ffb6c1", - lightsalmon: "#ffa07a", - lightseagreen: "#20b2aa", - lightskyblue: "#87cefa", - lightslategray: "#778899", - lightslategrey: "#778899", - lightsteelblue: "#b0c4de", - lightyellow: "#ffffe0", - lime: "#00ff00", - limegreen: "#32cd32", - linen: "#faf0e6", - magenta: "#ff00ff", - maroon: "#800000", - mediumaquamarine: "#66cdaa", - mediumblue: "#0000cd", - mediumorchid: "#ba55d3", - mediumpurple: "#9370db", - mediumseagreen: "#3cb371", - mediumslateblue: "#7b68ee", - mediumspringgreen: "#00fa9a", - mediumturquoise: "#48d1cc", - mediumvioletred: "#c71585", - midnightblue: "#191970", - mintcream: "#f5fffa", - mistyrose: "#ffe4e1", - moccasin: "#ffe4b5", - navajowhite: "#ffdead", - navy: "#000080", - oldlace: "#fdf5e6", - olive: "#808000", - olivedrab: "#6b8e23", - orange: "#ffa500", - orangered: "#ff4500", - orchid: "#da70d6", - palegoldenrod: "#eee8aa", - palegreen: "#98fb98", - paleturquoise: "#afeeee", - palevioletred: "#db7093", - papayawhip: "#ffefd5", - peachpuff: "#ffdab9", - peru: "#cd853f", - pink: "#ffc0cb", - plum: "#dda0dd", - powderblue: "#b0e0e6", - purple: "#800080", - red: "#ff0000", - rosybrown: "#bc8f8f", - royalblue: "#4169e1", - saddlebrown: "#8b4513", - salmon: "#fa8072", - sandybrown: "#f4a460", - seagreen: "#2e8b57", - seashell: "#fff5ee", - sienna: "#a0522d", - silver: "#c0c0c0", - skyblue: "#87ceeb", - slateblue: "#6a5acd", - slategray: "#708090", - slategrey: "#708090", - snow: "#fffafa", - springgreen: "#00ff7f", - steelblue: "#4682b4", - tan: "#d2b48c", - teal: "#008080", - thistle: "#d8bfd8", - tomato: "#ff6347", - turquoise: "#40e0d0", - violet: "#ee82ee", - wheat: "#f5deb3", - white: "#ffffff", - whitesmoke: "#f5f5f5", - yellow: "#ffff00", - yellowgreen: "#9acd32" -}); - -d3_rgb_names.forEach(function(key, value) { - d3_rgb_names.set(key, d3_rgb_parse(value, d3_rgb, d3_hsl_rgb)); -}); - -d3.interpolateRgb = d3_interpolateRgb; - -function d3_interpolateRgb(a, b) { - a = d3.rgb(a); - b = d3.rgb(b); - var ar = a.r, - ag = a.g, - ab = a.b, - br = b.r - ar, - bg = b.g - ag, - bb = b.b - ab; - return function(t) { - return "#" - + d3_rgb_hex(Math.round(ar + br * t)) - + d3_rgb_hex(Math.round(ag + bg * t)) - + d3_rgb_hex(Math.round(ab + bb * t)); - }; -} - -d3.transform = function(string) { - var g = d3_document.createElementNS(d3.ns.prefix.svg, "g"); - return (d3.transform = function(string) { - g.setAttribute("transform", string); - var t = g.transform.baseVal.consolidate(); - return new d3_transform(t ? t.matrix : d3_transformIdentity); - })(string); -}; - -// Compute x-scale and normalize the first row. -// Compute shear and make second row orthogonal to first. -// Compute y-scale and normalize the second row. -// Finally, compute the rotation. -function d3_transform(m) { - var r0 = [m.a, m.b], - r1 = [m.c, m.d], - kx = d3_transformNormalize(r0), - kz = d3_transformDot(r0, r1), - ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0; - if (r0[0] * r1[1] < r1[0] * r0[1]) { - r0[0] *= -1; - r0[1] *= -1; - kx *= -1; - kz *= -1; - } - this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees; - this.translate = [m.e, m.f]; - this.scale = [kx, ky]; - this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0; -}; - -d3_transform.prototype.toString = function() { - return "translate(" + this.translate - + ")rotate(" + this.rotate - + ")skewX(" + this.skew - + ")scale(" + this.scale - + ")"; -}; - -function d3_transformDot(a, b) { - return a[0] * b[0] + a[1] * b[1]; -} - -function d3_transformNormalize(a) { - var k = Math.sqrt(d3_transformDot(a, a)); - if (k) { - a[0] /= k; - a[1] /= k; - } - return k; -} - -function d3_transformCombine(a, b, k) { - a[0] += k * b[0]; - a[1] += k * b[1]; - return a; -} - -var d3_transformIdentity = {a: 1, b: 0, c: 0, d: 1, e: 0, f: 0}; -d3.interpolateNumber = d3_interpolateNumber; - -function d3_interpolateNumber(a, b) { - b -= a; - return function(t) { return a + b * t; }; -} - -d3.interpolateTransform = d3_interpolateTransform; - -function d3_interpolateTransform(a, b) { - var s = [], // string constants and placeholders - q = [], // number interpolators - n, - A = d3.transform(a), - B = d3.transform(b), - ta = A.translate, - tb = B.translate, - ra = A.rotate, - rb = B.rotate, - wa = A.skew, - wb = B.skew, - ka = A.scale, - kb = B.scale; - - if (ta[0] != tb[0] || ta[1] != tb[1]) { - s.push("translate(", null, ",", null, ")"); - q.push({i: 1, x: d3_interpolateNumber(ta[0], tb[0])}, {i: 3, x: d3_interpolateNumber(ta[1], tb[1])}); - } else if (tb[0] || tb[1]) { - s.push("translate(" + tb + ")"); - } else { - s.push(""); - } - - if (ra != rb) { - if (ra - rb > 180) rb += 360; else if (rb - ra > 180) ra += 360; // shortest path - q.push({i: s.push(s.pop() + "rotate(", null, ")") - 2, x: d3_interpolateNumber(ra, rb)}); - } else if (rb) { - s.push(s.pop() + "rotate(" + rb + ")"); - } - - if (wa != wb) { - q.push({i: s.push(s.pop() + "skewX(", null, ")") - 2, x: d3_interpolateNumber(wa, wb)}); - } else if (wb) { - s.push(s.pop() + "skewX(" + wb + ")"); - } - - if (ka[0] != kb[0] || ka[1] != kb[1]) { - n = s.push(s.pop() + "scale(", null, ",", null, ")"); - q.push({i: n - 4, x: d3_interpolateNumber(ka[0], kb[0])}, {i: n - 2, x: d3_interpolateNumber(ka[1], kb[1])}); - } else if (kb[0] != 1 || kb[1] != 1) { - s.push(s.pop() + "scale(" + kb + ")"); - } - - n = q.length; - return function(t) { - var i = -1, o; - while (++i < n) s[(o = q[i]).i] = o.x(t); - return s.join(""); - }; -} - -d3.interpolateObject = d3_interpolateObject; - -function d3_interpolateObject(a, b) { - var i = {}, - c = {}, - k; - for (k in a) { - if (k in b) { - i[k] = d3_interpolateByName(k)(a[k], b[k]); - } else { - c[k] = a[k]; - } - } - for (k in b) { - if (!(k in a)) { - c[k] = b[k]; - } - } - return function(t) { - for (k in i) c[k] = i[k](t); - return c; - }; -} - -d3.interpolateArray = d3_interpolateArray; - -function d3_interpolateArray(a, b) { - var x = [], - c = [], - na = a.length, - nb = b.length, - n0 = Math.min(a.length, b.length), - i; - for (i = 0; i < n0; ++i) x.push(d3_interpolate(a[i], b[i])); - for (; i < na; ++i) c[i] = a[i]; - for (; i < nb; ++i) c[i] = b[i]; - return function(t) { - for (i = 0; i < n0; ++i) c[i] = x[i](t); - return c; - }; -} - -d3.interpolateString = d3_interpolateString; - -function d3_interpolateString(a, b) { - var m, // current match - i, // current index - j, // current index (for coalescing) - s0 = 0, // start index of current string prefix - s1 = 0, // end index of current string prefix - s = [], // string constants and placeholders - q = [], // number interpolators - n, // q.length - o; - - // Reset our regular expression! - d3_interpolate_number.lastIndex = 0; - - // Find all numbers in b. - for (i = 0; m = d3_interpolate_number.exec(b); ++i) { - if (m.index) s.push(b.substring(s0, s1 = m.index)); - q.push({i: s.length, x: m[0]}); - s.push(null); - s0 = d3_interpolate_number.lastIndex; - } - if (s0 < b.length) s.push(b.substring(s0)); - - // Find all numbers in a. - for (i = 0, n = q.length; (m = d3_interpolate_number.exec(a)) && i < n; ++i) { - o = q[i]; - if (o.x == m[0]) { // The numbers match, so coalesce. - if (o.i) { - if (s[o.i + 1] == null) { // This match is followed by another number. - s[o.i - 1] += o.x; - s.splice(o.i, 1); - for (j = i + 1; j < n; ++j) q[j].i--; - } else { // This match is followed by a string, so coalesce twice. - s[o.i - 1] += o.x + s[o.i + 1]; - s.splice(o.i, 2); - for (j = i + 1; j < n; ++j) q[j].i -= 2; + function arrayAggregator(array2, setter, iteratee, accumulator) { + var index = -1, length = array2 == null ? 0 : array2.length; + while (++index < length) { + var value = array2[index]; + setter(accumulator, value, iteratee(value), array2); + } + return accumulator; } - } else { - if (s[o.i + 1] == null) { // This match is followed by another number. - s[o.i] = o.x; - } else { // This match is followed by a string, so coalesce twice. - s[o.i] = o.x + s[o.i + 1]; - s.splice(o.i + 1, 1); - for (j = i + 1; j < n; ++j) q[j].i--; + function arrayEach(array2, iteratee) { + var index = -1, length = array2 == null ? 0 : array2.length; + while (++index < length) { + if (iteratee(array2[index], index, array2) === false) { + break; + } + } + return array2; } - } - q.splice(i, 1); - n--; - i--; - } else { - o.x = d3_interpolateNumber(parseFloat(m[0]), parseFloat(o.x)); - } - } - - // Remove any numbers in b not found in a. - while (i < n) { - o = q.pop(); - if (s[o.i + 1] == null) { // This match is followed by another number. - s[o.i] = o.x; - } else { // This match is followed by a string, so coalesce twice. - s[o.i] = o.x + s[o.i + 1]; - s.splice(o.i + 1, 1); - } - n--; - } - - // Special optimization for only a single match. - if (s.length === 1) { - return s[0] == null ? q[0].x : function() { return b; }; - } - - // Otherwise, interpolate each of the numbers and rejoin the string. - return function(t) { - for (i = 0; i < n; ++i) s[(o = q[i]).i] = o.x(t); - return s.join(""); - }; -} - -var d3_interpolate_number = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g; - -d3.interpolate = d3_interpolate; - -function d3_interpolate(a, b) { - var i = d3.interpolators.length, f; - while (--i >= 0 && !(f = d3.interpolators[i](a, b))); - return f; -} - -function d3_interpolateByName(name) { - return name == "transform" - ? d3_interpolateTransform - : d3_interpolate; -} - -d3.interpolators = [ - d3_interpolateObject, - function(a, b) { return Array.isArray(b) && d3_interpolateArray(a, b); }, - function(a, b) { return (typeof a === "string" || typeof b === "string") && d3_interpolateString(a + "", b + ""); }, - function(a, b) { return (typeof b === "string" ? d3_rgb_names.has(b) || /^(#|rgb\(|hsl\()/.test(b) : b instanceof d3_Color) && d3_interpolateRgb(a, b); }, - function(a, b) { return !isNaN(a = +a) && !isNaN(b = +b) && d3_interpolateNumber(a, b); } -]; - -d3_transitionPrototype.tween = function(name, tween) { - var id = this.id; - if (arguments.length < 2) return this.node().__transition__[id].tween.get(name); - return d3_selection_each(this, tween == null - ? function(node) { node.__transition__[id].tween.remove(name); } - : function(node) { node.__transition__[id].tween.set(name, tween); }); -}; - -function d3_transition_tween(groups, name, value, tween) { - var id = groups.id; - return d3_selection_each(groups, typeof value === "function" - ? function(node, i, j) { node.__transition__[id].tween.set(name, tween(value.call(node, node.__data__, i, j))); } - : (value = tween(value), function(node) { node.__transition__[id].tween.set(name, value); })); -} - -d3_transitionPrototype.attr = function(nameNS, value) { - if (arguments.length < 2) { - - // For attr(object), the object specifies the names and values of the - // attributes to transition. The values may be functions that are - // evaluated for each element. - for (value in nameNS) this.attr(value, nameNS[value]); - return this; - } - - var interpolate = d3_interpolateByName(nameNS), - name = d3.ns.qualify(nameNS); - - // For attr(string, null), remove the attribute with the specified name. - function attrNull() { - this.removeAttribute(name); - } - function attrNullNS() { - this.removeAttributeNS(name.space, name.local); - } - - return d3_transition_tween(this, "attr." + nameNS, value, function(b) { - - // For attr(string, string), set the attribute with the specified name. - function attrString() { - var a = this.getAttribute(name), i; - return a !== b && (i = interpolate(a, b), function(t) { this.setAttribute(name, i(t)); }); - } - function attrStringNS() { - var a = this.getAttributeNS(name.space, name.local), i; - return a !== b && (i = interpolate(a, b), function(t) { this.setAttributeNS(name.space, name.local, i(t)); }); - } - - return b == null ? (name.local ? attrNullNS : attrNull) - : (b += "", name.local ? attrStringNS : attrString); - }); -}; - -d3_transitionPrototype.attrTween = function(nameNS, tween) { - var name = d3.ns.qualify(nameNS); - - function attrTween(d, i) { - var f = tween.call(this, d, i, this.getAttribute(name)); - return f && function(t) { this.setAttribute(name, f(t)); }; - } - - function attrTweenNS(d, i) { - var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local)); - return f && function(t) { this.setAttributeNS(name.space, name.local, f(t)); }; - } - - return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween); -}; - -d3_transitionPrototype.style = function(name, value, priority) { - var n = arguments.length; - if (n < 3) { - - // For style(object) or style(object, string), the object specifies the - // names and values of the attributes to set or remove. The values may be - // functions that are evaluated for each element. The optional string - // specifies the priority. - if (typeof name !== "string") { - if (n < 2) value = ""; - for (priority in name) this.style(priority, name[priority], value); - return this; - } - - // For style(string, string) or style(string, function), use the default - // priority. The priority is ignored for style(string, null). - priority = ""; - } - - var interpolate = d3_interpolateByName(name); - - // For style(name, null) or style(name, null, priority), remove the style - // property with the specified name. The priority is ignored. - function styleNull() { - this.style.removeProperty(name); - } - - // Otherwise, a name, value and priority are specified, and handled as below. - return d3_transition_tween(this, "style." + name, value, function(b) { - - // For style(name, string) or style(name, string, priority), set the style - // property with the specified name, using the specified priority. - function styleString() { - var a = d3_window.getComputedStyle(this, null).getPropertyValue(name), i; - return a !== b && (i = interpolate(a, b), function(t) { this.style.setProperty(name, i(t), priority); }); - } - - return b == null ? styleNull - : (b += "", styleString); - }); -}; - -d3_transitionPrototype.styleTween = function(name, tween, priority) { - if (arguments.length < 3) priority = ""; - return this.tween("style." + name, function(d, i) { - var f = tween.call(this, d, i, d3_window.getComputedStyle(this, null).getPropertyValue(name)); - return f && function(t) { this.style.setProperty(name, f(t), priority); }; - }); -}; - -d3_transitionPrototype.text = function(value) { - return d3_transition_tween(this, "text", value, d3_transition_text); -}; - -function d3_transition_text(b) { - if (b == null) b = ""; - return function() { this.textContent = b; }; -} - -d3_transitionPrototype.remove = function() { - return this.each("end.transition", function() { - var p; - if (!this.__transition__ && (p = this.parentNode)) p.removeChild(this); - }); -}; - -d3_transitionPrototype.ease = function(value) { - var id = this.id; - if (arguments.length < 1) return this.node().__transition__[id].ease; - if (typeof value !== "function") value = d3.ease.apply(d3, arguments); - return d3_selection_each(this, function(node) { node.__transition__[id].ease = value; }); -}; - -d3_transitionPrototype.delay = function(value) { - var id = this.id; - return d3_selection_each(this, typeof value === "function" - ? function(node, i, j) { node.__transition__[id].delay = value.call(node, node.__data__, i, j) | 0; } - : (value |= 0, function(node) { node.__transition__[id].delay = value; })); -}; - -d3_transitionPrototype.duration = function(value) { - var id = this.id; - return d3_selection_each(this, typeof value === "function" - ? function(node, i, j) { node.__transition__[id].duration = Math.max(1, value.call(node, node.__data__, i, j) | 0); } - : (value = Math.max(1, value | 0), function(node) { node.__transition__[id].duration = value; })); -}; - -d3_transitionPrototype.each = function(type, listener) { - var id = this.id; - if (arguments.length < 2) { - var inherit = d3_transitionInherit, - inheritId = d3_transitionInheritId; - d3_transitionInheritId = id; - d3_selection_each(this, function(node, i, j) { - d3_transitionInherit = node.__transition__[id]; - type.call(node, node.__data__, i, j); - }); - d3_transitionInherit = inherit; - d3_transitionInheritId = inheritId; - } else { - d3_selection_each(this, function(node) { - node.__transition__[id].event.on(type, listener); - }); - } - return this; -}; - -d3_transitionPrototype.transition = function() { - var id0 = this.id, - id1 = ++d3_transitionId, - subgroups = [], - subgroup, - group, - node, - transition; - - for (var j = 0, m = this.length; j < m; j++) { - subgroups.push(subgroup = []); - for (var group = this[j], i = 0, n = group.length; i < n; i++) { - if (node = group[i]) { - transition = Object.create(node.__transition__[id0]); - transition.delay += transition.duration; - d3_transitionNode(node, i, id1, transition); - } - subgroup.push(node); - } - } - - return d3_transition(subgroups, id1); -}; - -function d3_transitionNode(node, i, id, inherit) { - var lock = node.__transition__ || (node.__transition__ = {active: 0, count: 0}), - transition = lock[id]; - - if (!transition) { - var time = inherit.time; - - transition = lock[id] = { - tween: new d3_Map, - event: d3.dispatch("start", "end"), // TODO construct lazily? - time: time, - ease: inherit.ease, - delay: inherit.delay, - duration: inherit.duration - }; - - ++lock.count; - - d3.timer(function(elapsed) { - var d = node.__data__, - ease = transition.ease, - event = transition.event, - delay = transition.delay, - duration = transition.duration, - tweened = []; - - return delay <= elapsed - ? start(elapsed) - : d3.timer(start, delay, time), 1; - - function start(elapsed) { - if (lock.active > id) return stop(); - lock.active = id; - event.start.call(node, d, i); - - transition.tween.forEach(function(key, value) { - if (value = value.call(node, d, i)) { - tweened.push(value); + function arrayEachRight(array2, iteratee) { + var length = array2 == null ? 0 : array2.length; + while (length--) { + if (iteratee(array2[length], length, array2) === false) { + break; + } } - }); - - if (!tick(elapsed)) d3.timer(tick, 0, time); - return 1; - } - - function tick(elapsed) { - if (lock.active !== id) return stop(); - - var t = (elapsed - delay) / duration, - e = ease(t), - n = tweened.length; - - while (n > 0) { - tweened[--n].call(node, e); + return array2; } - - if (t >= 1) { - stop(); - event.end.call(node, d, i); - return 1; + function arrayEvery(array2, predicate) { + var index = -1, length = array2 == null ? 0 : array2.length; + while (++index < length) { + if (!predicate(array2[index], index, array2)) { + return false; + } + } + return true; } - } - - function stop() { - if (--lock.count) delete lock[id]; - else delete node.__transition__; - return 1; - } - }, 0, time); - - return transition; - } -} - -d3.xhr = function(url, mimeType, callback) { - var xhr = {}, - dispatch = d3.dispatch("progress", "load", "error"), - headers = {}, - response = d3_identity, - request = new (d3_window.XDomainRequest && /^(http(s)?:)?\/\//.test(url) ? XDomainRequest : XMLHttpRequest); - - "onload" in request - ? request.onload = request.onerror = respond - : request.onreadystatechange = function() { request.readyState > 3 && respond(); }; - - function respond() { - var s = request.status; - !s && request.responseText || s >= 200 && s < 300 || s === 304 - ? dispatch.load.call(xhr, response.call(xhr, request)) - : dispatch.error.call(xhr, request); - } - - request.onprogress = function(event) { - var o = d3.event; - d3.event = event; - try { dispatch.progress.call(xhr, request); } - finally { d3.event = o; } - }; - - xhr.header = function(name, value) { - name = (name + "").toLowerCase(); - if (arguments.length < 2) return headers[name]; - if (value == null) delete headers[name]; - else headers[name] = value + ""; - return xhr; - }; - - // If mimeType is non-null and no Accept header is set, a default is used. - xhr.mimeType = function(value) { - if (!arguments.length) return mimeType; - mimeType = value == null ? null : value + ""; - return xhr; - }; - - // Specify how to convert the response content to a specific type; - // changes the callback value on "load" events. - xhr.response = function(value) { - response = value; - return xhr; - }; - - // Convenience methods. - ["get", "post"].forEach(function(method) { - xhr[method] = function() { - return xhr.send.apply(xhr, [method].concat(d3_array(arguments))); - }; - }); - - // If callback is non-null, it will be used for error and load events. - xhr.send = function(method, data, callback) { - if (arguments.length === 2 && typeof data === "function") callback = data, data = null; - request.open(method, url, true); - if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*"; - if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]); - if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType); - if (callback != null) xhr.on("error", callback).on("load", function(request) { callback(null, request); }); - request.send(data == null ? null : data); - return xhr; - }; - - xhr.abort = function() { - request.abort(); - return xhr; - }; - - d3.rebind(xhr, dispatch, "on"); - - if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, mimeType = null; - return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback)); -}; - -function d3_xhr_fixCallback(callback) { - return callback.length === 1 - ? function(error, request) { callback(error == null ? request : null); } - : callback; -} - -d3.text = function() { - return d3.xhr.apply(d3, arguments).response(d3_text); -}; - -function d3_text(request) { - return request.responseText; -} - -d3.json = function(url, callback) { - return d3.xhr(url, "application/json", callback).response(d3_json); -}; - -function d3_json(request) { - return JSON.parse(request.responseText); -} - -d3.html = function(url, callback) { - return d3.xhr(url, "text/html", callback).response(d3_html); -}; - -function d3_html(request) { - var range = d3_document.createRange(); - range.selectNode(d3_document.body); - return range.createContextualFragment(request.responseText); -} - -d3.xml = function() { - return d3.xhr.apply(d3, arguments).response(d3_xml); -}; - -function d3_xml(request) { - return request.responseXML; -} - return d3; -})(); -d3.combobox = function() { - var event = d3.dispatch('accept'), - id = d3.combobox.id ++, - data = []; - - var fetcher = function(val, data, cb) { - cb(data.filter(function(d) { - return d.title - .toString() - .toLowerCase() - .indexOf(val.toLowerCase()) !== -1; - })); - }; - - var combobox = function(input) { - var idx = -1, container, shown = false; - - input - .classed('combobox-input', true) - .each(function() { - var parent = this.parentNode, - sibling = this.nextSibling; - d3.select(parent) - .insert('div', function() { return sibling; }) - .attr('class', 'combobox-carat') - .on('mousedown', function () { - // prevent the form element from blurring. it blurs - // on mousedown - d3.event.stopPropagation(); - d3.event.preventDefault(); - mousedown(); - }); - }); - - function updateSize() { - var rect = input.node().getBoundingClientRect(); - container.style({ - 'left': rect.left + 'px', - 'width': rect.width + 'px', - 'top': rect.height + rect.top + 'px' - }); + function arrayFilter2(array2, predicate) { + var index = -1, length = array2 == null ? 0 : array2.length, resIndex = 0, result = []; + while (++index < length) { + var value = array2[index]; + if (predicate(value, index, array2)) { + result[resIndex++] = value; + } + } + return result; } - - function blur() { - // hide the combobox whenever the input element - // loses focus - slowHide(); + function arrayIncludes(array2, value) { + var length = array2 == null ? 0 : array2.length; + return !!length && baseIndexOf(array2, value, 0) > -1; } - - function show() { - if (!shown) { - container = d3.select(document.body) - .insert('div', ':first-child') - .attr('class', 'combobox') - .style({ - position: 'absolute', - display: 'block', - left: '0px' - }); - - shown = true; + function arrayIncludesWith(array2, value, comparator) { + var index = -1, length = array2 == null ? 0 : array2.length; + while (++index < length) { + if (comparator(value, array2[index])) { + return true; } + } + return false; } - - function hide() { - if (shown) { - idx = -1; - container.remove(); - shown = false; - } + function arrayMap2(array2, iteratee) { + var index = -1, length = array2 == null ? 0 : array2.length, result = Array(length); + while (++index < length) { + result[index] = iteratee(array2[index], index, array2); + } + return result; } - - function slowHide() { - window.setTimeout(hide, 150); + function arrayPush2(array2, values) { + var index = -1, length = values.length, offset = array2.length; + while (++index < length) { + array2[offset + index] = values[index]; + } + return array2; } - function keydown() { - if (!shown) return; - switch (d3.event.keyCode) { - // down arrow - case 40: - next(); - d3.event.preventDefault(); - break; - // up arrow - case 38: - prev(); - d3.event.preventDefault(); - break; - // escape, tab - case 13: - d3.event.preventDefault(); - break; - } - d3.event.stopPropagation(); + function arrayReduce(array2, iteratee, accumulator, initAccum) { + var index = -1, length = array2 == null ? 0 : array2.length; + if (initAccum && length) { + accumulator = array2[++index]; + } + while (++index < length) { + accumulator = iteratee(accumulator, array2[index], index, array2); + } + return accumulator; } - - function keyup() { - switch (d3.event.keyCode) { - // escape - case 27: - hide(); - break; - // escape, tab - case 9: - case 13: - if (!shown) return; - accept(); - break; - default: - update(); - d3.event.preventDefault(); - } - d3.event.stopPropagation(); + function arrayReduceRight(array2, iteratee, accumulator, initAccum) { + var length = array2 == null ? 0 : array2.length; + if (initAccum && length) { + accumulator = array2[--length]; + } + while (length--) { + accumulator = iteratee(accumulator, array2[length], length, array2); + } + return accumulator; } - - function accept() { - if (container.select('a.selected').node()) { - select(container.select('a.selected').datum()); + function arraySome2(array2, predicate) { + var index = -1, length = array2 == null ? 0 : array2.length; + while (++index < length) { + if (predicate(array2[index], index, array2)) { + return true; } - hide(); + } + return false; } - - function next() { - var len = container.selectAll('a').data().length; - idx = Math.min(idx + 1, len - 1); - highlight(); + var asciiSize = baseProperty("length"); + function asciiToArray(string) { + return string.split(""); } - - function prev() { - idx = Math.max(idx - 1, 0); - highlight(); + function asciiWords(string) { + return string.match(reAsciiWord) || []; } - - var prevValue, prevCompletion; - - function autocomplete(e, data) { - - var value = input.property('value'), - match; - - for (var i = 0; i < data.length; i++) { - if (data[i].value.toLowerCase().indexOf(value.toLowerCase()) === 0) { - match = data[i].value; - break; - } - } - - // backspace - if (e.keyCode === 8) { - prevValue = value; - prevCompletion = ''; - - } else if (value && match && value !== prevValue + prevCompletion) { - prevValue = value; - prevCompletion = match.substr(value.length); - input.property('value', prevValue + prevCompletion); - input.node().setSelectionRange(value.length, value.length + prevCompletion.length); + function baseFindKey(collection, predicate, eachFunc) { + var result; + eachFunc(collection, function(value, key, collection2) { + if (predicate(value, key, collection2)) { + result = key; + return false; } + }); + return result; } - - - function highlight() { - container - .selectAll('a') - .classed('selected', function(d, i) { return i == idx; }); - var height = container.node().offsetHeight, - top = container.select('a.selected').node().offsetTop, - selectedHeight = container.select('a.selected').node().offsetHeight; - if ((top + selectedHeight) < height) { - container.node().scrollTop = 0; - } else { - container.node().scrollTop = top; + function baseFindIndex(array2, predicate, fromIndex, fromRight) { + var length = array2.length, index = fromIndex + (fromRight ? 1 : -1); + while (fromRight ? index-- : ++index < length) { + if (predicate(array2[index], index, array2)) { + return index; } + } + return -1; } - - function update(value) { - - if (typeof value === 'undefined') { - value = input.property('value'); - } - - var e = d3.event; - - function render(data) { - - if (data.length && - document.activeElement === input.node()) show(); - else return hide(); - - autocomplete(e, data); - - updateSize(); - - var options = container - .selectAll('a.combobox-option') - .data(data, function(d) { return d.value; }); - - options.enter() - .append('a') - .text(function(d) { return d.value; }) - .attr('class', 'combobox-option') - .attr('title', function(d) { return d.title; }) - .on('click', select); - - options.exit().remove(); - - options - .classed('selected', function(d, i) { return i == idx; }) - .order(); + function baseIndexOf(array2, value, fromIndex) { + return value === value ? strictIndexOf(array2, value, fromIndex) : baseFindIndex(array2, baseIsNaN, fromIndex); + } + function baseIndexOfWith(array2, value, fromIndex, comparator) { + var index = fromIndex - 1, length = array2.length; + while (++index < length) { + if (comparator(array2[index], value)) { + return index; } - - fetcher.apply(input, [value, data, render]); + } + return -1; } - - // select the choice given as d - function select(d) { - input - .property('value', d.value) - .trigger('change'); - event.accept(d); - hide(); + function baseIsNaN(value) { + return value !== value; } - - function mousedown() { - - if (shown) return hide(); - - input.node().focus(); - update(''); - - if (!container) return; - - var entries = container.selectAll('a'), - height = container.node().scrollHeight / entries[0].length, - w = d3.select(window); - - function getIndex(m) { - return Math.floor((m[1] + container.node().scrollTop) / height); - } - - function withinBounds(m) { - var n = container.node(); - return m[0] >= 0 && m[0] < n.offsetWidth && - m[1] >= 0 && m[1] < n.offsetHeight; + function baseMean(array2, iteratee) { + var length = array2 == null ? 0 : array2.length; + return length ? baseSum(array2, iteratee) / length : NAN2; + } + function baseProperty(key) { + return function(object) { + return object == null ? undefined2 : object[key]; + }; + } + function basePropertyOf2(object) { + return function(key) { + return object == null ? undefined2 : object[key]; + }; + } + function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { + eachFunc(collection, function(value, index, collection2) { + accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2); + }); + return accumulator; + } + function baseSortBy(array2, comparer) { + var length = array2.length; + array2.sort(comparer); + while (length--) { + array2[length] = array2[length].value; + } + return array2; + } + function baseSum(array2, iteratee) { + var result, index = -1, length = array2.length; + while (++index < length) { + var current = iteratee(array2[index]); + if (current !== undefined2) { + result = result === undefined2 ? current : result + current; } - - w.on('mousemove.typeahead', function() { - var m = d3.mouse(container.node()); - var within = withinBounds(m); - var n = getIndex(m); - entries.classed('selected', function(d, i) { return within && i === n; }); - }); - - w.on('mouseup.typeahead', function() { - var m = d3.mouse(container.node()); - if (withinBounds(m)) select(d3.select(entries[0][getIndex(m)]).datum()); - entries.classed('selected', false); - w.on('mouseup.typeahead', null); - w.on('mousemove.typeahead', null); - }); + } + return result; } - - input - .on('blur.typeahead', blur) - .on('keydown.typeahead', keydown) - .on('keyup.typeahead', keyup) - .on('mousedown.typeahead', mousedown); - - d3.select(document.body).on('scroll.combo' + id, function() { - if (shown) updateSize(); - }, true); - }; - - combobox.fetcher = function(_) { - if (!arguments.length) return fetcher; - fetcher = _; - return combobox; - }; - - combobox.data = function(_) { - if (!arguments.length) return data; - data = _; - return combobox; - }; - - return d3.rebind(combobox, event, 'on'); -}; - -d3.combobox.id = 0; -d3.geo.tile = function() { - var size = [960, 500], - scale = 256, - scaleExtent = [0, 20], - translate = [size[0] / 2, size[1] / 2], - zoomDelta = 0; - - function bound(_) { - return Math.min(scaleExtent[1], Math.max(scaleExtent[0], _)); - } - - function tile() { - var z = Math.max(Math.log(scale) / Math.LN2 - 8, 0), - z0 = bound(Math.round(z + zoomDelta)), - k = Math.pow(2, z - z0 + 8), - origin = [(translate[0] - scale / 2) / k, (translate[1] - scale / 2) / k], - tiles = [], - cols = d3.range(Math.max(0, Math.floor(-origin[0])), Math.max(0, Math.ceil(size[0] / k - origin[0]))), - rows = d3.range(Math.max(0, Math.floor(-origin[1])), Math.max(0, Math.ceil(size[1] / k - origin[1]))); - - rows.forEach(function(y) { - cols.forEach(function(x) { - tiles.push([x, y, z0]); - }); - }); - - tiles.translate = origin; - tiles.scale = k; - - return tiles; - } - - tile.scaleExtent = function(_) { - if (!arguments.length) return scaleExtent; - scaleExtent = _; - return tile; - }; - - tile.size = function(_) { - if (!arguments.length) return size; - size = _; - return tile; - }; - - tile.scale = function(_) { - if (!arguments.length) return scale; - scale = _; - return tile; - }; - - tile.translate = function(_) { - if (!arguments.length) return translate; - translate = _; - return tile; - }; - - tile.zoomDelta = function(_) { - if (!arguments.length) return zoomDelta; - zoomDelta = +_; - return tile; - }; - - return tile; -}; -d3.jsonp = function (url, callback) { - function rand() { - var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', - c = '', i = -1; - while (++i < 15) c += chars.charAt(Math.floor(Math.random() * 52)); - return c; - } - - function create(url) { - var e = url.match(/callback=d3.jsonp.(\w+)/), - c = e ? e[1] : rand(); - d3.jsonp[c] = function(data) { - callback(data); - delete d3.jsonp[c]; - script.remove(); - }; - return 'd3.jsonp.' + c; - } - - var cb = create(url), - script = d3.select('head') - .append('script') - .attr('type', 'text/javascript') - .attr('src', url.replace(/(\{|%7B)callback(\}|%7D)/, cb)); -}; -/* - * This code is licensed under the MIT license. - * - * Copyright © 2013, iD authors. - * - * Portions copyright © 2011, Keith Cirkel - * See https://github.com/keithamus/jwerty - * - */ -d3.keybinding = function(namespace) { - var bindings = []; - - function matches(binding, event) { - for (var p in binding.event) { - if (event[p] != binding.event[p]) - return false; + function baseTimes2(n2, iteratee) { + var index = -1, result = Array(n2); + while (++index < n2) { + result[index] = iteratee(index); + } + return result; } - - return (!binding.capture) === (event.eventPhase !== Event.CAPTURING_PHASE); - } - - function capture() { - for (var i = 0; i < bindings.length; i++) { - var binding = bindings[i]; - if (matches(binding, d3.event)) { - binding.callback(); + function baseToPairs(object, props) { + return arrayMap2(props, function(key) { + return [key, object[key]]; + }); + } + function baseTrim2(string) { + return string ? string.slice(0, trimmedEndIndex2(string) + 1).replace(reTrimStart2, "") : string; + } + function baseUnary2(func) { + return function(value) { + return func(value); + }; + } + function baseValues(object, props) { + return arrayMap2(props, function(key) { + return object[key]; + }); + } + function cacheHas2(cache, key) { + return cache.has(key); + } + function charsStartIndex(strSymbols, chrSymbols) { + var index = -1, length = strSymbols.length; + while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) { + } + return index; + } + function charsEndIndex(strSymbols, chrSymbols) { + var index = strSymbols.length; + while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) { + } + return index; + } + function countHolders(array2, placeholder) { + var length = array2.length, result = 0; + while (length--) { + if (array2[length] === placeholder) { + ++result; } + } + return result; } - } - - function bubble() { - var tagName = d3.select(d3.event.target).node().tagName; - if (tagName == 'INPUT' || tagName == 'SELECT' || tagName == 'TEXTAREA') { - return; + var deburrLetter = basePropertyOf2(deburredLetters); + var escapeHtmlChar2 = basePropertyOf2(htmlEscapes2); + function escapeStringChar(chr) { + return "\\" + stringEscapes[chr]; } - capture(); - } - - function keybinding(selection) { - selection = selection || d3.select(document); - selection.on('keydown.capture' + namespace, capture, true); - selection.on('keydown.bubble' + namespace, bubble, false); - return keybinding; - } - - keybinding.off = function(selection) { - selection = selection || d3.select(document); - selection.on('keydown.capture' + namespace, null); - selection.on('keydown.bubble' + namespace, null); - return keybinding; - }; - - keybinding.on = function(code, callback, capture) { - var binding = { - event: { - keyCode: 0, - shiftKey: false, - ctrlKey: false, - altKey: false, - metaKey: false - }, - capture: capture, - callback: callback - }; - - code = code.toLowerCase().match(/(?:(?:[^+⇧⌃⌥⌘])+|[⇧⌃⌥⌘]|\+\+|^\+$)/g); - - for (var i = 0; i < code.length; i++) { - // Normalise matching errors - if (code[i] === '++') code[i] = '+'; - - if (code[i] in d3.keybinding.modifierCodes) { - binding.event[d3.keybinding.modifierProperties[d3.keybinding.modifierCodes[code[i]]]] = true; - } else if (code[i] in d3.keybinding.keyCodes) { - binding.event.keyCode = d3.keybinding.keyCodes[code[i]]; + function getValue2(object, key) { + return object == null ? undefined2 : object[key]; + } + function hasUnicode(string) { + return reHasUnicode.test(string); + } + function hasUnicodeWord(string) { + return reHasUnicodeWord.test(string); + } + function iteratorToArray(iterator) { + var data, result = []; + while (!(data = iterator.next()).done) { + result.push(data.value); + } + return result; + } + function mapToArray2(map2) { + var index = -1, result = Array(map2.size); + map2.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + function overArg2(func, transform2) { + return function(arg) { + return func(transform2(arg)); + }; + } + function replaceHolders(array2, placeholder) { + var index = -1, length = array2.length, resIndex = 0, result = []; + while (++index < length) { + var value = array2[index]; + if (value === placeholder || value === PLACEHOLDER) { + array2[index] = PLACEHOLDER; + result[resIndex++] = index; } + } + return result; } - - bindings.push(binding); - - return keybinding; - }; - - return keybinding; -}; - -(function () { - d3.keybinding.modifierCodes = { - // Shift key, ⇧ - '⇧': 16, shift: 16, - // CTRL key, on Mac: ⌃ - '⌃': 17, ctrl: 17, - // ALT key, on Mac: ⌥ (Alt) - '⌥': 18, alt: 18, option: 18, - // META, on Mac: ⌘ (CMD), on Windows (Win), on Linux (Super) - '⌘': 91, meta: 91, cmd: 91, 'super': 91, win: 91 - }; - - d3.keybinding.modifierProperties = { - 16: 'shiftKey', - 17: 'ctrlKey', - 18: 'altKey', - 91: 'metaKey' - }; - - d3.keybinding.keyCodes = { - // Backspace key, on Mac: ⌫ (Backspace) - '⌫': 8, backspace: 8, - // Tab Key, on Mac: ⇥ (Tab), on Windows ⇥⇥ - '⇥': 9, '⇆': 9, tab: 9, - // Return key, ↩ - '↩': 13, 'return': 13, enter: 13, '⌅': 13, - // Pause/Break key - 'pause': 19, 'pause-break': 19, - // Caps Lock key, ⇪ - '⇪': 20, caps: 20, 'caps-lock': 20, - // Escape key, on Mac: ⎋, on Windows: Esc - '⎋': 27, escape: 27, esc: 27, - // Space key - space: 32, - // Page-Up key, or pgup, on Mac: ↖ - '↖': 33, pgup: 33, 'page-up': 33, - // Page-Down key, or pgdown, on Mac: ↘ - '↘': 34, pgdown: 34, 'page-down': 34, - // END key, on Mac: ⇟ - '⇟': 35, end: 35, - // HOME key, on Mac: ⇞ - '⇞': 36, home: 36, - // Insert key, or ins - ins: 45, insert: 45, - // Delete key, on Mac: ⌦ (Delete) - '⌦': 46, del: 46, 'delete': 46, - // Left Arrow Key, or ← - '←': 37, left: 37, 'arrow-left': 37, - // Up Arrow Key, or ↑ - '↑': 38, up: 38, 'arrow-up': 38, - // Right Arrow Key, or → - '→': 39, right: 39, 'arrow-right': 39, - // Up Arrow Key, or ↓ - '↓': 40, down: 40, 'arrow-down': 40, - // odities, printing characters that come out wrong: - // Num-Multiply, or * - '*': 106, star: 106, asterisk: 106, multiply: 106, - // Num-Plus or + - '+': 107, 'plus': 107, - // Num-Subtract, or - - '-': 109, subtract: 109, - // Semicolon - ';': 186, semicolon:186, - // = or equals - '=': 187, 'equals': 187, - // Comma, or , - ',': 188, comma: 188, - 'dash': 189, //??? - // Period, or ., or full-stop - '.': 190, period: 190, 'full-stop': 190, - // Slash, or /, or forward-slash - '/': 191, slash: 191, 'forward-slash': 191, - // Tick, or `, or back-quote - '`': 192, tick: 192, 'back-quote': 192, - // Open bracket, or [ - '[': 219, 'open-bracket': 219, - // Back slash, or \ - '\\': 220, 'back-slash': 220, - // Close backet, or ] - ']': 221, 'close-bracket': 221, - // Apostrophe, or Quote, or ' - '\'': 222, quote: 222, apostrophe: 222 - }; - - // NUMPAD 0-9 - var i = 95, n = 0; - while (++i < 106) { - d3.keybinding.keyCodes['num-' + n] = i; - ++n; - } - - // 0-9 - i = 47; n = 0; - while (++i < 58) { - d3.keybinding.keyCodes[n] = i; - ++n; - } - - // F1-F25 - i = 111; n = 1; - while (++i < 136) { - d3.keybinding.keyCodes['f' + n] = i; - ++n; - } - - // a-z - i = 64; - while (++i < 91) { - d3.keybinding.keyCodes[String.fromCharCode(i).toLowerCase()] = i; - } -})(); -d3.selection.prototype.one = function (type, listener, capture) { - var target = this, typeOnce = type + ".once"; - function one() { - target.on(typeOnce, null); - listener.apply(this, arguments); - } - target.on(typeOnce, one, capture); - return this; -}; -d3.selection.prototype.size = function (size) { - if (!arguments.length) { - var node = this.node(); - return [node.offsetWidth, - node.offsetHeight]; - } - return this.attr({width: size[0], height: size[1]}); -}; -d3.selection.prototype.trigger = function (type) { - this.each(function() { - var evt = document.createEvent('HTMLEvents'); - evt.initEvent(type, true, true); - this.dispatchEvent(evt); - }); -}; -d3.typeahead = function() { - var event = d3.dispatch('accept'), - autohighlight = false, - data; - - var typeahead = function(selection) { - var container, - hidden, - idx = autohighlight ? 0 : -1; - - function setup() { - var rect = selection.node().getBoundingClientRect(); - container = d3.select(document.body) - .append('div').attr('class', 'typeahead') - .style({ - position: 'absolute', - left: rect.left + 'px', - top: rect.bottom + 'px' - }); - selection - .on('keyup.typeahead', key); - hidden = false; + function setToArray2(set3) { + var index = -1, result = Array(set3.size); + set3.forEach(function(value) { + result[++index] = value; + }); + return result; } - - function hide() { - container.remove(); - idx = autohighlight ? 0 : -1; - hidden = true; + function setToPairs(set3) { + var index = -1, result = Array(set3.size); + set3.forEach(function(value) { + result[++index] = [value, value]; + }); + return result; } - - function slowHide() { - if (autohighlight) { - if (container.select('a.selected').node()) { - select(container.select('a.selected').datum()); - event.accept(); - } + function strictIndexOf(array2, value, fromIndex) { + var index = fromIndex - 1, length = array2.length; + while (++index < length) { + if (array2[index] === value) { + return index; } - window.setTimeout(hide, 150); + } + return -1; } - - selection - .on('focus.typeahead', setup) - .on('blur.typeahead', slowHide); - - function key() { - var len = container.selectAll('a').data().length; - if (d3.event.keyCode === 40) { - idx = Math.min(idx + 1, len - 1); - return highlight(); - } else if (d3.event.keyCode === 38) { - idx = Math.max(idx - 1, 0); - return highlight(); - } else if (d3.event.keyCode === 13) { - if (container.select('a.selected').node()) { - select(container.select('a.selected').datum()); - } - event.accept(); - hide(); - } else { - update(); - } + function strictLastIndexOf(array2, value, fromIndex) { + var index = fromIndex + 1; + while (index--) { + if (array2[index] === value) { + return index; + } + } + return index; } - - function highlight() { - container - .selectAll('a') - .classed('selected', function(d, i) { return i == idx; }); + function stringSize(string) { + return hasUnicode(string) ? unicodeSize(string) : asciiSize(string); } - - function update() { - if (hidden) setup(); - - data(selection, function(data) { - container.style('display', function() { - return data.length ? 'block' : 'none'; - }); - - var options = container - .selectAll('a') - .data(data, function(d) { return d.value; }); - - options.enter() - .append('a') - .text(function(d) { return d.value; }) - .attr('title', function(d) { return d.title; }) - .on('click', select); - - options.exit().remove(); - - options - .classed('selected', function(d, i) { return i == idx; }); - }); + function stringToArray(string) { + return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string); } - - function select(d) { - selection - .property('value', d.value) - .trigger('change'); + function trimmedEndIndex2(string) { + var index = string.length; + while (index-- && reWhitespace2.test(string.charAt(index))) { + } + return index; } - - }; - - typeahead.data = function(_) { - if (!arguments.length) return data; - data = _; - return typeahead; - }; - - typeahead.autohighlight = function(_) { - if (!arguments.length) return autohighlight; - autohighlight = _; - return typeahead; - }; - - return d3.rebind(typeahead, event, 'on'); -}; -// Tooltips and svg mask used to highlight certain features -d3.curtain = function() { - - var event = d3.dispatch(), - surface, - tooltip, - darkness; - - function curtain(selection) { - - surface = selection.append('svg') - .attr('id', 'curtain') - .style({ - 'z-index': 1000, - 'pointer-events': 'none', - 'position': 'absolute', - 'top': 0, - 'left': 0 - }); - - darkness = surface.append('path') - .attr({ - x: 0, - y: 0, - 'class': 'curtain-darkness' - }); - - d3.select(window).on('resize.curtain', resize); - - tooltip = selection.append('div') - .attr('class', 'tooltip') - .style('z-index', 1002); - - tooltip.append('div').attr('class', 'tooltip-arrow'); - tooltip.append('div').attr('class', 'tooltip-inner'); - - resize(); - - function resize() { - surface.attr({ - width: window.innerWidth, - height: window.innerHeight - }); - curtain.cut(darkness.datum()); + var unescapeHtmlChar2 = basePropertyOf2(htmlUnescapes2); + function unicodeSize(string) { + var result = reUnicode.lastIndex = 0; + while (reUnicode.test(string)) { + ++result; + } + return result; } - } - - curtain.reveal = function(box, text, tooltipclass, duration) { - if (typeof box === 'string') box = d3.select(box).node(); - if (box.getBoundingClientRect) box = box.getBoundingClientRect(); - - curtain.cut(box, duration); - - if (text) { - // pseudo markdown bold text hack - var parts = text.split('**'); - var html = parts[0] ? '' + parts[0] + '' : ''; - if (parts[1]) html += '' + parts[1] + ''; - - var size = tooltip.classed('in', true) - .select('.tooltip-inner') - .html(html) - .size(); - - var pos; - - var w = window.innerWidth, - h = window.innerHeight; - - if (box.top + box.height < Math.min(100, box.width + box.left)) { - side = 'bottom'; - pos = [box.left + box.width / 2 - size[0]/ 2, box.top + box.height]; - - } else if (box.left + box.width + 300 < window.innerWidth) { - side = 'right'; - pos = [box.left + box.width, box.top + box.height / 2 - size[1] / 2]; - - } else if (box.left > 300) { - side = 'left'; - pos = [box.left - 200, box.top + box.height / 2 - size[1] / 2]; + function unicodeToArray(string) { + return string.match(reUnicode) || []; + } + function unicodeWords(string) { + return string.match(reUnicodeWord) || []; + } + var runInContext = function runInContext2(context) { + context = context == null ? root3 : _.defaults(root3.Object(), context, _.pick(root3, contextProps)); + var Array2 = context.Array, Date2 = context.Date, Error2 = context.Error, Function2 = context.Function, Math2 = context.Math, Object2 = context.Object, RegExp2 = context.RegExp, String2 = context.String, TypeError2 = context.TypeError; + var arrayProto2 = Array2.prototype, funcProto3 = Function2.prototype, objectProto13 = Object2.prototype; + var coreJsData2 = context["__core-js_shared__"]; + var funcToString3 = funcProto3.toString; + var hasOwnProperty10 = objectProto13.hasOwnProperty; + var idCounter = 0; + var maskSrcKey2 = function() { + var uid = /[^.]+$/.exec(coreJsData2 && coreJsData2.keys && coreJsData2.keys.IE_PROTO || ""); + return uid ? "Symbol(src)_1." + uid : ""; + }(); + var nativeObjectToString3 = objectProto13.toString; + var objectCtorString = funcToString3.call(Object2); + var oldDash = root3._; + var reIsNative2 = RegExp2( + "^" + funcToString3.call(hasOwnProperty10).replace(reRegExpChar2, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$" + ); + var Buffer3 = moduleExports3 ? context.Buffer : undefined2, Symbol3 = context.Symbol, Uint8Array3 = context.Uint8Array, allocUnsafe = Buffer3 ? Buffer3.allocUnsafe : undefined2, getPrototype = overArg2(Object2.getPrototypeOf, Object2), objectCreate = Object2.create, propertyIsEnumerable3 = objectProto13.propertyIsEnumerable, splice2 = arrayProto2.splice, spreadableSymbol = Symbol3 ? Symbol3.isConcatSpreadable : undefined2, symIterator = Symbol3 ? Symbol3.iterator : undefined2, symToStringTag3 = Symbol3 ? Symbol3.toStringTag : undefined2; + var defineProperty = function() { + try { + var func = getNative2(Object2, "defineProperty"); + func({}, "", {}); + return func; + } catch (e) { + } + }(); + var ctxClearTimeout = context.clearTimeout !== root3.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root3.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root3.setTimeout && context.setTimeout; + var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols2 = Object2.getOwnPropertySymbols, nativeIsBuffer2 = Buffer3 ? Buffer3.isBuffer : undefined2, nativeIsFinite = context.isFinite, nativeJoin = arrayProto2.join, nativeKeys2 = overArg2(Object2.keys, Object2), nativeMax2 = Math2.max, nativeMin2 = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto2.reverse; + var DataView3 = getNative2(context, "DataView"), Map3 = getNative2(context, "Map"), Promise3 = getNative2(context, "Promise"), Set3 = getNative2(context, "Set"), WeakMap2 = getNative2(context, "WeakMap"), nativeCreate2 = getNative2(Object2, "create"); + var metaMap = WeakMap2 && new WeakMap2(); + var realNames = {}; + var dataViewCtorString2 = toSource2(DataView3), mapCtorString2 = toSource2(Map3), promiseCtorString2 = toSource2(Promise3), setCtorString2 = toSource2(Set3), weakMapCtorString2 = toSource2(WeakMap2); + var symbolProto3 = Symbol3 ? Symbol3.prototype : undefined2, symbolValueOf2 = symbolProto3 ? symbolProto3.valueOf : undefined2, symbolToString2 = symbolProto3 ? symbolProto3.toString : undefined2; + function lodash(value) { + if (isObjectLike2(value) && !isArray2(value) && !(value instanceof LazyWrapper)) { + if (value instanceof LodashWrapper) { + return value; + } + if (hasOwnProperty10.call(value, "__wrapped__")) { + return wrapperClone(value); + } + } + return new LodashWrapper(value); + } + var baseCreate = function() { + function object() { + } + return function(proto) { + if (!isObject3(proto)) { + return {}; + } + if (objectCreate) { + return objectCreate(proto); + } + object.prototype = proto; + var result2 = new object(); + object.prototype = undefined2; + return result2; + }; + }(); + function baseLodash() { + } + function LodashWrapper(value, chainAll) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__chain__ = !!chainAll; + this.__index__ = 0; + this.__values__ = undefined2; + } + 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 + } + }; + lodash.prototype = baseLodash.prototype; + lodash.prototype.constructor = lodash; + LodashWrapper.prototype = baseCreate(baseLodash.prototype); + LodashWrapper.prototype.constructor = LodashWrapper; + function LazyWrapper(value) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__dir__ = 1; + this.__filtered__ = false; + this.__iteratees__ = []; + this.__takeCount__ = MAX_ARRAY_LENGTH; + this.__views__ = []; + } + function lazyClone() { + var result2 = new LazyWrapper(this.__wrapped__); + result2.__actions__ = copyArray(this.__actions__); + result2.__dir__ = this.__dir__; + result2.__filtered__ = this.__filtered__; + result2.__iteratees__ = copyArray(this.__iteratees__); + result2.__takeCount__ = this.__takeCount__; + result2.__views__ = copyArray(this.__views__); + return result2; + } + function lazyReverse() { + if (this.__filtered__) { + var result2 = new LazyWrapper(this); + result2.__dir__ = -1; + result2.__filtered__ = true; } else { - side = 'bottom'; - pos = [box.left, box.top + box.height]; + result2 = this.clone(); + result2.__dir__ *= -1; } - - pos = [ - Math.min(Math.max(10, pos[0]), w - size[0] - 10), - Math.min(Math.max(10, pos[1]), h - size[1] - 10) - ]; - - - if (duration !== 0 || !tooltip.classed(side)) tooltip.call(iD.ui.Toggle(true)); - - tooltip - .style('top', pos[1] + 'px') - .style('left', pos[0] + 'px') - .attr('class', 'curtain-tooltip tooltip in ' + side + ' ' + tooltipclass) - .select('.tooltip-inner') - .html(html); - - } else { - tooltip.call(iD.ui.Toggle(false)); - } - }; - - curtain.cut = function(datum, duration) { - darkness.datum(datum); - - (duration === 0 ? darkness : darkness.transition().duration(duration || 600)) - .attr('d', function(d) { - var string = "M 0,0 L 0," + window.innerHeight + " L " + - window.innerWidth + "," + window.innerHeight + "L" + - window.innerWidth + ",0 Z"; - - if (!d) return string; - return string + 'M' + - d.left + ',' + d.top + 'L' + - d.left + ',' + (d.top + d.height) + 'L' + - (d.left + d.width) + ',' + (d.top + d.height) + 'L' + - (d.left + d.width) + ',' + (d.top) + 'Z'; - - }); - }; - - curtain.remove = function() { - surface.remove(); - tooltip.remove(); - }; - - return d3.rebind(curtain, event, 'on'); -}; -var JXON = new (function () { - var - sValueProp = "keyValue", sAttributesProp = "keyAttributes", sAttrPref = "@", /* you can customize these values */ - aCache = [], rIsNull = /^\s*$/, rIsBool = /^(?:true|false)$/i; - - function parseText (sValue) { - if (rIsNull.test(sValue)) { return null; } - if (rIsBool.test(sValue)) { return sValue.toLowerCase() === "true"; } - if (isFinite(sValue)) { return parseFloat(sValue); } - if (isFinite(Date.parse(sValue))) { return new Date(sValue); } - return sValue; - } - - function EmptyTree () { } - EmptyTree.prototype.toString = function () { return "null"; }; - EmptyTree.prototype.valueOf = function () { return null; }; - - function objectify (vValue) { - return vValue === null ? new EmptyTree() : vValue instanceof Object ? vValue : new vValue.constructor(vValue); - } - - function createObjTree (oParentNode, nVerb, bFreeze, bNesteAttr) { - var - nLevelStart = aCache.length, bChildren = oParentNode.hasChildNodes(), - bAttributes = oParentNode.hasAttributes(), bHighVerb = Boolean(nVerb & 2); - - var - sProp, vContent, nLength = 0, sCollectedTxt = "", - vResult = bHighVerb ? {} : /* put here the default value for empty nodes: */ true; - - if (bChildren) { - for (var oNode, nItem = 0; nItem < oParentNode.childNodes.length; nItem++) { - oNode = oParentNode.childNodes.item(nItem); - if (oNode.nodeType === 4) { sCollectedTxt += oNode.nodeValue; } /* nodeType is "CDATASection" (4) */ - else if (oNode.nodeType === 3) { sCollectedTxt += oNode.nodeValue.trim(); } /* nodeType is "Text" (3) */ - else if (oNode.nodeType === 1 && !oNode.prefix) { aCache.push(oNode); } /* nodeType is "Element" (1) */ - } - } - - var nLevelEnd = aCache.length, vBuiltVal = parseText(sCollectedTxt); - - if (!bHighVerb && (bChildren || bAttributes)) { vResult = nVerb === 0 ? objectify(vBuiltVal) : {}; } - - for (var nElId = nLevelStart; nElId < nLevelEnd; nElId++) { - sProp = aCache[nElId].nodeName.toLowerCase(); - vContent = createObjTree(aCache[nElId], nVerb, bFreeze, bNesteAttr); - if (vResult.hasOwnProperty(sProp)) { - if (vResult[sProp].constructor !== Array) { vResult[sProp] = [vResult[sProp]]; } - vResult[sProp].push(vContent); - } else { - vResult[sProp] = vContent; - nLength++; - } - } - - if (bAttributes) { - var - nAttrLen = oParentNode.attributes.length, - sAPrefix = bNesteAttr ? "" : sAttrPref, oAttrParent = bNesteAttr ? {} : vResult; - - for (var oAttrib, nAttrib = 0; nAttrib < nAttrLen; nLength++, nAttrib++) { - oAttrib = oParentNode.attributes.item(nAttrib); - oAttrParent[sAPrefix + oAttrib.name.toLowerCase()] = parseText(oAttrib.value.trim()); - } - - if (bNesteAttr) { - if (bFreeze) { Object.freeze(oAttrParent); } - vResult[sAttributesProp] = oAttrParent; - nLength -= nAttrLen - 1; - } - } - - if (nVerb === 3 || (nVerb === 2 || nVerb === 1 && nLength > 0) && sCollectedTxt) { - vResult[sValueProp] = vBuiltVal; - } else if (!bHighVerb && nLength === 0 && sCollectedTxt) { - vResult = vBuiltVal; - } - - if (bFreeze && (bHighVerb || nLength > 0)) { Object.freeze(vResult); } - - aCache.length = nLevelStart; - - return vResult; - } - - function loadObjTree (oXMLDoc, oParentEl, oParentObj) { - var vValue, oChild; - - if (oParentObj instanceof String || oParentObj instanceof Number || oParentObj instanceof Boolean) { - oParentEl.appendChild(oXMLDoc.createTextNode(oParentObj.toString())); /* verbosity level is 0 */ - } else if (oParentObj.constructor === Date) { - oParentEl.appendChild(oXMLDoc.createTextNode(oParentObj.toGMTString())); - } - - for (var sName in oParentObj) { - vValue = oParentObj[sName]; - if (isFinite(sName) || vValue instanceof Function) { continue; } /* verbosity level is 0 */ - if (sName === sValueProp) { - if (vValue !== null && vValue !== true) { oParentEl.appendChild(oXMLDoc.createTextNode(vValue.constructor === Date ? vValue.toGMTString() : String(vValue))); } - } else if (sName === sAttributesProp) { /* verbosity level is 3 */ - for (var sAttrib in vValue) { oParentEl.setAttribute(sAttrib, vValue[sAttrib]); } - } else if (sName.charAt(0) === sAttrPref) { - oParentEl.setAttribute(sName.slice(1), vValue); - } else if (vValue.constructor === Array) { - for (var nItem = 0; nItem < vValue.length; nItem++) { - oChild = oXMLDoc.createElement(sName); - loadObjTree(oXMLDoc, oChild, vValue[nItem]); - oParentEl.appendChild(oChild); - } - } else { - oChild = oXMLDoc.createElement(sName); - if (vValue instanceof Object) { - loadObjTree(oXMLDoc, oChild, vValue); - } else if (vValue !== null && vValue !== true) { - oChild.appendChild(oXMLDoc.createTextNode(vValue.toString())); - } - oParentEl.appendChild(oChild); - } - } - } - - this.build = function (oXMLParent, nVerbosity /* optional */, bFreeze /* optional */, bNesteAttributes /* optional */) { - var _nVerb = arguments.length > 1 && typeof nVerbosity === "number" ? nVerbosity & 3 : /* put here the default verbosity level: */ 1; - return createObjTree(oXMLParent, _nVerb, bFreeze || false, arguments.length > 3 ? bNesteAttributes : _nVerb === 3); - }; - - this.unbuild = function (oObjTree) { - var oNewDoc = document.implementation.createDocument("", "", null); - loadObjTree(oNewDoc, oNewDoc, oObjTree); - return oNewDoc; - }; - - this.stringify = function (oObjTree) { - return (new XMLSerializer()).serializeToString(JXON.unbuild(oObjTree)); - }; -})(); -// var myObject = JXON.build(doc); -// we got our javascript object! try: alert(JSON.stringify(myObject)); - -// var newDoc = JXON.unbuild(myObject); -// we got our Document instance! try: alert((new XMLSerializer()).serializeToString(newDoc)); -/*! - * Lo-Dash 1.0.0-rc.3 - * (c) 2012 John-David Dalton - * Based on Underscore.js 1.4.3 - * (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc. - * Available under MIT license - */ -;(function(window, undefined) { - - /** Detect free variable `exports` */ - var freeExports = typeof exports == 'object' && exports; - - /** Detect free variable `global` and use it as `window` */ - var freeGlobal = typeof global == 'object' && global; - if (freeGlobal.global === freeGlobal) { - window = freeGlobal; - } - - /** Used for array and object method references */ - var arrayRef = [], - // avoid a Closure Compiler bug by creatively creating an object - objectRef = new function(){}; - - /** Used to generate unique IDs */ - var idCounter = 0; - - /** Used internally to indicate various things */ - var indicatorObject = objectRef; - - /** Used by `cachedContains` as the default size when optimizations are enabled for large arrays */ - var largeArraySize = 30; - - /** Used to restore the original `_` reference in `noConflict` */ - var oldDash = window._; - - /** Used to detect template delimiter values that require a with-statement */ - var reComplexDelimiter = /[-?+=!~*%&^<>|{(\/]|\[\D|\b(?:delete|in|instanceof|new|typeof|void)\b/; - - /** Used to match HTML entities */ - var reEscapedHtml = /&(?:amp|lt|gt|quot|#x27);/g; - - /** 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 regexp flags from their coerced string values */ - var reFlags = /\w*$/; - - /** Used to insert the data object variable into compiled template source */ - var reInsertVariable = /(?:__e|__t = )\(\s*(?![\d\s"']|this\.)/g; - - /** Used to detect if a method is native */ - var reNative = RegExp('^' + - (objectRef.valueOf + '') - .replace(/[.*+?^=!:${}()|[\]\/\\]/g, '\\$&') - .replace(/valueOf|for [^\]]+/g, '.+?') + '$' - ); - - /** - * Used to match ES6 template delimiters - * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6 - */ - var reEsTemplate = /\$\{((?:(?=\\?)\\?[\s\S])*?)}/g; - - /** Used to match "interpolate" template delimiters */ - var reInterpolate = /<%=([\s\S]+?)%>/g; - - /** Used to ensure capturing order of template delimiters */ - var reNoMatch = /($^)/; - - /** Used to match HTML characters */ - var reUnescapedHtml = /[&<>"']/g; - - /** Used to match unescaped characters in compiled string literals */ - var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g; - - /** Used to fix the JScript [[DontEnum]] bug */ - var shadowed = [ - 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', - 'toLocaleString', 'toString', 'valueOf' - ]; - - /** Used to make template sourceURLs easier to identify */ - var templateCounter = 0; - - /** Native method shortcuts */ - var ceil = Math.ceil, - concat = arrayRef.concat, - floor = Math.floor, - getPrototypeOf = reNative.test(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf, - hasOwnProperty = objectRef.hasOwnProperty, - push = arrayRef.push, - propertyIsEnumerable = objectRef.propertyIsEnumerable, - toString = objectRef.toString; - - /* Native method shortcuts for methods with the same name as other `lodash` methods */ - var nativeBind = reNative.test(nativeBind = slice.bind) && nativeBind, - nativeIsArray = reNative.test(nativeIsArray = Array.isArray) && nativeIsArray, - nativeIsFinite = window.isFinite, - nativeIsNaN = window.isNaN, - nativeKeys = reNative.test(nativeKeys = Object.keys) && nativeKeys, - nativeMax = Math.max, - nativeMin = Math.min, - nativeRandom = Math.random; - - /** `Object#toString` result shortcuts */ - var argsClass = '[object Arguments]', - arrayClass = '[object Array]', - boolClass = '[object Boolean]', - dateClass = '[object Date]', - funcClass = '[object Function]', - numberClass = '[object Number]', - objectClass = '[object Object]', - regexpClass = '[object RegExp]', - stringClass = '[object String]'; - - /** Detect various environments */ - var isIeOpera = !!window.attachEvent, - isV8 = nativeBind && !/\n|true/.test(nativeBind + isIeOpera); - - /* Detect if `Function#bind` exists and is inferred to be fast (all but V8) */ - var isBindFast = nativeBind && !isV8; - - /* Detect if `Object.keys` exists and is inferred to be fast (IE, Opera, V8) */ - var isKeysFast = nativeKeys && (isIeOpera || isV8); - - /** - * Detect the JScript [[DontEnum]] bug: - * - * In IE < 9 an objects own properties, shadowing non-enumerable ones, are - * made non-enumerable as well. - */ - var hasDontEnumBug; - - /** Detect if own properties are iterated after inherited properties (IE < 9) */ - var iteratesOwnLast; - - /** - * Detect if `Array#shift` and `Array#splice` augment array-like objects - * incorrectly: - * - * Firefox < 10, IE compatibility mode, and IE < 9 have buggy Array `shift()` - * and `splice()` functions that fail to remove the last element, `value[0]`, - * of array-like objects even though the `length` property is set to `0`. - * The `shift()` method is buggy in IE 8 compatibility mode, while `splice()` - * is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9. - */ - var hasObjectSpliceBug = (hasObjectSpliceBug = { '0': 1, 'length': 1 }, - arrayRef.splice.call(hasObjectSpliceBug, 0, 1), hasObjectSpliceBug[0]); - - /** Detect if an `arguments` object's indexes are non-enumerable (IE < 9) */ - var nonEnumArgs = true; - - (function() { - var props = []; - function ctor() { this.x = 1; } - ctor.prototype = { 'valueOf': 1, 'y': 1 }; - for (var prop in new ctor) { props.push(prop); } - for (prop in arguments) { nonEnumArgs = !prop; } - - hasDontEnumBug = !/valueOf/.test(props); - iteratesOwnLast = props[0] != 'x'; - }(1)); - - /** Detect if `arguments` objects are `Object` objects (all but Opera < 10.5) */ - var argsAreObjects = arguments.constructor == Object; - - /** Detect if `arguments` objects [[Class]] is unresolvable (Firefox < 4, IE < 9) */ - var noArgsClass = !isArguments(arguments); - - /** - * Detect lack of support for accessing string characters by index: - * - * IE < 8 can't access characters by index and IE 8 can only access - * characters by index on string literals. - */ - var noCharByIndex = ('x'[0] + Object('x')[0]) != 'xx'; - - /** - * Detect if a node's [[Class]] is unresolvable (IE < 9) - * and that the JS engine won't error when attempting to coerce an object to - * a string without a `toString` property value of `typeof` "function". - */ - try { - var noNodeClass = ({ 'toString': 0 } + '', toString.call(document) == objectClass); - } catch(e) { } - - /** - * Detect if sourceURL syntax is usable without erroring: - * - * The JS engine embedded in Adobe products will throw a syntax error when - * it encounters a single line comment beginning with the `@` symbol. - * - * The JS engine in Narwhal will generate the function `function anonymous(){//}` - * and throw a syntax error. - * - * Avoid comments beginning `@` symbols in IE because they are part of its - * non-standard conditional compilation support. - * http://msdn.microsoft.com/en-us/library/121hztk3(v=vs.94).aspx - */ - try { - var useSourceURL = (Function('//@')(), !isIeOpera); - } catch(e) { } - - /** Used to identify object classifications that `_.clone` supports */ - var cloneableClasses = {}; - cloneableClasses[funcClass] = false; - cloneableClasses[argsClass] = cloneableClasses[arrayClass] = - cloneableClasses[boolClass] = cloneableClasses[dateClass] = - cloneableClasses[numberClass] = cloneableClasses[objectClass] = - cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true; - - /** Used to lookup a built-in constructor by [[Class]] */ - var ctorByClass = {}; - ctorByClass[arrayClass] = Array; - ctorByClass[boolClass] = Boolean; - ctorByClass[dateClass] = Date; - ctorByClass[objectClass] = Object; - ctorByClass[numberClass] = Number; - ctorByClass[regexpClass] = RegExp; - ctorByClass[stringClass] = String; - - /** Used to determine if values are of the language type Object */ - var objectTypes = { - 'boolean': false, - 'function': true, - 'object': true, - 'number': false, - 'string': false, - 'undefined': false - }; - - /** Used to escape characters for inclusion in compiled string literals */ - var stringEscapes = { - '\\': '\\', - "'": "'", - '\n': 'n', - '\r': 'r', - '\t': 't', - '\u2028': 'u2028', - '\u2029': 'u2029' - }; - - /*--------------------------------------------------------------------------*/ - - /** - * Creates a `lodash` object, that wraps the given `value`, to enable - * method chaining. - * - * The chainable wrapper functions are: - * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`, `compose`, - * `concat`, `countBy`, `debounce`, `defaults`, `defer`, `delay`, `difference`, - * `filter`, `flatten`, `forEach`, `forIn`, `forOwn`, `functions`, `groupBy`, - * `initial`, `intersection`, `invert`, `invoke`, `keys`, `map`, `max`, `memoize`, - * `merge`, `min`, `object`, `omit`, `once`, `pairs`, `partial`, `pick`, `pluck`, - * `push`, `range`, `reject`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, - * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `union`, `uniq`, - * `unshift`, `values`, `where`, `without`, `wrap`, and `zip` - * - * The non-chainable wrapper functions are: - * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `has`, `identity`, - * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`, `isEmpty`, - * `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`, `isObject`, - * `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`, `lastIndexOf`, - * `mixin`, `noConflict`, `pop`, `random`, `reduce`, `reduceRight`, `result`, - * `shift`, `size`, `some`, `sortedIndex`, `template`, `unescape`, and `uniqueId` - * - * The wrapper functions `first` and `last` return wrapped values when `n` is - * passed, otherwise they return unwrapped values. - * - * @name _ - * @constructor - * @category Chaining - * @param {Mixed} value The value to wrap in a `lodash` instance. - * @returns {Object} Returns a `lodash` instance. - */ - function lodash(value) { - // exit early if already wrapped, even if wrapped by a different `lodash` constructor - if (value && typeof value == 'object' && value.__wrapped__) { - return value; - } - // allow invoking `lodash` without the `new` operator - if (!(this instanceof lodash)) { - return new lodash(value); - } - this.__wrapped__ = value; - } - - /** - * By default, the template delimiters used by Lo-Dash are similar to those in - * embedded Ruby (ERB). 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. - * - * @static - * @memberOf _.templateSettings - * @type RegExp - */ - 'escape': /<%-([\s\S]+?)%>/g, - - /** - * Used to detect code to be evaluated. - * - * @static - * @memberOf _.templateSettings - * @type RegExp - */ - 'evaluate': /<%([\s\S]+?)%>/g, - - /** - * Used to detect `data` property values to inject. - * - * @static - * @memberOf _.templateSettings - * @type RegExp - */ - 'interpolate': reInterpolate, - - /** - * Used to reference the data object in the template text. - * - * @static - * @memberOf _.templateSettings - * @type String - */ - 'variable': '' - }; - - /*--------------------------------------------------------------------------*/ - - /** - * The template used to create iterator functions. - * - * @private - * @param {Obect} data The data object used to populate the text. - * @returns {String} Returns the interpolated text. - */ - var iteratorTemplate = template( - // conditional strict mode - "<% if (obj.useStrict) { %>'use strict';\n<% } %>" + - - // the `iteratee` may be reassigned by the `top` snippet - 'var index, iteratee = <%= firstArg %>, ' + - // assign the `result` variable an initial value - 'result = <%= firstArg %>;\n' + - // exit early if the first argument is falsey - 'if (!<%= firstArg %>) return result;\n' + - // add code before the iteration branches - '<%= top %>;\n' + - - // array-like iteration: - '<% if (arrayLoop) { %>' + - 'var length = iteratee.length; index = -1;\n' + - "if (typeof length == 'number') {" + - - // add support for accessing string characters by index if needed - ' <% if (noCharByIndex) { %>\n' + - ' if (isString(iteratee)) {\n' + - " iteratee = iteratee.split('')\n" + - ' }' + - ' <% } %>\n' + - - // iterate over the array-like value - ' while (++index < length) {\n' + - ' <%= arrayLoop %>\n' + - ' }\n' + - '}\n' + - 'else {' + - - // object iteration: - // add support for iterating over `arguments` objects if needed - ' <% } else if (nonEnumArgs) { %>\n' + - ' var length = iteratee.length; index = -1;\n' + - ' if (length && isArguments(iteratee)) {\n' + - ' while (++index < length) {\n' + - " index += '';\n" + - ' <%= objectLoop %>\n' + - ' }\n' + - ' } else {' + - ' <% } %>' + - - // Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1 - // (if the prototype or a property on the prototype has been set) - // incorrectly sets a function's `prototype` property [[Enumerable]] - // value to `true`. Because of this Lo-Dash standardizes on skipping - // the the `prototype` property of functions regardless of its - // [[Enumerable]] value. - ' <% if (!hasDontEnumBug) { %>\n' + - " var skipProto = typeof iteratee == 'function' && \n" + - " propertyIsEnumerable.call(iteratee, 'prototype');\n" + - ' <% } %>' + - - // iterate own properties using `Object.keys` if it's fast - ' <% if (isKeysFast && useHas) { %>\n' + - ' var ownIndex = -1,\n' + - ' ownProps = objectTypes[typeof iteratee] ? nativeKeys(iteratee) : [],\n' + - ' length = ownProps.length;\n\n' + - ' while (++ownIndex < length) {\n' + - ' index = ownProps[ownIndex];\n' + - " <% if (!hasDontEnumBug) { %>if (!(skipProto && index == 'prototype')) {\n <% } %>" + - ' <%= objectLoop %>\n' + - ' <% if (!hasDontEnumBug) { %>}\n<% } %>' + - ' }' + - - // else using a for-in loop - ' <% } else { %>\n' + - ' for (index in iteratee) {<%' + - ' if (!hasDontEnumBug || useHas) { %>\n if (<%' + - " if (!hasDontEnumBug) { %>!(skipProto && index == 'prototype')<% }" + - ' if (!hasDontEnumBug && useHas) { %> && <% }' + - ' if (useHas) { %>hasOwnProperty.call(iteratee, index)<% }' + - ' %>) {' + - ' <% } %>\n' + - ' <%= objectLoop %>;' + - ' <% if (!hasDontEnumBug || useHas) { %>\n }<% } %>\n' + - ' }' + - ' <% } %>' + - - // Because IE < 9 can't set the `[[Enumerable]]` attribute of an - // existing property and the `constructor` property of a prototype - // defaults to non-enumerable, Lo-Dash skips the `constructor` - // property when it infers it's iterating over a `prototype` object. - ' <% if (hasDontEnumBug) { %>\n\n' + - ' var ctor = iteratee.constructor;\n' + - ' <% for (var k = 0; k < 7; k++) { %>\n' + - " index = '<%= shadowed[k] %>';\n" + - ' if (<%' + - " if (shadowed[k] == 'constructor') {" + - ' %>!(ctor && ctor.prototype === iteratee) && <%' + - ' } %>hasOwnProperty.call(iteratee, index)) {\n' + - ' <%= objectLoop %>\n' + - ' }' + - ' <% } %>' + - ' <% } %>' + - ' <% if (arrayLoop || nonEnumArgs) { %>\n}<% } %>\n' + - - // add code to the bottom of the iteration function - '<%= bottom %>;\n' + - // finally, return the `result` - 'return result' - ); - - /** Reusable iterator options for `assign` and `defaults` */ - var assignIteratorOptions = { - 'args': 'object, source, guard', - 'top': - "for (var argsIndex = 1, argsLength = typeof guard == 'number' ? 2 : arguments.length; argsIndex < argsLength; argsIndex++) {\n" + - ' if ((iteratee = arguments[argsIndex])) {', - 'objectLoop': 'result[index] = iteratee[index]', - 'bottom': ' }\n}' - }; - - /** - * Reusable iterator options shared by `each`, `forIn`, and `forOwn`. - */ - var eachIteratorOptions = { - 'args': 'collection, callback, thisArg', - 'top': "callback = callback && typeof thisArg == 'undefined' ? callback : createCallback(callback, thisArg)", - 'arrayLoop': 'if (callback(iteratee[index], index, collection) === false) return result', - 'objectLoop': 'if (callback(iteratee[index], index, collection) === false) return result' - }; - - /** Reusable iterator options for `forIn` and `forOwn` */ - var forOwnIteratorOptions = { - 'arrayLoop': null - }; - - /*--------------------------------------------------------------------------*/ - - /** - * Creates a function optimized to search large arrays for a given `value`, - * starting at `fromIndex`, using strict equality for comparisons, i.e. `===`. - * - * @private - * @param {Array} array The array to search. - * @param {Mixed} value The value to search for. - * @param {Number} [fromIndex=0] The index to search from. - * @param {Number} [largeSize=30] The length at which an array is considered large. - * @returns {Boolean} Returns `true` if `value` is found, else `false`. - */ - function cachedContains(array, fromIndex, largeSize) { - fromIndex || (fromIndex = 0); - - var length = array.length, - isLarge = (length - fromIndex) >= (largeSize || largeArraySize); - - if (isLarge) { - var cache = {}, - index = fromIndex - 1; - - while (++index < length) { - // manually coerce `value` to a string because `hasOwnProperty`, in some - // older versions of Firefox, coerces objects incorrectly - var key = array[index] + ''; - (hasOwnProperty.call(cache, key) ? cache[key] : (cache[key] = [])).push(array[index]); - } - } - return function(value) { - if (isLarge) { - var key = value + ''; - return hasOwnProperty.call(cache, key) && indexOf(cache[key], value) > -1; - } - return indexOf(array, value, fromIndex) > -1; - } - } - - /** - * Used by `_.max` and `_.min` as the default `callback` when a given - * `collection` is a string value. - * - * @private - * @param {String} value The character to inspect. - * @returns {Number} Returns the code unit of given character. - */ - function charAtCallback(value) { - return value.charCodeAt(0); - } - - /** - * Used by `sortBy` to compare transformed `collection` values, stable sorting - * them in ascending order. - * - * @private - * @param {Object} a The object to compare to `b`. - * @param {Object} b The object to compare to `a`. - * @returns {Number} Returns the sort order indicator of `1` or `-1`. - */ - function compareAscending(a, b) { - var ai = a.index, - bi = b.index; - - a = a.criteria; - b = b.criteria; - - // ensure a stable sort in V8 and other engines - // http://code.google.com/p/v8/issues/detail?id=90 - if (a !== b) { - if (a > b || typeof a == 'undefined') { - return 1; - } - if (a < b || typeof b == 'undefined') { - return -1; - } - } - return ai < bi ? -1 : 1; - } - - /** - * Creates a function that, when called, invokes `func` with the `this` - * binding of `thisArg` and prepends any `partailArgs` to the arguments passed - * to the bound function. - * - * @private - * @param {Function|String} func The function to bind or the method name. - * @param {Mixed} [thisArg] The `this` binding of `func`. - * @param {Array} partialArgs An array of arguments to be partially applied. - * @returns {Function} Returns the new bound function. - */ - function createBound(func, thisArg, partialArgs) { - var isFunc = isFunction(func), - isPartial = !partialArgs, - key = thisArg; - - // juggle arguments - if (isPartial) { - partialArgs = thisArg; - } - if (!isFunc) { - thisArg = func; - } - - function bound() { - // `Function#bind` spec - // http://es5.github.com/#x15.3.4.5 - var args = arguments, - thisBinding = isPartial ? this : thisArg; - - if (!isFunc) { - func = thisArg[key]; - } - if (partialArgs.length) { - args = args.length - ? partialArgs.concat(slice(args)) - : partialArgs; - } - if (this instanceof bound) { - // ensure `new bound` is an instance of `bound` and `func` - noop.prototype = func.prototype; - thisBinding = new noop; - noop.prototype = null; - - // mimic the constructor's `return` behavior - // http://es5.github.com/#x13.2.2 - var result = func.apply(thisBinding, args); - return isObject(result) ? result : thisBinding; - } - return func.apply(thisBinding, args); - } - return bound; - } - - /** - * Produces an iteration callback bound to an optional `thisArg`. If `func` is - * a property name, the callback will return the property value for a given element. - * - * @private - * @param {Function|String} [func=identity|property] The function called per - * iteration or property name to query. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @param {Object} [accumulating] Used to indicate that the callback should - * accept an `accumulator` argument. - * @returns {Function} Returns a callback function. - */ - function createCallback(func, thisArg, accumulating) { - if (!func) { - return identity; - } - if (typeof func != 'function') { - return function(object) { - return object[func]; - }; - } - if (typeof thisArg != 'undefined') { - if (accumulating) { - return function(accumulator, value, index, object) { - return func.call(thisArg, accumulator, value, index, object); - }; - } - return function(value, index, object) { - return func.call(thisArg, value, index, object); - }; - } - return func; - } - - /** - * Creates compiled iteration functions. - * - * @private - * @param {Object} [options1, options2, ...] The compile options object(s). - * useHas - A boolean to specify using `hasOwnProperty` checks in the object loop. - * args - A string of comma separated arguments the iteration function will accept. - * top - A string of code to execute before the iteration branches. - * arrayLoop - A string of code to execute in the array loop. - * objectLoop - A string of code to execute in the object loop. - * bottom - A string of code to execute after the iteration branches. - * - * @returns {Function} Returns the compiled function. - */ - function createIterator() { - var data = { - 'arrayLoop': '', - 'bottom': '', - 'hasDontEnumBug': hasDontEnumBug, - 'isKeysFast': isKeysFast, - 'objectLoop': '', - 'nonEnumArgs': nonEnumArgs, - 'noCharByIndex': noCharByIndex, - 'shadowed': shadowed, - 'top': '', - 'useHas': true - }; - - // merge options into a template data object - for (var object, index = 0; object = arguments[index]; index++) { - for (var key in object) { - data[key] = object[key]; - } - } - var args = data.args; - data.firstArg = /^[^,]+/.exec(args)[0]; - - // create the function factory - var factory = Function( - 'createCallback, hasOwnProperty, isArguments, isString, objectTypes, ' + - 'nativeKeys, propertyIsEnumerable', - 'return function(' + args + ') {\n' + iteratorTemplate(data) + '\n}' - ); - // return the compiled function - return factory( - createCallback, hasOwnProperty, isArguments, isString, objectTypes, - nativeKeys, propertyIsEnumerable - ); - } - - /** - * A function compiled to iterate `arguments` objects, arrays, objects, and - * strings consistenly across environments, executing the `callback` for each - * element in the `collection`. The `callback` is bound to `thisArg` and invoked - * with three arguments; (value, index|key, collection). Callbacks may exit - * iteration early by explicitly returning `false`. - * - * @private - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Array|Object|String} Returns `collection`. - */ - var each = createIterator(eachIteratorOptions); - - /** - * Used by `template` to escape characters for inclusion in compiled - * string literals. - * - * @private - * @param {String} match The matched character to escape. - * @returns {String} Returns the escaped character. - */ - function escapeStringChar(match) { - return '\\' + stringEscapes[match]; - } - - /** - * Used by `escape` to convert characters to HTML entities. - * - * @private - * @param {String} match The matched character to escape. - * @returns {String} Returns the escaped character. - */ - function escapeHtmlChar(match) { - return htmlEscapes[match]; - } - - /** - * Checks if `value` is a DOM node in IE < 9. - * - * @private - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a DOM node, else `false`. - */ - function isNode(value) { - // IE < 9 presents DOM nodes as `Object` objects except they have `toString` - // methods that are `typeof` "string" and still can coerce nodes to strings - return typeof value.toString != 'function' && typeof (value + '') == 'string'; - } - - /** - * A no-operation function. - * - * @private - */ - function noop() { - // no operation performed - } - - /** - * Slices the `collection` from the `start` index up to, but not including, - * the `end` index. - * - * Note: This function is used, instead of `Array#slice`, to support node lists - * in IE < 9 and to ensure dense arrays are returned. - * - * @private - * @param {Array|Object|String} collection The collection to slice. - * @param {Number} start The start index. - * @param {Number} end The end index. - * @returns {Array} Returns the new array. - */ - function slice(array, start, end) { - start || (start = 0); - if (typeof end == 'undefined') { - end = array ? array.length : 0; - } - var index = -1, - length = end - start || 0, - result = Array(length < 0 ? 0 : length); - - while (++index < length) { - result[index] = array[start + index]; - } - return result; - } - - /** - * Used by `unescape` to convert HTML entities to characters. - * - * @private - * @param {String} match The matched character to unescape. - * @returns {String} Returns the unescaped character. - */ - function unescapeHtmlChar(match) { - return htmlUnescapes[match]; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Assigns own enumerable properties of source object(s) to the `destination` - * object. Subsequent sources will overwrite propery assignments of previous - * sources. - * - * @static - * @memberOf _ - * @alias extend - * @category Objects - * @param {Object} object The destination object. - * @param {Object} [source1, source2, ...] The source objects. - * @returns {Object} Returns the destination object. - * @example - * - * _.assign({ 'name': 'moe' }, { 'age': 40 }); - * // => { 'name': 'moe', 'age': 40 } - */ - var assign = createIterator(assignIteratorOptions); - - /** - * Checks if `value` is an `arguments` object. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is an `arguments` object, else `false`. - * @example - * - * (function() { return _.isArguments(arguments); })(1, 2, 3); - * // => true - * - * _.isArguments([1, 2, 3]); - * // => false - */ - function isArguments(value) { - return toString.call(value) == argsClass; - } - // fallback for browsers that can't detect `arguments` objects by [[Class]] - if (noArgsClass) { - isArguments = function(value) { - return value ? hasOwnProperty.call(value, 'callee') : false; - }; - } - - /** - * Iterates over `object`'s own and inherited enumerable properties, executing - * the `callback` for each property. The `callback` is bound to `thisArg` and - * invoked with three arguments; (value, key, object). Callbacks may exit iteration - * early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns `object`. - * @example - * - * function Dog(name) { - * this.name = name; - * } - * - * Dog.prototype.bark = function() { - * alert('Woof, woof!'); - * }; - * - * _.forIn(new Dog('Dagny'), function(value, key) { - * alert(key); - * }); - * // => alerts 'name' and 'bark' (order is not guaranteed) - */ - var forIn = createIterator(eachIteratorOptions, forOwnIteratorOptions, { - 'useHas': false - }); - - /** - * Iterates over an object's own enumerable properties, executing the `callback` - * for each property. The `callback` is bound to `thisArg` and invoked with three - * arguments; (value, key, object). Callbacks may exit iteration early by explicitly - * returning `false`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns `object`. - * @example - * - * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) { - * alert(key); - * }); - * // => alerts '0', '1', and 'length' (order is not guaranteed) - */ - var forOwn = createIterator(eachIteratorOptions, forOwnIteratorOptions); - - /** - * A fallback implementation of `isPlainObject` that checks if a given `value` - * is an object created by the `Object` constructor, assuming objects created - * by the `Object` constructor have no inherited enumerable properties and that - * there are no `Object.prototype` extensions. - * - * @private - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if `value` is a plain object, else `false`. - */ - function shimIsPlainObject(value) { - // avoid non-objects and false positives for `arguments` objects - var result = false; - if (!(value && typeof value == 'object') || isArguments(value)) { - return result; - } - // check that the constructor is `Object` (i.e. `Object instanceof Object`) - var ctor = value.constructor; - if ((!isFunction(ctor) && (!noNodeClass || !isNode(value))) || ctor instanceof ctor) { - // IE < 9 iterates inherited properties before own properties. If the first - // iterated property is an object's own property then there are no inherited - // enumerable properties. - if (iteratesOwnLast) { - forIn(value, function(value, key, object) { - result = !hasOwnProperty.call(object, key); - return false; - }); - return result === false; - } - // In most environments an object's own properties are iterated before - // its inherited properties. If the last iterated property is an object's - // own property then there are no inherited enumerable properties. - forIn(value, function(value, key) { - result = key; - }); - return result === false || hasOwnProperty.call(value, result); - } - return result; - } - - /** - * A fallback implementation of `Object.keys` that produces an array of the - * given object's own enumerable property names. - * - * @private - * @param {Object} object The object to inspect. - * @returns {Array} Returns a new array of property names. - */ - function shimKeys(object) { - var result = []; - forOwn(object, function(value, key) { - result.push(key); - }); - return result; - } - - /** - * Used to convert characters to HTML entities: - * - * Though the `>` character is escaped for symmetry, characters like `>` and `/` - * don't require escaping in HTML and have no special meaning unless they're part - * of a tag or an unquoted attribute value. - * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact") - */ - var htmlEscapes = { - '&': '&', - '<': '<', - '>': '>', - '"': '"', - "'": ''' - }; - - /** Used to convert HTML entities to characters */ - var htmlUnescapes = invert(htmlEscapes); - - /*--------------------------------------------------------------------------*/ - - /** - * Creates a clone of `value`. If `deep` is `true`, nested objects will also - * be cloned, otherwise they will be assigned by reference. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to clone. - * @param {Boolean} deep A flag to indicate a deep clone. - * @param- {Object} [guard] Internally used to allow this method to work with - * others like `_.map` without using their callback `index` argument for `deep`. - * @param- {Array} [stackA=[]] Internally used to track traversed source objects. - * @param- {Array} [stackB=[]] Internally used to associate clones with their - * source counterparts. - * @returns {Mixed} Returns the cloned `value`. - * @example - * - * var stooges = [ - * { 'name': 'moe', 'age': 40 }, - * { 'name': 'larry', 'age': 50 }, - * { 'name': 'curly', 'age': 60 } - * ]; - * - * var shallow = _.clone(stooges); - * shallow[0] === stooges[0]; - * // => true - * - * var deep = _.clone(stooges, true); - * deep[0] === stooges[0]; - * // => false - */ - function clone(value, deep, guard, stackA, stackB) { - if (value == null) { - return value; - } - if (guard) { - deep = false; - } - // inspect [[Class]] - var isObj = isObject(value); - if (isObj) { - var className = toString.call(value); - if (!cloneableClasses[className] || (noNodeClass && isNode(value))) { - return value; - } - var isArr = isArray(value); - } - // shallow clone - if (!isObj || !deep) { - return isObj - ? (isArr ? slice(value) : assign({}, value)) - : value; - } - var ctor = ctorByClass[className]; - switch (className) { - case boolClass: - case dateClass: - return new ctor(+value); - - case numberClass: - case stringClass: - return new ctor(value); - - case regexpClass: - return ctor(value.source, reFlags.exec(value)); - } - // check for circular references and return corresponding clone - stackA || (stackA = []); - stackB || (stackB = []); - - var length = stackA.length; - while (length--) { - if (stackA[length] == value) { - return stackB[length]; - } - } - // init cloned object - var result = isArr ? ctor(value.length) : {}; - - // add the source value to the stack of traversed objects - // and associate it with its clone - stackA.push(value); - stackB.push(result); - - // recursively populate clone (susceptible to call stack limits) - (isArr ? forEach : forOwn)(value, function(objValue, key) { - result[key] = clone(objValue, deep, null, stackA, stackB); - }); - - // add array properties assigned by `RegExp#exec` - if (isArr) { - if (hasOwnProperty.call(value, 'index')) { - result.index = value.index; - } - if (hasOwnProperty.call(value, 'input')) { - result.input = value.input; - } - } - return result; - } - - /** - * Creates a deep clone of `value`. Functions and DOM nodes are **not** cloned. - * The enumerable properties of `arguments` objects and objects created by - * constructors other than `Object` are cloned to plain `Object` objects. - * - * Note: This function is loosely based on the structured clone algorithm. - * See http://www.w3.org/TR/html5/common-dom-interfaces.html#internal-structured-cloning-algorithm. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to deep clone. - * @returns {Mixed} Returns the deep cloned `value`. - * @example - * - * var stooges = [ - * { 'name': 'moe', 'age': 40 }, - * { 'name': 'larry', 'age': 50 }, - * { 'name': 'curly', 'age': 60 } - * ]; - * - * var deep = _.cloneDeep(stooges); - * deep[0] === stooges[0]; - * // => false - */ - function cloneDeep(value) { - return clone(value, true); - } - - /** - * Assigns own enumerable properties of source object(s) to the `destination` - * object for all `destination` properties that resolve to `null`/`undefined`. - * Once a property is set, additional defaults of the same property will be - * ignored. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The destination object. - * @param {Object} [default1, default2, ...] The default objects. - * @returns {Object} Returns the destination object. - * @example - * - * var iceCream = { 'flavor': 'chocolate' }; - * _.defaults(iceCream, { 'flavor': 'vanilla', 'sprinkles': 'rainbow' }); - * // => { 'flavor': 'chocolate', 'sprinkles': 'rainbow' } - */ - var defaults = createIterator(assignIteratorOptions, { - 'objectLoop': 'if (result[index] == null) ' + assignIteratorOptions.objectLoop - }); - - /** - * Creates a sorted array of all enumerable properties, own and inherited, - * of `object` that have function values. - * - * @static - * @memberOf _ - * @alias methods - * @category Objects - * @param {Object} object The object to inspect. - * @returns {Array} Returns a new array of property names that have function values. - * @example - * - * _.functions(_); - * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...] - */ - function functions(object) { - var result = []; - forIn(object, function(value, key) { - if (isFunction(value)) { - result.push(key); - } - }); - return result.sort(); - } - - /** - * Checks if the specified object `property` exists and is a direct property, - * instead of an inherited property. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to check. - * @param {String} property The property to check for. - * @returns {Boolean} Returns `true` if key is a direct property, else `false`. - * @example - * - * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b'); - * // => true - */ - function has(object, property) { - return object ? hasOwnProperty.call(object, property) : false; - } - - /** - * Creates an object composed of the inverted keys and values of the given `object`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to invert. - * @returns {Object} Returns the created inverted object. - * @example - * - * _.invert({ 'first': 'Moe', 'second': 'Larry', 'third': 'Curly' }); - * // => { 'Moe': 'first', 'Larry': 'second', 'Curly': 'third' } (order is not guaranteed) - */ - function invert(object) { - var result = {}; - forOwn(object, function(value, key) { - result[value] = key; - }); - return result; - } - - /** - * Checks if `value` is an array. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is an array, else `false`. - * @example - * - * (function() { return _.isArray(arguments); })(); - * // => false - * - * _.isArray([1, 2, 3]); - * // => true - */ - var isArray = nativeIsArray || function(value) { - // `instanceof` may cause a memory leak in IE 7 if `value` is a host object - // http://ajaxian.com/archives/working-aroung-the-instanceof-memory-leak - return (argsAreObjects && value instanceof Array) || toString.call(value) == arrayClass; - }; - - /** - * Checks if `value` is a boolean (`true` or `false`) value. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a boolean value, else `false`. - * @example - * - * _.isBoolean(null); - * // => false - */ - function isBoolean(value) { - return value === true || value === false || toString.call(value) == boolClass; - } - - /** - * Checks if `value` is a date. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a date, else `false`. - * @example - * - * _.isDate(new Date); - * // => true - */ - function isDate(value) { - return value instanceof Date || toString.call(value) == dateClass; - } - - /** - * Checks if `value` is a DOM element. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a DOM element, else `false`. - * @example - * - * _.isElement(document.body); - * // => true - */ - function isElement(value) { - return value ? value.nodeType === 1 : false; - } - - /** - * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a - * length of `0` and objects with no own enumerable properties are considered - * "empty". - * - * @static - * @memberOf _ - * @category Objects - * @param {Array|Object|String} value The value to inspect. - * @returns {Boolean} Returns `true` if the `value` is empty, else `false`. - * @example - * - * _.isEmpty([1, 2, 3]); - * // => false - * - * _.isEmpty({}); - * // => true - * - * _.isEmpty(''); - * // => true - */ - function isEmpty(value) { - var result = true; - if (!value) { - return result; - } - var className = toString.call(value), - length = value.length; - - if ((className == arrayClass || className == stringClass || - className == argsClass || (noArgsClass && isArguments(value))) || - (className == objectClass && typeof length == 'number' && isFunction(value.splice))) { - return !length; - } - forOwn(value, function() { - return (result = false); - }); - return result; - } - - /** - * Performs a deep comparison between two values to determine if they are - * equivalent to each other. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} a The value to compare. - * @param {Mixed} b The other value to compare. - * @param- {Object} [stackA=[]] Internally used track traversed `a` objects. - * @param- {Object} [stackB=[]] Internally used track traversed `b` objects. - * @returns {Boolean} Returns `true` if the values are equvalent, else `false`. - * @example - * - * var moe = { 'name': 'moe', 'luckyNumbers': [13, 27, 34] }; - * var clone = { 'name': 'moe', 'luckyNumbers': [13, 27, 34] }; - * - * moe == clone; - * // => false - * - * _.isEqual(moe, clone); - * // => true - */ - function isEqual(a, b, stackA, stackB) { - // exit early for identical values - if (a === b) { - // treat `+0` vs. `-0` as not equal - return a !== 0 || (1 / a == 1 / b); - } - // a strict comparison is necessary because `null == undefined` - if (a == null || b == null) { - return a === b; - } - // compare [[Class]] names - var className = toString.call(a), - otherName = toString.call(b); - - if (className == argsClass) { - className = objectClass; - } - if (otherName == argsClass) { - otherName = objectClass; - } - if (className != otherName) { - return false; - } - switch (className) { - case boolClass: - case dateClass: - // coerce dates and booleans to numbers, dates to milliseconds and booleans - // to `1` or `0`, treating invalid dates coerced to `NaN` as not equal - return +a == +b; - - case numberClass: - // treat `NaN` vs. `NaN` as equal - return a != +a - ? b != +b - // but treat `+0` vs. `-0` as not equal - : (a == 0 ? (1 / a == 1 / b) : a == +b); - - case regexpClass: - case stringClass: - // coerce regexes to strings (http://es5.github.com/#x15.10.6.4) - // treat string primitives and their corresponding object instances as equal - return a == b + ''; - } - var isArr = className == arrayClass; - if (!isArr) { - // unwrap any `lodash` wrapped values - if (a.__wrapped__ || b.__wrapped__) { - return isEqual(a.__wrapped__ || a, b.__wrapped__ || b); - } - // exit for functions and DOM nodes - if (className != objectClass || (noNodeClass && (isNode(a) || isNode(b)))) { - return false; - } - // in older versions of Opera, `arguments` objects have `Array` constructors - var ctorA = !argsAreObjects && isArguments(a) ? Object : a.constructor, - ctorB = !argsAreObjects && isArguments(b) ? Object : b.constructor; - - // non `Object` object instances with different constructors are not equal - if (ctorA != ctorB && !( - isFunction(ctorA) && ctorA instanceof ctorA && - isFunction(ctorB) && ctorB instanceof ctorB - )) { - return false; - } - } - // assume cyclic structures are equal - // the algorithm for detecting cyclic structures is adapted from ES 5.1 - // section 15.12.3, abstract operation `JO` (http://es5.github.com/#x15.12.3) - stackA || (stackA = []); - stackB || (stackB = []); - - var length = stackA.length; - while (length--) { - if (stackA[length] == a) { - return stackB[length] == b; - } - } - var index = -1, - result = true, - size = 0; - - // add `a` and `b` to the stack of traversed objects - stackA.push(a); - stackB.push(b); - - // recursively compare objects and arrays (susceptible to call stack limits) - if (isArr) { - // compare lengths to determine if a deep comparison is necessary - size = a.length; - result = size == b.length; - - if (result) { - // deep compare the contents, ignoring non-numeric properties - while (size--) { - if (!(result = isEqual(a[size], b[size], stackA, stackB))) { - break; + return result2; } - } - } - return result; - } - // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys` - // which, in this case, is more costly - forIn(a, function(value, key, a) { - if (hasOwnProperty.call(a, key)) { - // count the number of properties. - size++; - // deep compare each property value. - return (result = hasOwnProperty.call(b, key) && isEqual(value, b[key], stackA, stackB)); - } - }); - - if (result) { - // ensure both objects have the same number of properties - forIn(b, function(value, key, b) { - if (hasOwnProperty.call(b, key)) { - // `size` will be `-1` if `b` has more properties than `a` - return (result = --size > -1); - } - }); - } - return result; - } - - /** - * Checks if `value` is, or can be coerced to, a finite number. - * - * Note: This is not the same as native `isFinite`, which will return true for - * booleans and empty strings. See http://es5.github.com/#x15.1.2.5. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a finite number, else `false`. - * @example - * - * _.isFinite(-101); - * // => true - * - * _.isFinite('10'); - * // => true - * - * _.isFinite(true); - * // => false - * - * _.isFinite(''); - * // => false - * - * _.isFinite(Infinity); - * // => false - */ - function isFinite(value) { - return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value)); - } - - /** - * Checks if `value` is a function. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - */ - function isFunction(value) { - return typeof value == 'function'; - } - // fallback for older versions of Chrome and Safari - if (isFunction(/x/)) { - isFunction = function(value) { - return value instanceof Function || toString.call(value) == funcClass; - }; - } - - /** - * Checks if `value` is the language type of Object. - * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(1); - * // => false - */ - function isObject(value) { - // check if the value is the ECMAScript language type of Object - // http://es5.github.com/#x8 - // and avoid a V8 bug - // http://code.google.com/p/v8/issues/detail?id=2291 - return value ? objectTypes[typeof value] : false; - } - - /** - * Checks if `value` is `NaN`. - * - * Note: This is not the same as native `isNaN`, which will return `true` for - * `undefined` and other values. See http://es5.github.com/#x15.1.2.4. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is `NaN`, else `false`. - * @example - * - * _.isNaN(NaN); - * // => true - * - * _.isNaN(new Number(NaN)); - * // => true - * - * isNaN(undefined); - * // => true - * - * _.isNaN(undefined); - * // => false - */ - function isNaN(value) { - // `NaN` as a primitive is the only value that is not equal to itself - // (perform the [[Class]] check first to avoid errors with some host objects in IE) - return isNumber(value) && value != +value - } - - /** - * Checks if `value` is `null`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is `null`, else `false`. - * @example - * - * _.isNull(null); - * // => true - * - * _.isNull(undefined); - * // => false - */ - function isNull(value) { - return value === null; - } - - /** - * Checks if `value` is a number. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a number, else `false`. - * @example - * - * _.isNumber(8.4 * 5); - * // => true - */ - function isNumber(value) { - return typeof value == 'number' || toString.call(value) == numberClass; - } - - /** - * Checks if a given `value` is an object created by the `Object` constructor. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if `value` is a plain object, else `false`. - * @example - * - * function Stooge(name, age) { - * this.name = name; - * this.age = age; - * } - * - * _.isPlainObject(new Stooge('moe', 40)); - * // => false - * - * _.isPlainObject([1, 2, 3]); - * // => false - * - * _.isPlainObject({ 'name': 'moe', 'age': 40 }); - * // => true - */ - var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) { - if (!(value && typeof value == 'object')) { - return false; - } - var valueOf = value.valueOf, - objProto = typeof valueOf == 'function' && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto); - - return objProto - ? value == objProto || (getPrototypeOf(value) == objProto && !isArguments(value)) - : shimIsPlainObject(value); - }; - - /** - * Checks if `value` is a regular expression. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a regular expression, else `false`. - * @example - * - * _.isRegExp(/moe/); - * // => true - */ - function isRegExp(value) { - return value instanceof RegExp || toString.call(value) == regexpClass; - } - - /** - * Checks if `value` is a string. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is a string, else `false`. - * @example - * - * _.isString('moe'); - * // => true - */ - function isString(value) { - return typeof value == 'string' || toString.call(value) == stringClass; - } - - /** - * Checks if `value` is `undefined`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Mixed} value The value to check. - * @returns {Boolean} Returns `true` if the `value` is `undefined`, else `false`. - * @example - * - * _.isUndefined(void 0); - * // => true - */ - function isUndefined(value) { - return typeof value == 'undefined'; - } - - /** - * Creates an array composed of the own enumerable property names of `object`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to inspect. - * @returns {Array} Returns a new array of property names. - * @example - * - * _.keys({ 'one': 1, 'two': 2, 'three': 3 }); - * // => ['one', 'two', 'three'] (order is not guaranteed) - */ - var keys = !nativeKeys ? shimKeys : function(object) { - // avoid iterating over the `prototype` property - return typeof object == 'function' && propertyIsEnumerable.call(object, 'prototype') - ? shimKeys(object) - : (isObject(object) ? nativeKeys(object) : []); - }; - - /** - * Merges enumerable properties of the source object(s) into the `destination` - * object. Subsequent sources will overwrite propery assignments of previous - * sources. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The destination object. - * @param {Object} [source1, source2, ...] The source objects. - * @param- {Object} [indicator] Internally used to indicate that the `stack` - * argument is an array of traversed objects instead of another source object. - * @param- {Array} [stackA=[]] Internally used to track traversed source objects. - * @param- {Array} [stackB=[]] Internally used to associate values with their - * source counterparts. - * @returns {Object} Returns the destination object. - * @example - * - * var stooges = [ - * { 'name': 'moe' }, - * { 'name': 'larry' } - * ]; - * - * var ages = [ - * { 'age': 40 }, - * { 'age': 50 } - * ]; - * - * _.merge(stooges, ages); - * // => [{ 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }] - */ - function merge(object, source, indicator) { - var args = arguments, - index = 0, - length = 2, - stackA = args[3], - stackB = args[4]; - - if (indicator !== indicatorObject) { - stackA = []; - stackB = []; - - // work with `_.reduce` by only using its callback `accumulator` and `value` arguments - if (typeof indicator != 'number') { - length = args.length; - } - } - while (++index < length) { - forOwn(args[index], function(source, key) { - var found, isArr, value; - if (source && ((isArr = isArray(source)) || isPlainObject(source))) { - // avoid merging previously merged cyclic sources - var stackLength = stackA.length; - while (stackLength--) { - found = stackA[stackLength] == source; - if (found) { - break; + function lazyValue() { + var array2 = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray2(array2), isRight = dir < 0, arrLength = isArr ? array2.length : 0, view = getView(0, arrLength, this.__views__), start2 = view.start, end = view.end, length = end - start2, index = isRight ? end : start2 - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin2(length, this.__takeCount__); + if (!isArr || !isRight && arrLength == length && takeCount == length) { + return baseWrapperValue(array2, this.__actions__); } + var result2 = []; + outer: + while (length-- && resIndex < takeCount) { + index += dir; + var iterIndex = -1, value = array2[index]; + while (++iterIndex < iterLength) { + var data = iteratees[iterIndex], iteratee2 = data.iteratee, type2 = data.type, computed = iteratee2(value); + if (type2 == LAZY_MAP_FLAG) { + value = computed; + } else if (!computed) { + if (type2 == LAZY_FILTER_FLAG) { + continue outer; + } else { + break outer; + } + } + } + result2[resIndex++] = value; + } + return result2; } - if (found) { - object[key] = stackB[stackLength]; + LazyWrapper.prototype = baseCreate(baseLodash.prototype); + LazyWrapper.prototype.constructor = LazyWrapper; + function Hash2(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]); + } } - else { - // add `source` and associated `value` to the stack of traversed objects - stackA.push(source); - stackB.push(value = (value = object[key], isArr) - ? (isArray(value) ? value : []) - : (isPlainObject(value) ? value : {}) - ); - // recursively merge objects and arrays (susceptible to call stack limits) - object[key] = merge(value, source, indicatorObject, stackA, stackB); - } - } else if (source != null) { - object[key] = source; - } - }); - } - return object; - } - - /** - * Creates a shallow clone of `object` excluding the specified properties. - * Property names may be specified as individual arguments or as arrays of - * property names. If `callback` is passed, it will be executed for each property - * in the `object`, omitting the properties `callback` returns truthy for. The - * `callback` is bound to `thisArg` and invoked with three arguments; (value, key, object). - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The source object. - * @param {Function|String} callback|[prop1, prop2, ...] The properties to omit - * or the function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns an object without the omitted properties. - * @example - * - * _.omit({ 'name': 'moe', 'age': 40, 'userid': 'moe1' }, 'userid'); - * // => { 'name': 'moe', 'age': 40 } - * - * _.omit({ 'name': 'moe', '_hint': 'knucklehead', '_seed': '96c4eb' }, function(value, key) { - * return key.charAt(0) == '_'; - * }); - * // => { 'name': 'moe' } - */ - function omit(object, callback, thisArg) { - var isFunc = typeof callback == 'function', - result = {}; - - if (isFunc) { - callback = createCallback(callback, thisArg); - } else { - var props = concat.apply(arrayRef, arguments); - } - forIn(object, function(value, key, object) { - if (isFunc - ? !callback(value, key, object) - : indexOf(props, key, 1) < 0 - ) { - result[key] = value; - } - }); - return result; - } - - /** - * Creates a two dimensional array of the given object's key-value pairs, - * i.e. `[[key1, value1], [key2, value2]]`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to inspect. - * @returns {Array} Returns new array of key-value pairs. - * @example - * - * _.pairs({ 'moe': 30, 'larry': 40, 'curly': 50 }); - * // => [['moe', 30], ['larry', 40], ['curly', 50]] (order is not guaranteed) - */ - function pairs(object) { - var result = []; - forOwn(object, function(value, key) { - result.push([key, value]); - }); - return result; - } - - /** - * Creates a shallow clone of `object` composed of the specified properties. - * Property names may be specified as individual arguments or as arrays of - * property names. If `callback` is passed, it will be executed for each property - * in the `object`, picking the properties `callback` returns truthy for. The - * `callback` is bound to `thisArg` and invoked with three arguments; (value, key, object). - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The source object. - * @param {Function|String} callback|[prop1, prop2, ...] The properties to pick - * or the function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns an object composed of the picked properties. - * @example - * - * _.pick({ 'name': 'moe', 'age': 40, 'userid': 'moe1' }, 'name', 'age'); - * // => { 'name': 'moe', 'age': 40 } - * - * _.pick({ 'name': 'moe', '_hint': 'knucklehead', '_seed': '96c4eb' }, function(value, key) { - * return key.charAt(0) != '_'; - * }); - * // => { 'name': 'moe' } - */ - function pick(object, callback, thisArg) { - var result = {}; - if (typeof callback != 'function') { - var index = 0, - props = concat.apply(arrayRef, arguments), - length = props.length; - - while (++index < length) { - var key = props[index]; - if (key in object) { - result[key] = object[key]; - } - } - } else { - callback = createCallback(callback, thisArg); - forIn(object, function(value, key, object) { - if (callback(value, key, object)) { - result[key] = value; - } - }); - } - return result; - } - - /** - * Creates an array composed of the own enumerable property values of `object`. - * - * @static - * @memberOf _ - * @category Objects - * @param {Object} object The object to inspect. - * @returns {Array} Returns a new array of property values. - * @example - * - * _.values({ 'one': 1, 'two': 2, 'three': 3 }); - * // => [1, 2, 3] - */ - function values(object) { - var result = []; - forOwn(object, function(value) { - result.push(value); - }); - return result; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Checks if a given `target` element is present in a `collection` using strict - * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used - * as the offset from the end of the collection. - * - * @static - * @memberOf _ - * @alias include - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Mixed} target The value to check for. - * @param {Number} [fromIndex=0] The index to search from. - * @returns {Boolean} Returns `true` if the `target` element is found, else `false`. - * @example - * - * _.contains([1, 2, 3], 1); - * // => true - * - * _.contains([1, 2, 3], 1, 2); - * // => false - * - * _.contains({ 'name': 'moe', 'age': 40 }, 'moe'); - * // => true - * - * _.contains('curly', 'ur'); - * // => true - */ - function contains(collection, target, fromIndex) { - var index = -1, - length = collection ? collection.length : 0, - result = false; - - fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0; - if (typeof length == 'number') { - result = (isString(collection) - ? collection.indexOf(target, fromIndex) - : indexOf(collection, target, fromIndex) - ) > -1; - } else { - each(collection, function(value) { - if (++index >= fromIndex) { - return !(result = value === target); - } - }); - } - return result; - } - - /** - * Creates an object composed of keys returned from running each element of - * `collection` through a `callback`. The corresponding value of each key is - * the number of times the key was returned by `callback`. The `callback` is - * bound to `thisArg` and invoked with three arguments; (value, index|key, collection). - * The `callback` argument may also be the name of a property to count by (e.g. 'length'). - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function|String} callback|property The function called per iteration - * or property name to count by. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); }); - * // => { '4': 1, '6': 2 } - * - * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math); - * // => { '4': 1, '6': 2 } - * - * _.countBy(['one', 'two', 'three'], 'length'); - * // => { '3': 2, '5': 1 } - */ - function countBy(collection, callback, thisArg) { - var result = {}; - callback = createCallback(callback, thisArg); - - forEach(collection, function(value, key, collection) { - key = callback(value, key, collection); - (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1); - }); - return result; - } - - /** - * Checks if the `callback` returns a truthy value for **all** elements of a - * `collection`. The `callback` is bound to `thisArg` and invoked with three - * arguments; (value, index|key, collection). - * - * @static - * @memberOf _ - * @alias all - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Boolean} Returns `true` if all elements pass the callback check, - * else `false`. - * @example - * - * _.every([true, 1, null, 'yes'], Boolean); - * // => false - */ - function every(collection, callback, thisArg) { - var result = true; - callback = createCallback(callback, thisArg); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - if (!(result = !!callback(collection[index], index, collection))) { - break; - } - } - } else { - each(collection, function(value, index, collection) { - return (result = !!callback(value, index, collection)); - }); - } - return result; - } - - /** - * Examines each element in a `collection`, returning an array of all elements - * the `callback` returns truthy for. The `callback` is bound to `thisArg` and - * invoked with three arguments; (value, index|key, collection). - * - * @static - * @memberOf _ - * @alias select - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Array} Returns a new array of elements that passed the callback check. - * @example - * - * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); - * // => [2, 4, 6] - */ - function filter(collection, callback, thisArg) { - var result = []; - callback = createCallback(callback, thisArg); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - var value = collection[index]; - if (callback(value, index, collection)) { - result.push(value); - } - } - } else { - each(collection, function(value, index, collection) { - if (callback(value, index, collection)) { - result.push(value); - } - }); - } - return result; - } - - /** - * Examines each element in a `collection`, returning the first one the `callback` - * returns truthy for. The function returns as soon as it finds an acceptable - * element, and does not iterate over the entire `collection`. The `callback` is - * bound to `thisArg` and invoked with three arguments; (value, index|key, collection). - * - * @static - * @memberOf _ - * @alias detect - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Mixed} Returns the element that passed the callback check, - * else `undefined`. - * @example - * - * var even = _.find([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); - * // => 2 - */ - function find(collection, callback, thisArg) { - var result; - callback = createCallback(callback, thisArg); - - forEach(collection, function(value, index, collection) { - if (callback(value, index, collection)) { - result = value; - return false; - } - }); - return result; - } - - /** - * Iterates over a `collection`, executing the `callback` for each element in - * the `collection`. The `callback` is bound to `thisArg` and invoked with three - * arguments; (value, index|key, collection). Callbacks may exit iteration early - * by explicitly returning `false`. - * - * @static - * @memberOf _ - * @alias each - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Array|Object|String} Returns `collection`. - * @example - * - * _([1, 2, 3]).forEach(alert).join(','); - * // => alerts each number and returns '1,2,3' - * - * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, alert); - * // => alerts each number value (order is not guaranteed) - */ - function forEach(collection, callback, thisArg) { - if (callback && typeof thisArg == 'undefined' && isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - if (callback(collection[index], index, collection) === false) { - break; - } - } - } else { - each(collection, callback, thisArg); - } - return collection; - } - - /** - * Creates an object composed of keys returned from running each element of - * `collection` through a `callback`. The corresponding value of each key is an - * array of elements passed to `callback` that returned the key. The `callback` - * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection). - * The `callback` argument may also be the name of a property to group by (e.g. 'length'). - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function|String} callback|property The function called per iteration - * or property name to group by. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); }); - * // => { '4': [4.2], '6': [6.1, 6.4] } - * - * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math); - * // => { '4': [4.2], '6': [6.1, 6.4] } - * - * _.groupBy(['one', 'two', 'three'], 'length'); - * // => { '3': ['one', 'two'], '5': ['three'] } - */ - function groupBy(collection, callback, thisArg) { - var result = {}; - callback = createCallback(callback, thisArg); - - forEach(collection, function(value, key, collection) { - key = callback(value, key, collection); - (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value); - }); - return result; - } - - /** - * Invokes the method named by `methodName` on each element in the `collection`, - * returning an array of the results of each invoked method. Additional arguments - * will be passed to each invoked method. If `methodName` is a function it will - * be invoked for, and `this` bound to, each element in the `collection`. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function|String} methodName The name of the method to invoke or - * the function invoked per iteration. - * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with. - * @returns {Array} Returns a new array of the results of each invoked method. - * @example - * - * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); - * // => [[1, 5, 7], [1, 2, 3]] - * - * _.invoke([123, 456], String.prototype.split, ''); - * // => [['1', '2', '3'], ['4', '5', '6']] - */ - function invoke(collection, methodName) { - var args = slice(arguments, 2), - isFunc = typeof methodName == 'function', - result = []; - - forEach(collection, function(value) { - result.push((isFunc ? methodName : value[methodName]).apply(value, args)); - }); - return result; - } - - /** - * Creates an array of values by running each element in the `collection` - * through a `callback`. The `callback` is bound to `thisArg` and invoked with - * three arguments; (value, index|key, collection). - * - * @static - * @memberOf _ - * @alias collect - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Array} Returns a new array of the results of each `callback` execution. - * @example - * - * _.map([1, 2, 3], function(num) { return num * 3; }); - * // => [3, 6, 9] - * - * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; }); - * // => [3, 6, 9] (order is not guaranteed) - */ - function map(collection, callback, thisArg) { - var index = -1, - length = collection ? collection.length : 0, - result = Array(typeof length == 'number' ? length : 0); - - callback = createCallback(callback, thisArg); - if (isArray(collection)) { - while (++index < length) { - result[index] = callback(collection[index], index, collection); - } - } else { - each(collection, function(value, key, collection) { - result[++index] = callback(value, key, collection); - }); - } - return result; - } - - /** - * Retrieves the maximum value of an `array`. If `callback` is passed, - * it will be executed for each value in the `array` to generate the - * criterion by which the value is ranked. The `callback` is bound to - * `thisArg` and invoked with three arguments; (value, index, collection). - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Mixed} Returns the maximum value. - * @example - * - * var stooges = [ - * { 'name': 'moe', 'age': 40 }, - * { 'name': 'larry', 'age': 50 }, - * { 'name': 'curly', 'age': 60 } - * ]; - * - * _.max(stooges, function(stooge) { return stooge.age; }); - * // => { 'name': 'curly', 'age': 60 }; - */ - function max(collection, callback, thisArg) { - var computed = -Infinity, - index = -1, - length = collection ? collection.length : 0, - result = computed; - - if (callback || !isArray(collection)) { - callback = !callback && isString(collection) - ? charAtCallback - : createCallback(callback, thisArg); - - each(collection, function(value, index, collection) { - var current = callback(value, index, collection); - if (current > computed) { - computed = current; - result = value; - } - }); - } else { - while (++index < length) { - if (collection[index] > result) { - result = collection[index]; - } - } - } - return result; - } - - /** - * Retrieves the minimum value of an `array`. If `callback` is passed, - * it will be executed for each value in the `array` to generate the - * criterion by which the value is ranked. The `callback` is bound to `thisArg` - * and invoked with three arguments; (value, index, collection). - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Mixed} Returns the minimum value. - * @example - * - * _.min([10, 5, 100, 2, 1000]); - * // => 2 - */ - function min(collection, callback, thisArg) { - var computed = Infinity, - index = -1, - length = collection ? collection.length : 0, - result = computed; - - if (callback || !isArray(collection)) { - callback = !callback && isString(collection) - ? charAtCallback - : createCallback(callback, thisArg); - - each(collection, function(value, index, collection) { - var current = callback(value, index, collection); - if (current < computed) { - computed = current; - result = value; - } - }); - } else { - while (++index < length) { - if (collection[index] < result) { - result = collection[index]; - } - } - } - return result; - } - - /** - * Retrieves the value of a specified property from all elements in - * the `collection`. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {String} property The property to pluck. - * @returns {Array} Returns a new array of property values. - * @example - * - * var stooges = [ - * { 'name': 'moe', 'age': 40 }, - * { 'name': 'larry', 'age': 50 }, - * { 'name': 'curly', 'age': 60 } - * ]; - * - * _.pluck(stooges, 'name'); - * // => ['moe', 'larry', 'curly'] - */ - function pluck(collection, property) { - return map(collection, property + ''); - } - - /** - * Boils down a `collection` to a single value. The initial state of the - * reduction is `accumulator` and each successive step of it should be returned - * by the `callback`. The `callback` is bound to `thisArg` and invoked with 4 - * arguments; for arrays they are (accumulator, value, index|key, collection). - * - * @static - * @memberOf _ - * @alias foldl, inject - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [accumulator] Initial value of the accumulator. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Mixed} Returns the accumulated value. - * @example - * - * var sum = _.reduce([1, 2, 3], function(memo, num) { return memo + num; }); - * // => 6 - */ - function reduce(collection, callback, accumulator, thisArg) { - var noaccum = arguments.length < 3; - callback = createCallback(callback, thisArg, indicatorObject); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - if (noaccum) { - accumulator = collection[++index]; - } - while (++index < length) { - accumulator = callback(accumulator, collection[index], index, collection); - } - } else { - each(collection, function(value, index, collection) { - accumulator = noaccum - ? (noaccum = false, value) - : callback(accumulator, value, index, collection) - }); - } - return accumulator; - } - - /** - * The right-associative version of `_.reduce`. - * - * @static - * @memberOf _ - * @alias foldr - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [accumulator] Initial value of the accumulator. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Mixed} Returns the accumulated value. - * @example - * - * var list = [[0, 1], [2, 3], [4, 5]]; - * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []); - * // => [4, 5, 2, 3, 0, 1] - */ - function reduceRight(collection, callback, accumulator, thisArg) { - var iteratee = collection, - length = collection ? collection.length : 0, - noaccum = arguments.length < 3; - - if (typeof length != 'number') { - var props = keys(collection); - length = props.length; - } else if (noCharByIndex && isString(collection)) { - iteratee = collection.split(''); - } - callback = createCallback(callback, thisArg, indicatorObject); - forEach(collection, function(value, index, collection) { - index = props ? props[--length] : --length; - accumulator = noaccum - ? (noaccum = false, iteratee[index]) - : callback(accumulator, iteratee[index], index, collection); - }); - return accumulator; - } - - /** - * The opposite of `_.filter`, this method returns the values of a - * `collection` that `callback` does **not** return truthy for. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Array} Returns a new array of elements that did **not** pass the - * callback check. - * @example - * - * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); - * // => [1, 3, 5] - */ - function reject(collection, callback, thisArg) { - callback = createCallback(callback, thisArg); - return filter(collection, function(value, index, collection) { - return !callback(value, index, collection); - }); - } - - /** - * Creates an array of shuffled `array` values, using a version of the - * Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to shuffle. - * @returns {Array} Returns a new shuffled collection. - * @example - * - * _.shuffle([1, 2, 3, 4, 5, 6]); - * // => [4, 1, 6, 3, 5, 2] - */ - function shuffle(collection) { - var index = -1, - result = Array(collection ? collection.length : 0); - - forEach(collection, function(value) { - var rand = floor(nativeRandom() * (++index + 1)); - result[index] = result[rand]; - result[rand] = value; - }); - return result; - } - - /** - * Gets the size of the `collection` by returning `collection.length` for arrays - * and array-like objects or the number of own enumerable properties for objects. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to inspect. - * @returns {Number} Returns `collection.length` or number of own enumerable properties. - * @example - * - * _.size([1, 2]); - * // => 2 - * - * _.size({ 'one': 1, 'two': 2, 'three': 3 }); - * // => 3 - * - * _.size('curly'); - * // => 5 - */ - function size(collection) { - var length = collection ? collection.length : 0; - return typeof length == 'number' ? length : keys(collection).length; - } - - /** - * Checks if the `callback` returns a truthy value for **any** element of a - * `collection`. The function returns as soon as it finds passing value, and - * does not iterate over the entire `collection`. The `callback` is bound to - * `thisArg` and invoked with three arguments; (value, index|key, collection). - * - * @static - * @memberOf _ - * @alias any - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Boolean} Returns `true` if any element passes the callback check, - * else `false`. - * @example - * - * _.some([null, 0, 'yes', false], Boolean); - * // => true - */ - function some(collection, callback, thisArg) { - var result; - callback = createCallback(callback, thisArg); - - if (isArray(collection)) { - var index = -1, - length = collection.length; - - while (++index < length) { - if ((result = callback(collection[index], index, collection))) { - break; - } - } - } else { - each(collection, function(value, index, collection) { - return !(result = callback(value, index, collection)); - }); - } - return !!result; - } - - /** - * Creates an array, stable sorted in ascending order by the results of - * running each element of `collection` through a `callback`. The `callback` - * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection). - * The `callback` argument may also be the name of a property to sort by (e.g. 'length'). - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Function|String} callback|property The function called per iteration - * or property name to sort by. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Array} Returns a new array of sorted elements. - * @example - * - * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); }); - * // => [3, 1, 2] - * - * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math); - * // => [3, 1, 2] - * - * _.sortBy(['larry', 'brendan', 'moe'], 'length'); - * // => ['moe', 'larry', 'brendan'] - */ - function sortBy(collection, callback, thisArg) { - var result = []; - callback = createCallback(callback, thisArg); - - forEach(collection, function(value, index, collection) { - result.push({ - 'criteria': callback(value, index, collection), - 'index': index, - 'value': value - }); - }); - - var length = result.length; - result.sort(compareAscending); - while (length--) { - result[length] = result[length].value; - } - return result; - } - - /** - * Converts the `collection` to an array. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to convert. - * @returns {Array} Returns the new converted array. - * @example - * - * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4); - * // => [2, 3, 4] - */ - function toArray(collection) { - var length = collection ? collection.length : 0; - if (typeof length == 'number') { - return noCharByIndex && isString(collection) - ? collection.split('') - : slice(collection); - } - return values(collection); - } - - /** - * Examines each element in a `collection`, returning an array of all elements - * that contain the given `properties`. - * - * @static - * @memberOf _ - * @category Collections - * @param {Array|Object|String} collection The collection to iterate over. - * @param {Object} properties The object of property values to filter by. - * @returns {Array} Returns a new array of elements that contain the given `properties`. - * @example - * - * var stooges = [ - * { 'name': 'moe', 'age': 40 }, - * { 'name': 'larry', 'age': 50 }, - * { 'name': 'curly', 'age': 60 } - * ]; - * - * _.where(stooges, { 'age': 40 }); - * // => [{ 'name': 'moe', 'age': 40 }] - */ - function where(collection, properties) { - var props = keys(properties); - return filter(collection, function(object) { - var length = props.length; - while (length--) { - var result = object[props[length]] === properties[props[length]]; - if (!result) { - break; - } - } - return !!result; - }); - } - - /*--------------------------------------------------------------------------*/ - - /** - * Creates an array with all falsey values of `array` removed. The values - * `false`, `null`, `0`, `""`, `undefined` and `NaN` are all falsey. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to compact. - * @returns {Array} Returns a new filtered array. - * @example - * - * _.compact([0, 1, false, 2, '', 3]); - * // => [1, 2, 3] - */ - function compact(array) { - var index = -1, - length = array ? array.length : 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (value) { - result.push(value); - } - } - return result; - } - - /** - * Creates an array of `array` elements not present in the other arrays - * using strict equality for comparisons, i.e. `===`. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to process. - * @param {Array} [array1, array2, ...] Arrays to check. - * @returns {Array} Returns a new array of `array` elements not present in the - * other arrays. - * @example - * - * _.difference([1, 2, 3, 4, 5], [5, 2, 10]); - * // => [1, 3, 4] - */ - function difference(array) { - var index = -1, - length = array ? array.length : 0, - flattened = concat.apply(arrayRef, arguments), - contains = cachedContains(flattened, length), - result = []; - - while (++index < length) { - var value = array[index]; - if (!contains(value)) { - result.push(value); - } - } - return result; - } - - /** - * Gets the first element of the `array`. Pass `n` to return the first `n` - * elements of the `array`. - * - * @static - * @memberOf _ - * @alias head, take - * @category Arrays - * @param {Array} array The array to query. - * @param {Number} [n] The number of elements to return. - * @param- {Object} [guard] Internally used to allow this method to work with - * others like `_.map` without using their callback `index` argument for `n`. - * @returns {Mixed} Returns the first element, or an array of the first `n` - * elements, of `array`. - * @example - * - * _.first([5, 4, 3, 2, 1]); - * // => 5 - */ - function first(array, n, guard) { - if (array) { - var length = array.length; - return (n == null || guard) - ? array[0] - : slice(array, 0, nativeMin(nativeMax(0, n), length)); - } - } - - /** - * Flattens a nested array (the nesting can be to any depth). If `shallow` is - * truthy, `array` will only be flattened a single level. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to compact. - * @param {Boolean} shallow A flag to indicate only flattening a single level. - * @returns {Array} Returns a new flattened array. - * @example - * - * _.flatten([1, [2], [3, [[4]]]]); - * // => [1, 2, 3, 4]; - * - * _.flatten([1, [2], [3, [[4]]]], true); - * // => [1, 2, 3, [[4]]]; - */ - function flatten(array, shallow) { - var index = -1, - length = array ? array.length : 0, - result = []; - - while (++index < length) { - var value = array[index]; - - // recursively flatten arrays (susceptible to call stack limits) - if (isArray(value)) { - push.apply(result, shallow ? value : flatten(value)); - } else { - result.push(value); - } - } - return result; - } - - /** - * Gets the index at which the first occurrence of `value` is found using - * strict equality for comparisons, i.e. `===`. If the `array` is already - * sorted, passing `true` for `fromIndex` will run a faster binary search. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to search. - * @param {Mixed} value The value to search for. - * @param {Boolean|Number} [fromIndex=0] The index to search from or `true` to - * perform a binary search on a sorted `array`. - * @returns {Number} Returns the index of the matched value or `-1`. - * @example - * - * _.indexOf([1, 2, 3, 1, 2, 3], 2); - * // => 1 - * - * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3); - * // => 4 - * - * _.indexOf([1, 1, 2, 2, 3, 3], 2, true); - * // => 2 - */ - function indexOf(array, value, fromIndex) { - var index = -1, - length = array ? array.length : 0; - - if (typeof fromIndex == 'number') { - index = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0) - 1; - } else if (fromIndex) { - index = sortedIndex(array, value); - return array[index] === value ? index : -1; - } - while (++index < length) { - if (array[index] === value) { - return index; - } - } - return -1; - } - - /** - * Gets all but the last element of `array`. Pass `n` to exclude the last `n` - * elements from the result. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to query. - * @param {Number} [n=1] The number of elements to exclude. - * @param- {Object} [guard] Internally used to allow this method to work with - * others like `_.map` without using their callback `index` argument for `n`. - * @returns {Array} Returns all but the last element, or `n` elements, of `array`. - * @example - * - * _.initial([3, 2, 1]); - * // => [3, 2] - */ - function initial(array, n, guard) { - if (!array) { - return []; - } - var length = array.length; - n = n == null || guard ? 1 : n || 0; - return slice(array, 0, nativeMin(nativeMax(0, length - n), length)); - } - - /** - * Computes the intersection of all the passed-in arrays using strict equality - * for comparisons, i.e. `===`. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} [array1, array2, ...] Arrays to process. - * @returns {Array} Returns a new array of unique elements that are present - * in **all** of the arrays. - * @example - * - * _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]); - * // => [1, 2] - */ - function intersection(array) { - var args = arguments, - argsLength = args.length, - cache = { '0': {} }, - index = -1, - length = array ? array.length : 0, - isLarge = length >= 100, - result = [], - seen = result; - - outer: - while (++index < length) { - var value = array[index]; - if (isLarge) { - var key = value + ''; - var inited = hasOwnProperty.call(cache[0], key) - ? !(seen = cache[0][key]) - : (seen = cache[0][key] = []); - } - if (inited || indexOf(seen, value) < 0) { - if (isLarge) { - seen.push(value); - } - var argsIndex = argsLength; - while (--argsIndex) { - if (!(cache[argsIndex] || (cache[argsIndex] = cachedContains(args[argsIndex], 0, 100)))(value)) { - continue outer; + function hashClear2() { + this.__data__ = nativeCreate2 ? nativeCreate2(null) : {}; + this.size = 0; } - } - result.push(value); - } - } - return result; - } - - /** - * Gets the last element of the `array`. Pass `n` to return the last `n` - * elements of the `array`. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to query. - * @param {Number} [n] The number of elements to return. - * @param- {Object} [guard] Internally used to allow this method to work with - * others like `_.map` without using their callback `index` argument for `n`. - * @returns {Mixed} Returns the last element, or an array of the last `n` - * elements, of `array`. - * @example - * - * _.last([3, 2, 1]); - * // => 1 - */ - function last(array, n, guard) { - if (array) { - var length = array.length; - return (n == null || guard) ? array[length - 1] : slice(array, nativeMax(0, length - n)); - } - } - - /** - * Gets the index at which the last occurrence of `value` is found using strict - * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used - * as the offset from the end of the collection. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to search. - * @param {Mixed} 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 or `-1`. - * @example - * - * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2); - * // => 4 - * - * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3); - * // => 1 - */ - function lastIndexOf(array, value, fromIndex) { - var index = array ? array.length : 0; - if (typeof fromIndex == 'number') { - index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1; - } - while (index--) { - if (array[index] === value) { - return index; - } - } - return -1; - } - - /** - * Creates an object composed from arrays of `keys` and `values`. Pass either - * a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`, or - * two arrays, one of `keys` and one of corresponding `values`. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} keys The array of keys. - * @param {Array} [values=[]] The array of values. - * @returns {Object} Returns an object composed of the given keys and - * corresponding values. - * @example - * - * _.object(['moe', 'larry', 'curly'], [30, 40, 50]); - * // => { 'moe': 30, 'larry': 40, 'curly': 50 } - */ - function object(keys, values) { - var index = -1, - length = keys ? keys.length : 0, - result = {}; - - while (++index < length) { - var key = keys[index]; - if (values) { - result[key] = values[index]; - } else { - result[key[0]] = key[1]; - } - } - return result; - } - - /** - * Creates an array of numbers (positive and/or negative) progressing from - * `start` up to but not including `stop`. This method is a port of Python's - * `range()` function. See http://docs.python.org/library/functions.html#range. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Number} [start=0] The start of the range. - * @param {Number} end The end of the range. - * @param {Number} [step=1] The value to increment or descrement by. - * @returns {Array} Returns a new range array. - * @example - * - * _.range(10); - * // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - * - * _.range(1, 11); - * // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] - * - * _.range(0, 30, 5); - * // => [0, 5, 10, 15, 20, 25] - * - * _.range(0, -10, -1); - * // => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] - * - * _.range(0); - * // => [] - */ - function range(start, end, step) { - start = +start || 0; - step = +step || 1; - - if (end == null) { - end = start; - start = 0; - } - // use `Array(length)` so V8 will avoid the slower "dictionary" mode - // http://youtu.be/XAqIpGU8ZZk#t=17m25s - var index = -1, - length = nativeMax(0, ceil((end - start) / step)), - result = Array(length); - - while (++index < length) { - result[index] = start; - start += step; - } - return result; - } - - /** - * The opposite of `_.initial`, this method gets all but the first value of - * `array`. Pass `n` to exclude the first `n` values from the result. - * - * @static - * @memberOf _ - * @alias drop, tail - * @category Arrays - * @param {Array} array The array to query. - * @param {Number} [n=1] The number of elements to exclude. - * @param- {Object} [guard] Internally used to allow this method to work with - * others like `_.map` without using their callback `index` argument for `n`. - * @returns {Array} Returns all but the first element, or `n` elements, of `array`. - * @example - * - * _.rest([3, 2, 1]); - * // => [2, 1] - */ - function rest(array, n, guard) { - return slice(array, (n == null || guard) ? 1 : nativeMax(0, n)); - } - - /** - * Uses a binary search to determine the smallest index at which the `value` - * should be inserted into `array` in order to maintain the sort order of the - * sorted `array`. If `callback` is passed, it will be executed for `value` and - * each element in `array` to compute their sort ranking. The `callback` is - * bound to `thisArg` and invoked with one argument; (value). The `callback` - * argument may also be the name of a property to order by. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to iterate over. - * @param {Mixed} value The value to evaluate. - * @param {Function|String} [callback=identity|property] The function called - * per iteration or property name to order by. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Number} Returns the index at which the value should be inserted - * into `array`. - * @example - * - * _.sortedIndex([20, 30, 50], 40); - * // => 2 - * - * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x'); - * // => 2 - * - * var dict = { - * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 } - * }; - * - * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { - * return dict.wordToNumber[word]; - * }); - * // => 2 - * - * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { - * return this.wordToNumber[word]; - * }, dict); - * // => 2 - */ - function sortedIndex(array, value, callback, thisArg) { - var low = 0, - high = array ? array.length : low; - - // explicitly reference `identity` for better inlining in Firefox - callback = callback ? createCallback(callback, thisArg) : identity; - value = callback(value); - - while (low < high) { - var mid = (low + high) >>> 1; - callback(array[mid]) < value - ? low = mid + 1 - : high = mid; - } - return low; - } - - /** - * Computes the union of the passed-in arrays using strict equality for - * comparisons, i.e. `===`. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} [array1, array2, ...] Arrays to process. - * @returns {Array} Returns a new array of unique values, in order, that are - * present in one or more of the arrays. - * @example - * - * _.union([1, 2, 3], [101, 2, 1, 10], [2, 1]); - * // => [1, 2, 3, 101, 10] - */ - function union() { - return uniq(concat.apply(arrayRef, arguments)); - } - - /** - * Creates a duplicate-value-free version of the `array` using strict equality - * for comparisons, i.e. `===`. If the `array` is already sorted, passing `true` - * for `isSorted` will run a faster algorithm. If `callback` is passed, each - * element of `array` is passed through a callback` before uniqueness is computed. - * The `callback` is bound to `thisArg` and invoked with three arguments; (value, index, array). - * - * @static - * @memberOf _ - * @alias unique - * @category Arrays - * @param {Array} array The array to process. - * @param {Boolean} [isSorted=false] A flag to indicate that the `array` is already sorted. - * @param {Function} [callback=identity] The function called per iteration. - * @param {Mixed} [thisArg] The `this` binding of `callback`. - * @returns {Array} Returns a duplicate-value-free array. - * @example - * - * _.uniq([1, 2, 1, 3, 1]); - * // => [1, 2, 3] - * - * _.uniq([1, 1, 2, 2, 3], true); - * // => [1, 2, 3] - * - * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return Math.floor(num); }); - * // => [1, 2, 3] - * - * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return this.floor(num); }, Math); - * // => [1, 2, 3] - */ - function uniq(array, isSorted, callback, thisArg) { - var index = -1, - length = array ? array.length : 0, - result = [], - seen = result; - - // juggle arguments - if (typeof isSorted == 'function') { - thisArg = callback; - callback = isSorted; - isSorted = false; - } - // init value cache for large arrays - var isLarge = !isSorted && length >= 75; - if (isLarge) { - var cache = {}; - } - if (callback) { - seen = []; - callback = createCallback(callback, thisArg); - } - while (++index < length) { - var value = array[index], - computed = callback ? callback(value, index, array) : value; - - if (isLarge) { - var key = computed + ''; - var inited = hasOwnProperty.call(cache, key) - ? !(seen = cache[key]) - : (seen = cache[key] = []); - } - if (isSorted - ? !index || seen[seen.length - 1] !== computed - : inited || indexOf(seen, computed) < 0 - ) { - if (callback || isLarge) { - seen.push(computed); - } - result.push(value); - } - } - return result; - } - - /** - * Creates an array with all occurrences of the passed values removed using - * strict equality for comparisons, i.e. `===`. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} array The array to filter. - * @param {Mixed} [value1, value2, ...] Values to remove. - * @returns {Array} Returns a new filtered array. - * @example - * - * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1); - * // => [2, 3, 4] - */ - function without(array) { - var index = -1, - length = array ? array.length : 0, - contains = cachedContains(arguments, 1, 20), - result = []; - - while (++index < length) { - var value = array[index]; - if (!contains(value)) { - result.push(value); - } - } - return result; - } - - /** - * Groups the elements of each array at their corresponding indexes. Useful for - * separate data sources that are coordinated through matching array indexes. - * For a matrix of nested arrays, `_.zip.apply(...)` can transpose the matrix - * in a similar fashion. - * - * @static - * @memberOf _ - * @category Arrays - * @param {Array} [array1, array2, ...] Arrays to process. - * @returns {Array} Returns a new array of grouped elements. - * @example - * - * _.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]); - * // => [['moe', 30, true], ['larry', 40, false], ['curly', 50, false]] - */ - function zip(array) { - var index = -1, - length = array ? max(pluck(arguments, 'length')) : 0, - result = Array(length); - - while (++index < length) { - result[index] = pluck(arguments, index); - } - return result; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Creates a function that is restricted to executing `func` only after it is - * called `n` times. The `func` is executed with the `this` binding of the - * created function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Number} n The number of times the function must be called before - * it is executed. - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var renderNotes = _.after(notes.length, render); - * _.forEach(notes, function(note) { - * note.asyncSave({ 'success': renderNotes }); - * }); - * // `renderNotes` is run once, after all notes have saved - */ - function after(n, func) { - if (n < 1) { - return func(); - } - return function() { - if (--n < 1) { - return func.apply(this, arguments); - } - }; - } - - /** - * Creates a function that, when called, invokes `func` with the `this` - * binding of `thisArg` and prepends any additional `bind` arguments to those - * passed to the bound function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to bind. - * @param {Mixed} [thisArg] The `this` binding of `func`. - * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * var func = function(greeting) { - * return greeting + ' ' + this.name; - * }; - * - * func = _.bind(func, { 'name': 'moe' }, 'hi'); - * func(); - * // => 'hi moe' - */ - function bind(func, thisArg) { - // use `Function#bind` if it exists and is fast - // (in V8 `Function#bind` is slower except when partially applied) - return isBindFast || (nativeBind && arguments.length > 2) - ? nativeBind.call.apply(nativeBind, arguments) - : createBound(func, thisArg, slice(arguments, 2)); - } - - /** - * Binds methods on `object` to `object`, overwriting the existing method. - * If no method names are provided, all the function properties of `object` - * will be bound. - * - * @static - * @memberOf _ - * @category Functions - * @param {Object} object The object to bind and assign the bound methods to. - * @param {String} [methodName1, methodName2, ...] Method names on the object to bind. - * @returns {Object} Returns `object`. - * @example - * - * var buttonView = { - * 'label': 'lodash', - * 'onClick': function() { alert('clicked: ' + this.label); } - * }; - * - * _.bindAll(buttonView); - * jQuery('#lodash_button').on('click', buttonView.onClick); - * // => When the button is clicked, `this.label` will have the correct value - */ - function bindAll(object) { - var funcs = arguments, - index = funcs.length > 1 ? 0 : (funcs = functions(object), -1), - length = funcs.length; - - while (++index < length) { - var key = funcs[index]; - object[key] = bind(object[key], object); - } - return object; - } - - /** - * Creates a function that, when called, invokes the method at `object[key]` - * and prepends any additional `bindKey` arguments to those passed to the bound - * function. This method differs from `_.bind` by allowing bound functions to - * reference methods that will be redefined or don't yet exist. - * See http://michaux.ca/articles/lazy-function-definition-pattern. - * - * @static - * @memberOf _ - * @category Functions - * @param {Object} object The object the method belongs to. - * @param {String} key The key of the method. - * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * var object = { - * 'name': 'moe', - * 'greet': function(greeting) { - * return greeting + ' ' + this.name; - * } - * }; - * - * var func = _.bindKey(object, 'greet', 'hi'); - * func(); - * // => 'hi moe' - * - * object.greet = function(greeting) { - * return greeting + ', ' + this.name + '!'; - * }; - * - * func(); - * // => 'hi, moe!' - */ - function bindKey(object, key) { - return createBound(object, key, slice(arguments, 2)); - } - - /** - * Creates a function that is the composition of the passed functions, - * where each function consumes the return value of the function that follows. - * In math terms, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`. - * Each function is executed with the `this` binding of the composed function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} [func1, func2, ...] Functions to compose. - * @returns {Function} Returns the new composed function. - * @example - * - * var greet = function(name) { return 'hi: ' + name; }; - * var exclaim = function(statement) { return statement + '!'; }; - * var welcome = _.compose(exclaim, greet); - * welcome('moe'); - * // => 'hi: moe!' - */ - function compose() { - var funcs = arguments; - return function() { - var args = arguments, - length = funcs.length; - - while (length--) { - args = [funcs[length].apply(this, args)]; - } - return args[0]; - }; - } - - /** - * Creates a function that will delay the execution of `func` until after - * `wait` milliseconds have elapsed since the last time it was invoked. Pass - * `true` for `immediate` to cause debounce to invoke `func` on the leading, - * instead of the trailing, edge of the `wait` timeout. Subsequent calls to - * the debounced function will return the result of the last `func` call. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to debounce. - * @param {Number} wait The number of milliseconds to delay. - * @param {Boolean} immediate A flag to indicate execution is on the leading - * edge of the timeout. - * @returns {Function} Returns the new debounced function. - * @example - * - * var lazyLayout = _.debounce(calculateLayout, 300); - * jQuery(window).on('resize', lazyLayout); - */ - function debounce(func, wait, immediate) { - var args, - result, - thisArg, - timeoutId; - - function delayed() { - timeoutId = null; - if (!immediate) { - result = func.apply(thisArg, args); - } - } - return function() { - var isImmediate = immediate && !timeoutId; - args = arguments; - thisArg = this; - - clearTimeout(timeoutId); - timeoutId = setTimeout(delayed, wait); - - if (isImmediate) { - result = func.apply(thisArg, args); - } - return result; - }; - } - - /** - * Executes the `func` function after `wait` milliseconds. Additional arguments - * will be passed to `func` when it is invoked. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to delay. - * @param {Number} wait The number of milliseconds to delay execution. - * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with. - * @returns {Number} Returns the `setTimeout` timeout id. - * @example - * - * var log = _.bind(console.log, console); - * _.delay(log, 1000, 'logged later'); - * // => 'logged later' (Appears after one second.) - */ - function delay(func, wait) { - var args = slice(arguments, 2); - return setTimeout(function() { func.apply(undefined, args); }, wait); - } - - /** - * Defers executing the `func` function until the current call stack has cleared. - * Additional arguments will be passed to `func` when it is invoked. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to defer. - * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with. - * @returns {Number} Returns the `setTimeout` timeout id. - * @example - * - * _.defer(function() { alert('deferred'); }); - * // returns from the function before `alert` is called - */ - function defer(func) { - var args = slice(arguments, 1); - return setTimeout(function() { func.apply(undefined, args); }, 1); - } - - /** - * Creates a function that memoizes the result of `func`. If `resolver` is - * passed, it will be used to determine the cache key for storing the result - * based on the arguments passed to the memoized function. By default, the first - * argument passed to the memoized function is used as the cache key. The `func` - * is executed with the `this` binding of the memoized function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to have its output memoized. - * @param {Function} [resolver] A function used to resolve the cache key. - * @returns {Function} Returns the new memoizing function. - * @example - * - * var fibonacci = _.memoize(function(n) { - * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); - * }); - */ - function memoize(func, resolver) { - var cache = {}; - return function() { - var key = resolver ? resolver.apply(this, arguments) : arguments[0]; - return hasOwnProperty.call(cache, key) - ? cache[key] - : (cache[key] = func.apply(this, arguments)); - }; - } - - /** - * Creates a function that is restricted to execute `func` once. Repeat calls to - * the function will return the value of the first call. The `func` is executed - * with the `this` binding of the created function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var initialize = _.once(createApplication); - * initialize(); - * initialize(); - * // Application is only created once. - */ - function once(func) { - var result, - ran = false; - - return function() { - if (ran) { - return result; - } - ran = true; - result = func.apply(this, arguments); - - // clear the `func` variable so the function may be garbage collected - func = null; - return result; - }; - } - - /** - * Creates a function that, when called, invokes `func` with any additional - * `partial` arguments prepended to those passed to the new function. This - * method is similar to `bind`, except it does **not** alter the `this` binding. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to partially apply arguments to. - * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * var greet = function(greeting, name) { return greeting + ': ' + name; }; - * var hi = _.partial(greet, 'hi'); - * hi('moe'); - * // => 'hi: moe' - */ - function partial(func) { - return createBound(func, slice(arguments, 1)); - } - - /** - * Creates a function that, when executed, will only call the `func` - * function at most once per every `wait` milliseconds. If the throttled - * function is invoked more than once during the `wait` timeout, `func` will - * also be called on the trailing edge of the timeout. Subsequent calls to the - * throttled function will return the result of the last `func` call. - * - * @static - * @memberOf _ - * @category Functions - * @param {Function} func The function to throttle. - * @param {Number} wait The number of milliseconds to throttle executions to. - * @returns {Function} Returns the new throttled function. - * @example - * - * var throttled = _.throttle(updatePosition, 100); - * jQuery(window).on('scroll', throttled); - */ - function throttle(func, wait) { - var args, - result, - thisArg, - timeoutId, - lastCalled = 0; - - function trailingCall() { - lastCalled = new Date; - timeoutId = null; - result = func.apply(thisArg, args); - } - return function() { - var now = new Date, - remaining = wait - (now - lastCalled); - - args = arguments; - thisArg = this; - - if (remaining <= 0) { - clearTimeout(timeoutId); - timeoutId = null; - lastCalled = now; - result = func.apply(thisArg, args); - } - else if (!timeoutId) { - timeoutId = setTimeout(trailingCall, remaining); - } - return result; - }; - } - - /** - * Creates a function that passes `value` to the `wrapper` function as its - * first argument. Additional arguments passed to the function are appended - * to those passed to the `wrapper` function. The `wrapper` is executed with - * the `this` binding of the created function. - * - * @static - * @memberOf _ - * @category Functions - * @param {Mixed} value The value to wrap. - * @param {Function} wrapper The wrapper function. - * @returns {Function} Returns the new function. - * @example - * - * var hello = function(name) { return 'hello ' + name; }; - * hello = _.wrap(hello, function(func) { - * return 'before, ' + func('moe') + ', after'; - * }); - * hello(); - * // => 'before, hello moe, after' - */ - function wrap(value, wrapper) { - return function() { - var args = [value]; - push.apply(args, arguments); - return wrapper.apply(this, args); - }; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their - * corresponding HTML entities. - * - * @static - * @memberOf _ - * @category Utilities - * @param {String} string The string to escape. - * @returns {String} Returns the escaped string. - * @example - * - * _.escape('Moe, Larry & Curly'); - * // => 'Moe, Larry & Curly' - */ - function escape(string) { - return string == null ? '' : (string + '').replace(reUnescapedHtml, escapeHtmlChar); - } - - /** - * This function returns the first argument passed to it. - * - * @static - * @memberOf _ - * @category Utilities - * @param {Mixed} value Any value. - * @returns {Mixed} Returns `value`. - * @example - * - * var moe = { 'name': 'moe' }; - * moe === _.identity(moe); - * // => true - */ - function identity(value) { - return value; - } - - /** - * Adds functions properties of `object` to the `lodash` function and chainable - * wrapper. - * - * @static - * @memberOf _ - * @category Utilities - * @param {Object} object The object of function properties to add to `lodash`. - * @example - * - * _.mixin({ - * 'capitalize': function(string) { - * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase(); - * } - * }); - * - * _.capitalize('larry'); - * // => 'Larry' - * - * _('curly').capitalize(); - * // => 'Curly' - */ - function mixin(object) { - forEach(functions(object), function(methodName) { - var func = lodash[methodName] = object[methodName]; - - lodash.prototype[methodName] = function() { - var args = [this.__wrapped__]; - push.apply(args, arguments); - - var result = func.apply(lodash, args); - return new lodash(result); - }; - }); - } - - /** - * Reverts the '_' variable to its previous value and returns a reference to - * the `lodash` function. - * - * @static - * @memberOf _ - * @category Utilities - * @returns {Function} Returns the `lodash` function. - * @example - * - * var lodash = _.noConflict(); - */ - function noConflict() { - window._ = oldDash; - return this; - } - - /** - * Produces a random number between `min` and `max` (inclusive). If only one - * argument is passed, a number between `0` and the given number will be returned. - * - * @static - * @memberOf _ - * @category Utilities - * @param {Number} [min=0] The minimum possible value. - * @param {Number} [max=1] The maximum possible value. - * @returns {Number} Returns a random number. - * @example - * - * _.random(0, 5); - * // => a number between 1 and 5 - * - * _.random(5); - * // => also a number between 1 and 5 - */ - function random(min, max) { - if (min == null && max == null) { - max = 1; - } - min = +min || 0; - if (max == null) { - max = min; - min = 0; - } - return min + floor(nativeRandom() * ((+max || 0) - min + 1)); - } - - /** - * Resolves the value of `property` on `object`. If `property` is a function - * it will be invoked and its result returned, else the property value is - * returned. If `object` is falsey, then `null` is returned. - * - * @static - * @memberOf _ - * @category Utilities - * @param {Object} object The object to inspect. - * @param {String} property The property to get the value of. - * @returns {Mixed} Returns the resolved value. - * @example - * - * var object = { - * 'cheese': 'crumpets', - * 'stuff': function() { - * return 'nonsense'; - * } - * }; - * - * _.result(object, 'cheese'); - * // => 'crumpets' - * - * _.result(object, 'stuff'); - * // => 'nonsense' - */ - function result(object, property) { - // based on Backbone's private `getValue` function - // https://github.com/documentcloud/backbone/blob/0.9.2/backbone.js#L1419-1424 - var value = object ? object[property] : null; - return isFunction(value) ? object[property]() : value; - } - - /** - * A micro-templating method that handles arbitrary delimiters, preserves - * whitespace, and correctly escapes quotes within interpolated code. - * - * Note: In the development build `_.template` utilizes sourceURLs for easier - * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl - * - * Note: Lo-Dash may be used in Chrome extensions by either creating a `lodash csp` - * build and avoiding `_.template` use, or loading Lo-Dash in a sandboxed page. - * See http://developer.chrome.com/trunk/extensions/sandboxingEval.html - * - * @static - * @memberOf _ - * @category Utilities - * @param {String} text The template text. - * @param {Obect} data The data object used to populate the text. - * @param {Object} options The options object. - * escape - The "escape" delimiter regexp. - * evaluate - The "evaluate" delimiter regexp. - * interpolate - The "interpolate" delimiter regexp. - * sourceURL - The sourceURL of the template's compiled source. - * variable - The data object variable name. - * - * @returns {Function|String} Returns a compiled function when no `data` object - * is given, else it returns the interpolated text. - * @example - * - * // using a compiled template - * var compiled = _.template('hello <%= name %>'); - * compiled({ 'name': 'moe' }); - * // => 'hello moe' - * - * var list = '<% _.forEach(people, function(name) { %>
  • <%= name %>
  • <% }); %>'; - * _.template(list, { 'people': ['moe', 'larry', 'curly'] }); - * // => '
  • moe
  • larry
  • curly
  • ' - * - * // using the "escape" delimiter to escape HTML in data property values - * _.template('<%- value %>', { 'value': '