{"version":3,"sources":["webpack:///./node_modules/lodash/_listCacheHas.js","webpack:///./node_modules/topojson-client/src/identity.js","webpack:///./node_modules/topojson-client/src/transform.js","webpack:///./node_modules/topojson-client/src/feature.js","webpack:///./node_modules/topojson-client/src/reverse.js","webpack:///./node_modules/lodash/_coreJsData.js","webpack:///./node_modules/lodash/_toSource.js","webpack:///./node_modules/lodash/memoize.js","webpack:///./node_modules/lodash/_Hash.js","webpack:///./node_modules/preact-html-converter/dist/preact-html-converter.browser.js","webpack:///../../index.ts","webpack:///../src/apmonth.js","webpack:///../src/apdate.js","webpack:///../src/apmonthtab.js","webpack:///../src/apdatetab.js","webpack:///../src/utils.js","webpack:///../src/apnumber.js","webpack:///../src/aptime.js","webpack:///../src/capfirst.js","webpack:///../src/intcomma.js","webpack:///../src/intword.js","webpack:///../src/ordinalsuffix.js","webpack:///../src/ordinal.js","webpack:///../src/pluralize.js","webpack:///../src/widont.js","webpack:///../src/yesno.js","webpack:///./node_modules/lodash/_getRawTag.js","webpack:///./node_modules/lodash/_getNative.js","webpack:///./node_modules/lodash/_isMasked.js","webpack:///./node_modules/lodash/_isKeyable.js","webpack:///./node_modules/lodash/isObject.js","webpack:///./node_modules/lodash/_mapCacheSet.js","webpack:///./node_modules/lodash/_hashDelete.js","webpack:///./node_modules/d3-geo/src/identity.js","webpack:///./node_modules/lodash/_mapCacheGet.js","webpack:///./node_modules/lodash/_hashSet.js","webpack:///./node_modules/lodash/_listCacheClear.js","webpack:///./node_modules/lodash/_objectToString.js","webpack:///./node_modules/lodash/_root.js","webpack:///./node_modules/lodash/_baseIsNative.js","webpack:///./node_modules/lodash/_getValue.js","webpack:///./node_modules/lodash/_baseGetTag.js","webpack:///./node_modules/robust-predicates/esm/util.js","webpack:///./node_modules/robust-predicates/esm/orient2d.js","webpack:///./node_modules/robust-predicates/esm/orient3d.js","webpack:///./node_modules/robust-predicates/esm/incircle.js","webpack:///./node_modules/robust-predicates/esm/insphere.js","webpack:///./node_modules/point-in-polygon-hao/dist/esm/index.js","webpack:///./node_modules/lodash/_getMapData.js","webpack:///./node_modules/d3-geo/src/math.js","webpack:///./node_modules/d3-geo/src/path/bounds.js","webpack:///./node_modules/lodash/_hashClear.js","webpack:///./node_modules/classnames/index.js","webpack:///./node_modules/lodash/_freeGlobal.js","webpack:///./node_modules/lodash/_ListCache.js","webpack:///./node_modules/lodash/_nativeCreate.js","webpack:///./node_modules/lodash/_listCacheSet.js","webpack:///./node_modules/lodash/_listCacheDelete.js","webpack:///./node_modules/d3-geo/src/clip/rejoin.js","webpack:///./node_modules/d3-geo/src/pointEqual.js","webpack:///./node_modules/d3-geo/src/clip/rectangle.js","webpack:///./node_modules/d3-geo/src/clip/buffer.js","webpack:///./node_modules/d3-geo/src/clip/line.js","webpack:///./node_modules/d3-geo/src/transform.js","webpack:///./node_modules/d3-geo/src/projection/fit.js","webpack:///./node_modules/d3-geo/src/projection/identity.js","webpack:///./node_modules/lodash/_MapCache.js","webpack:///./node_modules/lodash/_Map.js","webpack:///./node_modules/lodash/_hashHas.js","webpack:///./node_modules/lodash/_mapCacheClear.js","webpack:///./node_modules/lodash/_mapCacheDelete.js","webpack:///./node_modules/lodash/isFunction.js","webpack:///./node_modules/lodash/eq.js","webpack:///./node_modules/d3-geo/src/noop.js","webpack:///./node_modules/lodash/_Symbol.js","webpack:///./node_modules/lodash/_mapCacheHas.js","webpack:///./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack:///./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/lodash/_listCacheGet.js","webpack:///./node_modules/d3-geo/src/stream.js","webpack:///./node_modules/lodash/_hashGet.js","webpack:///./node_modules/d3-geo/src/adder.js","webpack:///./node_modules/d3-geo/src/path/area.js","webpack:///./node_modules/d3-geo/src/path/centroid.js","webpack:///./node_modules/d3-geo/src/path/context.js","webpack:///./node_modules/d3-geo/src/path/measure.js","webpack:///./node_modules/d3-geo/src/path/string.js","webpack:///./node_modules/d3-geo/src/path/index.js","webpack:///./node_modules/lodash/_assocIndexOf.js","webpack:///../src/vnode.js","webpack:///../src/options.js","webpack:///../src/h.js","webpack:///../src/util.js","webpack:///../src/clone-element.js","webpack:///../src/constants.js","webpack:///../src/render-queue.js","webpack:///../src/vdom/index.js","webpack:///../src/dom/index.js","webpack:///../src/vdom/diff.js","webpack:///../src/vdom/component.js","webpack:///../src/vdom/component-recycler.js","webpack:///../src/component.js","webpack:///../src/render.js","webpack:///../src/preact.js","webpack:///(webpack)/buildin/global.js"],"names":["assocIndexOf","require","module","exports","key","this","__data__","x","transform","identity","x0","y0","kx","scale","ky","dx","translate","dy","input","i","j","n","length","output","Array","topology","o","objects","type","features","geometries","map","feature","id","bbox","properties","geometry","object","transformPoint","arcs","arc","points","pop","a","k","push","array","t","reverse","point","p","line","ring","polygon","coordinates","coreJsData","funcToString","Function","prototype","toString","func","call","e","MapCache","memoize","resolver","TypeError","memoized","args","arguments","apply","cache","has","get","result","set","Cache","hashClear","hashDelete","hashGet","hashHas","hashSet","Hash","entries","index","clear","entry","preact","NodeType","parser","parseFragment","htmlString","DOMParser","parseFromString","body","serialize","element","innerHTML","__assign","Object","assign","s","hasOwnProperty","trimHTMLString","html","replace","convertAttributes","attributes","convAttrs","name","value","split","reduce","obj","styleDeclaration","parts","keyCharacters","trim","toUpperCase","join","convertElement","registeredComponents","component","nodeName","toLowerCase","tagName","childNodes","h","children","convertNode","node","Text","nodeValue","isElement","undefined","BaseConverter","Map","convert","fragment","rootNode","nodeTree","traverseNodeTree","filter","registerComponent","baseConvertStatic","target","source","rootElement","dangerouslySetInnerHTML","__html","PreactHTMLConverter","convertStatic","defineProperty","factory","index_default","options","west","Number","south","east","north","Error","lowLeft","topLeft","topRight","lowRight","0","1","2","3","4","5","6","7","8","9","10","11","Date","getMonth","r","getDate","getFullYear","u","isFinite","l","Math","floor","f","v","getHours","getMinutes","c","String","charAt","slice","g","d","abs","ceil","log","LN10","pow","round","M","S","indexOf","D","w","y","isArray","b","RegExp","m","A","Symbol","objectProto","nativeObjectToString","symToStringTag","toStringTag","isOwn","tag","unmasked","baseIsNative","getValue","uid","maskSrcKey","exec","keys","IE_PROTO","getMapData","data","size","nativeCreate","freeGlobal","freeSelf","self","root","isFunction","isMasked","isObject","toSource","reIsHostCtor","funcProto","reIsNative","test","getRawTag","objectToString","splitter","sum","elen","flen","Q","Qnew","hh","bvirt","enow","fnow","eindex","findex","hindex","estimate","vec","Float64Array","B","C1","C2","orient2d","ax","ay","bx","by","cx","cy","detleft","detright","det","detsum","acxtail","acytail","bcxtail","bcytail","ahi","alo","bhi","blo","_i","_j","_0","s1","s0","t1","t0","u3","acx","bcx","acy","bcy","errbound","C1len","C2len","Dlen","orient2dadapt","pointInPolygon","ii","u1","v1","u2","v2","currentP","nextP","numContours","contour","contourLen","getCoord","coord","getGeom","geojson","inBBox","pt","geom","polys","polyResult","pip","ignoreBoundary","isKeyable","epsilon","pi","PI","tau","degrees","radians","cos","atan","atan2","sin","exp","sqrt","sign","tan","feat","isNumber","lineString","num","isNaN","Infinity","x1","y1","boundsStream","lineStart","noop","lineEnd","polygonStart","polygonEnd","bounds","hasOwn","classNames","classes","arg","appendClass","parseValue","includes","newClass","default","global","listCacheClear","listCacheDelete","listCacheGet","listCacheHas","listCacheSet","ListCache","getNative","splice","Intersection","other","z","segments","compareIntersection","startInside","interpolate","stream","subject","clip","forEach","segment","p0","p1","sort","link","start","current","isSubject","clipRectangle","visible","from","to","direction","a1","corner","comparePoint","ca","cb","x__","y__","v__","x_","y_","v_","first","clean","lines","activeStream","bufferStream","rejoin","concat","shift","clipStream","linePoint","NaN","winding","a0","b0","b1","polygonInside","cleanInside","merge","clipRejoin","max","min","clipLine","transformer","methods","TransformStream","constructor","sphere","fit","projection","fitBounds","clipExtent","geoStream","fitExtent","extent","sa","cacheStream","tx","ty","sx","sy","alpha","postclip","reset","invert","_","angle","reflectX","reflectY","fitSize","fitWidth","width","fitHeight","height","mapCacheClear","mapCacheDelete","mapCacheGet","mapCacheHas","mapCacheSet","coordEach","callback","excludeWrapCoord","stopG","coords","geometryMaybeCollection","isGeometryCollection","wrapShrink","coordIndex","isFeatureCollection","isFeature","stop","featureIndex","geomIndex","multiFeatureIndex","geometryIndex","geomType","recompute","baseGetTag","_typeof","iterator","toPropertyKey","toPrimitive","_defineProperty","enumerable","configurable","writable","streamGeometry","streamGeometryType","streamObjectType","Feature","FeatureCollection","Sphere","Point","MultiPoint","LineString","streamLine","MultiLineString","Polygon","streamPolygon","MultiPolygon","GeometryCollection","closed","coordinate","Adder","add","temp","valueOf","adder","bv","av","x00","y00","areaSum","areaRingSum","areaStream","areaRingStart","areaRingEnd","area","areaPointFirst","areaPoint","X0","Y0","Z0","X1","Y1","Z1","X2","Y2","Z2","centroidStream","centroidPoint","centroidLineStart","centroidLineEnd","centroidRingStart","centroidRingEnd","centroid","centroidPointFirstLine","centroidPointLine","centroidPointFirstRing","centroidPointRing","PathContext","context","_context","_radius","pointRadius","_line","_point","closePath","moveTo","lineTo","lengthRing","lengthSum","lengthStream","lengthPointFirst","lengthPoint","PathString","_string","circle","radius","_circle","projectionStream","contextStream","path","pathArea","measure","pathMeasure","pathBounds","pathCentroid","eq","VNode","stack","EMPTY_CHILDREN","lastSimple","child","simple","vnode","extend","props","applyRef","ref","defer","Promise","resolve","then","bind","setTimeout","cloneElement","IS_NON_DIMENSIONAL","items","enqueueRender","debounceRendering","rerender","_componentConstructor","isNamedNode","normalizedNodeName","getNodeProps","defaultProps","parentNode","setAccessor","old","isSvg","style","cssText","addEventListener","eventProxy","useCapture","_listeners","removeAttribute","ns","removeAttributeNS","setAttributeNS","setAttribute","className","mounts","hydrating","componentDidMount","diff","dom","mountAll","parent","componentRoot","isSvgMode","ownerSVGElement","diffLevel","flushMounts","ret","out","splitText","_component","document","createTextNode","replaceChild","isDirectOwner","isOwner","_parentComponent","base","originalComponent","oldDom","nextBase","vnodeName","createElementNS","createElement","firstChild","vchildren","fc","nextSibling","isHydrating","vchild","len","_child","originalChildren","vlen","__key","keyedLen","childrenLen","idiff","keyed","recollectNodeTree","attrs","prevSvgMode","unmountOnly","removeChildren","previousSibling","recyclerComponents","inst","Component","render","doRender","Ctor","state","componentWillMount","componentWillReceiveProps","prevProps","renderMode","syncComponentUpdates","__ref","renderComponent","isChild","rendered","cbase","prevState","initialBase","isUpdate","skip","snapshot","previousContext","getDerivedStateFromProps","previousProps","previousState","componentWillUpdate","prevContext","_dirty","getChildContext","getSnapshotBeforeUpdate","childProps","createComponent","childComponent","initialChildComponent","toUnmount","componentRef","componentDidUpdate","_renderCallbacks","beforeUnmount","componentWillUnmount","inner","createRef","window"],"mappings":"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","file":"3.94500f2a4f.mjs","sourcesContent":["var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","export default function(x) {\n  return x;\n}\n","import identity from \"./identity.js\";\n\nexport default function(transform) {\n  if (transform == null) return identity;\n  var x0,\n      y0,\n      kx = transform.scale[0],\n      ky = transform.scale[1],\n      dx = transform.translate[0],\n      dy = transform.translate[1];\n  return function(input, i) {\n    if (!i) x0 = y0 = 0;\n    var j = 2, n = input.length, output = new Array(n);\n    output[0] = (x0 += input[0]) * kx + dx;\n    output[1] = (y0 += input[1]) * ky + dy;\n    while (j < n) output[j] = input[j], ++j;\n    return output;\n  };\n}\n","import reverse from \"./reverse.js\";\nimport transform from \"./transform.js\";\n\nexport default function(topology, o) {\n  if (typeof o === \"string\") o = topology.objects[o];\n  return o.type === \"GeometryCollection\"\n      ? {type: \"FeatureCollection\", features: o.geometries.map(function(o) { return feature(topology, o); })}\n      : feature(topology, o);\n}\n\nfunction feature(topology, o) {\n  var id = o.id,\n      bbox = o.bbox,\n      properties = o.properties == null ? {} : o.properties,\n      geometry = object(topology, o);\n  return id == null && bbox == null ? {type: \"Feature\", properties: properties, geometry: geometry}\n      : bbox == null ? {type: \"Feature\", id: id, properties: properties, geometry: geometry}\n      : {type: \"Feature\", id: id, bbox: bbox, properties: properties, geometry: geometry};\n}\n\nexport function object(topology, o) {\n  var transformPoint = transform(topology.transform),\n      arcs = topology.arcs;\n\n  function arc(i, points) {\n    if (points.length) points.pop();\n    for (var a = arcs[i < 0 ? ~i : i], k = 0, n = a.length; k < n; ++k) {\n      points.push(transformPoint(a[k], k));\n    }\n    if (i < 0) reverse(points, n);\n  }\n\n  function point(p) {\n    return transformPoint(p);\n  }\n\n  function line(arcs) {\n    var points = [];\n    for (var i = 0, n = arcs.length; i < n; ++i) arc(arcs[i], points);\n    if (points.length < 2) points.push(points[0]); // This should never happen per the specification.\n    return points;\n  }\n\n  function ring(arcs) {\n    var points = line(arcs);\n    while (points.length < 4) points.push(points[0]); // This may happen if an arc has only two points.\n    return points;\n  }\n\n  function polygon(arcs) {\n    return arcs.map(ring);\n  }\n\n  function geometry(o) {\n    var type = o.type, coordinates;\n    switch (type) {\n      case \"GeometryCollection\": return {type: type, geometries: o.geometries.map(geometry)};\n      case \"Point\": coordinates = point(o.coordinates); break;\n      case \"MultiPoint\": coordinates = o.coordinates.map(point); break;\n      case \"LineString\": coordinates = line(o.arcs); break;\n      case \"MultiLineString\": coordinates = o.arcs.map(line); break;\n      case \"Polygon\": coordinates = polygon(o.arcs); break;\n      case \"MultiPolygon\": coordinates = o.arcs.map(polygon); break;\n      default: return null;\n    }\n    return {type: type, coordinates: coordinates};\n  }\n\n  return geometry(o);\n}\n","export default function(array, n) {\n  var t, j = array.length, i = j - n;\n  while (i < --j) t = array[i], array[i++] = array[j], array[j] = t;\n}\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n","var MapCache = require('./_MapCache');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  var memoized = function() {\n    var args = arguments,\n        key = resolver ? resolver.apply(this, args) : args[0],\n        cache = memoized.cache;\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    var result = func.apply(this, args);\n    memoized.cache = cache.set(key, result) || cache;\n    return result;\n  };\n  memoized.cache = new (memoize.Cache || MapCache);\n  return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nmodule.exports = memoize;\n","var hashClear = require('./_hashClear'),\n    hashDelete = require('./_hashDelete'),\n    hashGet = require('./_hashGet'),\n    hashHas = require('./_hashHas'),\n    hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('preact')) :\n    typeof define === 'function' && define.amd ? define(['exports', 'preact'], factory) :\n    (factory((global.preactHtmlConverter = {}),global.preact));\n}(this, (function (exports,preact) { 'use strict';\n\n    var parser = {\r\n        parseFragment: function (htmlString) {\r\n            var parser = new DOMParser();\r\n            var doc = parser.parseFromString(htmlString, \"text/html\");\r\n            return doc.body;\r\n        },\r\n        serialize: function (element) {\r\n            return element.innerHTML;\r\n        }\r\n    };\n\n    /*! *****************************************************************************\r\n    Copyright (c) Microsoft Corporation. All rights reserved.\r\n    Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\n    this file except in compliance with the License. You may obtain a copy of the\r\n    License at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\n    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\n    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\n    MERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\n    See the Apache Version 2.0 License for specific language governing permissions\r\n    and limitations under the License.\r\n    ***************************************************************************** */\r\n\r\n    var __assign = function() {\r\n        __assign = Object.assign || function __assign(t) {\r\n            for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n                s = arguments[i];\r\n                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n            }\r\n            return t;\r\n        };\r\n        return __assign.apply(this, arguments);\r\n    };\n\n    var NodeType;\r\n    (function (NodeType) {\r\n        NodeType[\"Text\"] = \"#text\";\r\n        NodeType[\"Comment\"] = \"#comment\";\r\n    })(NodeType || (NodeType = {}));\r\n    var convertStylesToObject = function (styles) {\r\n        return styles\r\n            .split(\";\")\r\n            .reduce(function (obj, styleDeclaration) {\r\n            if (styleDeclaration) {\r\n                var parts = styleDeclaration.split(\":\");\r\n                var key = parts[0].trim();\r\n                var keyCharacters = key.split(\"\");\r\n                for (var i = 0; i < keyCharacters.length; i++) {\r\n                    if (keyCharacters[i] === \"-\") {\r\n                        keyCharacters[i + 1] = keyCharacters[i + 1].toUpperCase();\r\n                        keyCharacters[i] = null;\r\n                    }\r\n                }\r\n                obj[keyCharacters.join(\"\")] = parts[1];\r\n            }\r\n            return obj;\r\n        }, {});\r\n    };\r\n    var trimHTMLString = function (html) {\r\n        html = html.replace(/\\n|\\t|\\r|\\0/g, \"\");\r\n        return html;\r\n    };\r\n    var assign = function (target, source) { return (__assign({}, target, source)); };\n\n    var convertAttributes = function (attributes, key) {\r\n        var convAttrs = {\r\n            key: key.toString()\r\n        };\r\n        if (!attributes)\r\n            return convAttrs;\r\n        for (var i = 0; i < attributes.length; i++) {\r\n            convAttrs[attributes[i].name] = (attributes[i].name === \"style\") ? convertStylesToObject(attributes[i].value) : attributes[i].value;\r\n        }\r\n        return convAttrs;\r\n    };\r\n    var convertElement = function (element, key, registeredComponents) {\r\n        var component = registeredComponents.get(element.nodeName.toLowerCase());\r\n        var attributes = convertAttributes(element.attributes, key);\r\n        var tagName = element.tagName.toLowerCase();\r\n        if (element.childNodes.length === 0) {\r\n            return component ? preact.h(component, attributes) : preact.h(tagName, attributes);\r\n        }\r\n        var children = new Array();\r\n        for (var i = 0; i < element.childNodes.length; i++) {\r\n            children.push(convertNode(element.childNodes[i], i, registeredComponents));\r\n        }\r\n        return component ? preact.h(component, attributes, children) : preact.h(tagName, attributes, children);\r\n    };\r\n    var convertNode = function (node, key, registeredComponents) {\r\n        if (node.nodeName === NodeType.Text && node.nodeValue.trim() !== \"\") {\r\n            return node.nodeValue;\r\n        }\r\n        if (isElement(node)) {\r\n            return convertElement(node, key, registeredComponents);\r\n        }\r\n        return null;\r\n    };\r\n    var traverseNodeTree = function (rootNode, registeredComponents) {\r\n        var nodeTree = new Array();\r\n        for (var i = 0; i < rootNode.childNodes.length; i++) {\r\n            nodeTree.push(convertNode(rootNode.childNodes[i], i, registeredComponents));\r\n        }\r\n        return nodeTree;\r\n    };\r\n    var isElement = function (node) {\r\n        return node.attributes !== undefined;\r\n    };\r\n    function BaseConverter(parser) {\r\n        var registeredComponents = new Map();\r\n        return {\r\n            convert: function (htmlString) {\r\n                if (typeof htmlString !== \"string\") {\r\n                    return null;\r\n                }\r\n                htmlString = trimHTMLString(htmlString);\r\n                var fragment = parser.parseFragment(htmlString);\r\n                if (fragment.childNodes.length > 0) {\r\n                    return traverseNodeTree(fragment, registeredComponents).filter(function (value) {\r\n                        return value ? true : false;\r\n                    });\r\n                }\r\n                return null;\r\n            },\r\n            registerComponent: function (name, component) {\r\n                registeredComponents.set(name.toLowerCase(), component);\r\n            }\r\n        };\r\n    }\r\n    function baseConvertStatic(htmlString, parser) {\r\n        if (typeof htmlString !== \"string\") {\r\n            return null;\r\n        }\r\n        htmlString = trimHTMLString(htmlString);\r\n        var fragment = parser.parseFragment(htmlString);\r\n        if (fragment.childNodes.length > 0) {\r\n            var rootElement = void 0;\r\n            if (fragment.childNodes.length === 1) {\r\n                var element = fragment.childNodes[0];\r\n                if (isElement(element)) {\r\n                    rootElement = preact.h(element.nodeName.toLowerCase(), assign({\r\n                        dangerouslySetInnerHTML: {\r\n                            __html: parser.serialize(element)\r\n                        }\r\n                    }, convertAttributes(element.attributes, 0)));\r\n                }\r\n            }\r\n            else {\r\n                rootElement = preact.h(\"div\", { dangerouslySetInnerHTML: { __html: htmlString } });\r\n            }\r\n            return rootElement;\r\n        }\r\n        return null;\r\n    }\n\n    var PreactHTMLConverter = function () { return BaseConverter(parser); };\r\n    var convertStatic = function (htmlString) { return baseConvertStatic(htmlString, parser); };\n\n    exports.PreactHTMLConverter = PreactHTMLConverter;\n    exports.convertStatic = convertStatic;\n\n    Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n","import { BBox } from \"geojson\";\nimport { AllGeoJSON } from \"@turf/helpers\";\nimport { coordEach } from \"@turf/meta\";\n\n/**\n * Calculates the bounding box for any GeoJSON object, including FeatureCollection.\n * Uses geojson.bbox if available and options.recompute is not set.\n *\n * @function\n * @param {GeoJSON} geojson any GeoJSON object\n * @param {Object} [options={}] Optional parameters\n * @param {boolean} [options.recompute] Whether to ignore an existing bbox property on geojson\n * @returns {BBox} bbox extent in [minX, minY, maxX, maxY] order\n * @example\n * var line = turf.lineString([[-74, 40], [-78, 42], [-82, 35]]);\n * var bbox = turf.bbox(line);\n * var bboxPolygon = turf.bboxPolygon(bbox);\n *\n * //addToMap\n * var addToMap = [line, bboxPolygon]\n */\nfunction bbox(\n  geojson: AllGeoJSON,\n  options: {\n    recompute?: boolean;\n  } = {}\n): BBox {\n  if (geojson.bbox != null && true !== options.recompute) {\n    return geojson.bbox;\n  }\n  const result: BBox = [Infinity, Infinity, -Infinity, -Infinity];\n  coordEach(geojson, (coord) => {\n    if (result[0] > coord[0]) {\n      result[0] = coord[0];\n    }\n    if (result[1] > coord[1]) {\n      result[1] = coord[1];\n    }\n    if (result[2] < coord[0]) {\n      result[2] = coord[0];\n    }\n    if (result[3] < coord[1]) {\n      result[3] = coord[1];\n    }\n  });\n  return result;\n}\n\nexport { bbox };\nexport default bbox;\n","/**\n * Map of AP month abbreviations. Note that they are zero-indexed due to\n * JavaScript's life choices. Exported for testing purposes.\n *\n * @private\n * @type {object}\n */\nexport const AP_MONTHS = {\n  0: 'Jan.',\n  1: 'Feb.',\n  2: 'March',\n  3: 'April',\n  4: 'May',\n  5: 'June',\n  6: 'July',\n  7: 'Aug.',\n  8: 'Sept.',\n  9: 'Oct.',\n  10: 'Nov.',\n  11: 'Dec.',\n};\n\n/**\n * Returns an AP-formatted month string that corresponds with the supplied\n * Date. If an `input` is not passed, it will use the result of `new Date();`.\n *\n * @param  {Date} [date] JavaScript Date object, defaults to current date if\n *                       not passed\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * // Remember that JavaScript zero-indexes months!\n * journalize.apmonth(new Date(2016, 10, 8));\n * // returns 'Nov.'\n *\n * // Uses the current date if no parameter is passed\n * journalize.apmonth();\n * // returns 'July' (pretend it is actually July)\n */\nexport default function apmonth(date = new Date()) {\n  return AP_MONTHS[date.getMonth()];\n}\n","import apmonth from './apmonth';\n\n/**\n * Returns an AP-formatted date string that corresponds with the supplied\n * Date. If an `input` is not passed, it will use the result of `new Date();`.\n *\n * @param  {Date} [date] JavaScript Date object, defaults to current date if\n *                       not passed\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * // Remember that JavaScript zero-indexes months!\n * journalize.apdate(new Date(2016, 10, 8));\n * // returns 'Nov. 8, 2016'\n *\n * // Uses the current date if no parameter is passed\n * journalize.apdate();\n * // returns 'July 4, 2016' (pretend it is actually July 4, 2016)\n */\nexport default function apdate(date = new Date()) {\n  const month = apmonth(date);\n  const dayOfMonth = date.getDate();\n  const year = date.getFullYear();\n\n  return `${month} ${dayOfMonth}, ${year}`;\n}\n","/**\n * Map of AP month abbreviations. Note that they are zero-indexed due to\n * JavaScript's life choices. Exported for testing purposes.\n *\n * @private\n * @type {object}\n */\nexport const AP_MONTHS_TAB = {\n  0: 'Jan',\n  1: 'Feb',\n  2: 'Mar',\n  3: 'Apr',\n  4: 'May',\n  5: 'Jun',\n  6: 'Jul',\n  7: 'Aug',\n  8: 'Sep',\n  9: 'Oct',\n  10: 'Nov',\n  11: 'Dec',\n};\n\n/**\n * Returns a tabular AP-formatted month string that corresponds with the supplied\n * Date. If an `input` is not passed, it will use the result of `new Date();`.\n *\n * @param  {Date} [date] JavaScript Date object, defaults to current date if\n *                       not passed\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * // Remember that JavaScript zero-indexes months!\n * journalize.apmonth(new Date(2016, 10, 8));\n * // returns 'Nov'\n *\n * // Uses the current date if no parameter is passed\n * journalize.apmonth();\n * // returns 'Jul' (pretend it is actually July)\n */\nexport default function apmonthtab(date = new Date()) {\n  return AP_MONTHS_TAB[date.getMonth()];\n}\n","import apmonthtab from './apmonthtab';\n\n/**\n * Returns a tabular AP-formatted date string that corresponds with the supplied\n * Date. If an `input` is not passed, it will use the result of `new Date();`.\n *\n * @param  {Date} [date] JavaScript Date object, defaults to current date if\n *                       not passed\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * // Remember that JavaScript zero-indexes months!\n * journalize.apdate(new Date(2016, 10, 8));\n * // returns 'Nov 8, 2016'\n *\n * // Uses the current date if no parameter is passed\n * journalize.apdate();\n * // returns 'Jul 4, 2016' (pretend it is actually July 4, 2016)\n */\nexport default function apdatetab(date = new Date()) {\n  const month = apmonthtab(date);\n  const dayOfMonth = date.getDate();\n  const year = date.getFullYear();\n\n  return `${month} ${dayOfMonth}, ${year}`;\n}\n","/**\n * Returns true if `value` is null or undefined;\n *\n * @private\n * @param  {*}  value\n * @return {boolean}\n */\nexport function isNil(value) {\n  return value == null;\n}\n\n/**\n * Returns true if `value` is a finite number.\n *\n * Based on: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite\n *\n * @private\n * @param  {*}  value\n * @return {boolean}\n */\nexport function _isFinite(value) {\n  return typeof value === 'number' && isFinite(value);\n}\n\n/**\n * Returns true if `value` is an integer.\n *\n * Based on: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger\n *\n * @private\n * @param  {*}  value\n * @return {boolean}\n */\nexport function isInteger(value) {\n  return _isFinite(value) && Math.floor(value) === value;\n}\n","import { isInteger, isNil } from './utils';\n\n/**\n * List of spelled out numbers per AP style.\n * @private\n * @type {string[]}\n */\nconst AP_NUMBERS = [\n  'one',\n  'two',\n  'three',\n  'four',\n  'five',\n  'six',\n  'seven',\n  'eight',\n  'nine',\n];\n\n/**\n * Converts an integer to string representation per AP style rules. If an\n * integer is not one that would be converted, it is returned in its original\n * form.\n *\n * If a non-integer is given, it will be returned in its original form as\n * well.\n *\n * @param  {number|string} val\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * journalize.apnumber(8);\n * // returns 'eight'\n *\n * journalize.apnumber(42);\n * // returns 42\n *\n */\nexport default function apnumber(val) {\n  // if `val` is undefined or null, return an empty string\n  if (isNil(val)) return '';\n\n  // convert `val` to a number\n  const convertedVal = +val;\n\n  // if `convertedVal` is not an integer, return `val` coerced to a string\n  if (!isInteger(convertedVal)) return val.toString();\n\n  // if `convertedVal` is not between 0 and 10, return `val` coerced to a string\n  if (convertedVal <= 0 || convertedVal >= 10) return val.toString();\n\n  return AP_NUMBERS[convertedVal - 1];\n}\n","/**\n * Returns an AP-formatted time string that corresponds with the supplied\n * Date. If an `input` is not passed, it will use the result of `new Date();`.\n *\n * @param  {Date} [date] JavaScript Date object, defaults to current date if\n *                       not passed\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * // Bright and early\n * journalize.aptime(new Date(2016, 10, 8, 6, 30));\n * // returns '6:30 a.m.'\n *\n * // It can handle `p.m.` too\n * journalize.aptime(new Date(2016, 10, 8, 16, 30));\n * // returns '4:30 p.m.'\n *\n * // Uses the current time if no parameter is passed\n * journalize.aptime();\n * // returns '6:45 p.m.' (pretend it is actually 6:45 p.m. right now)\n */\nexport default function aptime(date = new Date()) {\n  const hours = date.getHours();\n  const minutes = date.getMinutes();\n\n  const minutesAreZero = minutes === 0;\n\n  if (minutesAreZero) {\n    if (hours === 0) return 'midnight';\n    if (hours === 12) return 'noon';\n  }\n\n  let period, hour;\n\n  if (hours < 12) {\n    period = 'a.m.';\n    // account for how Date() returns 12 a.m. as 0\n    if (hours > 0) {\n      hour = hours;\n    } else {\n      hour = 12;\n    }\n  } else {\n    period = 'p.m.';\n\n    if (hours === 12) {\n      hour = hours;\n    } else {\n      hour = hours - 12;\n    }\n  }\n\n  if (minutesAreZero) {\n    return hour + ' ' + period;\n  }\n\n  const minute = minutes < 10 ? '0' + minutes : minutes;\n  return hour + ':' + minute + ' ' + period;\n}\n","import { isNil } from './utils';\n\n/**\n * Capitalizes the first character of a value and returns it.\n *\n * @param {any} val\n * @returns {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * journalize.capfirst('hello world');\n * // returns 'Hello world'\n */\nexport default function capfirst(val) {\n  // if `val` is undefined or null, return an empty string\n  if (isNil(val)) return '';\n\n  // coerce value to a String\n  const str = String(val);\n\n  return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;\n}\n","import { _isFinite, isNil } from './utils';\n\n/**\n * Converts a number to include commas, if necessary.\n *\n * Source: http://stackoverflow.com/a/2901298\n *\n * @private\n * @param  {number|string} n\n * @return {string}\n */\nfunction numberWithCommas(n) {\n  const parts = n.toString().split('.');\n  parts[0] = parts[0].replace(/\\B(?=(\\d{3})+(?!\\d))/g, ',');\n  return parts.join('.');\n}\n\n/**\n * Alters a string or number to include commas. If `val` is undefined or null,\n * an empty string is returned.\n *\n * @param  {number|string} val\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * journalize.intcomma(10311);\n * // returns '10,311'\n *\n * journalize.intcomma('1234567.1234567');\n * // returns '1,234,567.1234567'\n */\nexport default function intcomma(val) {\n  // if `val` is undefined or null, return an empty string\n  if (isNil(val)) return '';\n\n  const convertedVal = +val;\n\n  // if `convertedVal` is not a number, don't waste time converting it\n  if (!_isFinite(convertedVal)) return val.toString();\n\n  return numberWithCommas(convertedVal);\n}\n","import { isInteger, isNil } from './utils';\n\n/**\n * Array of suffixes to be used by intword.\n * @private\n * @type {string[]}\n */\nconst SUFFIXES = [\n  'million',\n  'billion',\n  'trillion',\n  'quadrillion',\n  'quintillion',\n  'sextillion',\n  'septillion',\n  'octillion',\n  'nonillion',\n  'decillion',\n];\n\n/**\n * Returns the number of digits found in a number. Accounts for exponents, too.\n *\n * @private\n * @param  {number} n\n * @return {number}\n */\nfunction getLengthOfNumber(n) {\n  return Math.ceil(Math.log(n + 1) / Math.LN10);\n}\n\n/**\n * Converts a large integer into a string representation. Only makes sense for\n * numbers at least 1 million or more.\n *\n * @param  {number|string} val\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * journalize.intword(1000000);\n * // returns '1 million'\n *\n * journalize.intword(6500000000000);\n * // returns '6.5 trillion'\n */\nexport default function intword(val) {\n  // if `val` is undefined or null, return an empty string\n  if (isNil(val)) return '';\n\n  const convertedVal = +val;\n\n  // if `convertedVal` is not an integer, return `val`\n  if (!isInteger(convertedVal)) return val.toString();\n\n  // get the absolute value to de-sign it\n  const absConvertedVal = Math.abs(convertedVal);\n\n  // if `convertedVal` is less than 1 million, no conversion is needed\n  if (absConvertedVal < 1000000) return val.toString();\n\n  // get the number of digits in the number, and substract remainder to get\n  // exponent value\n  const numDigits = getLengthOfNumber(absConvertedVal) - 1;\n  const exponent = numDigits - (numDigits % 3);\n\n  // calculate the rounded version of `convertedVal`\n  let newVal = convertedVal / Math.pow(10, exponent);\n  newVal = Math.round(newVal * 10) / 10;\n\n  return newVal + ' ' + SUFFIXES[Math.floor(exponent / 3) - 2];\n}\n","import { isInteger, isNil } from './utils.js';\n\n/**\n * A list of suffixes for conversions.\n * @private\n * @type {string[]}\n */\nconst SUFFIXES = ['th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th'];\n\n/**\n * A list of funky English ordinals.\n * @private\n * @type {number[]}\n */\nconst ENGLISH_ORDINAL_EXCEPTIONS = [11, 12, 13];\n\n/**\n * Determines the ordinal suffix for a given integer. Handles the special\n * cases of 11, 12 and 13. If a non-integer is submitted an empty string will\n * be returned.\n *\n * @param  {number|string} val\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * journalize.ordinalsuffix(5);\n * // returns 'th'\n *\n * journalize.ordinalsuffix(13);\n * // returns 'th'\n *\n * journalize.ordinalsuffix(103);\n * // returns 'rd'\n *\n * journalize.ordinalsuffix(7);\n * // returns 'th'\n *\n * journalize.ordinalsuffix('foo');\n * // returns ''\n */\nexport default function ordinalsuffix(val) {\n  // if `val` is undefined or null, return an empty string\n  if (isNil(val)) return '';\n\n  // ensure `val` is a number\n  const convertedVal = +val;\n\n  // if `convertedVal` is not an integer, return an empty string\n  if (!isInteger(convertedVal)) return '';\n\n  // if `convertedVal` is 11, 12 or 13, English gets weird\n  if (ENGLISH_ORDINAL_EXCEPTIONS.indexOf(convertedVal % 100) > -1) {\n    return SUFFIXES[0];\n  }\n\n  // return the appropriate suffix\n  return SUFFIXES[convertedVal % 10];\n}\n","import { isInteger, isNil } from './utils';\nimport ordinalsuffix from './ordinalsuffix';\n\n/**\n * List of spelled out ordinals per AP style.\n * @private\n * @type {string[]}\n */\nconst AP_ORDINALS = [\n  'first',\n  'second',\n  'third',\n  'fourth',\n  'fifth',\n  'sixth',\n  'seventh',\n  'eighth',\n  'ninth',\n];\n\n/**\n * Converts an integer into its ordinal form. If `spellOutOrdinals` is `true`,\n * 1 through 9 will be spelled out per AP style. Handles the special cases of\n * 11, 12 and 13, too. If a non-integer is submitted it will be returned in\n * its original form.\n *\n * @param  {number|string} val\n * @param {boolean} [spellOutOrdinals]\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * journalize.ordinal(5);\n * // returns '5th'\n *\n * journalize.ordinal(13);\n * // returns '13th'\n *\n * journalize.ordinal(103);\n * // returns '103rd'\n *\n * journalize.ordinal(7, true);\n * // returns 'seventh'\n */\nexport default function ordinal(val, spellOutOrdinals = false) {\n  // if `val` is undefined or null, return an empty string\n  if (isNil(val)) return '';\n\n  // ensure `val` is a number\n  const convertedVal = +val;\n\n  // if `convertedVal` is not an integer, return `val`\n  if (!isInteger(convertedVal)) return val.toString();\n\n  // if `spellOutOrdinals` is true, return the spelled out versions of 1-9\n  if (spellOutOrdinals && convertedVal < 10) {\n    return AP_ORDINALS[convertedVal - 1];\n  }\n\n  // get the suffix\n  const suffix = ordinalsuffix(convertedVal);\n\n  // return the original value with the suffix\n  return convertedVal + suffix;\n}\n","/**\n * Returns a plural suffix if the value is not 1. By default, `pluralize`\n * uses \"s\" as the suffix. If a `String` is provided, `pluralize` will attempt\n * to convert it into a `Number`. If an `Array` is provided instead of a\n * number, the length of the `Array` is used to determine the suffix. An\n * alternative plural suffix can be provided as the second parameter, and if\n * necessary, an alternative singular suffix can be provided as the third.\n *\n * @param {number|string|array} value\n * @param {string} [pluralSuffix='s']\n * @param {string} [singularSuffix='']\n * @return {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * // typical usage\n * 'vote' + journalize.pluralize(0); // votes\n * 'vote' + journalize.pluralize(1); // vote\n * 'vote' + journalize.pluralize(2); // votes\n *\n * // the plural suffix may be changed\n * 'class' + journalize.pluralize(0, 'es'); // classes\n * 'class' + journalize.pluralize(1, 'es'); // class\n * 'class' + journalize.pluralize(2, 'es'); // classes\n *\n * // some words also need a custom singular suffix\n * 'cand' + journalize.pluralize(0, 'ies', 'y'); // candies\n * 'cand' + journalize.pluralize(1, 'ies', 'y'); // candy\n * 'cand' + journalize.pluralize(2, 'ies', 'y'); // candies\n */\nexport default function pluralize(\n  value,\n  pluralSuffix = 's',\n  singularSuffix = ''\n) {\n  // if this is an array, base the return value on the length\n  if (Array.isArray(value)) {\n    if (value.length !== 1) {\n      return pluralSuffix;\n    } else {\n      return singularSuffix;\n    }\n  }\n\n  // otherwise we have a string or number - convert it and test if its 1\n  if (Number(value) !== 1) {\n    return pluralSuffix;\n  }\n\n  return singularSuffix;\n}\n","import { isNil } from './utils';\n\n/**\n * The non-breaking space character added to the string passed to widont.\n * Exported for testing purposes.\n *\n * @private\n * @type {string}\n */\nexport const nbsp = '\\xA0';\n\n/**\n * The regular expression to find the final space in a string for widont.\n *\n * @private\n * @type {RegExp}\n */\nconst widontRegex = new RegExp(/\\s+([^\\s]*)\\s*$/);\n\n/**\n * Prevents \"widows\" - a word by itself on a line - from appearing in strings\n * by replacing the space between the last two words with a non-breaking space\n * character.\n *\n * @param {string} val\n * @param {string} [replaceChar='\\xA0'] The character to replace the space with\n * @returns {string}\n * @example\n *\n * var journalize = require('journalize');\n *\n * journalize.widont('this is a string');\n * // returns 'this is a&nbsp;string'\n *\n * journalize.widont('this is a string', 'HELLO');\n * // returns 'this is aHELLOstring'\n *\n */\nexport default function widont(val, replaceChar = nbsp) {\n  // if `val` is undefined or null, return an empty string\n  if (isNil(val)) return '';\n\n  // coerce value to a String\n  const str = String(val);\n\n  return str.replace(widontRegex, `${replaceChar}$1`);\n}\n","import { isNil } from './utils';\n\n/**\n * Given a mapping of arguments for `true`, `false`, and (optionally)\n * `null`/`undefined`, return a string according to the value. If `maybe` is not\n * provided, a `null` or `undefined` value will return the `no` argument.\n *\n * @param {boolean|Null|undefined} val\n * @param {string} [yes='yes']\n * @param {string} [no='no']\n * @param {string} [maybe='maybe']\n * @returns {string|boolean|Null|undefined}\n * @example\n *\n * var journalize = require('journalize');\n *\n * journalize.yesno(true);\n * // returns 'yes'\n * journalize.yesno(false);\n * // returns 'no'\n * journalize.yesno(null);\n * // returns 'maybe'\n *\n * journalize.yesno(true, 'yay', 'nay', 'shruggie');\n * // returns 'yay'\n * journalize.yesno(false, 'yay', 'nay', 'shruggie');\n * // returns 'nay'\n * journalize.yesno(null, 'yay', 'nay', 'shruggie');\n * // returns 'shruggie'\n */\nexport default function yesno(val, yes = 'yes', no = 'no', maybe = 'maybe') {\n  const numberOfArguments = arguments.length;\n\n  // if the user only passes the value and a `yes` argument that's too\n  // ambiguous, so we give up\n  if (numberOfArguments === 2) return val;\n  // if the user passes the value, a `yes` and a `no` argument, don't assume\n  // the default `maybe` is what they want and use `no` instead\n  if (numberOfArguments === 3) maybe = no;\n\n  // if null or undefined, use `maybe`\n  if (isNil(val)) return maybe;\n\n  // if true, use `yes`\n  if (val) {\n    return yes;\n  }\n\n  // otherwise, must be `no`\n  return no;\n}\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nmodule.exports = isKeyable;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nmodule.exports = mapCacheSet;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = hashDelete;\n","export default function(x) {\n  return x;\n}\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nmodule.exports = hashSet;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","export const epsilon = 1.1102230246251565e-16;\nexport const splitter = 134217729;\nexport const resulterrbound = (3 + 8 * epsilon) * epsilon;\n\n// fast_expansion_sum_zeroelim routine from oritinal code\nexport function sum(elen, e, flen, f, h) {\n    let Q, Qnew, hh, bvirt;\n    let enow = e[0];\n    let fnow = f[0];\n    let eindex = 0;\n    let findex = 0;\n    if ((fnow > enow) === (fnow > -enow)) {\n        Q = enow;\n        enow = e[++eindex];\n    } else {\n        Q = fnow;\n        fnow = f[++findex];\n    }\n    let hindex = 0;\n    if (eindex < elen && findex < flen) {\n        if ((fnow > enow) === (fnow > -enow)) {\n            Qnew = enow + Q;\n            hh = Q - (Qnew - enow);\n            enow = e[++eindex];\n        } else {\n            Qnew = fnow + Q;\n            hh = Q - (Qnew - fnow);\n            fnow = f[++findex];\n        }\n        Q = Qnew;\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n        while (eindex < elen && findex < flen) {\n            if ((fnow > enow) === (fnow > -enow)) {\n                Qnew = Q + enow;\n                bvirt = Qnew - Q;\n                hh = Q - (Qnew - bvirt) + (enow - bvirt);\n                enow = e[++eindex];\n            } else {\n                Qnew = Q + fnow;\n                bvirt = Qnew - Q;\n                hh = Q - (Qnew - bvirt) + (fnow - bvirt);\n                fnow = f[++findex];\n            }\n            Q = Qnew;\n            if (hh !== 0) {\n                h[hindex++] = hh;\n            }\n        }\n    }\n    while (eindex < elen) {\n        Qnew = Q + enow;\n        bvirt = Qnew - Q;\n        hh = Q - (Qnew - bvirt) + (enow - bvirt);\n        enow = e[++eindex];\n        Q = Qnew;\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n    }\n    while (findex < flen) {\n        Qnew = Q + fnow;\n        bvirt = Qnew - Q;\n        hh = Q - (Qnew - bvirt) + (fnow - bvirt);\n        fnow = f[++findex];\n        Q = Qnew;\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n    }\n    if (Q !== 0 || hindex === 0) {\n        h[hindex++] = Q;\n    }\n    return hindex;\n}\n\nexport function sum_three(alen, a, blen, b, clen, c, tmp, out) {\n    return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);\n}\n\n// scale_expansion_zeroelim routine from oritinal code\nexport function scale(elen, e, b, h) {\n    let Q, sum, hh, product1, product0;\n    let bvirt, c, ahi, alo, bhi, blo;\n\n    c = splitter * b;\n    bhi = c - (c - b);\n    blo = b - bhi;\n    let enow = e[0];\n    Q = enow * b;\n    c = splitter * enow;\n    ahi = c - (c - enow);\n    alo = enow - ahi;\n    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);\n    let hindex = 0;\n    if (hh !== 0) {\n        h[hindex++] = hh;\n    }\n    for (let i = 1; i < elen; i++) {\n        enow = e[i];\n        product1 = enow * b;\n        c = splitter * enow;\n        ahi = c - (c - enow);\n        alo = enow - ahi;\n        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);\n        sum = Q + product0;\n        bvirt = sum - Q;\n        hh = Q - (sum - bvirt) + (product0 - bvirt);\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n        Q = product1 + sum;\n        hh = sum - (Q - product1);\n        if (hh !== 0) {\n            h[hindex++] = hh;\n        }\n    }\n    if (Q !== 0 || hindex === 0) {\n        h[hindex++] = Q;\n    }\n    return hindex;\n}\n\nexport function negate(elen, e) {\n    for (let i = 0; i < elen; i++) e[i] = -e[i];\n    return elen;\n}\n\nexport function estimate(elen, e) {\n    let Q = e[0];\n    for (let i = 1; i < elen; i++) Q += e[i];\n    return Q;\n}\n\nexport function vec(n) {\n    return new Float64Array(n);\n}\n","import {epsilon, splitter, resulterrbound, estimate, vec, sum} from './util.js';\n\nconst ccwerrboundA = (3 + 16 * epsilon) * epsilon;\nconst ccwerrboundB = (2 + 12 * epsilon) * epsilon;\nconst ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;\n\nconst B = vec(4);\nconst C1 = vec(8);\nconst C2 = vec(12);\nconst D = vec(16);\nconst u = vec(4);\n\nfunction orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {\n    let acxtail, acytail, bcxtail, bcytail;\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;\n\n    const acx = ax - cx;\n    const bcx = bx - cx;\n    const acy = ay - cy;\n    const bcy = by - cy;\n\n    s1 = acx * bcy;\n    c = splitter * acx;\n    ahi = c - (c - acx);\n    alo = acx - ahi;\n    c = splitter * bcy;\n    bhi = c - (c - bcy);\n    blo = bcy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = acy * bcx;\n    c = splitter * acy;\n    ahi = c - (c - acy);\n    alo = acy - ahi;\n    c = splitter * bcx;\n    bhi = c - (c - bcx);\n    blo = bcx - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    B[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    B[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    B[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    B[3] = u3;\n\n    let det = estimate(4, B);\n    let errbound = ccwerrboundB * detsum;\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    bvirt = ax - acx;\n    acxtail = ax - (acx + bvirt) + (bvirt - cx);\n    bvirt = bx - bcx;\n    bcxtail = bx - (bcx + bvirt) + (bvirt - cx);\n    bvirt = ay - acy;\n    acytail = ay - (acy + bvirt) + (bvirt - cy);\n    bvirt = by - bcy;\n    bcytail = by - (bcy + bvirt) + (bvirt - cy);\n\n    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {\n        return det;\n    }\n\n    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);\n    det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);\n    if (det >= errbound || -det >= errbound) return det;\n\n    s1 = acxtail * bcy;\n    c = splitter * acxtail;\n    ahi = c - (c - acxtail);\n    alo = acxtail - ahi;\n    c = splitter * bcy;\n    bhi = c - (c - bcy);\n    blo = bcy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = acytail * bcx;\n    c = splitter * acytail;\n    ahi = c - (c - acytail);\n    alo = acytail - ahi;\n    c = splitter * bcx;\n    bhi = c - (c - bcx);\n    blo = bcx - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    u[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    u[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    u[3] = u3;\n    const C1len = sum(4, B, 4, u, C1);\n\n    s1 = acx * bcytail;\n    c = splitter * acx;\n    ahi = c - (c - acx);\n    alo = acx - ahi;\n    c = splitter * bcytail;\n    bhi = c - (c - bcytail);\n    blo = bcytail - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = acy * bcxtail;\n    c = splitter * acy;\n    ahi = c - (c - acy);\n    alo = acy - ahi;\n    c = splitter * bcxtail;\n    bhi = c - (c - bcxtail);\n    blo = bcxtail - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    u[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    u[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    u[3] = u3;\n    const C2len = sum(C1len, C1, 4, u, C2);\n\n    s1 = acxtail * bcytail;\n    c = splitter * acxtail;\n    ahi = c - (c - acxtail);\n    alo = acxtail - ahi;\n    c = splitter * bcytail;\n    bhi = c - (c - bcytail);\n    blo = bcytail - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = acytail * bcxtail;\n    c = splitter * acytail;\n    ahi = c - (c - acytail);\n    alo = acytail - ahi;\n    c = splitter * bcxtail;\n    bhi = c - (c - bcxtail);\n    blo = bcxtail - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    u[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    u[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    u[3] = u3;\n    const Dlen = sum(C2len, C2, 4, u, D);\n\n    return D[Dlen - 1];\n}\n\nexport function orient2d(ax, ay, bx, by, cx, cy) {\n    const detleft = (ay - cy) * (bx - cx);\n    const detright = (ax - cx) * (by - cy);\n    const det = detleft - detright;\n\n    const detsum = Math.abs(detleft + detright);\n    if (Math.abs(det) >= ccwerrboundA * detsum) return det;\n\n    return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);\n}\n\nexport function orient2dfast(ax, ay, bx, by, cx, cy) {\n    return (ay - cy) * (bx - cx) - (ax - cx) * (by - cy);\n}\n","import {epsilon, splitter, resulterrbound, estimate, vec, sum, scale} from './util.js';\n\nconst o3derrboundA = (7 + 56 * epsilon) * epsilon;\nconst o3derrboundB = (3 + 28 * epsilon) * epsilon;\nconst o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;\n\nconst bc = vec(4);\nconst ca = vec(4);\nconst ab = vec(4);\nconst at_b = vec(4);\nconst at_c = vec(4);\nconst bt_c = vec(4);\nconst bt_a = vec(4);\nconst ct_a = vec(4);\nconst ct_b = vec(4);\nconst bct = vec(8);\nconst cat = vec(8);\nconst abt = vec(8);\nconst u = vec(4);\n\nconst _8 = vec(8);\nconst _8b = vec(8);\nconst _16 = vec(8);\nconst _12 = vec(12);\n\nlet fin = vec(192);\nlet fin2 = vec(192);\n\nfunction finadd(finlen, alen, a) {\n    finlen = sum(finlen, fin, alen, a, fin2);\n    const tmp = fin; fin = fin2; fin2 = tmp;\n    return finlen;\n}\n\nfunction tailinit(xtail, ytail, ax, ay, bx, by, a, b) {\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, t1, t0, u3, negate;\n    if (xtail === 0) {\n        if (ytail === 0) {\n            a[0] = 0;\n            b[0] = 0;\n            return 1;\n        } else {\n            negate = -ytail;\n            s1 = negate * ax;\n            c = splitter * negate;\n            ahi = c - (c - negate);\n            alo = negate - ahi;\n            c = splitter * ax;\n            bhi = c - (c - ax);\n            blo = ax - bhi;\n            a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            a[1] = s1;\n            s1 = ytail * bx;\n            c = splitter * ytail;\n            ahi = c - (c - ytail);\n            alo = ytail - ahi;\n            c = splitter * bx;\n            bhi = c - (c - bx);\n            blo = bx - bhi;\n            b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            b[1] = s1;\n            return 2;\n        }\n    } else {\n        if (ytail === 0) {\n            s1 = xtail * ay;\n            c = splitter * xtail;\n            ahi = c - (c - xtail);\n            alo = xtail - ahi;\n            c = splitter * ay;\n            bhi = c - (c - ay);\n            blo = ay - bhi;\n            a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            a[1] = s1;\n            negate = -xtail;\n            s1 = negate * by;\n            c = splitter * negate;\n            ahi = c - (c - negate);\n            alo = negate - ahi;\n            c = splitter * by;\n            bhi = c - (c - by);\n            blo = by - bhi;\n            b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            b[1] = s1;\n            return 2;\n        } else {\n            s1 = xtail * ay;\n            c = splitter * xtail;\n            ahi = c - (c - xtail);\n            alo = xtail - ahi;\n            c = splitter * ay;\n            bhi = c - (c - ay);\n            blo = ay - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = ytail * ax;\n            c = splitter * ytail;\n            ahi = c - (c - ytail);\n            alo = ytail - ahi;\n            c = splitter * ax;\n            bhi = c - (c - ax);\n            blo = ax - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            a[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            a[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            a[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            a[3] = u3;\n            s1 = ytail * bx;\n            c = splitter * ytail;\n            ahi = c - (c - ytail);\n            alo = ytail - ahi;\n            c = splitter * bx;\n            bhi = c - (c - bx);\n            blo = bx - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = xtail * by;\n            c = splitter * xtail;\n            ahi = c - (c - xtail);\n            alo = xtail - ahi;\n            c = splitter * by;\n            bhi = c - (c - by);\n            blo = by - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            b[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            b[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            b[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            b[3] = u3;\n            return 4;\n        }\n    }\n}\n\nfunction tailadd(finlen, a, b, k, z) {\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, u3;\n    s1 = a * b;\n    c = splitter * a;\n    ahi = c - (c - a);\n    alo = a - ahi;\n    c = splitter * b;\n    bhi = c - (c - b);\n    blo = b - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    c = splitter * k;\n    bhi = c - (c - k);\n    blo = k - bhi;\n    _i = s0 * k;\n    c = splitter * s0;\n    ahi = c - (c - s0);\n    alo = s0 - ahi;\n    u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);\n    _j = s1 * k;\n    c = splitter * s1;\n    ahi = c - (c - s1);\n    alo = s1 - ahi;\n    _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);\n    _k = _i + _0;\n    bvirt = _k - _i;\n    u[1] = _i - (_k - bvirt) + (_0 - bvirt);\n    u3 = _j + _k;\n    u[2] = _k - (u3 - _j);\n    u[3] = u3;\n    finlen = finadd(finlen, 4, u);\n    if (z !== 0) {\n        c = splitter * z;\n        bhi = c - (c - z);\n        blo = z - bhi;\n        _i = s0 * z;\n        c = splitter * s0;\n        ahi = c - (c - s0);\n        alo = s0 - ahi;\n        u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);\n        _j = s1 * z;\n        c = splitter * s1;\n        ahi = c - (c - s1);\n        alo = s1 - ahi;\n        _0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);\n        _k = _i + _0;\n        bvirt = _k - _i;\n        u[1] = _i - (_k - bvirt) + (_0 - bvirt);\n        u3 = _j + _k;\n        u[2] = _k - (u3 - _j);\n        u[3] = u3;\n        finlen = finadd(finlen, 4, u);\n    }\n    return finlen;\n}\n\nfunction orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent) {\n    let finlen;\n    let adxtail, bdxtail, cdxtail;\n    let adytail, bdytail, cdytail;\n    let adztail, bdztail, cdztail;\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, t1, t0, u3;\n\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n    const adz = az - dz;\n    const bdz = bz - dz;\n    const cdz = cz - dz;\n\n    s1 = bdx * cdy;\n    c = splitter * bdx;\n    ahi = c - (c - bdx);\n    alo = bdx - ahi;\n    c = splitter * cdy;\n    bhi = c - (c - cdy);\n    blo = cdy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cdx * bdy;\n    c = splitter * cdx;\n    ahi = c - (c - cdx);\n    alo = cdx - ahi;\n    c = splitter * bdy;\n    bhi = c - (c - bdy);\n    blo = bdy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    bc[3] = u3;\n    s1 = cdx * ady;\n    c = splitter * cdx;\n    ahi = c - (c - cdx);\n    alo = cdx - ahi;\n    c = splitter * ady;\n    bhi = c - (c - ady);\n    blo = ady - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = adx * cdy;\n    c = splitter * adx;\n    ahi = c - (c - adx);\n    alo = adx - ahi;\n    c = splitter * cdy;\n    bhi = c - (c - cdy);\n    blo = cdy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ca[3] = u3;\n    s1 = adx * bdy;\n    c = splitter * adx;\n    ahi = c - (c - adx);\n    alo = adx - ahi;\n    c = splitter * bdy;\n    bhi = c - (c - bdy);\n    blo = bdy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bdx * ady;\n    c = splitter * bdx;\n    ahi = c - (c - bdx);\n    alo = bdx - ahi;\n    c = splitter * ady;\n    bhi = c - (c - ady);\n    blo = ady - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ab[3] = u3;\n\n    finlen = sum(\n        sum(\n            scale(4, bc, adz, _8), _8,\n            scale(4, ca, bdz, _8b), _8b, _16), _16,\n        scale(4, ab, cdz, _8), _8, fin);\n\n    let det = estimate(finlen, fin);\n    let errbound = o3derrboundB * permanent;\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    bvirt = ax - adx;\n    adxtail = ax - (adx + bvirt) + (bvirt - dx);\n    bvirt = bx - bdx;\n    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);\n    bvirt = cx - cdx;\n    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);\n    bvirt = ay - ady;\n    adytail = ay - (ady + bvirt) + (bvirt - dy);\n    bvirt = by - bdy;\n    bdytail = by - (bdy + bvirt) + (bvirt - dy);\n    bvirt = cy - cdy;\n    cdytail = cy - (cdy + bvirt) + (bvirt - dy);\n    bvirt = az - adz;\n    adztail = az - (adz + bvirt) + (bvirt - dz);\n    bvirt = bz - bdz;\n    bdztail = bz - (bdz + bvirt) + (bvirt - dz);\n    bvirt = cz - cdz;\n    cdztail = cz - (cdz + bvirt) + (bvirt - dz);\n\n    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 &&\n        adytail === 0 && bdytail === 0 && cdytail === 0 &&\n        adztail === 0 && bdztail === 0 && cdztail === 0) {\n        return det;\n    }\n\n    errbound = o3derrboundC * permanent + resulterrbound * Math.abs(det);\n    det +=\n        adz * (bdx * cdytail + cdy * bdxtail - (bdy * cdxtail + cdx * bdytail)) + adztail * (bdx * cdy - bdy * cdx) +\n        bdz * (cdx * adytail + ady * cdxtail - (cdy * adxtail + adx * cdytail)) + bdztail * (cdx * ady - cdy * adx) +\n        cdz * (adx * bdytail + bdy * adxtail - (ady * bdxtail + bdx * adytail)) + cdztail * (adx * bdy - ady * bdx);\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    const at_len = tailinit(adxtail, adytail, bdx, bdy, cdx, cdy, at_b, at_c);\n    const bt_len = tailinit(bdxtail, bdytail, cdx, cdy, adx, ady, bt_c, bt_a);\n    const ct_len = tailinit(cdxtail, cdytail, adx, ady, bdx, bdy, ct_a, ct_b);\n\n    const bctlen = sum(bt_len, bt_c, ct_len, ct_b, bct);\n    finlen = finadd(finlen, scale(bctlen, bct, adz, _16), _16);\n\n    const catlen = sum(ct_len, ct_a, at_len, at_c, cat);\n    finlen = finadd(finlen, scale(catlen, cat, bdz, _16), _16);\n\n    const abtlen = sum(at_len, at_b, bt_len, bt_a, abt);\n    finlen = finadd(finlen, scale(abtlen, abt, cdz, _16), _16);\n\n    if (adztail !== 0) {\n        finlen = finadd(finlen, scale(4, bc, adztail, _12), _12);\n        finlen = finadd(finlen, scale(bctlen, bct, adztail, _16), _16);\n    }\n    if (bdztail !== 0) {\n        finlen = finadd(finlen, scale(4, ca, bdztail, _12), _12);\n        finlen = finadd(finlen, scale(catlen, cat, bdztail, _16), _16);\n    }\n    if (cdztail !== 0) {\n        finlen = finadd(finlen, scale(4, ab, cdztail, _12), _12);\n        finlen = finadd(finlen, scale(abtlen, abt, cdztail, _16), _16);\n    }\n\n    if (adxtail !== 0) {\n        if (bdytail !== 0) {\n            finlen = tailadd(finlen, adxtail, bdytail, cdz, cdztail);\n        }\n        if (cdytail !== 0) {\n            finlen = tailadd(finlen, -adxtail, cdytail, bdz, bdztail);\n        }\n    }\n    if (bdxtail !== 0) {\n        if (cdytail !== 0) {\n            finlen = tailadd(finlen, bdxtail, cdytail, adz, adztail);\n        }\n        if (adytail !== 0) {\n            finlen = tailadd(finlen, -bdxtail, adytail, cdz, cdztail);\n        }\n    }\n    if (cdxtail !== 0) {\n        if (adytail !== 0) {\n            finlen = tailadd(finlen, cdxtail, adytail, bdz, bdztail);\n        }\n        if (bdytail !== 0) {\n            finlen = tailadd(finlen, -cdxtail, bdytail, adz, adztail);\n        }\n    }\n\n    return fin[finlen - 1];\n}\n\nexport function orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n    const adz = az - dz;\n    const bdz = bz - dz;\n    const cdz = cz - dz;\n\n    const bdxcdy = bdx * cdy;\n    const cdxbdy = cdx * bdy;\n\n    const cdxady = cdx * ady;\n    const adxcdy = adx * cdy;\n\n    const adxbdy = adx * bdy;\n    const bdxady = bdx * ady;\n\n    const det =\n        adz * (bdxcdy - cdxbdy) +\n        bdz * (cdxady - adxcdy) +\n        cdz * (adxbdy - bdxady);\n\n    const permanent =\n        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * Math.abs(adz) +\n        (Math.abs(cdxady) + Math.abs(adxcdy)) * Math.abs(bdz) +\n        (Math.abs(adxbdy) + Math.abs(bdxady)) * Math.abs(cdz);\n\n    const errbound = o3derrboundA * permanent;\n    if (det > errbound || -det > errbound) {\n        return det;\n    }\n\n    return orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent);\n}\n\nexport function orient3dfast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n    const adz = az - dz;\n    const bdz = bz - dz;\n    const cdz = cz - dz;\n\n    return adx * (bdy * cdz - bdz * cdy) +\n        bdx * (cdy * adz - cdz * ady) +\n        cdx * (ady * bdz - adz * bdy);\n}\n","import {epsilon, splitter, resulterrbound, estimate, vec, sum, sum_three, scale} from './util.js';\n\nconst iccerrboundA = (10 + 96 * epsilon) * epsilon;\nconst iccerrboundB = (4 + 48 * epsilon) * epsilon;\nconst iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;\n\nconst bc = vec(4);\nconst ca = vec(4);\nconst ab = vec(4);\nconst aa = vec(4);\nconst bb = vec(4);\nconst cc = vec(4);\nconst u = vec(4);\nconst v = vec(4);\nconst axtbc = vec(8);\nconst aytbc = vec(8);\nconst bxtca = vec(8);\nconst bytca = vec(8);\nconst cxtab = vec(8);\nconst cytab = vec(8);\nconst abt = vec(8);\nconst bct = vec(8);\nconst cat = vec(8);\nconst abtt = vec(4);\nconst bctt = vec(4);\nconst catt = vec(4);\n\nconst _8 = vec(8);\nconst _16 = vec(16);\nconst _16b = vec(16);\nconst _16c = vec(16);\nconst _32 = vec(32);\nconst _32b = vec(32);\nconst _48 = vec(48);\nconst _64 = vec(64);\n\nlet fin = vec(1152);\nlet fin2 = vec(1152);\n\nfunction finadd(finlen, a, alen) {\n    finlen = sum(finlen, fin, a, alen, fin2);\n    const tmp = fin; fin = fin2; fin2 = tmp;\n    return finlen;\n}\n\nfunction incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {\n    let finlen;\n    let adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;\n    let axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;\n    let abtlen, bctlen, catlen;\n    let abttlen, bcttlen, cattlen;\n    let n1, n0;\n\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;\n\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n\n    s1 = bdx * cdy;\n    c = splitter * bdx;\n    ahi = c - (c - bdx);\n    alo = bdx - ahi;\n    c = splitter * cdy;\n    bhi = c - (c - cdy);\n    blo = cdy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cdx * bdy;\n    c = splitter * cdx;\n    ahi = c - (c - cdx);\n    alo = cdx - ahi;\n    c = splitter * bdy;\n    bhi = c - (c - bdy);\n    blo = bdy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    bc[3] = u3;\n    s1 = cdx * ady;\n    c = splitter * cdx;\n    ahi = c - (c - cdx);\n    alo = cdx - ahi;\n    c = splitter * ady;\n    bhi = c - (c - ady);\n    blo = ady - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = adx * cdy;\n    c = splitter * adx;\n    ahi = c - (c - adx);\n    alo = adx - ahi;\n    c = splitter * cdy;\n    bhi = c - (c - cdy);\n    blo = cdy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ca[3] = u3;\n    s1 = adx * bdy;\n    c = splitter * adx;\n    ahi = c - (c - adx);\n    alo = adx - ahi;\n    c = splitter * bdy;\n    bhi = c - (c - bdy);\n    blo = bdy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bdx * ady;\n    c = splitter * bdx;\n    ahi = c - (c - bdx);\n    alo = bdx - ahi;\n    c = splitter * ady;\n    bhi = c - (c - ady);\n    blo = ady - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ab[3] = u3;\n\n    finlen = sum(\n        sum(\n            sum(\n                scale(scale(4, bc, adx, _8), _8, adx, _16), _16,\n                scale(scale(4, bc, ady, _8), _8, ady, _16b), _16b, _32), _32,\n            sum(\n                scale(scale(4, ca, bdx, _8), _8, bdx, _16), _16,\n                scale(scale(4, ca, bdy, _8), _8, bdy, _16b), _16b, _32b), _32b, _64), _64,\n        sum(\n            scale(scale(4, ab, cdx, _8), _8, cdx, _16), _16,\n            scale(scale(4, ab, cdy, _8), _8, cdy, _16b), _16b, _32), _32, fin);\n\n    let det = estimate(finlen, fin);\n    let errbound = iccerrboundB * permanent;\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    bvirt = ax - adx;\n    adxtail = ax - (adx + bvirt) + (bvirt - dx);\n    bvirt = ay - ady;\n    adytail = ay - (ady + bvirt) + (bvirt - dy);\n    bvirt = bx - bdx;\n    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);\n    bvirt = by - bdy;\n    bdytail = by - (bdy + bvirt) + (bvirt - dy);\n    bvirt = cx - cdx;\n    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);\n    bvirt = cy - cdy;\n    cdytail = cy - (cdy + bvirt) + (bvirt - dy);\n    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 && adytail === 0 && bdytail === 0 && cdytail === 0) {\n        return det;\n    }\n\n    errbound = iccerrboundC * permanent + resulterrbound * Math.abs(det);\n    det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +\n        2 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +\n        ((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +\n        2 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +\n        ((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +\n        2 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));\n\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {\n        s1 = adx * adx;\n        c = splitter * adx;\n        ahi = c - (c - adx);\n        alo = adx - ahi;\n        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);\n        t1 = ady * ady;\n        c = splitter * ady;\n        ahi = c - (c - ady);\n        alo = ady - ahi;\n        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);\n        _i = s0 + t0;\n        bvirt = _i - s0;\n        aa[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n        _j = s1 + _i;\n        bvirt = _j - s1;\n        _0 = s1 - (_j - bvirt) + (_i - bvirt);\n        _i = _0 + t1;\n        bvirt = _i - _0;\n        aa[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n        u3 = _j + _i;\n        bvirt = u3 - _j;\n        aa[2] = _j - (u3 - bvirt) + (_i - bvirt);\n        aa[3] = u3;\n    }\n    if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {\n        s1 = bdx * bdx;\n        c = splitter * bdx;\n        ahi = c - (c - bdx);\n        alo = bdx - ahi;\n        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);\n        t1 = bdy * bdy;\n        c = splitter * bdy;\n        ahi = c - (c - bdy);\n        alo = bdy - ahi;\n        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);\n        _i = s0 + t0;\n        bvirt = _i - s0;\n        bb[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n        _j = s1 + _i;\n        bvirt = _j - s1;\n        _0 = s1 - (_j - bvirt) + (_i - bvirt);\n        _i = _0 + t1;\n        bvirt = _i - _0;\n        bb[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n        u3 = _j + _i;\n        bvirt = u3 - _j;\n        bb[2] = _j - (u3 - bvirt) + (_i - bvirt);\n        bb[3] = u3;\n    }\n    if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {\n        s1 = cdx * cdx;\n        c = splitter * cdx;\n        ahi = c - (c - cdx);\n        alo = cdx - ahi;\n        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);\n        t1 = cdy * cdy;\n        c = splitter * cdy;\n        ahi = c - (c - cdy);\n        alo = cdy - ahi;\n        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);\n        _i = s0 + t0;\n        bvirt = _i - s0;\n        cc[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n        _j = s1 + _i;\n        bvirt = _j - s1;\n        _0 = s1 - (_j - bvirt) + (_i - bvirt);\n        _i = _0 + t1;\n        bvirt = _i - _0;\n        cc[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n        u3 = _j + _i;\n        bvirt = u3 - _j;\n        cc[2] = _j - (u3 - bvirt) + (_i - bvirt);\n        cc[3] = u3;\n    }\n\n    if (adxtail !== 0) {\n        axtbclen = scale(4, bc, adxtail, axtbc);\n        finlen = finadd(finlen, sum_three(\n            scale(axtbclen, axtbc, 2 * adx, _16), _16,\n            scale(scale(4, cc, adxtail, _8), _8, bdy, _16b), _16b,\n            scale(scale(4, bb, adxtail, _8), _8, -cdy, _16c), _16c, _32, _48), _48);\n    }\n    if (adytail !== 0) {\n        aytbclen = scale(4, bc, adytail, aytbc);\n        finlen = finadd(finlen, sum_three(\n            scale(aytbclen, aytbc, 2 * ady, _16), _16,\n            scale(scale(4, bb, adytail, _8), _8, cdx, _16b), _16b,\n            scale(scale(4, cc, adytail, _8), _8, -bdx, _16c), _16c, _32, _48), _48);\n    }\n    if (bdxtail !== 0) {\n        bxtcalen = scale(4, ca, bdxtail, bxtca);\n        finlen = finadd(finlen, sum_three(\n            scale(bxtcalen, bxtca, 2 * bdx, _16), _16,\n            scale(scale(4, aa, bdxtail, _8), _8, cdy, _16b), _16b,\n            scale(scale(4, cc, bdxtail, _8), _8, -ady, _16c), _16c, _32, _48), _48);\n    }\n    if (bdytail !== 0) {\n        bytcalen = scale(4, ca, bdytail, bytca);\n        finlen = finadd(finlen, sum_three(\n            scale(bytcalen, bytca, 2 * bdy, _16), _16,\n            scale(scale(4, cc, bdytail, _8), _8, adx, _16b), _16b,\n            scale(scale(4, aa, bdytail, _8), _8, -cdx, _16c), _16c, _32, _48), _48);\n    }\n    if (cdxtail !== 0) {\n        cxtablen = scale(4, ab, cdxtail, cxtab);\n        finlen = finadd(finlen, sum_three(\n            scale(cxtablen, cxtab, 2 * cdx, _16), _16,\n            scale(scale(4, bb, cdxtail, _8), _8, ady, _16b), _16b,\n            scale(scale(4, aa, cdxtail, _8), _8, -bdy, _16c), _16c, _32, _48), _48);\n    }\n    if (cdytail !== 0) {\n        cytablen = scale(4, ab, cdytail, cytab);\n        finlen = finadd(finlen, sum_three(\n            scale(cytablen, cytab, 2 * cdy, _16), _16,\n            scale(scale(4, aa, cdytail, _8), _8, bdx, _16b), _16b,\n            scale(scale(4, bb, cdytail, _8), _8, -adx, _16c), _16c, _32, _48), _48);\n    }\n\n    if (adxtail !== 0 || adytail !== 0) {\n        if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {\n            s1 = bdxtail * cdy;\n            c = splitter * bdxtail;\n            ahi = c - (c - bdxtail);\n            alo = bdxtail - ahi;\n            c = splitter * cdy;\n            bhi = c - (c - cdy);\n            blo = cdy - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = bdx * cdytail;\n            c = splitter * bdx;\n            ahi = c - (c - bdx);\n            alo = bdx - ahi;\n            c = splitter * cdytail;\n            bhi = c - (c - cdytail);\n            blo = cdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            u[3] = u3;\n            s1 = cdxtail * -bdy;\n            c = splitter * cdxtail;\n            ahi = c - (c - cdxtail);\n            alo = cdxtail - ahi;\n            c = splitter * -bdy;\n            bhi = c - (c - -bdy);\n            blo = -bdy - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = cdx * -bdytail;\n            c = splitter * cdx;\n            ahi = c - (c - cdx);\n            alo = cdx - ahi;\n            c = splitter * -bdytail;\n            bhi = c - (c - -bdytail);\n            blo = -bdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            v[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            v[3] = u3;\n            bctlen = sum(4, u, 4, v, bct);\n            s1 = bdxtail * cdytail;\n            c = splitter * bdxtail;\n            ahi = c - (c - bdxtail);\n            alo = bdxtail - ahi;\n            c = splitter * cdytail;\n            bhi = c - (c - cdytail);\n            blo = cdytail - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = cdxtail * bdytail;\n            c = splitter * cdxtail;\n            ahi = c - (c - cdxtail);\n            alo = cdxtail - ahi;\n            c = splitter * bdytail;\n            bhi = c - (c - bdytail);\n            blo = bdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            bctt[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            bctt[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            bctt[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            bctt[3] = u3;\n            bcttlen = 4;\n        } else {\n            bct[0] = 0;\n            bctlen = 1;\n            bctt[0] = 0;\n            bcttlen = 1;\n        }\n        if (adxtail !== 0) {\n            const len = scale(bctlen, bct, adxtail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(axtbclen, axtbc, adxtail, _16), _16,\n                scale(len, _16c, 2 * adx, _32), _32, _48), _48);\n\n            const len2 = scale(bcttlen, bctt, adxtail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * adx, _16), _16,\n                scale(len2, _8, adxtail, _16b), _16b,\n                scale(len, _16c, adxtail, _32), _32, _32b, _64), _64);\n\n            if (bdytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, cc, adxtail, _8), _8, bdytail, _16), _16);\n            }\n            if (cdytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, bb, -adxtail, _8), _8, cdytail, _16), _16);\n            }\n        }\n        if (adytail !== 0) {\n            const len = scale(bctlen, bct, adytail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(aytbclen, aytbc, adytail, _16), _16,\n                scale(len, _16c, 2 * ady, _32), _32, _48), _48);\n\n            const len2 = scale(bcttlen, bctt, adytail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * ady, _16), _16,\n                scale(len2, _8, adytail, _16b), _16b,\n                scale(len, _16c, adytail, _32), _32, _32b, _64), _64);\n        }\n    }\n    if (bdxtail !== 0 || bdytail !== 0) {\n        if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {\n            s1 = cdxtail * ady;\n            c = splitter * cdxtail;\n            ahi = c - (c - cdxtail);\n            alo = cdxtail - ahi;\n            c = splitter * ady;\n            bhi = c - (c - ady);\n            blo = ady - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = cdx * adytail;\n            c = splitter * cdx;\n            ahi = c - (c - cdx);\n            alo = cdx - ahi;\n            c = splitter * adytail;\n            bhi = c - (c - adytail);\n            blo = adytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            u[3] = u3;\n            n1 = -cdy;\n            n0 = -cdytail;\n            s1 = adxtail * n1;\n            c = splitter * adxtail;\n            ahi = c - (c - adxtail);\n            alo = adxtail - ahi;\n            c = splitter * n1;\n            bhi = c - (c - n1);\n            blo = n1 - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = adx * n0;\n            c = splitter * adx;\n            ahi = c - (c - adx);\n            alo = adx - ahi;\n            c = splitter * n0;\n            bhi = c - (c - n0);\n            blo = n0 - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            v[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            v[3] = u3;\n            catlen = sum(4, u, 4, v, cat);\n            s1 = cdxtail * adytail;\n            c = splitter * cdxtail;\n            ahi = c - (c - cdxtail);\n            alo = cdxtail - ahi;\n            c = splitter * adytail;\n            bhi = c - (c - adytail);\n            blo = adytail - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = adxtail * cdytail;\n            c = splitter * adxtail;\n            ahi = c - (c - adxtail);\n            alo = adxtail - ahi;\n            c = splitter * cdytail;\n            bhi = c - (c - cdytail);\n            blo = cdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            catt[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            catt[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            catt[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            catt[3] = u3;\n            cattlen = 4;\n        } else {\n            cat[0] = 0;\n            catlen = 1;\n            catt[0] = 0;\n            cattlen = 1;\n        }\n        if (bdxtail !== 0) {\n            const len = scale(catlen, cat, bdxtail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(bxtcalen, bxtca, bdxtail, _16), _16,\n                scale(len, _16c, 2 * bdx, _32), _32, _48), _48);\n\n            const len2 = scale(cattlen, catt, bdxtail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * bdx, _16), _16,\n                scale(len2, _8, bdxtail, _16b), _16b,\n                scale(len, _16c, bdxtail, _32), _32, _32b, _64), _64);\n\n            if (cdytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, aa, bdxtail, _8), _8, cdytail, _16), _16);\n            }\n            if (adytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, cc, -bdxtail, _8), _8, adytail, _16), _16);\n            }\n        }\n        if (bdytail !== 0) {\n            const len = scale(catlen, cat, bdytail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(bytcalen, bytca, bdytail, _16), _16,\n                scale(len, _16c, 2 * bdy, _32), _32, _48), _48);\n\n            const len2 = scale(cattlen, catt, bdytail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * bdy, _16), _16,\n                scale(len2, _8, bdytail, _16b), _16b,\n                scale(len, _16c, bdytail, _32), _32,  _32b, _64), _64);\n        }\n    }\n    if (cdxtail !== 0 || cdytail !== 0) {\n        if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {\n            s1 = adxtail * bdy;\n            c = splitter * adxtail;\n            ahi = c - (c - adxtail);\n            alo = adxtail - ahi;\n            c = splitter * bdy;\n            bhi = c - (c - bdy);\n            blo = bdy - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = adx * bdytail;\n            c = splitter * adx;\n            ahi = c - (c - adx);\n            alo = adx - ahi;\n            c = splitter * bdytail;\n            bhi = c - (c - bdytail);\n            blo = bdytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            u[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            u[3] = u3;\n            n1 = -ady;\n            n0 = -adytail;\n            s1 = bdxtail * n1;\n            c = splitter * bdxtail;\n            ahi = c - (c - bdxtail);\n            alo = bdxtail - ahi;\n            c = splitter * n1;\n            bhi = c - (c - n1);\n            blo = n1 - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = bdx * n0;\n            c = splitter * bdx;\n            ahi = c - (c - bdx);\n            alo = bdx - ahi;\n            c = splitter * n0;\n            bhi = c - (c - n0);\n            blo = n0 - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 + t0;\n            bvirt = _i - s0;\n            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 + t1;\n            bvirt = _i - _0;\n            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            v[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            v[3] = u3;\n            abtlen = sum(4, u, 4, v, abt);\n            s1 = adxtail * bdytail;\n            c = splitter * adxtail;\n            ahi = c - (c - adxtail);\n            alo = adxtail - ahi;\n            c = splitter * bdytail;\n            bhi = c - (c - bdytail);\n            blo = bdytail - bhi;\n            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n            t1 = bdxtail * adytail;\n            c = splitter * bdxtail;\n            ahi = c - (c - bdxtail);\n            alo = bdxtail - ahi;\n            c = splitter * adytail;\n            bhi = c - (c - adytail);\n            blo = adytail - bhi;\n            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n            _i = s0 - t0;\n            bvirt = s0 - _i;\n            abtt[0] = s0 - (_i + bvirt) + (bvirt - t0);\n            _j = s1 + _i;\n            bvirt = _j - s1;\n            _0 = s1 - (_j - bvirt) + (_i - bvirt);\n            _i = _0 - t1;\n            bvirt = _0 - _i;\n            abtt[1] = _0 - (_i + bvirt) + (bvirt - t1);\n            u3 = _j + _i;\n            bvirt = u3 - _j;\n            abtt[2] = _j - (u3 - bvirt) + (_i - bvirt);\n            abtt[3] = u3;\n            abttlen = 4;\n        } else {\n            abt[0] = 0;\n            abtlen = 1;\n            abtt[0] = 0;\n            abttlen = 1;\n        }\n        if (cdxtail !== 0) {\n            const len = scale(abtlen, abt, cdxtail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(cxtablen, cxtab, cdxtail, _16), _16,\n                scale(len, _16c, 2 * cdx, _32), _32, _48), _48);\n\n            const len2 = scale(abttlen, abtt, cdxtail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * cdx, _16), _16,\n                scale(len2, _8, cdxtail, _16b), _16b,\n                scale(len, _16c, cdxtail, _32), _32, _32b, _64), _64);\n\n            if (adytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, bb, cdxtail, _8), _8, adytail, _16), _16);\n            }\n            if (bdytail !== 0) {\n                finlen = finadd(finlen, scale(scale(4, aa, -cdxtail, _8), _8, bdytail, _16), _16);\n            }\n        }\n        if (cdytail !== 0) {\n            const len = scale(abtlen, abt, cdytail, _16c);\n            finlen = finadd(finlen, sum(\n                scale(cytablen, cytab, cdytail, _16), _16,\n                scale(len, _16c, 2 * cdy, _32), _32, _48), _48);\n\n            const len2 = scale(abttlen, abtt, cdytail, _8);\n            finlen = finadd(finlen, sum_three(\n                scale(len2, _8, 2 * cdy, _16), _16,\n                scale(len2, _8, cdytail, _16b), _16b,\n                scale(len, _16c, cdytail, _32), _32, _32b, _64), _64);\n        }\n    }\n\n    return fin[finlen - 1];\n}\n\nexport function incircle(ax, ay, bx, by, cx, cy, dx, dy) {\n    const adx = ax - dx;\n    const bdx = bx - dx;\n    const cdx = cx - dx;\n    const ady = ay - dy;\n    const bdy = by - dy;\n    const cdy = cy - dy;\n\n    const bdxcdy = bdx * cdy;\n    const cdxbdy = cdx * bdy;\n    const alift = adx * adx + ady * ady;\n\n    const cdxady = cdx * ady;\n    const adxcdy = adx * cdy;\n    const blift = bdx * bdx + bdy * bdy;\n\n    const adxbdy = adx * bdy;\n    const bdxady = bdx * ady;\n    const clift = cdx * cdx + cdy * cdy;\n\n    const det =\n        alift * (bdxcdy - cdxbdy) +\n        blift * (cdxady - adxcdy) +\n        clift * (adxbdy - bdxady);\n\n    const permanent =\n        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * alift +\n        (Math.abs(cdxady) + Math.abs(adxcdy)) * blift +\n        (Math.abs(adxbdy) + Math.abs(bdxady)) * clift;\n\n    const errbound = iccerrboundA * permanent;\n\n    if (det > errbound || -det > errbound) {\n        return det;\n    }\n    return incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent);\n}\n\nexport function incirclefast(ax, ay, bx, by, cx, cy, dx, dy) {\n    const adx = ax - dx;\n    const ady = ay - dy;\n    const bdx = bx - dx;\n    const bdy = by - dy;\n    const cdx = cx - dx;\n    const cdy = cy - dy;\n\n    const abdet = adx * bdy - bdx * ady;\n    const bcdet = bdx * cdy - cdx * bdy;\n    const cadet = cdx * ady - adx * cdy;\n    const alift = adx * adx + ady * ady;\n    const blift = bdx * bdx + bdy * bdy;\n    const clift = cdx * cdx + cdy * cdy;\n\n    return alift * bcdet + blift * cadet + clift * abdet;\n}\n","import {epsilon, splitter, resulterrbound, estimate, vec, sum, sum_three, scale, negate} from './util.js';\n\nconst isperrboundA = (16 + 224 * epsilon) * epsilon;\nconst isperrboundB = (5 + 72 * epsilon) * epsilon;\nconst isperrboundC = (71 + 1408 * epsilon) * epsilon * epsilon;\n\nconst ab = vec(4);\nconst bc = vec(4);\nconst cd = vec(4);\nconst de = vec(4);\nconst ea = vec(4);\nconst ac = vec(4);\nconst bd = vec(4);\nconst ce = vec(4);\nconst da = vec(4);\nconst eb = vec(4);\n\nconst abc = vec(24);\nconst bcd = vec(24);\nconst cde = vec(24);\nconst dea = vec(24);\nconst eab = vec(24);\nconst abd = vec(24);\nconst bce = vec(24);\nconst cda = vec(24);\nconst deb = vec(24);\nconst eac = vec(24);\n\nconst adet = vec(1152);\nconst bdet = vec(1152);\nconst cdet = vec(1152);\nconst ddet = vec(1152);\nconst edet = vec(1152);\nconst abdet = vec(2304);\nconst cddet = vec(2304);\nconst cdedet = vec(3456);\nconst deter = vec(5760);\n\nconst _8 = vec(8);\nconst _8b = vec(8);\nconst _8c = vec(8);\nconst _16 = vec(16);\nconst _24 = vec(24);\nconst _48 = vec(48);\nconst _48b = vec(48);\nconst _96 = vec(96);\nconst _192 = vec(192);\nconst _384x = vec(384);\nconst _384y = vec(384);\nconst _384z = vec(384);\nconst _768 = vec(768);\n\nfunction sum_three_scale(a, b, c, az, bz, cz, out) {\n    return sum_three(\n        scale(4, a, az, _8), _8,\n        scale(4, b, bz, _8b), _8b,\n        scale(4, c, cz, _8c), _8c, _16, out);\n}\n\nfunction liftexact(alen, a, blen, b, clen, c, dlen, d, x, y, z, out) {\n    const len = sum(\n        sum(alen, a, blen, b, _48), _48,\n        negate(sum(clen, c, dlen, d, _48b), _48b), _48b, _96);\n\n    return sum_three(\n        scale(scale(len, _96, x, _192), _192, x, _384x), _384x,\n        scale(scale(len, _96, y, _192), _192, y, _384y), _384y,\n        scale(scale(len, _96, z, _192), _192, z, _384z), _384z, _768, out);\n}\n\nfunction insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;\n\n    s1 = ax * by;\n    c = splitter * ax;\n    ahi = c - (c - ax);\n    alo = ax - ahi;\n    c = splitter * by;\n    bhi = c - (c - by);\n    blo = by - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bx * ay;\n    c = splitter * bx;\n    ahi = c - (c - bx);\n    alo = bx - ahi;\n    c = splitter * ay;\n    bhi = c - (c - ay);\n    blo = ay - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ab[3] = u3;\n    s1 = bx * cy;\n    c = splitter * bx;\n    ahi = c - (c - bx);\n    alo = bx - ahi;\n    c = splitter * cy;\n    bhi = c - (c - cy);\n    blo = cy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cx * by;\n    c = splitter * cx;\n    ahi = c - (c - cx);\n    alo = cx - ahi;\n    c = splitter * by;\n    bhi = c - (c - by);\n    blo = by - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    bc[3] = u3;\n    s1 = cx * dy;\n    c = splitter * cx;\n    ahi = c - (c - cx);\n    alo = cx - ahi;\n    c = splitter * dy;\n    bhi = c - (c - dy);\n    blo = dy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = dx * cy;\n    c = splitter * dx;\n    ahi = c - (c - dx);\n    alo = dx - ahi;\n    c = splitter * cy;\n    bhi = c - (c - cy);\n    blo = cy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    cd[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    cd[3] = u3;\n    s1 = dx * ey;\n    c = splitter * dx;\n    ahi = c - (c - dx);\n    alo = dx - ahi;\n    c = splitter * ey;\n    bhi = c - (c - ey);\n    blo = ey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = ex * dy;\n    c = splitter * ex;\n    ahi = c - (c - ex);\n    alo = ex - ahi;\n    c = splitter * dy;\n    bhi = c - (c - dy);\n    blo = dy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    de[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    de[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    de[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    de[3] = u3;\n    s1 = ex * ay;\n    c = splitter * ex;\n    ahi = c - (c - ex);\n    alo = ex - ahi;\n    c = splitter * ay;\n    bhi = c - (c - ay);\n    blo = ay - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = ax * ey;\n    c = splitter * ax;\n    ahi = c - (c - ax);\n    alo = ax - ahi;\n    c = splitter * ey;\n    bhi = c - (c - ey);\n    blo = ey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ea[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ea[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ea[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ea[3] = u3;\n    s1 = ax * cy;\n    c = splitter * ax;\n    ahi = c - (c - ax);\n    alo = ax - ahi;\n    c = splitter * cy;\n    bhi = c - (c - cy);\n    blo = cy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cx * ay;\n    c = splitter * cx;\n    ahi = c - (c - cx);\n    alo = cx - ahi;\n    c = splitter * ay;\n    bhi = c - (c - ay);\n    blo = ay - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ac[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ac[3] = u3;\n    s1 = bx * dy;\n    c = splitter * bx;\n    ahi = c - (c - bx);\n    alo = bx - ahi;\n    c = splitter * dy;\n    bhi = c - (c - dy);\n    blo = dy - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = dx * by;\n    c = splitter * dx;\n    ahi = c - (c - dx);\n    alo = dx - ahi;\n    c = splitter * by;\n    bhi = c - (c - by);\n    blo = by - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    bd[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    bd[3] = u3;\n    s1 = cx * ey;\n    c = splitter * cx;\n    ahi = c - (c - cx);\n    alo = cx - ahi;\n    c = splitter * ey;\n    bhi = c - (c - ey);\n    blo = ey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = ex * cy;\n    c = splitter * ex;\n    ahi = c - (c - ex);\n    alo = ex - ahi;\n    c = splitter * cy;\n    bhi = c - (c - cy);\n    blo = cy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ce[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ce[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    ce[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    ce[3] = u3;\n    s1 = dx * ay;\n    c = splitter * dx;\n    ahi = c - (c - dx);\n    alo = dx - ahi;\n    c = splitter * ay;\n    bhi = c - (c - ay);\n    blo = ay - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = ax * dy;\n    c = splitter * ax;\n    ahi = c - (c - ax);\n    alo = ax - ahi;\n    c = splitter * dy;\n    bhi = c - (c - dy);\n    blo = dy - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    da[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    da[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    da[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    da[3] = u3;\n    s1 = ex * by;\n    c = splitter * ex;\n    ahi = c - (c - ex);\n    alo = ex - ahi;\n    c = splitter * by;\n    bhi = c - (c - by);\n    blo = by - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bx * ey;\n    c = splitter * bx;\n    ahi = c - (c - bx);\n    alo = bx - ahi;\n    c = splitter * ey;\n    bhi = c - (c - ey);\n    blo = ey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    eb[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    eb[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    u3 = _j + _i;\n    bvirt = u3 - _j;\n    eb[2] = _j - (u3 - bvirt) + (_i - bvirt);\n    eb[3] = u3;\n\n    const abclen = sum_three_scale(ab, bc, ac, cz, az, -bz, abc);\n    const bcdlen = sum_three_scale(bc, cd, bd, dz, bz, -cz, bcd);\n    const cdelen = sum_three_scale(cd, de, ce, ez, cz, -dz, cde);\n    const dealen = sum_three_scale(de, ea, da, az, dz, -ez, dea);\n    const eablen = sum_three_scale(ea, ab, eb, bz, ez, -az, eab);\n    const abdlen = sum_three_scale(ab, bd, da, dz, az, bz, abd);\n    const bcelen = sum_three_scale(bc, ce, eb, ez, bz, cz, bce);\n    const cdalen = sum_three_scale(cd, da, ac, az, cz, dz, cda);\n    const deblen = sum_three_scale(de, eb, bd, bz, dz, ez, deb);\n    const eaclen = sum_three_scale(ea, ac, ce, cz, ez, az, eac);\n\n    const deterlen = sum_three(\n        liftexact(cdelen, cde, bcelen, bce, deblen, deb, bcdlen, bcd, ax, ay, az, adet), adet,\n        liftexact(dealen, dea, cdalen, cda, eaclen, eac, cdelen, cde, bx, by, bz, bdet), bdet,\n        sum_three(\n            liftexact(eablen, eab, deblen, deb, abdlen, abd, dealen, dea, cx, cy, cz, cdet), cdet,\n            liftexact(abclen, abc, eaclen, eac, bcelen, bce, eablen, eab, dx, dy, dz, ddet), ddet,\n            liftexact(bcdlen, bcd, abdlen, abd, cdalen, cda, abclen, abc, ex, ey, ez, edet), edet, cddet, cdedet), cdedet, abdet, deter);\n\n    return deter[deterlen - 1];\n}\n\nconst xdet = vec(96);\nconst ydet = vec(96);\nconst zdet = vec(96);\nconst fin = vec(1152);\n\nfunction liftadapt(a, b, c, az, bz, cz, x, y, z, out) {\n    const len = sum_three_scale(a, b, c, az, bz, cz, _24);\n    return sum_three(\n        scale(scale(len, _24, x, _48), _48, x, xdet), xdet,\n        scale(scale(len, _24, y, _48), _48, y, ydet), ydet,\n        scale(scale(len, _24, z, _48), _48, z, zdet), zdet, _192, out);\n}\n\nfunction insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent) {\n    let ab3, bc3, cd3, da3, ac3, bd3;\n\n    let aextail, bextail, cextail, dextail;\n    let aeytail, beytail, ceytail, deytail;\n    let aeztail, beztail, ceztail, deztail;\n\n    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0;\n\n    const aex = ax - ex;\n    const bex = bx - ex;\n    const cex = cx - ex;\n    const dex = dx - ex;\n    const aey = ay - ey;\n    const bey = by - ey;\n    const cey = cy - ey;\n    const dey = dy - ey;\n    const aez = az - ez;\n    const bez = bz - ez;\n    const cez = cz - ez;\n    const dez = dz - ez;\n\n    s1 = aex * bey;\n    c = splitter * aex;\n    ahi = c - (c - aex);\n    alo = aex - ahi;\n    c = splitter * bey;\n    bhi = c - (c - bey);\n    blo = bey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = bex * aey;\n    c = splitter * bex;\n    ahi = c - (c - bex);\n    alo = bex - ahi;\n    c = splitter * aey;\n    bhi = c - (c - aey);\n    blo = aey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    ab3 = _j + _i;\n    bvirt = ab3 - _j;\n    ab[2] = _j - (ab3 - bvirt) + (_i - bvirt);\n    ab[3] = ab3;\n    s1 = bex * cey;\n    c = splitter * bex;\n    ahi = c - (c - bex);\n    alo = bex - ahi;\n    c = splitter * cey;\n    bhi = c - (c - cey);\n    blo = cey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cex * bey;\n    c = splitter * cex;\n    ahi = c - (c - cex);\n    alo = cex - ahi;\n    c = splitter * bey;\n    bhi = c - (c - bey);\n    blo = bey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    bc3 = _j + _i;\n    bvirt = bc3 - _j;\n    bc[2] = _j - (bc3 - bvirt) + (_i - bvirt);\n    bc[3] = bc3;\n    s1 = cex * dey;\n    c = splitter * cex;\n    ahi = c - (c - cex);\n    alo = cex - ahi;\n    c = splitter * dey;\n    bhi = c - (c - dey);\n    blo = dey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = dex * cey;\n    c = splitter * dex;\n    ahi = c - (c - dex);\n    alo = dex - ahi;\n    c = splitter * cey;\n    bhi = c - (c - cey);\n    blo = cey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    cd[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    cd[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    cd3 = _j + _i;\n    bvirt = cd3 - _j;\n    cd[2] = _j - (cd3 - bvirt) + (_i - bvirt);\n    cd[3] = cd3;\n    s1 = dex * aey;\n    c = splitter * dex;\n    ahi = c - (c - dex);\n    alo = dex - ahi;\n    c = splitter * aey;\n    bhi = c - (c - aey);\n    blo = aey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = aex * dey;\n    c = splitter * aex;\n    ahi = c - (c - aex);\n    alo = aex - ahi;\n    c = splitter * dey;\n    bhi = c - (c - dey);\n    blo = dey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    da[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    da[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    da3 = _j + _i;\n    bvirt = da3 - _j;\n    da[2] = _j - (da3 - bvirt) + (_i - bvirt);\n    da[3] = da3;\n    s1 = aex * cey;\n    c = splitter * aex;\n    ahi = c - (c - aex);\n    alo = aex - ahi;\n    c = splitter * cey;\n    bhi = c - (c - cey);\n    blo = cey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = cex * aey;\n    c = splitter * cex;\n    ahi = c - (c - cex);\n    alo = cex - ahi;\n    c = splitter * aey;\n    bhi = c - (c - aey);\n    blo = aey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    ac[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    ac[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    ac3 = _j + _i;\n    bvirt = ac3 - _j;\n    ac[2] = _j - (ac3 - bvirt) + (_i - bvirt);\n    ac[3] = ac3;\n    s1 = bex * dey;\n    c = splitter * bex;\n    ahi = c - (c - bex);\n    alo = bex - ahi;\n    c = splitter * dey;\n    bhi = c - (c - dey);\n    blo = dey - bhi;\n    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);\n    t1 = dex * bey;\n    c = splitter * dex;\n    ahi = c - (c - dex);\n    alo = dex - ahi;\n    c = splitter * bey;\n    bhi = c - (c - bey);\n    blo = bey - bhi;\n    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);\n    _i = s0 - t0;\n    bvirt = s0 - _i;\n    bd[0] = s0 - (_i + bvirt) + (bvirt - t0);\n    _j = s1 + _i;\n    bvirt = _j - s1;\n    _0 = s1 - (_j - bvirt) + (_i - bvirt);\n    _i = _0 - t1;\n    bvirt = _0 - _i;\n    bd[1] = _0 - (_i + bvirt) + (bvirt - t1);\n    bd3 = _j + _i;\n    bvirt = bd3 - _j;\n    bd[2] = _j - (bd3 - bvirt) + (_i - bvirt);\n    bd[3] = bd3;\n\n    const finlen = sum(\n        sum(\n            negate(liftadapt(bc, cd, bd, dez, bez, -cez, aex, aey, aez, adet), adet), adet,\n            liftadapt(cd, da, ac, aez, cez, dez, bex, bey, bez, bdet), bdet, abdet), abdet,\n        sum(\n            negate(liftadapt(da, ab, bd, bez, dez, aez, cex, cey, cez, cdet), cdet), cdet,\n            liftadapt(ab, bc, ac, cez, aez, -bez, dex, dey, dez, ddet), ddet, cddet), cddet, fin);\n\n    let det = estimate(finlen, fin);\n    let errbound = isperrboundB * permanent;\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    bvirt = ax - aex;\n    aextail = ax - (aex + bvirt) + (bvirt - ex);\n    bvirt = ay - aey;\n    aeytail = ay - (aey + bvirt) + (bvirt - ey);\n    bvirt = az - aez;\n    aeztail = az - (aez + bvirt) + (bvirt - ez);\n    bvirt = bx - bex;\n    bextail = bx - (bex + bvirt) + (bvirt - ex);\n    bvirt = by - bey;\n    beytail = by - (bey + bvirt) + (bvirt - ey);\n    bvirt = bz - bez;\n    beztail = bz - (bez + bvirt) + (bvirt - ez);\n    bvirt = cx - cex;\n    cextail = cx - (cex + bvirt) + (bvirt - ex);\n    bvirt = cy - cey;\n    ceytail = cy - (cey + bvirt) + (bvirt - ey);\n    bvirt = cz - cez;\n    ceztail = cz - (cez + bvirt) + (bvirt - ez);\n    bvirt = dx - dex;\n    dextail = dx - (dex + bvirt) + (bvirt - ex);\n    bvirt = dy - dey;\n    deytail = dy - (dey + bvirt) + (bvirt - ey);\n    bvirt = dz - dez;\n    deztail = dz - (dez + bvirt) + (bvirt - ez);\n    if (aextail === 0 && aeytail === 0 && aeztail === 0 &&\n        bextail === 0 && beytail === 0 && beztail === 0 &&\n        cextail === 0 && ceytail === 0 && ceztail === 0 &&\n        dextail === 0 && deytail === 0 && deztail === 0) {\n        return det;\n    }\n\n    errbound = isperrboundC * permanent + resulterrbound * Math.abs(det);\n\n    const abeps = (aex * beytail + bey * aextail) - (aey * bextail + bex * aeytail);\n    const bceps = (bex * ceytail + cey * bextail) - (bey * cextail + cex * beytail);\n    const cdeps = (cex * deytail + dey * cextail) - (cey * dextail + dex * ceytail);\n    const daeps = (dex * aeytail + aey * dextail) - (dey * aextail + aex * deytail);\n    const aceps = (aex * ceytail + cey * aextail) - (aey * cextail + cex * aeytail);\n    const bdeps = (bex * deytail + dey * bextail) - (bey * dextail + dex * beytail);\n    det +=\n        (((bex * bex + bey * bey + bez * bez) * ((cez * daeps + dez * aceps + aez * cdeps) +\n        (ceztail * da3 + deztail * ac3 + aeztail * cd3)) + (dex * dex + dey * dey + dez * dez) *\n        ((aez * bceps - bez * aceps + cez * abeps) + (aeztail * bc3 - beztail * ac3 + ceztail * ab3))) -\n        ((aex * aex + aey * aey + aez * aez) * ((bez * cdeps - cez * bdeps + dez * bceps) +\n        (beztail * cd3 - ceztail * bd3 + deztail * bc3)) + (cex * cex + cey * cey + cez * cez) *\n        ((dez * abeps + aez * bdeps + bez * daeps) + (deztail * ab3 + aeztail * bd3 + beztail * da3)))) +\n        2 * (((bex * bextail + bey * beytail + bez * beztail) * (cez * da3 + dez * ac3 + aez * cd3) +\n        (dex * dextail + dey * deytail + dez * deztail) * (aez * bc3 - bez * ac3 + cez * ab3)) -\n        ((aex * aextail + aey * aeytail + aez * aeztail) * (bez * cd3 - cez * bd3 + dez * bc3) +\n        (cex * cextail + cey * ceytail + cez * ceztail) * (dez * ab3 + aez * bd3 + bez * da3)));\n\n    if (det >= errbound || -det >= errbound) {\n        return det;\n    }\n\n    return insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez);\n}\n\nexport function insphere(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez) {\n    const aex = ax - ex;\n    const bex = bx - ex;\n    const cex = cx - ex;\n    const dex = dx - ex;\n    const aey = ay - ey;\n    const bey = by - ey;\n    const cey = cy - ey;\n    const dey = dy - ey;\n    const aez = az - ez;\n    const bez = bz - ez;\n    const cez = cz - ez;\n    const dez = dz - ez;\n\n    const aexbey = aex * bey;\n    const bexaey = bex * aey;\n    const ab = aexbey - bexaey;\n    const bexcey = bex * cey;\n    const cexbey = cex * bey;\n    const bc = bexcey - cexbey;\n    const cexdey = cex * dey;\n    const dexcey = dex * cey;\n    const cd = cexdey - dexcey;\n    const dexaey = dex * aey;\n    const aexdey = aex * dey;\n    const da = dexaey - aexdey;\n    const aexcey = aex * cey;\n    const cexaey = cex * aey;\n    const ac = aexcey - cexaey;\n    const bexdey = bex * dey;\n    const dexbey = dex * bey;\n    const bd = bexdey - dexbey;\n\n    const alift = aex * aex + aey * aey + aez * aez;\n    const blift = bex * bex + bey * bey + bez * bez;\n    const clift = cex * cex + cey * cey + cez * cez;\n    const dlift = dex * dex + dey * dey + dez * dez;\n\n    const det =\n        (clift * (dez * ab + aez * bd + bez * da) - dlift * (aez * bc - bez * ac + cez * ab)) +\n        (alift * (bez * cd - cez * bd + dez * bc) - blift * (cez * da + dez * ac + aez * cd));\n\n    const aezplus = Math.abs(aez);\n    const bezplus = Math.abs(bez);\n    const cezplus = Math.abs(cez);\n    const dezplus = Math.abs(dez);\n    const aexbeyplus = Math.abs(aexbey) + Math.abs(bexaey);\n    const bexceyplus = Math.abs(bexcey) + Math.abs(cexbey);\n    const cexdeyplus = Math.abs(cexdey) + Math.abs(dexcey);\n    const dexaeyplus = Math.abs(dexaey) + Math.abs(aexdey);\n    const aexceyplus = Math.abs(aexcey) + Math.abs(cexaey);\n    const bexdeyplus = Math.abs(bexdey) + Math.abs(dexbey);\n    const permanent =\n        (cexdeyplus * bezplus + bexdeyplus * cezplus + bexceyplus * dezplus) * alift +\n        (dexaeyplus * cezplus + aexceyplus * dezplus + cexdeyplus * aezplus) * blift +\n        (aexbeyplus * dezplus + bexdeyplus * aezplus + dexaeyplus * bezplus) * clift +\n        (bexceyplus * aezplus + aexceyplus * bezplus + aexbeyplus * cezplus) * dlift;\n\n    const errbound = isperrboundA * permanent;\n    if (det > errbound || -det > errbound) {\n        return det;\n    }\n    return -insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent);\n}\n\nexport function inspherefast(pax, pay, paz, pbx, pby, pbz, pcx, pcy, pcz, pdx, pdy, pdz, pex, pey, pez) {\n    const aex = pax - pex;\n    const bex = pbx - pex;\n    const cex = pcx - pex;\n    const dex = pdx - pex;\n    const aey = pay - pey;\n    const bey = pby - pey;\n    const cey = pcy - pey;\n    const dey = pdy - pey;\n    const aez = paz - pez;\n    const bez = pbz - pez;\n    const cez = pcz - pez;\n    const dez = pdz - pez;\n\n    const ab = aex * bey - bex * aey;\n    const bc = bex * cey - cex * bey;\n    const cd = cex * dey - dex * cey;\n    const da = dex * aey - aex * dey;\n    const ac = aex * cey - cex * aey;\n    const bd = bex * dey - dex * bey;\n\n    const abc = aez * bc - bez * ac + cez * ab;\n    const bcd = bez * cd - cez * bd + dez * bc;\n    const cda = cez * da + dez * ac + aez * cd;\n    const dab = dez * ab + aez * bd + bez * da;\n\n    const alift = aex * aex + aey * aey + aez * aez;\n    const blift = bex * bex + bey * bey + bez * bez;\n    const clift = cex * cex + cey * cey + cez * cez;\n    const dlift = dex * dex + dey * dey + dez * dez;\n\n    return (clift * dab - dlift * abc) + (alift * bcd - blift * cda);\n}\n","import { orient2d } from 'robust-predicates';\n\nfunction pointInPolygon(p, polygon) {\n    var i;\n    var ii;\n    var k = 0;\n    var f;\n    var u1;\n    var v1;\n    var u2;\n    var v2;\n    var currentP;\n    var nextP;\n\n    var x = p[0];\n    var y = p[1];\n\n    var numContours = polygon.length;\n    for (i = 0; i < numContours; i++) {\n        ii = 0;\n        var contour = polygon[i];\n        var contourLen = contour.length - 1;\n\n        currentP = contour[0];\n        if (currentP[0] !== contour[contourLen][0] &&\n            currentP[1] !== contour[contourLen][1]) {\n            throw new Error('First and last coordinates in a ring must be the same')\n        }\n\n        u1 = currentP[0] - x;\n        v1 = currentP[1] - y;\n\n        for (ii; ii < contourLen; ii++) {\n            nextP = contour[ii + 1];\n\n            u2 = nextP[0] - x;\n            v2 = nextP[1] - y;\n\n            if (v1 === 0 && v2 === 0) {\n                if ((u2 <= 0 && u1 >= 0) || (u1 <= 0 && u2 >= 0)) { return 0 }\n            } else if ((v2 >= 0 && v1 <= 0) || (v2 <= 0 && v1 >= 0)) {\n                f = orient2d(u1, u2, v1, v2, 0, 0);\n                if (f === 0) { return 0 }\n                if ((f > 0 && v2 > 0 && v1 <= 0) || (f < 0 && v2 <= 0 && v1 > 0)) { k++; }\n            }\n            currentP = nextP;\n            v1 = v2;\n            u1 = u2;\n        }\n    }\n\n    if (k % 2 === 0) { return false }\n    return true\n}\n\nexport { pointInPolygon as default };\n","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nmodule.exports = getMapData;\n","export var epsilon = 1e-6;\nexport var epsilon2 = 1e-12;\nexport var pi = Math.PI;\nexport var halfPi = pi / 2;\nexport var quarterPi = pi / 4;\nexport var tau = pi * 2;\n\nexport var degrees = 180 / pi;\nexport var radians = pi / 180;\n\nexport var abs = Math.abs;\nexport var atan = Math.atan;\nexport var atan2 = Math.atan2;\nexport var cos = Math.cos;\nexport var ceil = Math.ceil;\nexport var exp = Math.exp;\nexport var floor = Math.floor;\nexport var log = Math.log;\nexport var pow = Math.pow;\nexport var sin = Math.sin;\nexport var sign = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; };\nexport var sqrt = Math.sqrt;\nexport var tan = Math.tan;\n\nexport function acos(x) {\n  return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);\n}\n\nexport function asin(x) {\n  return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x);\n}\n\nexport function haversin(x) {\n  return (x = sin(x / 2)) * x;\n}\n","import noop from \"../noop.js\";\n\nvar x0 = Infinity,\n    y0 = x0,\n    x1 = -x0,\n    y1 = x1;\n\nvar boundsStream = {\n  point: boundsPoint,\n  lineStart: noop,\n  lineEnd: noop,\n  polygonStart: noop,\n  polygonEnd: noop,\n  result: function() {\n    var bounds = [[x0, y0], [x1, y1]];\n    x1 = y1 = -(y0 = x0 = Infinity);\n    return bounds;\n  }\n};\n\nfunction boundsPoint(x, y) {\n  if (x < x0) x0 = x;\n  if (x > x1) x1 = x;\n  if (y < y0) y0 = y;\n  if (y > y1) y1 = y;\n}\n\nexport default boundsStream;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nmodule.exports = hashClear;\n","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (arg) {\n\t\t\t\tclasses = appendClass(classes, parseValue(arg));\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction parseValue (arg) {\n\t\tif (typeof arg === 'string' || typeof arg === 'number') {\n\t\t\treturn arg;\n\t\t}\n\n\t\tif (typeof arg !== 'object') {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (Array.isArray(arg)) {\n\t\t\treturn classNames.apply(null, arg);\n\t\t}\n\n\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\treturn arg.toString();\n\t\t}\n\n\t\tvar classes = '';\n\n\t\tfor (var key in arg) {\n\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\tclasses = appendClass(classes, key);\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction appendClass (value, newClass) {\n\t\tif (!newClass) {\n\t\t\treturn value;\n\t\t}\n\t\n\t\tif (value) {\n\t\t\treturn value + ' ' + newClass;\n\t\t}\n\t\n\t\treturn value + newClass;\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var listCacheClear = require('./_listCacheClear'),\n    listCacheDelete = require('./_listCacheDelete'),\n    listCacheGet = require('./_listCacheGet'),\n    listCacheHas = require('./_listCacheHas'),\n    listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nmodule.exports = listCacheSet;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nmodule.exports = listCacheDelete;\n","import pointEqual from \"../pointEqual.js\";\nimport {epsilon} from \"../math.js\";\n\nfunction Intersection(point, points, other, entry) {\n  this.x = point;\n  this.z = points;\n  this.o = other; // another intersection\n  this.e = entry; // is an entry?\n  this.v = false; // visited\n  this.n = this.p = null; // next & previous\n}\n\n// A generalized polygon clipping algorithm: given a polygon that has been cut\n// into its visible line segments, and rejoins the segments by interpolating\n// along the clip edge.\nexport default function(segments, compareIntersection, startInside, interpolate, stream) {\n  var subject = [],\n      clip = [],\n      i,\n      n;\n\n  segments.forEach(function(segment) {\n    if ((n = segment.length - 1) <= 0) return;\n    var n, p0 = segment[0], p1 = segment[n], x;\n\n    if (pointEqual(p0, p1)) {\n      if (!p0[2] && !p1[2]) {\n        stream.lineStart();\n        for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]);\n        stream.lineEnd();\n        return;\n      }\n      // handle degenerate cases by moving the point\n      p1[0] += 2 * epsilon;\n    }\n\n    subject.push(x = new Intersection(p0, segment, null, true));\n    clip.push(x.o = new Intersection(p0, null, x, false));\n    subject.push(x = new Intersection(p1, segment, null, false));\n    clip.push(x.o = new Intersection(p1, null, x, true));\n  });\n\n  if (!subject.length) return;\n\n  clip.sort(compareIntersection);\n  link(subject);\n  link(clip);\n\n  for (i = 0, n = clip.length; i < n; ++i) {\n    clip[i].e = startInside = !startInside;\n  }\n\n  var start = subject[0],\n      points,\n      point;\n\n  while (1) {\n    // Find first unvisited intersection.\n    var current = start,\n        isSubject = true;\n    while (current.v) if ((current = current.n) === start) return;\n    points = current.z;\n    stream.lineStart();\n    do {\n      current.v = current.o.v = true;\n      if (current.e) {\n        if (isSubject) {\n          for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]);\n        } else {\n          interpolate(current.x, current.n.x, 1, stream);\n        }\n        current = current.n;\n      } else {\n        if (isSubject) {\n          points = current.p.z;\n          for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]);\n        } else {\n          interpolate(current.x, current.p.x, -1, stream);\n        }\n        current = current.p;\n      }\n      current = current.o;\n      points = current.z;\n      isSubject = !isSubject;\n    } while (!current.v);\n    stream.lineEnd();\n  }\n}\n\nfunction link(array) {\n  if (!(n = array.length)) return;\n  var n,\n      i = 0,\n      a = array[0],\n      b;\n  while (++i < n) {\n    a.n = b = array[i];\n    b.p = a;\n    a = b;\n  }\n  a.n = b = array[0];\n  b.p = a;\n}\n","import {abs, epsilon} from \"./math.js\";\n\nexport default function(a, b) {\n  return abs(a[0] - b[0]) < epsilon && abs(a[1] - b[1]) < epsilon;\n}\n","import {abs, epsilon} from \"../math.js\";\nimport clipBuffer from \"./buffer.js\";\nimport clipLine from \"./line.js\";\nimport clipRejoin from \"./rejoin.js\";\nimport {merge} from \"d3-array\";\n\nvar clipMax = 1e9, clipMin = -clipMax;\n\n// TODO Use d3-polygon’s polygonContains here for the ring check?\n// TODO Eliminate duplicate buffering in clipBuffer and polygon.push?\n\nexport default function clipRectangle(x0, y0, x1, y1) {\n\n  function visible(x, y) {\n    return x0 <= x && x <= x1 && y0 <= y && y <= y1;\n  }\n\n  function interpolate(from, to, direction, stream) {\n    var a = 0, a1 = 0;\n    if (from == null\n        || (a = corner(from, direction)) !== (a1 = corner(to, direction))\n        || comparePoint(from, to) < 0 ^ direction > 0) {\n      do stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);\n      while ((a = (a + direction + 4) % 4) !== a1);\n    } else {\n      stream.point(to[0], to[1]);\n    }\n  }\n\n  function corner(p, direction) {\n    return abs(p[0] - x0) < epsilon ? direction > 0 ? 0 : 3\n        : abs(p[0] - x1) < epsilon ? direction > 0 ? 2 : 1\n        : abs(p[1] - y0) < epsilon ? direction > 0 ? 1 : 0\n        : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon\n  }\n\n  function compareIntersection(a, b) {\n    return comparePoint(a.x, b.x);\n  }\n\n  function comparePoint(a, b) {\n    var ca = corner(a, 1),\n        cb = corner(b, 1);\n    return ca !== cb ? ca - cb\n        : ca === 0 ? b[1] - a[1]\n        : ca === 1 ? a[0] - b[0]\n        : ca === 2 ? a[1] - b[1]\n        : b[0] - a[0];\n  }\n\n  return function(stream) {\n    var activeStream = stream,\n        bufferStream = clipBuffer(),\n        segments,\n        polygon,\n        ring,\n        x__, y__, v__, // first point\n        x_, y_, v_, // previous point\n        first,\n        clean;\n\n    var clipStream = {\n      point: point,\n      lineStart: lineStart,\n      lineEnd: lineEnd,\n      polygonStart: polygonStart,\n      polygonEnd: polygonEnd\n    };\n\n    function point(x, y) {\n      if (visible(x, y)) activeStream.point(x, y);\n    }\n\n    function polygonInside() {\n      var winding = 0;\n\n      for (var i = 0, n = polygon.length; i < n; ++i) {\n        for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) {\n          a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1];\n          if (a1 <= y1) { if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding; }\n          else { if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding; }\n        }\n      }\n\n      return winding;\n    }\n\n    // Buffer geometry within a polygon and then clip it en masse.\n    function polygonStart() {\n      activeStream = bufferStream, segments = [], polygon = [], clean = true;\n    }\n\n    function polygonEnd() {\n      var startInside = polygonInside(),\n          cleanInside = clean && startInside,\n          visible = (segments = merge(segments)).length;\n      if (cleanInside || visible) {\n        stream.polygonStart();\n        if (cleanInside) {\n          stream.lineStart();\n          interpolate(null, null, 1, stream);\n          stream.lineEnd();\n        }\n        if (visible) {\n          clipRejoin(segments, compareIntersection, startInside, interpolate, stream);\n        }\n        stream.polygonEnd();\n      }\n      activeStream = stream, segments = polygon = ring = null;\n    }\n\n    function lineStart() {\n      clipStream.point = linePoint;\n      if (polygon) polygon.push(ring = []);\n      first = true;\n      v_ = false;\n      x_ = y_ = NaN;\n    }\n\n    // TODO rather than special-case polygons, simply handle them separately.\n    // Ideally, coincident intersection points should be jittered to avoid\n    // clipping issues.\n    function lineEnd() {\n      if (segments) {\n        linePoint(x__, y__);\n        if (v__ && v_) bufferStream.rejoin();\n        segments.push(bufferStream.result());\n      }\n      clipStream.point = point;\n      if (v_) activeStream.lineEnd();\n    }\n\n    function linePoint(x, y) {\n      var v = visible(x, y);\n      if (polygon) ring.push([x, y]);\n      if (first) {\n        x__ = x, y__ = y, v__ = v;\n        first = false;\n        if (v) {\n          activeStream.lineStart();\n          activeStream.point(x, y);\n        }\n      } else {\n        if (v && v_) activeStream.point(x, y);\n        else {\n          var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))],\n              b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))];\n          if (clipLine(a, b, x0, y0, x1, y1)) {\n            if (!v_) {\n              activeStream.lineStart();\n              activeStream.point(a[0], a[1]);\n            }\n            activeStream.point(b[0], b[1]);\n            if (!v) activeStream.lineEnd();\n            clean = false;\n          } else if (v) {\n            activeStream.lineStart();\n            activeStream.point(x, y);\n            clean = false;\n          }\n        }\n      }\n      x_ = x, y_ = y, v_ = v;\n    }\n\n    return clipStream;\n  };\n}\n","import noop from \"../noop.js\";\n\nexport default function() {\n  var lines = [],\n      line;\n  return {\n    point: function(x, y, m) {\n      line.push([x, y, m]);\n    },\n    lineStart: function() {\n      lines.push(line = []);\n    },\n    lineEnd: noop,\n    rejoin: function() {\n      if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));\n    },\n    result: function() {\n      var result = lines;\n      lines = [];\n      line = null;\n      return result;\n    }\n  };\n}\n","export default function(a, b, x0, y0, x1, y1) {\n  var ax = a[0],\n      ay = a[1],\n      bx = b[0],\n      by = b[1],\n      t0 = 0,\n      t1 = 1,\n      dx = bx - ax,\n      dy = by - ay,\n      r;\n\n  r = x0 - ax;\n  if (!dx && r > 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dx > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = x1 - ax;\n  if (!dx && r < 0) return;\n  r /= dx;\n  if (dx < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dx > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  r = y0 - ay;\n  if (!dy && r > 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  } else if (dy > 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  }\n\n  r = y1 - ay;\n  if (!dy && r < 0) return;\n  r /= dy;\n  if (dy < 0) {\n    if (r > t1) return;\n    if (r > t0) t0 = r;\n  } else if (dy > 0) {\n    if (r < t0) return;\n    if (r < t1) t1 = r;\n  }\n\n  if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy;\n  if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy;\n  return true;\n}\n","export default function(methods) {\n  return {\n    stream: transformer(methods)\n  };\n}\n\nexport function transformer(methods) {\n  return function(stream) {\n    var s = new TransformStream;\n    for (var key in methods) s[key] = methods[key];\n    s.stream = stream;\n    return s;\n  };\n}\n\nfunction TransformStream() {}\n\nTransformStream.prototype = {\n  constructor: TransformStream,\n  point: function(x, y) { this.stream.point(x, y); },\n  sphere: function() { this.stream.sphere(); },\n  lineStart: function() { this.stream.lineStart(); },\n  lineEnd: function() { this.stream.lineEnd(); },\n  polygonStart: function() { this.stream.polygonStart(); },\n  polygonEnd: function() { this.stream.polygonEnd(); }\n};\n","import {default as geoStream} from \"../stream.js\";\nimport boundsStream from \"../path/bounds.js\";\n\nfunction fit(projection, fitBounds, object) {\n  var clip = projection.clipExtent && projection.clipExtent();\n  projection.scale(150).translate([0, 0]);\n  if (clip != null) projection.clipExtent(null);\n  geoStream(object, projection.stream(boundsStream));\n  fitBounds(boundsStream.result());\n  if (clip != null) projection.clipExtent(clip);\n  return projection;\n}\n\nexport function fitExtent(projection, extent, object) {\n  return fit(projection, function(b) {\n    var w = extent[1][0] - extent[0][0],\n        h = extent[1][1] - extent[0][1],\n        k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])),\n        x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2,\n        y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;\n    projection.scale(150 * k).translate([x, y]);\n  }, object);\n}\n\nexport function fitSize(projection, size, object) {\n  return fitExtent(projection, [[0, 0], size], object);\n}\n\nexport function fitWidth(projection, width, object) {\n  return fit(projection, function(b) {\n    var w = +width,\n        k = w / (b[1][0] - b[0][0]),\n        x = (w - k * (b[1][0] + b[0][0])) / 2,\n        y = -k * b[0][1];\n    projection.scale(150 * k).translate([x, y]);\n  }, object);\n}\n\nexport function fitHeight(projection, height, object) {\n  return fit(projection, function(b) {\n    var h = +height,\n        k = h / (b[1][1] - b[0][1]),\n        x = -k * b[0][0],\n        y = (h - k * (b[1][1] + b[0][1])) / 2;\n    projection.scale(150 * k).translate([x, y]);\n  }, object);\n}\n","import clipRectangle from \"../clip/rectangle.js\";\nimport identity from \"../identity.js\";\nimport {transformer} from \"../transform.js\";\nimport {fitExtent, fitSize, fitWidth, fitHeight} from \"./fit.js\";\nimport {cos, degrees, radians, sin} from \"../math.js\";\n\nexport default function() {\n  var k = 1, tx = 0, ty = 0, sx = 1, sy = 1, // scale, translate and reflect\n      alpha = 0, ca, sa, // angle\n      x0 = null, y0, x1, y1, // clip extent\n      kx = 1, ky = 1,\n      transform = transformer({\n        point: function(x, y) {\n          var p = projection([x, y])\n          this.stream.point(p[0], p[1]);\n        }\n      }),\n      postclip = identity,\n      cache,\n      cacheStream;\n\n  function reset() {\n    kx = k * sx;\n    ky = k * sy;\n    cache = cacheStream = null;\n    return projection;\n  }\n\n  function projection (p) {\n    var x = p[0] * kx, y = p[1] * ky;\n    if (alpha) {\n      var t = y * ca - x * sa;\n      x = x * ca + y * sa;\n      y = t;\n    }    \n    return [x + tx, y + ty];\n  }\n  projection.invert = function(p) {\n    var x = p[0] - tx, y = p[1] - ty;\n    if (alpha) {\n      var t = y * ca + x * sa;\n      x = x * ca - y * sa;\n      y = t;\n    }\n    return [x / kx, y / ky];\n  };\n  projection.stream = function(stream) {\n    return cache && cacheStream === stream ? cache : cache = transform(postclip(cacheStream = stream));\n  };\n  projection.postclip = function(_) {\n    return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip;\n  };\n  projection.clipExtent = function(_) {\n    return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, identity) : clipRectangle(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];\n  };\n  projection.scale = function(_) {\n    return arguments.length ? (k = +_, reset()) : k;\n  };\n  projection.translate = function(_) {\n    return arguments.length ? (tx = +_[0], ty = +_[1], reset()) : [tx, ty];\n  }\n  projection.angle = function(_) {\n    return arguments.length ? (alpha = _ % 360 * radians, sa = sin(alpha), ca = cos(alpha), reset()) : alpha * degrees;\n  };\n  projection.reflectX = function(_) {\n    return arguments.length ? (sx = _ ? -1 : 1, reset()) : sx < 0;\n  };\n  projection.reflectY = function(_) {\n    return arguments.length ? (sy = _ ? -1 : 1, reset()) : sy < 0;\n  };\n  projection.fitExtent = function(extent, object) {\n    return fitExtent(projection, extent, object);\n  };\n  projection.fitSize = function(size, object) {\n    return fitSize(projection, size, object);\n  };\n  projection.fitWidth = function(width, object) {\n    return fitWidth(projection, width, object);\n  };\n  projection.fitHeight = function(height, object) {\n    return fitHeight(projection, height, object);\n  };\n\n  return projection;\n}\n","var mapCacheClear = require('./_mapCacheClear'),\n    mapCacheDelete = require('./_mapCacheDelete'),\n    mapCacheGet = require('./_mapCacheGet'),\n    mapCacheHas = require('./_mapCacheHas'),\n    mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","var Hash = require('./_Hash'),\n    ListCache = require('./_ListCache'),\n    Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nmodule.exports = mapCacheClear;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = mapCacheDelete;\n","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","export default function noop() {}\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}\nexport { _typeof as default };","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nexport { toPropertyKey as default };","import _typeof from \"./typeof.js\";\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nexport { toPrimitive as default };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperty(e, r, t) {\n  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nexport { _defineProperty as default };","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","function streamGeometry(geometry, stream) {\n  if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {\n    streamGeometryType[geometry.type](geometry, stream);\n  }\n}\n\nvar streamObjectType = {\n  Feature: function(object, stream) {\n    streamGeometry(object.geometry, stream);\n  },\n  FeatureCollection: function(object, stream) {\n    var features = object.features, i = -1, n = features.length;\n    while (++i < n) streamGeometry(features[i].geometry, stream);\n  }\n};\n\nvar streamGeometryType = {\n  Sphere: function(object, stream) {\n    stream.sphere();\n  },\n  Point: function(object, stream) {\n    object = object.coordinates;\n    stream.point(object[0], object[1], object[2]);\n  },\n  MultiPoint: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);\n  },\n  LineString: function(object, stream) {\n    streamLine(object.coordinates, stream, 0);\n  },\n  MultiLineString: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) streamLine(coordinates[i], stream, 0);\n  },\n  Polygon: function(object, stream) {\n    streamPolygon(object.coordinates, stream);\n  },\n  MultiPolygon: function(object, stream) {\n    var coordinates = object.coordinates, i = -1, n = coordinates.length;\n    while (++i < n) streamPolygon(coordinates[i], stream);\n  },\n  GeometryCollection: function(object, stream) {\n    var geometries = object.geometries, i = -1, n = geometries.length;\n    while (++i < n) streamGeometry(geometries[i], stream);\n  }\n};\n\nfunction streamLine(coordinates, stream, closed) {\n  var i = -1, n = coordinates.length - closed, coordinate;\n  stream.lineStart();\n  while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);\n  stream.lineEnd();\n}\n\nfunction streamPolygon(coordinates, stream) {\n  var i = -1, n = coordinates.length;\n  stream.polygonStart();\n  while (++i < n) streamLine(coordinates[i], stream, 1);\n  stream.polygonEnd();\n}\n\nexport default function(object, stream) {\n  if (object && streamObjectType.hasOwnProperty(object.type)) {\n    streamObjectType[object.type](object, stream);\n  } else {\n    streamGeometry(object, stream);\n  }\n}\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","// Adds floating point numbers with twice the normal precision.\n// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and\n// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3)\n// 305–363 (1997).\n// Code adapted from GeographicLib by Charles F. F. Karney,\n// http://geographiclib.sourceforge.net/\n\nexport default function() {\n  return new Adder;\n}\n\nfunction Adder() {\n  this.reset();\n}\n\nAdder.prototype = {\n  constructor: Adder,\n  reset: function() {\n    this.s = // rounded value\n    this.t = 0; // exact error\n  },\n  add: function(y) {\n    add(temp, y, this.t);\n    add(this, temp.s, this.s);\n    if (this.s) this.t += temp.t;\n    else this.s = temp.t;\n  },\n  valueOf: function() {\n    return this.s;\n  }\n};\n\nvar temp = new Adder;\n\nfunction add(adder, a, b) {\n  var x = adder.s = a + b,\n      bv = x - a,\n      av = x - bv;\n  adder.t = (a - av) + (b - bv);\n}\n","import adder from \"../adder.js\";\nimport {abs} from \"../math.js\";\nimport noop from \"../noop.js\";\n\nvar areaSum = adder(),\n    areaRingSum = adder(),\n    x00,\n    y00,\n    x0,\n    y0;\n\nvar areaStream = {\n  point: noop,\n  lineStart: noop,\n  lineEnd: noop,\n  polygonStart: function() {\n    areaStream.lineStart = areaRingStart;\n    areaStream.lineEnd = areaRingEnd;\n  },\n  polygonEnd: function() {\n    areaStream.lineStart = areaStream.lineEnd = areaStream.point = noop;\n    areaSum.add(abs(areaRingSum));\n    areaRingSum.reset();\n  },\n  result: function() {\n    var area = areaSum / 2;\n    areaSum.reset();\n    return area;\n  }\n};\n\nfunction areaRingStart() {\n  areaStream.point = areaPointFirst;\n}\n\nfunction areaPointFirst(x, y) {\n  areaStream.point = areaPoint;\n  x00 = x0 = x, y00 = y0 = y;\n}\n\nfunction areaPoint(x, y) {\n  areaRingSum.add(y0 * x - x0 * y);\n  x0 = x, y0 = y;\n}\n\nfunction areaRingEnd() {\n  areaPoint(x00, y00);\n}\n\nexport default areaStream;\n","import {sqrt} from \"../math.js\";\n\n// TODO Enforce positive area for exterior, negative area for interior?\n\nvar X0 = 0,\n    Y0 = 0,\n    Z0 = 0,\n    X1 = 0,\n    Y1 = 0,\n    Z1 = 0,\n    X2 = 0,\n    Y2 = 0,\n    Z2 = 0,\n    x00,\n    y00,\n    x0,\n    y0;\n\nvar centroidStream = {\n  point: centroidPoint,\n  lineStart: centroidLineStart,\n  lineEnd: centroidLineEnd,\n  polygonStart: function() {\n    centroidStream.lineStart = centroidRingStart;\n    centroidStream.lineEnd = centroidRingEnd;\n  },\n  polygonEnd: function() {\n    centroidStream.point = centroidPoint;\n    centroidStream.lineStart = centroidLineStart;\n    centroidStream.lineEnd = centroidLineEnd;\n  },\n  result: function() {\n    var centroid = Z2 ? [X2 / Z2, Y2 / Z2]\n        : Z1 ? [X1 / Z1, Y1 / Z1]\n        : Z0 ? [X0 / Z0, Y0 / Z0]\n        : [NaN, NaN];\n    X0 = Y0 = Z0 =\n    X1 = Y1 = Z1 =\n    X2 = Y2 = Z2 = 0;\n    return centroid;\n  }\n};\n\nfunction centroidPoint(x, y) {\n  X0 += x;\n  Y0 += y;\n  ++Z0;\n}\n\nfunction centroidLineStart() {\n  centroidStream.point = centroidPointFirstLine;\n}\n\nfunction centroidPointFirstLine(x, y) {\n  centroidStream.point = centroidPointLine;\n  centroidPoint(x0 = x, y0 = y);\n}\n\nfunction centroidPointLine(x, y) {\n  var dx = x - x0, dy = y - y0, z = sqrt(dx * dx + dy * dy);\n  X1 += z * (x0 + x) / 2;\n  Y1 += z * (y0 + y) / 2;\n  Z1 += z;\n  centroidPoint(x0 = x, y0 = y);\n}\n\nfunction centroidLineEnd() {\n  centroidStream.point = centroidPoint;\n}\n\nfunction centroidRingStart() {\n  centroidStream.point = centroidPointFirstRing;\n}\n\nfunction centroidRingEnd() {\n  centroidPointRing(x00, y00);\n}\n\nfunction centroidPointFirstRing(x, y) {\n  centroidStream.point = centroidPointRing;\n  centroidPoint(x00 = x0 = x, y00 = y0 = y);\n}\n\nfunction centroidPointRing(x, y) {\n  var dx = x - x0,\n      dy = y - y0,\n      z = sqrt(dx * dx + dy * dy);\n\n  X1 += z * (x0 + x) / 2;\n  Y1 += z * (y0 + y) / 2;\n  Z1 += z;\n\n  z = y0 * x - x0 * y;\n  X2 += z * (x0 + x);\n  Y2 += z * (y0 + y);\n  Z2 += z * 3;\n  centroidPoint(x0 = x, y0 = y);\n}\n\nexport default centroidStream;\n","import {tau} from \"../math.js\";\nimport noop from \"../noop.js\";\n\nexport default function PathContext(context) {\n  this._context = context;\n}\n\nPathContext.prototype = {\n  _radius: 4.5,\n  pointRadius: function(_) {\n    return this._radius = _, this;\n  },\n  polygonStart: function() {\n    this._line = 0;\n  },\n  polygonEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line === 0) this._context.closePath();\n    this._point = NaN;\n  },\n  point: function(x, y) {\n    switch (this._point) {\n      case 0: {\n        this._context.moveTo(x, y);\n        this._point = 1;\n        break;\n      }\n      case 1: {\n        this._context.lineTo(x, y);\n        break;\n      }\n      default: {\n        this._context.moveTo(x + this._radius, y);\n        this._context.arc(x, y, this._radius, 0, tau);\n        break;\n      }\n    }\n  },\n  result: noop\n};\n","import adder from \"../adder.js\";\nimport {sqrt} from \"../math.js\";\nimport noop from \"../noop.js\";\n\nvar lengthSum = adder(),\n    lengthRing,\n    x00,\n    y00,\n    x0,\n    y0;\n\nvar lengthStream = {\n  point: noop,\n  lineStart: function() {\n    lengthStream.point = lengthPointFirst;\n  },\n  lineEnd: function() {\n    if (lengthRing) lengthPoint(x00, y00);\n    lengthStream.point = noop;\n  },\n  polygonStart: function() {\n    lengthRing = true;\n  },\n  polygonEnd: function() {\n    lengthRing = null;\n  },\n  result: function() {\n    var length = +lengthSum;\n    lengthSum.reset();\n    return length;\n  }\n};\n\nfunction lengthPointFirst(x, y) {\n  lengthStream.point = lengthPoint;\n  x00 = x0 = x, y00 = y0 = y;\n}\n\nfunction lengthPoint(x, y) {\n  x0 -= x, y0 -= y;\n  lengthSum.add(sqrt(x0 * x0 + y0 * y0));\n  x0 = x, y0 = y;\n}\n\nexport default lengthStream;\n","export default function PathString() {\n  this._string = [];\n}\n\nPathString.prototype = {\n  _radius: 4.5,\n  _circle: circle(4.5),\n  pointRadius: function(_) {\n    if ((_ = +_) !== this._radius) this._radius = _, this._circle = null;\n    return this;\n  },\n  polygonStart: function() {\n    this._line = 0;\n  },\n  polygonEnd: function() {\n    this._line = NaN;\n  },\n  lineStart: function() {\n    this._point = 0;\n  },\n  lineEnd: function() {\n    if (this._line === 0) this._string.push(\"Z\");\n    this._point = NaN;\n  },\n  point: function(x, y) {\n    switch (this._point) {\n      case 0: {\n        this._string.push(\"M\", x, \",\", y);\n        this._point = 1;\n        break;\n      }\n      case 1: {\n        this._string.push(\"L\", x, \",\", y);\n        break;\n      }\n      default: {\n        if (this._circle == null) this._circle = circle(this._radius);\n        this._string.push(\"M\", x, \",\", y, this._circle);\n        break;\n      }\n    }\n  },\n  result: function() {\n    if (this._string.length) {\n      var result = this._string.join(\"\");\n      this._string = [];\n      return result;\n    } else {\n      return null;\n    }\n  }\n};\n\nfunction circle(radius) {\n  return \"m0,\" + radius\n      + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + -2 * radius\n      + \"a\" + radius + \",\" + radius + \" 0 1,1 0,\" + 2 * radius\n      + \"z\";\n}\n","import identity from \"../identity.js\";\nimport stream from \"../stream.js\";\nimport pathArea from \"./area.js\";\nimport pathBounds from \"./bounds.js\";\nimport pathCentroid from \"./centroid.js\";\nimport PathContext from \"./context.js\";\nimport pathMeasure from \"./measure.js\";\nimport PathString from \"./string.js\";\n\nexport default function(projection, context) {\n  var pointRadius = 4.5,\n      projectionStream,\n      contextStream;\n\n  function path(object) {\n    if (object) {\n      if (typeof pointRadius === \"function\") contextStream.pointRadius(+pointRadius.apply(this, arguments));\n      stream(object, projectionStream(contextStream));\n    }\n    return contextStream.result();\n  }\n\n  path.area = function(object) {\n    stream(object, projectionStream(pathArea));\n    return pathArea.result();\n  };\n\n  path.measure = function(object) {\n    stream(object, projectionStream(pathMeasure));\n    return pathMeasure.result();\n  };\n\n  path.bounds = function(object) {\n    stream(object, projectionStream(pathBounds));\n    return pathBounds.result();\n  };\n\n  path.centroid = function(object) {\n    stream(object, projectionStream(pathCentroid));\n    return pathCentroid.result();\n  };\n\n  path.projection = function(_) {\n    return arguments.length ? (projectionStream = _ == null ? (projection = null, identity) : (projection = _).stream, path) : projection;\n  };\n\n  path.context = function(_) {\n    if (!arguments.length) return context;\n    contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);\n    if (typeof pointRadius !== \"function\") contextStream.pointRadius(pointRadius);\n    return path;\n  };\n\n  path.pointRadius = function(_) {\n    if (!arguments.length) return pointRadius;\n    pointRadius = typeof _ === \"function\" ? _ : (contextStream.pointRadius(+_), +_);\n    return path;\n  };\n\n  return path.projection(projection).context(context);\n}\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = assocIndexOf;\n","/**\n * Virtual DOM Node\n * @typedef VNode\n * @property {string | function} nodeName The string of the DOM node to create or Component constructor to render\n * @property {Array<VNode | string>} children The children of node\n * @property {string | number | undefined} key The key used to identify this VNode in a list\n * @property {object} attributes The properties of this VNode\n */\nexport const VNode = function VNode() {};\n","/**\n * @typedef {import('./component').Component} Component\n * @typedef {import('./vnode').VNode} VNode\n */\n\n/**\n * Global options\n * @public\n * @typedef Options\n * @property {boolean} [syncComponentUpdates] If `true`, `prop` changes trigger synchronous component updates. Defaults to true.\n * @property {(vnode: VNode) => void} [vnode] Processes all created VNodes.\n * @property {(component: Component) => void} [afterMount] Hook invoked after a component is mounted.\n * @property {(component: Component) => void} [afterUpdate] Hook invoked after the DOM is updated with a component's latest render.\n * @property {(component: Component) => void} [beforeUnmount] Hook invoked immediately before a component is unmounted.\n * @property {(rerender: function) => void} [debounceRendering] Hook invoked whenever a rerender is requested. Can be used to debounce rerenders.\n * @property {(event: Event) => Event | void} [event] Hook invoked before any Preact event listeners. The return value (if any) replaces the native browser event given to event listeners\n */\n\n/** @type {Options}  */\nconst options = {};\n\nexport default options;\n","import { VNode } from './vnode';\nimport options from './options';\n\n\nconst stack = [];\n\nconst EMPTY_CHILDREN = [];\n\n/**\n * JSX/hyperscript reviver.\n * @see http://jasonformat.com/wtf-is-jsx\n * Benchmarks: https://esbench.com/bench/57ee8f8e330ab09900a1a1a0\n *\n * Note: this is exported as both `h()` and `createElement()` for compatibility\n * reasons.\n *\n * Creates a VNode (virtual DOM element). A tree of VNodes can be used as a\n * lightweight representation of the structure of a DOM tree. This structure can\n * be realized by recursively comparing it against the current _actual_ DOM\n * structure, and applying only the differences.\n *\n * `h()`/`createElement()` accepts an element name, a list of attributes/props,\n * and optionally children to append to the element.\n *\n * @example The following DOM tree\n *\n * `<div id=\"foo\" name=\"bar\">Hello!</div>`\n *\n * can be constructed using this function as:\n *\n * `h('div', { id: 'foo', name : 'bar' }, 'Hello!');`\n *\n * @param {string | function} nodeName An element name. Ex: `div`, `a`, `span`, etc.\n * @param {object | null} attributes Any attributes/props to set on the created element.\n * @param {VNode[]} [rest] Additional arguments are taken to be children to\n *  append. Can be infinitely nested Arrays.\n *\n * @public\n */\nexport function h(nodeName, attributes) {\n\tlet children=EMPTY_CHILDREN, lastSimple, child, simple, i;\n\tfor (i=arguments.length; i-- > 2; ) {\n\t\tstack.push(arguments[i]);\n\t}\n\tif (attributes && attributes.children!=null) {\n\t\tif (!stack.length) stack.push(attributes.children);\n\t\tdelete attributes.children;\n\t}\n\twhile (stack.length) {\n\t\tif ((child = stack.pop()) && child.pop!==undefined) {\n\t\t\tfor (i=child.length; i--; ) stack.push(child[i]);\n\t\t}\n\t\telse {\n\t\t\tif (typeof child==='boolean') child = null;\n\n\t\t\tif ((simple = typeof nodeName!=='function')) {\n\t\t\t\tif (child==null) child = '';\n\t\t\t\telse if (typeof child==='number') child = String(child);\n\t\t\t\telse if (typeof child!=='string') simple = false;\n\t\t\t}\n\n\t\t\tif (simple && lastSimple) {\n\t\t\t\tchildren[children.length-1] += child;\n\t\t\t}\n\t\t\telse if (children===EMPTY_CHILDREN) {\n\t\t\t\tchildren = [child];\n\t\t\t}\n\t\t\telse {\n\t\t\t\tchildren.push(child);\n\t\t\t}\n\n\t\t\tlastSimple = simple;\n\t\t}\n\t}\n\n\tlet p = new VNode();\n\tp.nodeName = nodeName;\n\tp.children = children;\n\tp.attributes = attributes==null ? undefined : attributes;\n\tp.key = attributes==null ? undefined : attributes.key;\n\n\t// if a \"vnode hook\" is defined, pass every created VNode to it\n\tif (options.vnode!==undefined) options.vnode(p);\n\n\treturn p;\n}\n","/**\n * Copy all properties from `props` onto `obj`.\n * @param {object} obj Object onto which properties should be copied.\n * @param {object} props Object from which to copy properties.\n * @returns {object}\n * @private\n */\nexport function extend(obj, props) {\n\tfor (let i in props) obj[i] = props[i];\n\treturn obj;\n}\n\n/** Invoke or update a ref, depending on whether it is a function or object ref.\n *  @param {object|function} [ref=null]\n *  @param {any} [value]\n */\nexport function applyRef(ref, value) {\n\tif (ref) {\n\t\tif (typeof ref=='function') ref(value);\n\t\telse ref.current = value;\n\t}\n}\n\n/**\n * Call a function asynchronously, as soon as possible. Makes\n * use of HTML Promise to schedule the callback if available,\n * otherwise falling back to `setTimeout` (mainly for IE<11).\n * @type {(callback: function) => void}\n */\nexport const defer = typeof Promise=='function' ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout;\n","import { extend } from './util';\nimport { h } from './h';\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its\n * children.\n * @param {import('./vnode').VNode} vnode The virtual DOM element to clone\n * @param {object} props Attributes/props to add when cloning\n * @param {Array<import('./vnode').VNode>} [rest] Any additional arguments will be used as replacement\n *  children.\n */\nexport function cloneElement(vnode, props) {\n\treturn h(\n\t\tvnode.nodeName,\n\t\textend(extend({}, vnode.attributes), props),\n\t\targuments.length>2 ? [].slice.call(arguments, 2) : vnode.children\n\t);\n}\n","// render modes\n\n/** Do not re-render a component */\nexport const NO_RENDER = 0;\n/** Synchronously re-render a component and its children */\nexport const SYNC_RENDER = 1;\n/** Synchronously re-render a component, even if its lifecycle methods attempt to prevent it. */\nexport const FORCE_RENDER = 2;\n/** Queue asynchronous re-render of a component and it's children */\nexport const ASYNC_RENDER = 3;\n\n\nexport const ATTR_KEY = '__preactattr_';\n\n/** DOM properties that should NOT have \"px\" added when numeric */\nexport const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;\n\n","import options from './options';\nimport { defer } from './util';\nimport { renderComponent } from './vdom/component';\n\n/**\n * Managed queue of dirty components to be re-rendered\n * @type {Array<import('./component').Component>}\n */\nlet items = [];\n\n/**\n * Enqueue a rerender of a component\n * @param {import('./component').Component} component The component to rerender\n */\nexport function enqueueRender(component) {\n\tif (!component._dirty && (component._dirty = true) && items.push(component)==1) {\n\t\t(options.debounceRendering || defer)(rerender);\n\t}\n}\n\n/** Rerender all enqueued dirty components */\nexport function rerender() {\n\tlet p;\n\twhile ( (p = items.pop()) ) {\n\t\tif (p._dirty) renderComponent(p);\n\t}\n}\n","import { extend } from '../util';\n\n\n/**\n * Check if two nodes are equivalent.\n * @param {import('../dom').PreactElement} node DOM Node to compare\n * @param {import('../vnode').VNode} vnode Virtual DOM node to compare\n * @param {boolean} [hydrating=false] If true, ignores component constructors\n *  when comparing.\n * @private\n */\nexport function isSameNodeType(node, vnode, hydrating) {\n\tif (typeof vnode==='string' || typeof vnode==='number') {\n\t\treturn node.splitText!==undefined;\n\t}\n\tif (typeof vnode.nodeName==='string') {\n\t\treturn !node._componentConstructor && isNamedNode(node, vnode.nodeName);\n\t}\n\treturn hydrating || node._componentConstructor===vnode.nodeName;\n}\n\n\n/**\n * Check if an Element has a given nodeName, case-insensitively.\n * @param {import('../dom').PreactElement} node A DOM Element to inspect the name of.\n * @param {string} nodeName Unnormalized name to compare against.\n */\nexport function isNamedNode(node, nodeName) {\n\treturn node.normalizedNodeName===nodeName || node.nodeName.toLowerCase()===nodeName.toLowerCase();\n}\n\n\n/**\n * Reconstruct Component-style `props` from a VNode.\n * Ensures default/fallback values from `defaultProps`:\n * Own-properties of `defaultProps` not present in `vnode.attributes` are added.\n * @param {import('../vnode').VNode} vnode The VNode to get props for\n * @returns {object} The props to use for this VNode\n */\nexport function getNodeProps(vnode) {\n\tlet props = extend({}, vnode.attributes);\n\tprops.children = vnode.children;\n\n\tlet defaultProps = vnode.nodeName.defaultProps;\n\tif (defaultProps!==undefined) {\n\t\tfor (let i in defaultProps) {\n\t\t\tif (props[i]===undefined) {\n\t\t\t\tprops[i] = defaultProps[i];\n\t\t\t}\n\t\t}\n\t}\n\n\treturn props;\n}\n","import { IS_NON_DIMENSIONAL } from '../constants';\nimport { applyRef } from '../util';\nimport options from '../options';\n\n/**\n * A DOM event listener\n * @typedef {(e: Event) => void} EventListner\n */\n\n/**\n * A mapping of event types to event listeners\n * @typedef {Object.<string, EventListener>} EventListenerMap\n */\n\n/**\n * Properties Preact adds to elements it creates\n * @typedef PreactElementExtensions\n * @property {string} [normalizedNodeName] A normalized node name to use in diffing\n * @property {EventListenerMap} [_listeners] A map of event listeners added by components to this DOM node\n * @property {import('../component').Component} [_component] The component that rendered this DOM node\n * @property {function} [_componentConstructor] The constructor of the component that rendered this DOM node\n */\n\n/**\n * A DOM element that has been extended with Preact properties\n * @typedef {Element & ElementCSSInlineStyle & PreactElementExtensions} PreactElement\n */\n\n/**\n * Create an element with the given nodeName.\n * @param {string} nodeName The DOM node to create\n * @param {boolean} [isSvg=false] If `true`, creates an element within the SVG\n *  namespace.\n * @returns {PreactElement} The created DOM node\n */\nexport function createNode(nodeName, isSvg) {\n\t/** @type {PreactElement} */\n\tlet node = isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName);\n\tnode.normalizedNodeName = nodeName;\n\treturn node;\n}\n\n\n/**\n * Remove a child node from its parent if attached.\n * @param {Node} node The node to remove\n */\nexport function removeNode(node) {\n\tlet parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n\n\n/**\n * Set a named attribute on the given Node, with special behavior for some names\n * and event handlers. If `value` is `null`, the attribute/handler will be\n * removed.\n * @param {PreactElement} node An element to mutate\n * @param {string} name The name/key to set, such as an event or attribute name\n * @param {*} old The last value that was set for this name/node pair\n * @param {*} value An attribute value, such as a function to be used as an\n *  event handler\n * @param {boolean} isSvg Are we currently diffing inside an svg?\n * @private\n */\nexport function setAccessor(node, name, old, value, isSvg) {\n\tif (name==='className') name = 'class';\n\n\n\tif (name==='key') {\n\t\t// ignore\n\t}\n\telse if (name==='ref') {\n\t\tapplyRef(old, null);\n\t\tapplyRef(value, node);\n\t}\n\telse if (name==='class' && !isSvg) {\n\t\tnode.className = value || '';\n\t}\n\telse if (name==='style') {\n\t\tif (!value || typeof value==='string' || typeof old==='string') {\n\t\t\tnode.style.cssText = value || '';\n\t\t}\n\t\tif (value && typeof value==='object') {\n\t\t\tif (typeof old!=='string') {\n\t\t\t\tfor (let i in old) if (!(i in value)) node.style[i] = '';\n\t\t\t}\n\t\t\tfor (let i in value) {\n\t\t\t\tnode.style[i] = typeof value[i]==='number' && IS_NON_DIMENSIONAL.test(i)===false ? (value[i]+'px') : value[i];\n\t\t\t}\n\t\t}\n\t}\n\telse if (name==='dangerouslySetInnerHTML') {\n\t\tif (value) node.innerHTML = value.__html || '';\n\t}\n\telse if (name[0]=='o' && name[1]=='n') {\n\t\tlet useCapture = name !== (name=name.replace(/Capture$/, ''));\n\t\tname = name.toLowerCase().substring(2);\n\t\tif (value) {\n\t\t\tif (!old) node.addEventListener(name, eventProxy, useCapture);\n\t\t}\n\t\telse {\n\t\t\tnode.removeEventListener(name, eventProxy, useCapture);\n\t\t}\n\t\t(node._listeners || (node._listeners = {}))[name] = value;\n\t}\n\telse if (name!=='list' && name!=='type' && !isSvg && name in node) {\n\t\t// Attempt to set a DOM property to the given value.\n\t\t// IE & FF throw for certain property-value combinations.\n\t\ttry {\n\t\t\tnode[name] = value==null ? '' : value;\n\t\t} catch (e) { }\n\t\tif ((value==null || value===false) && name!='spellcheck') node.removeAttribute(name);\n\t}\n\telse {\n\t\tlet ns = isSvg && (name !== (name = name.replace(/^xlink:?/, '')));\n\t\t// spellcheck is treated differently than all other boolean values and\n\t\t// should not be removed when the value is `false`. See:\n\t\t// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-spellcheck\n\t\tif (value==null || value===false) {\n\t\t\tif (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase());\n\t\t\telse node.removeAttribute(name);\n\t\t}\n\t\telse if (typeof value!=='function') {\n\t\t\tif (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase(), value);\n\t\t\telse node.setAttribute(name, value);\n\t\t}\n\t}\n}\n\n\n/**\n * Proxy an event to hooked event handlers\n * @param {Event} e The event object from the browser\n * @private\n */\nfunction eventProxy(e) {\n\treturn this._listeners[e.type](options.event && options.event(e) || e);\n}\n","import { ATTR_KEY } from '../constants';\nimport { isSameNodeType, isNamedNode } from './index';\nimport { buildComponentFromVNode } from './component';\nimport { createNode, setAccessor } from '../dom/index';\nimport { unmountComponent } from './component';\nimport options from '../options';\nimport { applyRef } from '../util';\nimport { removeNode } from '../dom/index';\n\n/**\n * Queue of components that have been mounted and are awaiting componentDidMount\n * @type {Array<import('../component').Component>}\n */\nexport const mounts = [];\n\n/** Diff recursion count, used to track the end of the diff cycle. */\nexport let diffLevel = 0;\n\n/** Global flag indicating if the diff is currently within an SVG */\nlet isSvgMode = false;\n\n/** Global flag indicating if the diff is performing hydration */\nlet hydrating = false;\n\n/** Invoke queued componentDidMount lifecycle methods */\nexport function flushMounts() {\n\tlet c;\n\twhile ((c = mounts.shift())) {\n\t\tif (options.afterMount) options.afterMount(c);\n\t\tif (c.componentDidMount) c.componentDidMount();\n\t}\n}\n\n\n/**\n * Apply differences in a given vnode (and it's deep children) to a real DOM Node.\n * @param {import('../dom').PreactElement} dom A DOM node to mutate into the shape of a `vnode`\n * @param {import('../vnode').VNode} vnode A VNode (with descendants forming a tree) representing\n *  the desired DOM structure\n * @param {object} context The current context\n * @param {boolean} mountAll Whether or not to immediately mount all components\n * @param {Element} parent ?\n * @param {boolean} componentRoot ?\n * @returns {import('../dom').PreactElement} The created/mutated element\n * @private\n */\nexport function diff(dom, vnode, context, mountAll, parent, componentRoot) {\n\t// diffLevel having been 0 here indicates initial entry into the diff (not a subdiff)\n\tif (!diffLevel++) {\n\t\t// when first starting the diff, check if we're diffing an SVG or within an SVG\n\t\tisSvgMode = parent!=null && parent.ownerSVGElement!==undefined;\n\n\t\t// hydration is indicated by the existing element to be diffed not having a prop cache\n\t\thydrating = dom!=null && !(ATTR_KEY in dom);\n\t}\n\n\tlet ret = idiff(dom, vnode, context, mountAll, componentRoot);\n\n\t// append the element if its a new parent\n\tif (parent && ret.parentNode!==parent) parent.appendChild(ret);\n\n\t// diffLevel being reduced to 0 means we're exiting the diff\n\tif (!--diffLevel) {\n\t\thydrating = false;\n\t\t// invoke queued componentDidMount lifecycle methods\n\t\tif (!componentRoot) flushMounts();\n\t}\n\n\treturn ret;\n}\n\n\n/**\n * Internals of `diff()`, separated to allow bypassing diffLevel / mount flushing.\n * @param {import('../dom').PreactElement} dom A DOM node to mutate into the shape of a `vnode`\n * @param {import('../vnode').VNode} vnode A VNode (with descendants forming a tree) representing the desired DOM structure\n * @param {object} context The current context\n * @param {boolean} mountAll Whether or not to immediately mount all components\n * @param {boolean} [componentRoot] ?\n * @private\n */\nfunction idiff(dom, vnode, context, mountAll, componentRoot) {\n\tlet out = dom,\n\t\tprevSvgMode = isSvgMode;\n\n\t// empty values (null, undefined, booleans) render as empty Text nodes\n\tif (vnode==null || typeof vnode==='boolean') vnode = '';\n\n\n\t// Fast case: Strings & Numbers create/update Text nodes.\n\tif (typeof vnode==='string' || typeof vnode==='number') {\n\n\t\t// update if it's already a Text node:\n\t\tif (dom && dom.splitText!==undefined && dom.parentNode && (!dom._component || componentRoot)) {\n\t\t\t/* istanbul ignore if */ /* Browser quirk that can't be covered: https://github.com/developit/preact/commit/fd4f21f5c45dfd75151bd27b4c217d8003aa5eb9 */\n\t\t\tif (dom.nodeValue!=vnode) {\n\t\t\t\tdom.nodeValue = vnode;\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\t// it wasn't a Text node: replace it with one and recycle the old Element\n\t\t\tout = document.createTextNode(vnode);\n\t\t\tif (dom) {\n\t\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\t\t\t\trecollectNodeTree(dom, true);\n\t\t\t}\n\t\t}\n\n\t\tout[ATTR_KEY] = true;\n\n\t\treturn out;\n\t}\n\n\n\t// If the VNode represents a Component, perform a component diff:\n\tlet vnodeName = vnode.nodeName;\n\tif (typeof vnodeName==='function') {\n\t\treturn buildComponentFromVNode(dom, vnode, context, mountAll);\n\t}\n\n\n\t// Tracks entering and exiting SVG namespace when descending through the tree.\n\tisSvgMode = vnodeName==='svg' ? true : vnodeName==='foreignObject' ? false : isSvgMode;\n\n\n\t// If there's no existing element or it's the wrong type, create a new one:\n\tvnodeName = String(vnodeName);\n\tif (!dom || !isNamedNode(dom, vnodeName)) {\n\t\tout = createNode(vnodeName, isSvgMode);\n\n\t\tif (dom) {\n\t\t\t// move children into the replacement node\n\t\t\twhile (dom.firstChild) out.appendChild(dom.firstChild);\n\n\t\t\t// if the previous Element was mounted into the DOM, replace it inline\n\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\n\t\t\t// recycle the old element (skips non-Element node types)\n\t\t\trecollectNodeTree(dom, true);\n\t\t}\n\t}\n\n\n\tlet fc = out.firstChild,\n\t\tprops = out[ATTR_KEY],\n\t\tvchildren = vnode.children;\n\n\tif (props==null) {\n\t\tprops = out[ATTR_KEY] = {};\n\t\tfor (let a=out.attributes, i=a.length; i--; ) props[a[i].name] = a[i].value;\n\t}\n\n\t// Optimization: fast-path for elements containing a single TextNode:\n\tif (!hydrating && vchildren && vchildren.length===1 && typeof vchildren[0]==='string' && fc!=null && fc.splitText!==undefined && fc.nextSibling==null) {\n\t\tif (fc.nodeValue!=vchildren[0]) {\n\t\t\tfc.nodeValue = vchildren[0];\n\t\t}\n\t}\n\t// otherwise, if there are existing or new children, diff them:\n\telse if (vchildren && vchildren.length || fc!=null) {\n\t\tinnerDiffNode(out, vchildren, context, mountAll, hydrating || props.dangerouslySetInnerHTML!=null);\n\t}\n\n\n\t// Apply attributes/props from VNode to the DOM Element:\n\tdiffAttributes(out, vnode.attributes, props);\n\n\n\t// restore previous SVG mode: (in case we're exiting an SVG namespace)\n\tisSvgMode = prevSvgMode;\n\n\treturn out;\n}\n\n\n/**\n * Apply child and attribute changes between a VNode and a DOM Node to the DOM.\n * @param {import('../dom').PreactElement} dom Element whose children should be compared & mutated\n * @param {Array<import('../vnode').VNode>} vchildren Array of VNodes to compare to `dom.childNodes`\n * @param {object} context Implicitly descendant context object (from most\n *  recent `getChildContext()`)\n * @param {boolean} mountAll Whether or not to immediately mount all components\n * @param {boolean} isHydrating if `true`, consumes externally created elements\n *  similar to hydration\n */\nfunction innerDiffNode(dom, vchildren, context, mountAll, isHydrating) {\n\tlet originalChildren = dom.childNodes,\n\t\tchildren = [],\n\t\tkeyed = {},\n\t\tkeyedLen = 0,\n\t\tmin = 0,\n\t\tlen = originalChildren.length,\n\t\tchildrenLen = 0,\n\t\tvlen = vchildren ? vchildren.length : 0,\n\t\tj, c, f, vchild, child;\n\n\t// Build up a map of keyed children and an Array of unkeyed children:\n\tif (len!==0) {\n\t\tfor (let i=0; i<len; i++) {\n\t\t\tlet child = originalChildren[i],\n\t\t\t\tprops = child[ATTR_KEY],\n\t\t\t\tkey = vlen && props ? child._component ? child._component.__key : props.key : null;\n\t\t\tif (key!=null) {\n\t\t\t\tkeyedLen++;\n\t\t\t\tkeyed[key] = child;\n\t\t\t}\n\t\t\telse if (props || (child.splitText!==undefined ? (isHydrating ? child.nodeValue.trim() : true) : isHydrating)) {\n\t\t\t\tchildren[childrenLen++] = child;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (vlen!==0) {\n\t\tfor (let i=0; i<vlen; i++) {\n\t\t\tvchild = vchildren[i];\n\t\t\tchild = null;\n\n\t\t\t// attempt to find a node based on key matching\n\t\t\tlet key = vchild.key;\n\t\t\tif (key!=null) {\n\t\t\t\tif (keyedLen && keyed[key]!==undefined) {\n\t\t\t\t\tchild = keyed[key];\n\t\t\t\t\tkeyed[key] = undefined;\n\t\t\t\t\tkeyedLen--;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// attempt to pluck a node of the same type from the existing children\n\t\t\telse if (min<childrenLen) {\n\t\t\t\tfor (j=min; j<childrenLen; j++) {\n\t\t\t\t\tif (children[j]!==undefined && isSameNodeType(c = children[j], vchild, isHydrating)) {\n\t\t\t\t\t\tchild = c;\n\t\t\t\t\t\tchildren[j] = undefined;\n\t\t\t\t\t\tif (j===childrenLen-1) childrenLen--;\n\t\t\t\t\t\tif (j===min) min++;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// morph the matched/found/created DOM child to match vchild (deep)\n\t\t\tchild = idiff(child, vchild, context, mountAll);\n\n\t\t\tf = originalChildren[i];\n\t\t\tif (child && child!==dom && child!==f) {\n\t\t\t\tif (f==null) {\n\t\t\t\t\tdom.appendChild(child);\n\t\t\t\t}\n\t\t\t\telse if (child===f.nextSibling) {\n\t\t\t\t\tremoveNode(f);\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tdom.insertBefore(child, f);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\n\t// remove unused keyed children:\n\tif (keyedLen) {\n\t\tfor (let i in keyed) if (keyed[i]!==undefined) recollectNodeTree(keyed[i], false);\n\t}\n\n\t// remove orphaned unkeyed children:\n\twhile (min<=childrenLen) {\n\t\tif ((child = children[childrenLen--])!==undefined) recollectNodeTree(child, false);\n\t}\n}\n\n\n\n/**\n * Recursively recycle (or just unmount) a node and its descendants.\n * @param {import('../dom').PreactElement} node DOM node to start\n *  unmount/removal from\n * @param {boolean} [unmountOnly=false] If `true`, only triggers unmount\n *  lifecycle, skips removal\n */\nexport function recollectNodeTree(node, unmountOnly) {\n\tlet component = node._component;\n\tif (component) {\n\t\t// if node is owned by a Component, unmount that component (ends up recursing back here)\n\t\tunmountComponent(component);\n\t}\n\telse {\n\t\t// If the node's VNode had a ref function, invoke it with null here.\n\t\t// (this is part of the React spec, and smart for unsetting references)\n\t\tif (node[ATTR_KEY]!=null) applyRef(node[ATTR_KEY].ref, null);\n\n\t\tif (unmountOnly===false || node[ATTR_KEY]==null) {\n\t\t\tremoveNode(node);\n\t\t}\n\n\t\tremoveChildren(node);\n\t}\n}\n\n\n/**\n * Recollect/unmount all children.\n *\t- we use .lastChild here because it causes less reflow than .firstChild\n *\t- it's also cheaper than accessing the .childNodes Live NodeList\n */\nexport function removeChildren(node) {\n\tnode = node.lastChild;\n\twhile (node) {\n\t\tlet next = node.previousSibling;\n\t\trecollectNodeTree(node, true);\n\t\tnode = next;\n\t}\n}\n\n\n/**\n * Apply differences in attributes from a VNode to the given DOM Element.\n * @param {import('../dom').PreactElement} dom Element with attributes to diff `attrs` against\n * @param {object} attrs The desired end-state key-value attribute pairs\n * @param {object} old Current/previous attributes (from previous VNode or\n *  element's prop cache)\n */\nfunction diffAttributes(dom, attrs, old) {\n\tlet name;\n\n\t// remove attributes no longer present on the vnode by setting them to undefined\n\tfor (name in old) {\n\t\tif (!(attrs && attrs[name]!=null) && old[name]!=null) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = undefined, isSvgMode);\n\t\t}\n\t}\n\n\t// add new & update changed attributes\n\tfor (name in attrs) {\n\t\tif (name!=='children' && name!=='innerHTML' && (!(name in old) || attrs[name]!==(name==='value' || name==='checked' ? dom[name] : old[name]))) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = attrs[name], isSvgMode);\n\t\t}\n\t}\n}\n","import { SYNC_RENDER, NO_RENDER, FORCE_RENDER, ASYNC_RENDER, ATTR_KEY } from '../constants';\nimport options from '../options';\nimport { extend, applyRef } from '../util';\nimport { enqueueRender } from '../render-queue';\nimport { getNodeProps } from './index';\nimport { diff, mounts, diffLevel, flushMounts, recollectNodeTree, removeChildren } from './diff';\nimport { createComponent, recyclerComponents } from './component-recycler';\nimport { removeNode } from '../dom/index';\n\n/**\n * Set a component's `props` and possibly re-render the component\n * @param {import('../component').Component} component The Component to set props on\n * @param {object} props The new props\n * @param {number} renderMode Render options - specifies how to re-render the component\n * @param {object} context The new context\n * @param {boolean} mountAll Whether or not to immediately mount all components\n */\nexport function setComponentProps(component, props, renderMode, context, mountAll) {\n\tif (component._disable) return;\n\tcomponent._disable = true;\n\n\tcomponent.__ref = props.ref;\n\tcomponent.__key = props.key;\n\tdelete props.ref;\n\tdelete props.key;\n\n\tif (typeof component.constructor.getDerivedStateFromProps === 'undefined') {\n\t\tif (!component.base || mountAll) {\n\t\t\tif (component.componentWillMount) component.componentWillMount();\n\t\t}\n\t\telse if (component.componentWillReceiveProps) {\n\t\t\tcomponent.componentWillReceiveProps(props, context);\n\t\t}\n\t}\n\n\tif (context && context!==component.context) {\n\t\tif (!component.prevContext) component.prevContext = component.context;\n\t\tcomponent.context = context;\n\t}\n\n\tif (!component.prevProps) component.prevProps = component.props;\n\tcomponent.props = props;\n\n\tcomponent._disable = false;\n\n\tif (renderMode!==NO_RENDER) {\n\t\tif (renderMode===SYNC_RENDER || options.syncComponentUpdates!==false || !component.base) {\n\t\t\trenderComponent(component, SYNC_RENDER, mountAll);\n\t\t}\n\t\telse {\n\t\t\tenqueueRender(component);\n\t\t}\n\t}\n\n\tapplyRef(component.__ref, component);\n}\n\n\n\n/**\n * Render a Component, triggering necessary lifecycle events and taking\n * High-Order Components into account.\n * @param {import('../component').Component} component The component to render\n * @param {number} [renderMode] render mode, see constants.js for available options.\n * @param {boolean} [mountAll] Whether or not to immediately mount all components\n * @param {boolean} [isChild] ?\n * @private\n */\nexport function renderComponent(component, renderMode, mountAll, isChild) {\n\tif (component._disable) return;\n\n\tlet props = component.props,\n\t\tstate = component.state,\n\t\tcontext = component.context,\n\t\tpreviousProps = component.prevProps || props,\n\t\tpreviousState = component.prevState || state,\n\t\tpreviousContext = component.prevContext || context,\n\t\tisUpdate = component.base,\n\t\tnextBase = component.nextBase,\n\t\tinitialBase = isUpdate || nextBase,\n\t\tinitialChildComponent = component._component,\n\t\tskip = false,\n\t\tsnapshot = previousContext,\n\t\trendered, inst, cbase;\n\n\tif (component.constructor.getDerivedStateFromProps) {\n\t\tstate = extend(extend({}, state), component.constructor.getDerivedStateFromProps(props, state));\n\t\tcomponent.state = state;\n\t}\n\n\t// if updating\n\tif (isUpdate) {\n\t\tcomponent.props = previousProps;\n\t\tcomponent.state = previousState;\n\t\tcomponent.context = previousContext;\n\t\tif (renderMode!==FORCE_RENDER\n\t\t\t&& component.shouldComponentUpdate\n\t\t\t&& component.shouldComponentUpdate(props, state, context) === false) {\n\t\t\tskip = true;\n\t\t}\n\t\telse if (component.componentWillUpdate) {\n\t\t\tcomponent.componentWillUpdate(props, state, context);\n\t\t}\n\t\tcomponent.props = props;\n\t\tcomponent.state = state;\n\t\tcomponent.context = context;\n\t}\n\n\tcomponent.prevProps = component.prevState = component.prevContext = component.nextBase = null;\n\tcomponent._dirty = false;\n\n\tif (!skip) {\n\t\trendered = component.render(props, state, context);\n\n\t\t// context to pass to the child, can be updated via (grand-)parent component\n\t\tif (component.getChildContext) {\n\t\t\tcontext = extend(extend({}, context), component.getChildContext());\n\t\t}\n\n\t\tif (isUpdate && component.getSnapshotBeforeUpdate) {\n\t\t\tsnapshot = component.getSnapshotBeforeUpdate(previousProps, previousState);\n\t\t}\n\n\t\tlet childComponent = rendered && rendered.nodeName,\n\t\t\ttoUnmount, base;\n\n\t\tif (typeof childComponent==='function') {\n\t\t\t// set up high order component link\n\n\t\t\tlet childProps = getNodeProps(rendered);\n\t\t\tinst = initialChildComponent;\n\n\t\t\tif (inst && inst.constructor===childComponent && childProps.key==inst.__key) {\n\t\t\t\tsetComponentProps(inst, childProps, SYNC_RENDER, context, false);\n\t\t\t}\n\t\t\telse {\n\t\t\t\ttoUnmount = inst;\n\n\t\t\t\tcomponent._component = inst = createComponent(childComponent, childProps, context);\n\t\t\t\tinst.nextBase = inst.nextBase || nextBase;\n\t\t\t\tinst._parentComponent = component;\n\t\t\t\tsetComponentProps(inst, childProps, NO_RENDER, context, false);\n\t\t\t\trenderComponent(inst, SYNC_RENDER, mountAll, true);\n\t\t\t}\n\n\t\t\tbase = inst.base;\n\t\t}\n\t\telse {\n\t\t\tcbase = initialBase;\n\n\t\t\t// destroy high order component link\n\t\t\ttoUnmount = initialChildComponent;\n\t\t\tif (toUnmount) {\n\t\t\t\tcbase = component._component = null;\n\t\t\t}\n\n\t\t\tif (initialBase || renderMode===SYNC_RENDER) {\n\t\t\t\tif (cbase) cbase._component = null;\n\t\t\t\tbase = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, true);\n\t\t\t}\n\t\t}\n\n\t\tif (initialBase && base!==initialBase && inst!==initialChildComponent) {\n\t\t\tlet baseParent = initialBase.parentNode;\n\t\t\tif (baseParent && base!==baseParent) {\n\t\t\t\tbaseParent.replaceChild(base, initialBase);\n\n\t\t\t\tif (!toUnmount) {\n\t\t\t\t\tinitialBase._component = null;\n\t\t\t\t\trecollectNodeTree(initialBase, false);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (toUnmount) {\n\t\t\tunmountComponent(toUnmount);\n\t\t}\n\n\t\tcomponent.base = base;\n\t\tif (base && !isChild) {\n\t\t\tlet componentRef = component,\n\t\t\t\tt = component;\n\t\t\twhile ((t=t._parentComponent)) {\n\t\t\t\t(componentRef = t).base = base;\n\t\t\t}\n\t\t\tbase._component = componentRef;\n\t\t\tbase._componentConstructor = componentRef.constructor;\n\t\t}\n\t}\n\n\tif (!isUpdate || mountAll) {\n\t\tmounts.push(component);\n\t}\n\telse if (!skip) {\n\t\t// Ensure that pending componentDidMount() hooks of child components\n\t\t// are called before the componentDidUpdate() hook in the parent.\n\t\t// Note: disabled as it causes duplicate hooks, see https://github.com/developit/preact/issues/750\n\t\t// flushMounts();\n\n\t\tif (component.componentDidUpdate) {\n\t\t\tcomponent.componentDidUpdate(previousProps, previousState, snapshot);\n\t\t}\n\t\tif (options.afterUpdate) options.afterUpdate(component);\n\t}\n\n\twhile (component._renderCallbacks.length) component._renderCallbacks.pop().call(component);\n\n\tif (!diffLevel && !isChild) flushMounts();\n}\n\n\n\n/**\n * Apply the Component referenced by a VNode to the DOM.\n * @param {import('../dom').PreactElement} dom The DOM node to mutate\n * @param {import('../vnode').VNode} vnode A Component-referencing VNode\n * @param {object} context The current context\n * @param {boolean} mountAll Whether or not to immediately mount all components\n * @returns {import('../dom').PreactElement} The created/mutated element\n * @private\n */\nexport function buildComponentFromVNode(dom, vnode, context, mountAll) {\n\tlet c = dom && dom._component,\n\t\toriginalComponent = c,\n\t\toldDom = dom,\n\t\tisDirectOwner = c && dom._componentConstructor===vnode.nodeName,\n\t\tisOwner = isDirectOwner,\n\t\tprops = getNodeProps(vnode);\n\twhile (c && !isOwner && (c=c._parentComponent)) {\n\t\tisOwner = c.constructor===vnode.nodeName;\n\t}\n\n\tif (c && isOwner && (!mountAll || c._component)) {\n\t\tsetComponentProps(c, props, ASYNC_RENDER, context, mountAll);\n\t\tdom = c.base;\n\t}\n\telse {\n\t\tif (originalComponent && !isDirectOwner) {\n\t\t\tunmountComponent(originalComponent);\n\t\t\tdom = oldDom = null;\n\t\t}\n\n\t\tc = createComponent(vnode.nodeName, props, context);\n\t\tif (dom && !c.nextBase) {\n\t\t\tc.nextBase = dom;\n\t\t\t// passing dom/oldDom as nextBase will recycle it if unused, so bypass recycling on L229:\n\t\t\toldDom = null;\n\t\t}\n\t\tsetComponentProps(c, props, SYNC_RENDER, context, mountAll);\n\t\tdom = c.base;\n\n\t\tif (oldDom && dom!==oldDom) {\n\t\t\toldDom._component = null;\n\t\t\trecollectNodeTree(oldDom, false);\n\t\t}\n\t}\n\n\treturn dom;\n}\n\n\n\n/**\n * Remove a component from the DOM and recycle it.\n * @param {import('../component').Component} component The Component instance to unmount\n * @private\n */\nexport function unmountComponent(component) {\n\tif (options.beforeUnmount) options.beforeUnmount(component);\n\n\tlet base = component.base;\n\n\tcomponent._disable = true;\n\n\tif (component.componentWillUnmount) component.componentWillUnmount();\n\n\tcomponent.base = null;\n\n\t// recursively tear down & recollect high-order component children:\n\tlet inner = component._component;\n\tif (inner) {\n\t\tunmountComponent(inner);\n\t}\n\telse if (base) {\n\t\tif (base[ATTR_KEY]!=null) applyRef(base[ATTR_KEY].ref, null);\n\n\t\tcomponent.nextBase = base;\n\n\t\tremoveNode(base);\n\t\trecyclerComponents.push(component);\n\n\t\tremoveChildren(base);\n\t}\n\n\tapplyRef(component.__ref, null);\n}\n","import { Component } from '../component';\n\n/**\n * Retains a pool of Components for re-use.\n * @type {Component[]}\n * @private\n */\nexport const recyclerComponents = [];\n\n\n/**\n * Create a component. Normalizes differences between PFC's and classful\n * Components.\n * @param {function} Ctor The constructor of the component to create\n * @param {object} props The initial props of the component\n * @param {object} context The initial context of the component\n * @returns {import('../component').Component}\n */\nexport function createComponent(Ctor, props, context) {\n\tlet inst, i = recyclerComponents.length;\n\n\tif (Ctor.prototype && Ctor.prototype.render) {\n\t\tinst = new Ctor(props, context);\n\t\tComponent.call(inst, props, context);\n\t}\n\telse {\n\t\tinst = new Component(props, context);\n\t\tinst.constructor = Ctor;\n\t\tinst.render = doRender;\n\t}\n\n\n\twhile (i--) {\n\t\tif (recyclerComponents[i].constructor===Ctor) {\n\t\t\tinst.nextBase = recyclerComponents[i].nextBase;\n\t\t\trecyclerComponents.splice(i, 1);\n\t\t\treturn inst;\n\t\t}\n\t}\n\n\treturn inst;\n}\n\n\n/** The `.render()` method for a PFC backing instance. */\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n","import { FORCE_RENDER } from './constants';\nimport { extend } from './util';\nimport { renderComponent } from './vdom/component';\nimport { enqueueRender } from './render-queue';\n/**\n * Base Component class.\n * Provides `setState()` and `forceUpdate()`, which trigger rendering.\n * @typedef {object} Component\n * @param {object} props The initial component props\n * @param {object} context The initial context from parent components' getChildContext\n * @public\n *\n * @example\n * class MyFoo extends Component {\n *   render(props, state) {\n *     return <div />;\n *   }\n * }\n */\nexport function Component(props, context) {\n\tthis._dirty = true;\n\n\t/**\n\t * @public\n\t * @type {object}\n\t */\n\tthis.context = context;\n\n\t/**\n\t * @public\n\t * @type {object}\n\t */\n\tthis.props = props;\n\n\t/**\n\t * @public\n\t * @type {object}\n\t */\n\tthis.state = this.state || {};\n\n\tthis._renderCallbacks = [];\n}\n\n\nextend(Component.prototype, {\n\n\t/**\n\t * Update component state and schedule a re-render.\n\t * @param {object} state A dict of state properties to be shallowly merged\n\t * \tinto the current state, or a function that will produce such a dict. The\n\t * \tfunction is called with the current state and props.\n\t * @param {() => void} callback A function to be called once component state is\n\t * \tupdated\n\t */\n\tsetState(state, callback) {\n\t\tif (!this.prevState) this.prevState = this.state;\n\t\tthis.state = extend(\n\t\t\textend({}, this.state),\n\t\t\ttypeof state === 'function' ? state(this.state, this.props) : state\n\t\t);\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\tenqueueRender(this);\n\t},\n\n\n\t/**\n\t * Immediately perform a synchronous re-render of the component.\n\t * @param {() => void} callback A function to be called after component is\n\t * \tre-rendered.\n\t * @private\n\t */\n\tforceUpdate(callback) {\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\trenderComponent(this, FORCE_RENDER);\n\t},\n\n\n\t/**\n\t * Accepts `props` and `state`, and returns a new Virtual DOM tree to build.\n\t * Virtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).\n\t * @param {object} props Props (eg: JSX attributes) received from parent\n\t * \telement/component\n\t * @param {object} state The component's current state\n\t * @param {object} context Context object, as returned by the nearest\n\t *  ancestor's `getChildContext()`\n\t * @returns {import('./vnode').VNode | void}\n\t */\n\trender() {}\n\n});\n","import { diff } from './vdom/diff';\n\n/**\n * Render JSX into a `parent` Element.\n * @param {import('./vnode').VNode} vnode A (JSX) VNode to render\n * @param {import('./dom').PreactElement} parent DOM element to render into\n * @param {import('./dom').PreactElement} [merge] Attempt to re-use an existing DOM tree rooted at\n *  `merge`\n * @public\n *\n * @example\n * // render a div into <body>:\n * render(<div id=\"hello\">hello!</div>, document.body);\n *\n * @example\n * // render a \"Thing\" component into #foo:\n * const Thing = ({ name }) => <span>{ name }</span>;\n * render(<Thing name=\"one\" />, document.querySelector('#foo'));\n */\nexport function render(vnode, parent, merge) {\n\treturn diff(merge, vnode, {}, false, parent, false);\n}\n","import { h, h as createElement } from './h';\nimport { cloneElement } from './clone-element';\nimport { Component } from './component';\nimport { render } from './render';\nimport { rerender } from './render-queue';\nimport options from './options';\n\nfunction createRef() {\n\treturn {};\n}\n\nexport default {\n\th,\n\tcreateElement,\n\tcloneElement,\n\tcreateRef,\n\tComponent,\n\trender,\n\trerender,\n\toptions\n};\n\nexport {\n\th,\n\tcreateElement,\n\tcloneElement,\n\tcreateRef,\n\tComponent,\n\trender,\n\trerender,\n\toptions\n};\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}