{"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/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/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/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/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/lodash/_hashGet.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","PI","feat","isNumber","lineString","num","isNaN","hasOwn","classNames","classes","arg","appendClass","parseValue","includes","newClass","default","global","listCacheClear","listCacheDelete","listCacheGet","listCacheHas","listCacheSet","ListCache","getNative","splice","mapCacheClear","mapCacheDelete","mapCacheGet","mapCacheHas","mapCacheSet","coordEach","callback","excludeWrapCoord","stopG","coords","geometryMaybeCollection","isGeometryCollection","wrapShrink","coordIndex","isFeatureCollection","isFeature","stop","featureIndex","geomIndex","multiFeatureIndex","geometryIndex","geomType","recompute","Infinity","baseGetTag","other","_typeof","iterator","constructor","toPropertyKey","toPrimitive","_defineProperty","enumerable","configurable","writable","eq","VNode","stack","EMPTY_CHILDREN","lastSimple","child","simple","vnode","extend","props","applyRef","ref","current","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","shift","componentDidMount","diff","dom","context","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","min","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","merge","createRef","window"],"mappings":"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","file":"2.6789a59d98.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","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 original 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(16);\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        }\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    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    }\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\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(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 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","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","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","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","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","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":""}