autumnplot-gl 4.0.0-beta → 4.1.0

package/dist/autumnplot-gl.js.map

@@ -1 +1 @@
-{"version":3,"file":"autumnplot-gl.js","mappings":"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AAyBvZ,GAAmC,yBAG5FrC,GAA4B,KAAOA,GAA4BqC,GAAsC,4BACrG+D,GAAYjE,EAAoB,aAChCmE,GAAenE,EAAoB,gBACnC0D,GAAa1D,EAAoB,cAGjCqP,IADwBrP,EAAoB,wBACNA,EAAoB,uCAE1D4D,IADsC5D,EAAoB,sCAC/B7F,EAAiC,yBAAI6F,EAAoB,4BACpFuG,GAAmBvG,EAAoB,mBACvCyF,GAAyBzF,EAAoB,yBAC7CwY,GAAYre,EAAkB,UAAI6F,EAAoB,aACvC7F,EAAqB,aAAI6F,EAAoB,gBAyGpC,CAC1B,gBACA,uBACA,yBACA,uBACA,yBACA,iBACA,iBACA,sBACA,sBACA,aACA,SACA,aACA,eACA,WACA,UACA,WACA,YACA,YACA,YACA,YACA,eACA,gBACA,gBACA,iBACA,aACA,eACA,gBACA,4BACA,gBACA,UACA,UACA,oBACA,aACA,yBACA,kBACA,mBACA,uBACA,sBACA,mBACA,YACA,cACA,YACA,cACA,YACA,oBACA,aACA,cACA,eACA,aACA,WACA,QACA,QACA,gBACA,iBACA,mBACA,0BACA,oBACA,iBACA,qBACA,cACA,iBACA,iBACA,SACA,SACA,SACA,eACA,qBACA,mBACA,gBACA,gBACA,kBACA,sBACA,qBACA,2BACA,yBACA,kBACA,wBACA,wBACA,qBACA,6BACA,6BACA,0BACA,6BACA,iCACA,yCACA,4BACA,oCACA,oBACA,iCACA,yCACA,gCACA,wCACA,6BACA,qCACA,0BACA,mCACA,wBACA,eACA,wCACA,sBACA,iCACA,yCACA,wCACA,qBACA,gCACA,wCACA,6BACA,uBACA,+BACA,oCACA,uBACA,UACA,+BACA,uBACA,uBACA,WACA,cACA,eACA,aACA,gBACA,iBACA,yBACA,yBACA,uBACA,iBACA,sBACA,wBACA,uBACA,aACA,cACA,gBACA,sBACA,cACA,kBACA,mBACA,yBACA,uBACA,aACA,mBACA,oBACA,YACA,eACA,sBACA,yBACA,8BACA,sCACA,uCACA,kCACA,gCACA,qBACA,gCACA,iCACA,iCACA,gBACA,4BACA,0BACA,6CACA,uBACA,iCACA,+BACA,eACA,6BACA,qBACA,cACA,iBACA,YACA,eACA,cACA,WACA,sBACA,qBACA,sBACA,cACA,mBACA,4BACA,8BACA,uBACA,4BACA,4BACA,2BACA,2BACA,sCACA,yCACA,yBACA,oBACA,iCACA,gBACA,qBACA,kBACA,kBACA,kBACA,mBACA,cACA,8BACA,sBACA,mBACA,kBACA,6BACA,kBACA,gBACA,eACA,SACA,SACA,wBACA,oBAEoBlF,SA7uEtB,SAA8BoH,GACF,oBAAfE,YAA+BpH,OAAOC,yBAAyBmH,WAAYF,IACpFlH,OAAOE,eAAekH,WAAYF,EAAK,CACrCH,cAAc,EACd5G,MAGE,IAAIgH,EAAM,KAAKD,mJAIXwX,EAAgBxX,EACfwX,EAAc3Z,WAAW,OAC5B2Z,EAAgB,IAAMxX,GAExBC,GAAO,8CAA8CuX,MACjD1X,EAA4BE,KAC9BC,GAAO,4FAETE,GAASF,EAEX,IAKJG,EAAwBJ,EAC1B,IAotEA,IA2KIyX,GAQJ,SAASC,KA35FT,IACMrnB,EA85FJknB,KA75FAld,EAAoB,IAAN,GADVhK,EAAMsL,QAKC,GAAPtL,IACFA,GAAO,GAKTuK,EAAS,GAAO,GAAM,SACtBA,EAAU,EAAM,GAAM,GAAM,WAE5BA,EAAQ,GAAY,UAm5FtB,CAEA,SAAS+c,KAeP,SAASC,IAGHH,KACJA,IAAY,EACZxf,EAAkB,WAAI,EAElB8C,IA13FNV,GAAQ+B,GACRA,GAAqB,EAErBV,IAGA2E,EAAqBnE,GAw3FnB3D,EAAoBN,GAChBA,EAA6B,sBAAGA,EAA6B,uBAEjEoC,GAAQpC,EAAc,MAAG,4GAx3F7B,WAGE,GAFAyD,IAEIzD,EAAgB,QAElB,IADgC,mBAArBA,EAAgB,UAAiBA,EAAgB,QAAI,CAACA,EAAgB,UAC1EA,EAAgB,QAAErJ,QAmBPuW,EAlBHlN,EAAgB,QAAEsI,QAmBnCpE,EAAc2a,QAAQ3R,GADxB,IAAsBA,EAdpB9E,EAAqBlE,EACvB,CA+2FI0b,IACF,CA9BIpb,EAAkB,IAIpBib,KAr3FJ,WACE,GAAIzf,EAAe,OAEjB,IAD+B,mBAApBA,EAAe,SAAiBA,EAAe,OAAI,CAACA,EAAe,SACvEA,EAAe,OAAErJ,QA8BPuW,EA7BHlN,EAAe,OAAEsI,QA8BjCtE,EAAa6a,QAAQ3R,GADvB,IAAqBA,EA1BnB9E,EAAqBpE,EACvB,CA+2FE6b,GAGIrb,EAAkB,IAuBlBxE,EAAkB,WACpBA,EAAkB,UAAE,cACpB8f,YAAW,WACTA,YAAW,WACT9f,EAAkB,UAAE,GACtB,GAAG,GACH2f,GACF,GAAG,IAGHA,IAEFlc,KACF,CA+BA,GA1QwB,CACtB,MACA,cACA,YACA,eACA,YACA,eACA,mBACA,sBACA,kBACA,gBACA,oBACA,gBACA,kBACA,cACA,MACA,MACA,WACA,QACA,aACA,cACA,aACA,YACA,eACA,cACA,cACA,mBACA,mBACA,6BACA,cACA,aACA,aACA,MACA,qBACA,kBACA,gCACA,6BACA,cACA,iBACA,MACA,YACA,UACA,SACA,WACA,eACA,qBACA,gBACA,eACA,UACA,sBACA,kBACA,YACA,gBACA,mBACA,sBACA,WACA,WACA,OACA,UACA,cACA,oBACA,eACA,oBACA,eACA,kBACA,eACA,gBACA,gBACA,mBACA,gBACA,gBACA,mBACA,WACA,qBACA,4BACA,0BACA,aACA,sBACA,aACA,yBACA,gBACA,kBACA,gBACA,oBACA,4BACA,6BACA,6BACA,sBACA,UACA,OACA,WACA,iBACA,0BACA,KACA,QACA,MACA,SACA,SACA,uBACA,4BACA,0BACA,KACA,qCACA,KACA,OACA,MACA,OACA,WACA,MACA,UACA,eACA,sBACA,gBACA,eACA,qBACA,oBACA,kBACA,uBACA,mBACA,qBACA,sBACA,qBACA,gCACA,mBACA,wBACA,mBACA,cACA,kBACA,sBACA,wBACA,mBACA,mBACA,sBACA,wBACA,sBACA,qBACA,sBACA,cACA,sBACA,aACA,sBACA,qBACA,eACA,8BACA,4BACA,6BACA,cACA,iBACA,UACA,uBACA,0BACA,uBACA,uBACA,gBACA,gBACA,gBACA,gBACA,aACA,sBACA,oBACA,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","sources":["webpack://apgl/webpack/universalModuleDefinition","webpack://apgl/./node_modules/ieee754/index.js","webpack://apgl/./node_modules/kd-tree-javascript/kdTree-min.js","webpack://apgl/./node_modules/pbf/index.js","webpack://apgl/./src/glsl/billboard_fragment.glsl","webpack://apgl/./src/glsl/billboard_vertex.glsl","webpack://apgl/./src/glsl/colormap.glsl","webpack://apgl/./src/glsl/contourfill_fragment.glsl","webpack://apgl/./src/glsl/contourfill_vertex.glsl","webpack://apgl/./src/glsl/paintball_fragment.glsl","webpack://apgl/./src/glsl/paintball_vertex.glsl","webpack://apgl/./src/glsl/polyline_fragment.glsl","webpack://apgl/./src/glsl/polyline_vertex.glsl","webpack://apgl/./src/glsl/text_fragment.glsl","webpack://apgl/./src/glsl/text_vertex.glsl","webpack://apgl/./src/cpp/marchingsquares.js","webpack://apgl/webpack/bootstrap","webpack://apgl/webpack/runtime/compat get default export","webpack://apgl/webpack/runtime/define property getters","webpack://apgl/webpack/runtime/get javascript chunk filename","webpack://apgl/webpack/runtime/global","webpack://apgl/webpack/runtime/hasOwnProperty shorthand","webpack://apgl/webpack/runtime/make namespace object","webpack://apgl/webpack/runtime/publicPath","webpack://apgl/webpack/runtime/jsonp chunk loading","webpack://apgl/./node_modules/comlink/dist/esm/comlink.mjs","webpack://apgl/./src/utils.ts","webpack://apgl/./src/AutumnTypes.ts","webpack://apgl/./src/PlotComponent.ts","webpack://apgl/./src/Map.ts","webpack://apgl/./node_modules/autumn-wgl/lib/WGLBuffer.js","webpack://apgl/./node_modules/autumn-wgl/lib/utils.js","webpack://apgl/./node_modules/autumn-wgl/lib/WGLTexture.js","webpack://apgl/./node_modules/autumn-wgl/lib/WGLProgram.js","webpack://apgl/./node_modules/autumn-wgl/lib/WGLFramebuffer.js","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/messages.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/primordials.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/arrayIterator.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/is.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/brand.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/converter.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/spec.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/Float16Array.mjs","webpack://apgl/./src/Color.ts","webpack://apgl/./src/Colormap.ts","webpack://apgl/./src/PolylineCollection.ts","webpack://apgl/./src/TextCollection.ts","webpack://apgl/./node_modules/potpack/index.js","webpack://apgl/./src/Contour.ts","webpack://apgl/./src/Fill.ts","webpack://apgl/./src/BillboardCollection.ts","webpack://apgl/./src/Barbs.ts","webpack://apgl/./src/Paintball.ts","webpack://apgl/./src/Hodographs.ts","webpack://apgl/./src/PlotLayer.ts","webpack://apgl/./src/ColorBar.ts","webpack://apgl/./src/ContourCreator.ts","webpack://apgl/./src/RawField.ts","webpack://apgl/./src/Grid.ts","webpack://apgl/./src/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"apgl\"] = factory();\n\telse\n\t\troot[\"apgl\"] = factory();\n})(this, () => {\nreturn ","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","/**\n * k-d Tree JavaScript - V 1.01\n *\n * https://github.com/ubilabs/kd-tree-javascript\n *\n * @author Mircea Pricop <pricop@ubilabs.net>, 2012\n * @author Martin Kleppe <kleppe@ubilabs.net>, 2012\n * @author Ubilabs http://ubilabs.net, 2012\n * @license MIT License <http://www.opensource.org/licenses/mit-license.php>\n */!function(t,n){\"function\"==typeof define&&define.amd?define([\"exports\"],n):n(\"object\"==typeof exports?exports:t)}(this,function(t){function n(t,n,o){this.obj=t,this.left=null,this.right=null,this.parent=o,this.dimension=n}function o(t){this.content=[],this.scoreFunction=t}o.prototype={push:function(t){this.content.push(t),this.bubbleUp(this.content.length-1)},pop:function(){var t=this.content[0],n=this.content.pop();return this.content.length>0&&(this.content[0]=n,this.sinkDown(0)),t},peek:function(){return this.content[0]},remove:function(t){for(var n=this.content.length,o=0;o<n;o++)if(this.content[o]==t){var i=this.content.pop();return void(o!=n-1&&(this.content[o]=i,this.scoreFunction(i)<this.scoreFunction(t)?this.bubbleUp(o):this.sinkDown(o)))}throw new Error(\"Node not found.\")},size:function(){return this.content.length},bubbleUp:function(t){for(var n=this.content[t];t>0;){var o=Math.floor((t+1)/2)-1,i=this.content[o];if(!(this.scoreFunction(n)<this.scoreFunction(i)))break;this.content[o]=n,this.content[t]=i,t=o}},sinkDown:function(t){for(var n=this.content.length,o=this.content[t],i=this.scoreFunction(o);;){var e=2*(t+1),r=e-1,l=null;if(r<n){var u=this.content[r],h=this.scoreFunction(u);h<i&&(l=r)}if(e<n){var s=this.content[e];this.scoreFunction(s)<(null==l?i:h)&&(l=e)}if(null==l)break;this.content[t]=this.content[l],this.content[l]=o,t=l}}},t.kdTree=function(t,i,e){function r(t,o,i){var l,u,h=o%e.length;return 0===t.length?null:1===t.length?new n(t[0],h,i):(t.sort(function(t,n){return t[e[h]]-n[e[h]]}),l=Math.floor(t.length/2),u=new n(t[l],h,i),u.left=r(t.slice(0,l),o+1,u),u.right=r(t.slice(l+1),o+1,u),u)}var l=this;Array.isArray(t)?this.root=r(t,0,null):function(t){function n(t){t.left&&(t.left.parent=t,n(t.left)),t.right&&(t.right.parent=t,n(t.right))}l.root=t,n(l.root)}(t),this.toJSON=function(t){t||(t=this.root);var o=new n(t.obj,t.dimension,null);return t.left&&(o.left=l.toJSON(t.left)),t.right&&(o.right=l.toJSON(t.right)),o},this.insert=function(t){function o(n,i){if(null===n)return i;var r=e[n.dimension];return t[r]<n.obj[r]?o(n.left,n):o(n.right,n)}var i,r,l=o(this.root,null);null!==l?(i=new n(t,(l.dimension+1)%e.length,l),r=e[l.dimension],t[r]<l.obj[r]?l.left=i:l.right=i):this.root=new n(t,0,null)},this.remove=function(t){function n(o){if(null===o)return null;if(o.obj===t)return o;var i=e[o.dimension];return t[i]<o.obj[i]?n(o.left,o):n(o.right,o)}function o(t){function n(t,o){var i,r,l,u,h;return null===t?null:(i=e[o],t.dimension===o?null!==t.left?n(t.left,o):t:(r=t.obj[i],l=n(t.left,o),u=n(t.right,o),h=t,null!==l&&l.obj[i]<r&&(h=l),null!==u&&u.obj[i]<h.obj[i]&&(h=u),h))}var i,r,u;if(null===t.left&&null===t.right)return null===t.parent?void(l.root=null):(u=e[t.parent.dimension],void(t.obj[u]<t.parent.obj[u]?t.parent.left=null:t.parent.right=null));null!==t.right?(r=(i=n(t.right,t.dimension)).obj,o(i),t.obj=r):(r=(i=n(t.left,t.dimension)).obj,o(i),t.right=t.left,t.left=null,t.obj=r)}var i;null!==(i=n(l.root))&&o(i)},this.nearest=function(t,n,r){function u(o){function r(t,o){f.push([t,o]),f.size()>n&&f.pop()}var l,h,s,c,a=e[o.dimension],g=i(t,o.obj),p={};for(c=0;c<e.length;c+=1)c===o.dimension?p[e[c]]=t[e[c]]:p[e[c]]=o.obj[e[c]];h=i(p,o.obj),null!==o.right||null!==o.left?(u(l=null===o.right?o.left:null===o.left?o.right:t[a]<o.obj[a]?o.left:o.right),(f.size()<n||g<f.peek()[1])&&r(o,g),(f.size()<n||Math.abs(h)<f.peek()[1])&&null!==(s=l===o.left?o.right:o.left)&&u(s)):(f.size()<n||g<f.peek()[1])&&r(o,g)}var h,s,f;if(f=new o(function(t){return-t[1]}),r)for(h=0;h<n;h+=1)f.push([null,r]);for(l.root&&u(l.root),s=[],h=0;h<Math.min(n,f.content.length);h+=1)f.content[h][0]&&s.push([f.content[h][0].obj,f.content[h][1]]);return s},this.balanceFactor=function(){function t(n){return null===n?0:Math.max(t(n.left),t(n.right))+1}function n(t){return null===t?0:n(t.left)+n(t.right)+1}return t(l.root)/(Math.log(n(l.root))/Math.log(2))}},t.BinaryHeap=o});\n","'use strict';\n\nmodule.exports = Pbf;\n\nvar ieee754 = require('ieee754');\n\nfunction Pbf(buf) {\n    this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);\n    this.pos = 0;\n    this.type = 0;\n    this.length = this.buf.length;\n}\n\nPbf.Varint  = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum\nPbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64\nPbf.Bytes   = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields\nPbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32\n\nvar SHIFT_LEFT_32 = (1 << 16) * (1 << 16),\n    SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;\n\n// Threshold chosen based on both benchmarking and knowledge about browser string\n// data structures (which currently switch structure types at 12 bytes or more)\nvar TEXT_DECODER_MIN_LENGTH = 12;\nvar utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf8');\n\nPbf.prototype = {\n\n    destroy: function() {\n        this.buf = null;\n    },\n\n    // === READING =================================================================\n\n    readFields: function(readField, result, end) {\n        end = end || this.length;\n\n        while (this.pos < end) {\n            var val = this.readVarint(),\n                tag = val >> 3,\n                startPos = this.pos;\n\n            this.type = val & 0x7;\n            readField(tag, result, this);\n\n            if (this.pos === startPos) this.skip(val);\n        }\n        return result;\n    },\n\n    readMessage: function(readField, result) {\n        return this.readFields(readField, result, this.readVarint() + this.pos);\n    },\n\n    readFixed32: function() {\n        var val = readUInt32(this.buf, this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readSFixed32: function() {\n        var val = readInt32(this.buf, this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)\n\n    readFixed64: function() {\n        var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readSFixed64: function() {\n        var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readFloat: function() {\n        var val = ieee754.read(this.buf, this.pos, true, 23, 4);\n        this.pos += 4;\n        return val;\n    },\n\n    readDouble: function() {\n        var val = ieee754.read(this.buf, this.pos, true, 52, 8);\n        this.pos += 8;\n        return val;\n    },\n\n    readVarint: function(isSigned) {\n        var buf = this.buf,\n            val, b;\n\n        b = buf[this.pos++]; val  =  b & 0x7f;        if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 7;  if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 14; if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 21; if (b < 0x80) return val;\n        b = buf[this.pos];   val |= (b & 0x0f) << 28;\n\n        return readVarintRemainder(val, isSigned, this);\n    },\n\n    readVarint64: function() { // for compatibility with v2.0.1\n        return this.readVarint(true);\n    },\n\n    readSVarint: function() {\n        var num = this.readVarint();\n        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding\n    },\n\n    readBoolean: function() {\n        return Boolean(this.readVarint());\n    },\n\n    readString: function() {\n        var end = this.readVarint() + this.pos;\n        var pos = this.pos;\n        this.pos = end;\n\n        if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {\n            // longer strings are fast with the built-in browser TextDecoder API\n            return readUtf8TextDecoder(this.buf, pos, end);\n        }\n        // short strings are fast with our custom implementation\n        return readUtf8(this.buf, pos, end);\n    },\n\n    readBytes: function() {\n        var end = this.readVarint() + this.pos,\n            buffer = this.buf.subarray(this.pos, end);\n        this.pos = end;\n        return buffer;\n    },\n\n    // verbose for performance reasons; doesn't affect gzipped size\n\n    readPackedVarint: function(arr, isSigned) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readVarint(isSigned));\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readVarint(isSigned));\n        return arr;\n    },\n    readPackedSVarint: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSVarint());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSVarint());\n        return arr;\n    },\n    readPackedBoolean: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readBoolean());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readBoolean());\n        return arr;\n    },\n    readPackedFloat: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFloat());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFloat());\n        return arr;\n    },\n    readPackedDouble: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readDouble());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readDouble());\n        return arr;\n    },\n    readPackedFixed32: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed32());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFixed32());\n        return arr;\n    },\n    readPackedSFixed32: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed32());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSFixed32());\n        return arr;\n    },\n    readPackedFixed64: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed64());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFixed64());\n        return arr;\n    },\n    readPackedSFixed64: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed64());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSFixed64());\n        return arr;\n    },\n\n    skip: function(val) {\n        var type = val & 0x7;\n        if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}\n        else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;\n        else if (type === Pbf.Fixed32) this.pos += 4;\n        else if (type === Pbf.Fixed64) this.pos += 8;\n        else throw new Error('Unimplemented type: ' + type);\n    },\n\n    // === WRITING =================================================================\n\n    writeTag: function(tag, type) {\n        this.writeVarint((tag << 3) | type);\n    },\n\n    realloc: function(min) {\n        var length = this.length || 16;\n\n        while (length < this.pos + min) length *= 2;\n\n        if (length !== this.length) {\n            var buf = new Uint8Array(length);\n            buf.set(this.buf);\n            this.buf = buf;\n            this.length = length;\n        }\n    },\n\n    finish: function() {\n        this.length = this.pos;\n        this.pos = 0;\n        return this.buf.subarray(0, this.length);\n    },\n\n    writeFixed32: function(val) {\n        this.realloc(4);\n        writeInt32(this.buf, val, this.pos);\n        this.pos += 4;\n    },\n\n    writeSFixed32: function(val) {\n        this.realloc(4);\n        writeInt32(this.buf, val, this.pos);\n        this.pos += 4;\n    },\n\n    writeFixed64: function(val) {\n        this.realloc(8);\n        writeInt32(this.buf, val & -1, this.pos);\n        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeSFixed64: function(val) {\n        this.realloc(8);\n        writeInt32(this.buf, val & -1, this.pos);\n        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeVarint: function(val) {\n        val = +val || 0;\n\n        if (val > 0xfffffff || val < 0) {\n            writeBigVarint(val, this);\n            return;\n        }\n\n        this.realloc(4);\n\n        this.buf[this.pos++] =           val & 0x7f  | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] =   (val >>> 7) & 0x7f;\n    },\n\n    writeSVarint: function(val) {\n        this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);\n    },\n\n    writeBoolean: function(val) {\n        this.writeVarint(Boolean(val));\n    },\n\n    writeString: function(str) {\n        str = String(str);\n        this.realloc(str.length * 4);\n\n        this.pos++; // reserve 1 byte for short string length\n\n        var startPos = this.pos;\n        // write the string directly to the buffer and see how much was written\n        this.pos = writeUtf8(this.buf, str, this.pos);\n        var len = this.pos - startPos;\n\n        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeFloat: function(val) {\n        this.realloc(4);\n        ieee754.write(this.buf, val, this.pos, true, 23, 4);\n        this.pos += 4;\n    },\n\n    writeDouble: function(val) {\n        this.realloc(8);\n        ieee754.write(this.buf, val, this.pos, true, 52, 8);\n        this.pos += 8;\n    },\n\n    writeBytes: function(buffer) {\n        var len = buffer.length;\n        this.writeVarint(len);\n        this.realloc(len);\n        for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];\n    },\n\n    writeRawMessage: function(fn, obj) {\n        this.pos++; // reserve 1 byte for short message length\n\n        // write the message directly to the buffer and see how much was written\n        var startPos = this.pos;\n        fn(obj, this);\n        var len = this.pos - startPos;\n\n        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeMessage: function(tag, fn, obj) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeRawMessage(fn, obj);\n    },\n\n    writePackedVarint:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedVarint, arr);   },\n    writePackedSVarint:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSVarint, arr);  },\n    writePackedBoolean:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedBoolean, arr);  },\n    writePackedFloat:    function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFloat, arr);    },\n    writePackedDouble:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedDouble, arr);   },\n    writePackedFixed32:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed32, arr);  },\n    writePackedSFixed32: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed32, arr); },\n    writePackedFixed64:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed64, arr);  },\n    writePackedSFixed64: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed64, arr); },\n\n    writeBytesField: function(tag, buffer) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeBytes(buffer);\n    },\n    writeFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFixed32(val);\n    },\n    writeSFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeSFixed32(val);\n    },\n    writeFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeFixed64(val);\n    },\n    writeSFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeSFixed64(val);\n    },\n    writeVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeVarint(val);\n    },\n    writeSVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeSVarint(val);\n    },\n    writeStringField: function(tag, str) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeString(str);\n    },\n    writeFloatField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFloat(val);\n    },\n    writeDoubleField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeDouble(val);\n    },\n    writeBooleanField: function(tag, val) {\n        this.writeVarintField(tag, Boolean(val));\n    }\n};\n\nfunction readVarintRemainder(l, s, p) {\n    var buf = p.buf,\n        h, b;\n\n    b = buf[p.pos++]; h  = (b & 0x70) >> 4;  if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 3;  if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 10; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 17; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 24; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x01) << 31; if (b < 0x80) return toNum(l, h, s);\n\n    throw new Error('Expected varint not more than 10 bytes');\n}\n\nfunction readPackedEnd(pbf) {\n    return pbf.type === Pbf.Bytes ?\n        pbf.readVarint() + pbf.pos : pbf.pos + 1;\n}\n\nfunction toNum(low, high, isSigned) {\n    if (isSigned) {\n        return high * 0x100000000 + (low >>> 0);\n    }\n\n    return ((high >>> 0) * 0x100000000) + (low >>> 0);\n}\n\nfunction writeBigVarint(val, pbf) {\n    var low, high;\n\n    if (val >= 0) {\n        low  = (val % 0x100000000) | 0;\n        high = (val / 0x100000000) | 0;\n    } else {\n        low  = ~(-val % 0x100000000);\n        high = ~(-val / 0x100000000);\n\n        if (low ^ 0xffffffff) {\n            low = (low + 1) | 0;\n        } else {\n            low = 0;\n            high = (high + 1) | 0;\n        }\n    }\n\n    if (val >= 0x10000000000000000 || val < -0x10000000000000000) {\n        throw new Error('Given varint doesn\\'t fit into 10 bytes');\n    }\n\n    pbf.realloc(10);\n\n    writeBigVarintLow(low, high, pbf);\n    writeBigVarintHigh(high, pbf);\n}\n\nfunction writeBigVarintLow(low, high, pbf) {\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos]   = low & 0x7f;\n}\n\nfunction writeBigVarintHigh(high, pbf) {\n    var lsb = (high & 0x07) << 4;\n\n    pbf.buf[pbf.pos++] |= lsb         | ((high >>>= 3) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f;\n}\n\nfunction makeRoomForExtraLength(startPos, len, pbf) {\n    var extraLen =\n        len <= 0x3fff ? 1 :\n        len <= 0x1fffff ? 2 :\n        len <= 0xfffffff ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));\n\n    // if 1 byte isn't enough for encoding message length, shift the data to the right\n    pbf.realloc(extraLen);\n    for (var i = pbf.pos - 1; i >= startPos; i--) pbf.buf[i + extraLen] = pbf.buf[i];\n}\n\nfunction writePackedVarint(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);   }\nfunction writePackedSVarint(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);  }\nfunction writePackedFloat(arr, pbf)    { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);    }\nfunction writePackedDouble(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);   }\nfunction writePackedBoolean(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);  }\nfunction writePackedFixed32(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);  }\nfunction writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }\nfunction writePackedFixed64(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);  }\nfunction writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }\n\n// Buffer code below from https://github.com/feross/buffer, MIT-licensed\n\nfunction readUInt32(buf, pos) {\n    return ((buf[pos]) |\n        (buf[pos + 1] << 8) |\n        (buf[pos + 2] << 16)) +\n        (buf[pos + 3] * 0x1000000);\n}\n\nfunction writeInt32(buf, val, pos) {\n    buf[pos] = val;\n    buf[pos + 1] = (val >>> 8);\n    buf[pos + 2] = (val >>> 16);\n    buf[pos + 3] = (val >>> 24);\n}\n\nfunction readInt32(buf, pos) {\n    return ((buf[pos]) |\n        (buf[pos + 1] << 8) |\n        (buf[pos + 2] << 16)) +\n        (buf[pos + 3] << 24);\n}\n\nfunction readUtf8(buf, pos, end) {\n    var str = '';\n    var i = pos;\n\n    while (i < end) {\n        var b0 = buf[i];\n        var c = null; // codepoint\n        var bytesPerSequence =\n            b0 > 0xEF ? 4 :\n            b0 > 0xDF ? 3 :\n            b0 > 0xBF ? 2 : 1;\n\n        if (i + bytesPerSequence > end) break;\n\n        var b1, b2, b3;\n\n        if (bytesPerSequence === 1) {\n            if (b0 < 0x80) {\n                c = b0;\n            }\n        } else if (bytesPerSequence === 2) {\n            b1 = buf[i + 1];\n            if ((b1 & 0xC0) === 0x80) {\n                c = (b0 & 0x1F) << 0x6 | (b1 & 0x3F);\n                if (c <= 0x7F) {\n                    c = null;\n                }\n            }\n        } else if (bytesPerSequence === 3) {\n            b1 = buf[i + 1];\n            b2 = buf[i + 2];\n            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80) {\n                c = (b0 & 0xF) << 0xC | (b1 & 0x3F) << 0x6 | (b2 & 0x3F);\n                if (c <= 0x7FF || (c >= 0xD800 && c <= 0xDFFF)) {\n                    c = null;\n                }\n            }\n        } else if (bytesPerSequence === 4) {\n            b1 = buf[i + 1];\n            b2 = buf[i + 2];\n            b3 = buf[i + 3];\n            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n                c = (b0 & 0xF) << 0x12 | (b1 & 0x3F) << 0xC | (b2 & 0x3F) << 0x6 | (b3 & 0x3F);\n                if (c <= 0xFFFF || c >= 0x110000) {\n                    c = null;\n                }\n            }\n        }\n\n        if (c === null) {\n            c = 0xFFFD;\n            bytesPerSequence = 1;\n\n        } else if (c > 0xFFFF) {\n            c -= 0x10000;\n            str += String.fromCharCode(c >>> 10 & 0x3FF | 0xD800);\n            c = 0xDC00 | c & 0x3FF;\n        }\n\n        str += String.fromCharCode(c);\n        i += bytesPerSequence;\n    }\n\n    return str;\n}\n\nfunction readUtf8TextDecoder(buf, pos, end) {\n    return utf8TextDecoder.decode(buf.subarray(pos, end));\n}\n\nfunction writeUtf8(buf, str, pos) {\n    for (var i = 0, c, lead; i < str.length; i++) {\n        c = str.charCodeAt(i); // code point\n\n        if (c > 0xD7FF && c < 0xE000) {\n            if (lead) {\n                if (c < 0xDC00) {\n                    buf[pos++] = 0xEF;\n                    buf[pos++] = 0xBF;\n                    buf[pos++] = 0xBD;\n                    lead = c;\n                    continue;\n                } else {\n                    c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;\n                    lead = null;\n                }\n            } else {\n                if (c > 0xDBFF || (i + 1 === str.length)) {\n                    buf[pos++] = 0xEF;\n                    buf[pos++] = 0xBF;\n                    buf[pos++] = 0xBD;\n                } else {\n                    lead = c;\n                }\n                continue;\n            }\n        } else if (lead) {\n            buf[pos++] = 0xEF;\n            buf[pos++] = 0xBF;\n            buf[pos++] = 0xBD;\n            lead = null;\n        }\n\n        if (c < 0x80) {\n            buf[pos++] = c;\n        } else {\n            if (c < 0x800) {\n                buf[pos++] = c >> 0x6 | 0xC0;\n            } else {\n                if (c < 0x10000) {\n                    buf[pos++] = c >> 0xC | 0xE0;\n                } else {\n                    buf[pos++] = c >> 0x12 | 0xF0;\n                    buf[pos++] = c >> 0xC & 0x3F | 0x80;\n                }\n                buf[pos++] = c >> 0x6 & 0x3F | 0x80;\n            }\n            buf[pos++] = c & 0x3F | 0x80;\n        }\n    }\n    return pos;\n}\n","module.exports = \"varying highp vec2 v_tex_coord;\\n\\n#ifdef COLORMAP\\nvarying highp float v_mag;\\n#else\\nuniform lowp vec4 u_bb_color;\\n#endif\\n\\nuniform sampler2D u_sampler;\\n\\nvoid main() {\\n    lowp vec4 tex_color = texture2D(u_sampler, v_tex_coord);\\n\\n    lowp vec4 color;\\n#ifdef COLORMAP\\n    color = apply_colormap(v_mag);\\n#else\\n    color = u_bb_color;\\n#endif\\n\\n    color.a *= tex_color.a;\\n    gl_FragColor = color; // mix(vec4(1.0, 0.0, 0.0, 0.5), color, tex_color.a);\\n}\"","module.exports = \"uniform mat4 u_matrix;\\nuniform int u_offset;\\n\\nattribute vec3 a_pos;    // Has position, zoom, and corner info\\nattribute vec2 a_tex_coord;\\nuniform lowp float u_bb_size;\\nuniform lowp float u_map_aspect;\\nuniform lowp float u_zoom;\\nuniform highp float u_map_bearing;\\nuniform lowp float u_bb_width;  // Normalized by texture width\\nuniform lowp float u_bb_height; // Normalized by texture height\\nuniform highp float u_bb_mag_bin_size;\\n//uniform highp float u_bb_max_mag;\\nuniform highp float u_bb_mag_wrap;\\n\\nuniform sampler2D u_u_sampler;\\nuniform sampler2D u_v_sampler;\\nuniform sampler2D u_rot_sampler;\\n\\nvarying highp vec2 v_tex_coord;\\n#ifdef COLORMAP\\nvarying highp float v_mag;\\n#endif\\n\\nmat4 scalingMatrix(float x_scale, float y_scale, float z_scale) {\\n    return mat4(x_scale, 0.0,     0.0,     0.0,\\n                0.0,     y_scale, 0.0,     0.0,\\n                0.0,     0.0,     z_scale, 0.0,\\n                0.0,     0.0,     0.0,     1.0);\\n}\\n\\nmat4 rotationZMatrix(float angle) {\\n    float s = sin(angle);\\n    float c = cos(angle);\\n\\n    return mat4( c,  s,  0., 0.,\\n                -s,  c,  0., 0.,\\n                 0., 0., 1., 0.,\\n                 0., 0., 0., 1.);\\n}\\n\\nmat4 rotationXMatrix(float angle) {\\n    float s = sin(angle);\\n    float c = cos(angle);\\n\\n    return mat4( 1.,  0., 0., 0.,\\n                 0.,  c,  s,  0.,\\n                 0., -s,  c,  0.,\\n                 0.,  0., 0., 1.);\\n}\\n\\nvoid main() {\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    vec4 pivot_pos = u_matrix * vec4(a_pos.xy + globe_offset, 0.0, 1.0);\\n    highp float zoom_corner = a_pos.z;\\n    lowp float min_zoom = floor(zoom_corner / 4.0);\\n    lowp float corner = mod(zoom_corner, 4.0);\\n\\n    highp float u = texture2D(u_u_sampler, a_tex_coord).r;\\n    highp float v = texture2D(u_v_sampler, a_tex_coord).r;\\n    highp float rot = texture2D(u_rot_sampler, a_tex_coord).r;\\n\\n    lowp float bb_aspect = u_bb_width / u_bb_height;\\n    lowp float ang = (abs(u) < 1e-6 && abs(v) < 1e-6) ? 0. : atan(v, u) - 3.141592654 / 2.0;\\n    highp float mag = length(vec2(u, v));\\n#ifdef COLORMAP\\n    v_mag = mag;\\n#endif\\n    mag = floor(mag / u_bb_mag_bin_size + 0.5) * u_bb_mag_bin_size;\\n\\n    vec4 offset = vec4(0.0, 0.0, 0.0, 0.0);\\n    vec2 texcoord = vec2(0.0, 0.0);\\n    \\n    if (u_zoom >= min_zoom) {\\n        // Subtracting a small number off of u_bb_mag_wrap fixes (I think) a precision issue on some GPUs\\n        vec2 tex_loc = vec2(mod(mag, u_bb_mag_wrap - 1e-5) / u_bb_mag_bin_size * u_bb_width, floor(mag / (u_bb_mag_wrap - 1e-5)) * u_bb_height);\\n\\n        if (corner < 0.5) {\\n            offset = vec4(-u_bb_size, u_bb_size, 0., 0.);\\n            texcoord = tex_loc;\\n        }\\n        else if (corner < 1.5) {\\n            offset = vec4(u_bb_size, u_bb_size, 0., 0.);\\n            texcoord = tex_loc + vec2(u_bb_width, 0.0);\\n        }\\n        else if (corner < 2.5) {\\n            offset = vec4(-u_bb_size, -u_bb_size * (2. / bb_aspect - 1.), 0., 0.);\\n            texcoord = tex_loc + vec2(0.0, u_bb_height);\\n        }\\n        else if (corner < 3.5) {\\n            offset = vec4(u_bb_size, -u_bb_size * (2. / bb_aspect - 1.), 0., 0.);\\n            texcoord = tex_loc + vec2(u_bb_width, u_bb_height);\\n        }\\n\\n        mat4 barb_rotation = rotationZMatrix(ang + radians(u_map_bearing) - rot);\\n        mat4 map_stretch_matrix = scalingMatrix(1.0, 1. / u_map_aspect, 1.0);\\n        offset = map_stretch_matrix * barb_rotation * offset;\\n    }\\n\\n    gl_Position = pivot_pos + offset;\\n    v_tex_coord = texcoord;\\n}\"","module.exports = \"\\nuniform sampler2D u_cmap_sampler;\\nuniform sampler2D u_cmap_nonlin_sampler;\\nuniform highp float u_cmap_min;\\nuniform highp float u_cmap_max;\\nuniform highp vec4 u_underflow_color;\\nuniform highp vec4 u_overflow_color;\\nuniform int u_n_index;\\n\\nlowp vec4 apply_colormap(highp float value) {\\n    lowp float normed_val = (value - u_cmap_min) / (u_cmap_max - u_cmap_min);\\n    \\n    lowp vec4 color;\\n    if (normed_val < 0.0) {\\n        color = u_underflow_color;\\n    }\\n    else if (normed_val > 1.0) {\\n        color = u_overflow_color;\\n    }\\n    else {\\n        lowp float index_buffer = 1. / (2. * float(u_n_index));\\n        normed_val = index_buffer + normed_val * (1. - 2. * index_buffer); // Chop off the half pixels on either end of the texture\\n        highp float nonlin_val = texture2D(u_cmap_nonlin_sampler, vec2(normed_val, 0.5)).r;\\n        color = texture2D(u_cmap_sampler, vec2(nonlin_val, 0.5));\\n    }\\n\\n    return color;\\n}\"","module.exports = \"varying highp vec2 v_tex_coord;\\n\\nuniform sampler2D u_fill_sampler;\\nuniform highp float u_opacity;\\n\\nbool isnan(highp float val) {\\n    return ( val < 0.0 || 0.0 < val || val == 0.0 ) ? false : true;\\n}\\n\\nvoid main() {\\n    highp float fill_val = texture2D(u_fill_sampler, v_tex_coord).r;\\n\\n    if (isnan(fill_val)) {\\n        discard;\\n    }\\n\\n    lowp vec4 color = apply_colormap(fill_val);\\n    color.a = color.a * u_opacity;\\n    gl_FragColor = color;\\n}\"","module.exports = \"uniform mat4 u_matrix;\\nuniform int u_offset;\\n\\nattribute vec2 a_pos;\\nattribute vec2 a_tex_coord;\\n\\nvarying highp vec2 v_tex_coord;\\n\\nvoid main() {\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    gl_Position = u_matrix * vec4(a_pos + globe_offset, 0.0, 1.0);\\n    v_tex_coord = a_tex_coord;\\n}\"","module.exports = \"#define MAX_N_COLORS 24\\n\\nvarying highp vec2 v_tex_coord;\\n\\nuniform sampler2D u_fill_sampler;\\nuniform lowp vec4 u_colors[MAX_N_COLORS];\\nuniform int u_num_colors;\\nuniform highp float u_opacity;\\n\\nvoid main() {\\n    highp float fill_val = texture2D(u_fill_sampler, v_tex_coord).r;\\n    \\n    if (fill_val < 0.5) {\\n        discard;\\n    }\\n\\n    lowp vec4 color = vec4(0., 0., 0., 0.);\\n\\n    for (int nclr = 0; nclr < MAX_N_COLORS ; nclr++) {\\n        if (nclr >= u_num_colors || fill_val < 0.99) { break; }\\n\\n        lowp float mem_active = mod(fill_val, 2.);\\n        color = mix(color, u_colors[nclr], mem_active);\\n        fill_val = floor(fill_val / 2.);\\n    }\\n\\n    color.a = color.a * u_opacity;\\n    gl_FragColor = color;\\n}\"","module.exports = \"uniform mat4 u_matrix;\\nuniform int u_offset;\\n\\nattribute vec2 a_pos;\\nattribute vec2 a_tex_coord;\\n\\nvarying highp vec2 v_tex_coord;\\n\\nvoid main() {\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    gl_Position = u_matrix * vec4(a_pos + globe_offset, 0.0, 1.0);\\n    v_tex_coord = a_tex_coord;\\n}\"","module.exports = \"\\nuniform sampler2D u_dash_sampler;\\n\\n#ifndef DATA\\nuniform lowp vec4 u_color;\\n#endif\\n\\nuniform lowp float u_line_width;\\nuniform lowp float u_zoom;\\nuniform int u_dash_pattern_length;\\n\\n#ifdef DATA\\nvarying highp float v_data;\\n#endif\\n\\nvarying highp float v_dist;\\nvarying lowp float v_cross;\\n\\nvoid main() {\\n    lowp float dash_x = fract(v_dist * 2e2 * pow(2., floor(u_zoom)) / float(u_dash_pattern_length));\\n    lowp float dash = texture2D(u_dash_sampler, vec2(dash_x, 0.5)).r;\\n\\n    lowp vec4 color;\\n#ifdef DATA\\n    color = apply_colormap(v_data);\\n#else\\n    color = u_color;\\n#endif\\n\\n    lowp float feather = clamp((1. - abs(v_cross)) * u_line_width, 0., 1.);\\n    color.a *= (dash >= 1. ? 1. : 0.) * feather;\\n\\n    gl_FragColor = color;\\n}\"","module.exports = \"uniform mat4 u_matrix;\\nuniform int u_offset;\\n\\nattribute vec3 a_pos;\\nattribute vec2 a_extrusion;\\nattribute float a_data;\\n\\n#ifdef ZOOM\\nattribute float a_min_zoom;\\n#endif\\n\\n#ifdef OFFSET\\nattribute vec2 a_offset;\\n#endif\\n\\nuniform lowp float u_line_width;\\nuniform lowp float u_map_width;\\nuniform lowp float u_map_height;\\nuniform highp float u_map_bearing;\\n\\n#ifdef ZOOM\\nuniform lowp float u_zoom;\\n#endif\\n\\n#ifdef OFFSET\\nuniform lowp float u_offset_scale;\\n#endif\\n\\n#ifdef DATA\\nvarying highp float v_data;\\n#endif\\n\\nvarying highp float v_dist;\\nvarying lowp float v_cross;\\n\\nmat4 scalingMatrix(float x_scale, float y_scale, float z_scale) {\\n    return mat4(x_scale, 0.0,     0.0,     0.0,\\n                0.0,     y_scale, 0.0,     0.0,\\n                0.0,     0.0,     z_scale, 0.0,\\n                0.0,     0.0,     0.0,     1.0);\\n}\\n\\nmat4 rotationZMatrix(float angle) {\\n    float s = sin(angle);\\n    float c = cos(angle);\\n\\n    return mat4( c,  s,  0., 0.,\\n                -s,  c,  0., 0.,\\n                 0., 0., 1., 0.,\\n                 0., 0., 0., 1.);\\n}\\n\\nmat4 rotationXMatrix(float angle) {\\n    float s = sin(angle);\\n    float c = cos(angle);\\n\\n    return mat4( 1.,  0., 0., 0.,\\n                 0.,  c,  s,  0.,\\n                 0., -s,  c,  0.,\\n                 0.,  0., 0., 1.);\\n}\\n\\nvoid main() {\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    v_dist = abs(a_pos.z);\\n    v_cross = sign(a_pos.z);\\n    vec4 center_pos = u_matrix * vec4(a_pos.xy + globe_offset, 0.0, 1.0);\\n    vec4 offset = vec4(0.0, 0.0, 0.0, 0.0);\\n\\n#ifdef ZOOM\\n    if (u_zoom >= a_min_zoom) {\\n#endif\\n\\n        vec2 offset_ext = u_line_width * 2. * a_extrusion;\\n\\n        mat4 map_stretch_matrix = scalingMatrix(u_map_height / u_map_width, 1., 1.);\\n        mat4 rotation_matrix = rotationZMatrix(radians(u_map_bearing));  \\n        offset = map_stretch_matrix * rotation_matrix * vec4(offset_ext, 0., 0.);\\n\\n#ifdef OFFSET\\n        map_stretch_matrix = scalingMatrix(1., u_map_width / u_map_height, 1.);\\n        vec2 offset_offset = u_offset_scale * a_offset;\\n        offset += map_stretch_matrix * rotation_matrix * vec4(offset_offset, 0., 0.);\\n#endif\\n\\n#ifdef ZOOM\\n    }\\n#endif\\n\\n    gl_Position = center_pos + offset;\\n\\n#ifdef DATA\\n    v_data = a_data;\\n#endif\\n}\"","module.exports = \"\\nvarying highp vec2 v_tex_coord;\\nuniform sampler2D u_sdf_sampler;\\nuniform int u_is_halo;\\n\\nuniform lowp vec4 u_text_color;\\nuniform lowp vec4 u_halo_color;\\n\\n#define SDF_FILL 0.75\\n#define SDF_HALO 0.45\\n\\nvoid main() {\\n    highp float sdf_val = texture2D(u_sdf_sampler, v_tex_coord).r;\\n\\n    lowp float step_width = 0.08;\\n    lowp float alpha = smoothstep(SDF_FILL - step_width, SDF_FILL + step_width, sdf_val);\\n\\n    lowp vec4 color = u_is_halo == 1 ? u_halo_color : u_text_color;\\n\\n    if (u_is_halo == 1) {\\n        alpha = min(smoothstep(SDF_HALO - step_width, SDF_HALO + step_width, sdf_val), 1.0 - alpha);\\n    }\\n\\n    color.a *= alpha;\\n    gl_FragColor = color;\\n}\"","module.exports = \"\\nuniform mat4 u_matrix;\\nuniform int u_offset;\\nuniform highp float u_map_width;\\nuniform highp float u_map_height;\\nuniform highp float u_map_zoom;\\nuniform highp float u_font_size;\\n\\nattribute vec3 a_pos;\\nattribute vec2 a_offset;\\nattribute vec2 a_tex_coord;\\n\\nvarying highp vec2 v_tex_coord;\\n\\nmat4 scalingMatrix(float x_scale, float y_scale, float z_scale) {\\n    return mat4(x_scale, 0.0,     0.0,     0.0,\\n                0.0,     y_scale, 0.0,     0.0,\\n                0.0,     0.0,     z_scale, 0.0,\\n                0.0,     0.0,     0.0,     1.0);\\n}\\n\\nvoid main() {\\n    float min_zoom = a_pos.z;\\n\\n    vec2 offset = a_offset;\\n    if (u_map_zoom < min_zoom)\\n        offset = vec2(0., 0.);\\n\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    mat4 map_stretch_matrix = scalingMatrix(u_map_height / u_map_width, 1., 1.);\\n\\n    gl_Position = u_matrix * vec4(a_pos.xy + globe_offset, 0.0, 1.0) + u_font_size / 12. * 1.5 * map_stretch_matrix * vec4(offset, 0., 0.);\\n    v_tex_coord = a_tex_coord;\\n}\"","\nvar Module = (() => {\n  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;\n  \n  return (\nfunction(moduleArg = {}) {\n\n// include: shell.js\n// The Module object: Our interface to the outside world. We import\n// and export values on it. There are various ways Module can be used:\n// 1. Not defined. We create it here\n// 2. A function parameter, function(Module) { ..generated code.. }\n// 3. pre-run appended it, var Module = {}; ..generated code..\n// 4. External script tag defines var Module.\n// We need to check if Module already exists (e.g. case 3 above).\n// Substitution will be replaced with actual code on later stage of the build,\n// this way Closure Compiler will not mangle it (e.g. case 4. above).\n// Note that if you want to run closure, and also to use Module\n// after the generated code, you will need to define   var Module = {};\n// before the code. Then that object will be used in the code, and you\n// can continue to use Module afterwards as well.\nvar Module = moduleArg;\n\n// Set up the promise that indicates the Module is initialized\nvar readyPromiseResolve, readyPromiseReject;\nModule['ready'] = new Promise((resolve, reject) => {\n  readyPromiseResolve = resolve;\n  readyPromiseReject = reject;\n});\n[\"_main\",\"getExceptionMessage\",\"___get_exception_message\",\"_free\",\"_memory\",\"___indirect_function_table\",\"_fflush\",\"onRuntimeInitialized\"].forEach((prop) => {\n  if (!Object.getOwnPropertyDescriptor(Module['ready'], prop)) {\n    Object.defineProperty(Module['ready'], prop, {\n      get: () => abort('You are getting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),\n      set: () => abort('You are setting ' + prop + ' on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js'),\n    });\n  }\n});\n\n// --pre-jses are emitted after the Module integration code, so that they can\n// refer to Module (if they choose; they can also define Module)\n\n\n// Sometimes an existing Module object exists with properties\n// meant to overwrite the default module functionality. Here\n// we collect those properties and reapply _after_ we configure\n// the current environment's defaults to avoid having to be so\n// defensive during initialization.\nvar moduleOverrides = Object.assign({}, Module);\n\nvar arguments_ = [];\nvar thisProgram = './this.program';\nvar quit_ = (status, toThrow) => {\n  throw toThrow;\n};\n\n// Determine the runtime environment we are in. You can customize this by\n// setting the ENVIRONMENT setting at compile time (see settings.js).\n\nvar ENVIRONMENT_IS_WEB = true;\nvar ENVIRONMENT_IS_WORKER = false;\nvar ENVIRONMENT_IS_NODE = false;\nvar ENVIRONMENT_IS_SHELL = false;\n\nif (Module['ENVIRONMENT']) {\n  throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)');\n}\n\n// `/` should be present at the end if `scriptDirectory` is not empty\nvar scriptDirectory = '';\nfunction locateFile(path) {\n  if (Module['locateFile']) {\n    return Module['locateFile'](path, scriptDirectory);\n  }\n  return scriptDirectory + path;\n}\n\n// Hooks that are implemented differently in different runtime environments.\nvar read_,\n    readAsync,\n    readBinary;\n\nif (ENVIRONMENT_IS_SHELL) {\n\n  if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');\n\n  if (typeof read != 'undefined') {\n    read_ = read;\n  }\n\n  readBinary = (f) => {\n    if (typeof readbuffer == 'function') {\n      return new Uint8Array(readbuffer(f));\n    }\n    let data = read(f, 'binary');\n    assert(typeof data == 'object');\n    return data;\n  };\n\n  readAsync = (f, onload, onerror) => {\n    setTimeout(() => onload(readBinary(f)));\n  };\n\n  if (typeof clearTimeout == 'undefined') {\n    globalThis.clearTimeout = (id) => {};\n  }\n\n  if (typeof setTimeout == 'undefined') {\n    // spidermonkey lacks setTimeout but we use it above in readAsync.\n    globalThis.setTimeout = (f) => (typeof f == 'function') ? f() : abort();\n  }\n\n  if (typeof scriptArgs != 'undefined') {\n    arguments_ = scriptArgs;\n  } else if (typeof arguments != 'undefined') {\n    arguments_ = arguments;\n  }\n\n  if (typeof quit == 'function') {\n    quit_ = (status, toThrow) => {\n      // Unlike node which has process.exitCode, d8 has no such mechanism. So we\n      // have no way to set the exit code and then let the program exit with\n      // that code when it naturally stops running (say, when all setTimeouts\n      // have completed). For that reason, we must call `quit` - the only way to\n      // set the exit code - but quit also halts immediately.  To increase\n      // consistency with node (and the web) we schedule the actual quit call\n      // using a setTimeout to give the current stack and any exception handlers\n      // a chance to run.  This enables features such as addOnPostRun (which\n      // expected to be able to run code after main returns).\n      setTimeout(() => {\n        if (!(toThrow instanceof ExitStatus)) {\n          let toLog = toThrow;\n          if (toThrow && typeof toThrow == 'object' && toThrow.stack) {\n            toLog = [toThrow, toThrow.stack];\n          }\n          err(`exiting due to exception: ${toLog}`);\n        }\n        quit(status);\n      });\n      throw toThrow;\n    };\n  }\n\n  if (typeof print != 'undefined') {\n    // Prefer to use print/printErr where they exist, as they usually work better.\n    if (typeof console == 'undefined') console = /** @type{!Console} */({});\n    console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);\n    console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr != 'undefined' ? printErr : print);\n  }\n\n} else\n\n// Note that this includes Node.js workers when relevant (pthreads is enabled).\n// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and\n// ENVIRONMENT_IS_NODE.\nif (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {\n  if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled\n    scriptDirectory = self.location.href;\n  } else if (typeof document != 'undefined' && document.currentScript) { // web\n    scriptDirectory = document.currentScript.src;\n  }\n  // When MODULARIZE, this JS may be executed later, after document.currentScript\n  // is gone, so we saved it, and we use it here instead of any other info.\n  if (_scriptDir) {\n    scriptDirectory = _scriptDir;\n  }\n  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.\n  // otherwise, slice off the final part of the url to find the script directory.\n  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,\n  // and scriptDirectory will correctly be replaced with an empty string.\n  // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),\n  // they are removed because they could contain a slash.\n  if (scriptDirectory.indexOf('blob:') !== 0) {\n    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, \"\").lastIndexOf('/')+1);\n  } else {\n    scriptDirectory = '';\n  }\n\n  if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)');\n\n  // Differentiate the Web Worker from the Node Worker case, as reading must\n  // be done differently.\n  {\n// include: web_or_worker_shell_read.js\nread_ = (url) => {\n    var xhr = new XMLHttpRequest();\n    xhr.open('GET', url, false);\n    xhr.send(null);\n    return xhr.responseText;\n  }\n\n  if (ENVIRONMENT_IS_WORKER) {\n    readBinary = (url) => {\n      var xhr = new XMLHttpRequest();\n      xhr.open('GET', url, false);\n      xhr.responseType = 'arraybuffer';\n      xhr.send(null);\n      return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));\n    };\n  }\n\n  readAsync = (url, onload, onerror) => {\n    var xhr = new XMLHttpRequest();\n    xhr.open('GET', url, true);\n    xhr.responseType = 'arraybuffer';\n    xhr.onload = () => {\n      if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0\n        onload(xhr.response);\n        return;\n      }\n      onerror();\n    };\n    xhr.onerror = onerror;\n    xhr.send(null);\n  }\n\n// end include: web_or_worker_shell_read.js\n  }\n} else\n{\n  throw new Error('environment detection error');\n}\n\nvar out = Module['print'] || console.log.bind(console);\nvar err = Module['printErr'] || console.error.bind(console);\n\n// Merge back in the overrides\nObject.assign(Module, moduleOverrides);\n// Free the object hierarchy contained in the overrides, this lets the GC\n// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.\nmoduleOverrides = null;\ncheckIncomingModuleAPI();\n\n// Emit code to handle expected values on the Module object. This applies Module.x\n// to the proper local x. This has two benefits: first, we only emit it if it is\n// expected to arrive, and second, by using a local everywhere else that can be\n// minified.\n\nif (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_');\n\nif (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram');\n\nif (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_');\n\n// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message\n// Assertions on removed incoming Module JS APIs.\nassert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');\nassert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');\nassert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');\nassert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');\nassert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)');\nassert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');\nassert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');\nassert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)');\nassert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');\nlegacyModuleProp('asm', 'wasmExports');\nlegacyModuleProp('read', 'read_');\nlegacyModuleProp('readAsync', 'readAsync');\nlegacyModuleProp('readBinary', 'readBinary');\nlegacyModuleProp('setWindowTitle', 'setWindowTitle');\nvar IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';\nvar PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js';\nvar WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js';\nvar FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js';\nvar ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js';\nvar JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js';\nvar OPFS = 'OPFS is no longer included by default; build with -lopfs.js';\n\nvar NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';\n\nassert(!ENVIRONMENT_IS_WORKER, \"worker environment detected but not enabled at build time.  Add 'worker' to `-sENVIRONMENT` to enable.\");\n\nassert(!ENVIRONMENT_IS_NODE, \"node environment detected but not enabled at build time.  Add 'node' to `-sENVIRONMENT` to enable.\");\n\nassert(!ENVIRONMENT_IS_SHELL, \"shell environment detected but not enabled at build time.  Add 'shell' to `-sENVIRONMENT` to enable.\");\n\n\n// end include: shell.js\n// include: preamble.js\n// === Preamble library stuff ===\n\n// Documentation for the public APIs defined in this file must be updated in:\n//    site/source/docs/api_reference/preamble.js.rst\n// A prebuilt local version of the documentation is available at:\n//    site/build/text/docs/api_reference/preamble.js.txt\n// You can also build docs locally as HTML or other formats in site/\n// An online HTML version (which may be of a different version of Emscripten)\n//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html\n\nvar wasmBinary; \nif (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary');\n\nif (typeof WebAssembly != 'object') {\n  abort('no native wasm support detected');\n}\n\n// Wasm globals\n\nvar wasmMemory;\n\n//========================================\n// Runtime essentials\n//========================================\n\n// whether we are quitting the application. no code should run after this.\n// set in exit() and abort()\nvar ABORT = false;\n\n// set by exit() and abort().  Passed to 'onExit' handler.\n// NOTE: This is also used as the process return code code in shell environments\n// but only when noExitRuntime is false.\nvar EXITSTATUS;\n\n// In STRICT mode, we only define assert() when ASSERTIONS is set.  i.e. we\n// don't define it at all in release modes.  This matches the behaviour of\n// MINIMAL_RUNTIME.\n// TODO(sbc): Make this the default even without STRICT enabled.\n/** @type {function(*, string=)} */\nfunction assert(condition, text) {\n  if (!condition) {\n    abort('Assertion failed' + (text ? ': ' + text : ''));\n  }\n}\n\n// We used to include malloc/free by default in the past. Show a helpful error in\n// builds with assertions.\n\n// Memory management\n\nvar HEAP,\n/** @type {!Int8Array} */\n  HEAP8,\n/** @type {!Uint8Array} */\n  HEAPU8,\n/** @type {!Int16Array} */\n  HEAP16,\n/** @type {!Uint16Array} */\n  HEAPU16,\n/** @type {!Int32Array} */\n  HEAP32,\n/** @type {!Uint32Array} */\n  HEAPU32,\n/** @type {!Float32Array} */\n  HEAPF32,\n/** @type {!Float64Array} */\n  HEAPF64;\n\nfunction updateMemoryViews() {\n  var b = wasmMemory.buffer;\n  Module['HEAP8'] = HEAP8 = new Int8Array(b);\n  Module['HEAP16'] = HEAP16 = new Int16Array(b);\n  Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);\n  Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);\n  Module['HEAP32'] = HEAP32 = new Int32Array(b);\n  Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);\n  Module['HEAPF32'] = HEAPF32 = new Float32Array(b);\n  Module['HEAPF64'] = HEAPF64 = new Float64Array(b);\n}\n\nassert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time')\n\nassert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined,\n       'JS engine does not provide full typed array support');\n\n// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY\nassert(!Module['wasmMemory'], 'Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally');\nassert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically');\n\n// include: runtime_stack_check.js\n// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.\nfunction writeStackCookie() {\n  var max = _emscripten_stack_get_end();\n  assert((max & 3) == 0);\n  // If the stack ends at address zero we write our cookies 4 bytes into the\n  // stack.  This prevents interference with SAFE_HEAP and ASAN which also\n  // monitor writes to address zero.\n  if (max == 0) {\n    max += 4;\n  }\n  // The stack grow downwards towards _emscripten_stack_get_end.\n  // We write cookies to the final two words in the stack and detect if they are\n  // ever overwritten.\n  HEAPU32[((max)>>2)] = 0x02135467;\n  HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE;\n  // Also test the global address 0 for integrity.\n  HEAPU32[((0)>>2)] = 1668509029;\n}\n\nfunction checkStackCookie() {\n  if (ABORT) return;\n  var max = _emscripten_stack_get_end();\n  // See writeStackCookie().\n  if (max == 0) {\n    max += 4;\n  }\n  var cookie1 = HEAPU32[((max)>>2)];\n  var cookie2 = HEAPU32[(((max)+(4))>>2)];\n  if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) {\n    abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);\n  }\n  // Also test the global address 0 for integrity.\n  if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) {\n    abort('Runtime error: The application has corrupted its heap memory area (address zero)!');\n  }\n}\n// end include: runtime_stack_check.js\n// include: runtime_assertions.js\n// Endianness check\n(function() {\n  var h16 = new Int16Array(1);\n  var h8 = new Int8Array(h16.buffer);\n  h16[0] = 0x6373;\n  if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)';\n})();\n\n// end include: runtime_assertions.js\nvar __ATPRERUN__  = []; // functions called before the runtime is initialized\nvar __ATINIT__    = []; // functions called during startup\nvar __ATEXIT__    = []; // functions called during shutdown\nvar __ATPOSTRUN__ = []; // functions called after the main() is called\n\nvar runtimeInitialized = false;\n\nfunction preRun() {\n  if (Module['preRun']) {\n    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];\n    while (Module['preRun'].length) {\n      addOnPreRun(Module['preRun'].shift());\n    }\n  }\n  callRuntimeCallbacks(__ATPRERUN__);\n}\n\nfunction initRuntime() {\n  assert(!runtimeInitialized);\n  runtimeInitialized = true;\n\n  checkStackCookie();\n\n  \n  callRuntimeCallbacks(__ATINIT__);\n}\n\nfunction postRun() {\n  checkStackCookie();\n\n  if (Module['postRun']) {\n    if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];\n    while (Module['postRun'].length) {\n      addOnPostRun(Module['postRun'].shift());\n    }\n  }\n\n  callRuntimeCallbacks(__ATPOSTRUN__);\n}\n\nfunction addOnPreRun(cb) {\n  __ATPRERUN__.unshift(cb);\n}\n\nfunction addOnInit(cb) {\n  __ATINIT__.unshift(cb);\n}\n\nfunction addOnExit(cb) {\n}\n\nfunction addOnPostRun(cb) {\n  __ATPOSTRUN__.unshift(cb);\n}\n\n// include: runtime_math.js\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc\n\nassert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');\nassert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');\nassert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');\nassert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');\n// end include: runtime_math.js\n// A counter of dependencies for calling run(). If we need to\n// do asynchronous work before running, increment this and\n// decrement it. Incrementing must happen in a place like\n// Module.preRun (used by emcc to add file preloading).\n// Note that you can add dependencies in preRun, even though\n// it happens right before run - run will be postponed until\n// the dependencies are met.\nvar runDependencies = 0;\nvar runDependencyWatcher = null;\nvar dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled\nvar runDependencyTracking = {};\n\nfunction getUniqueRunDependency(id) {\n  var orig = id;\n  while (1) {\n    if (!runDependencyTracking[id]) return id;\n    id = orig + Math.random();\n  }\n}\n\nfunction addRunDependency(id) {\n  runDependencies++;\n\n  if (Module['monitorRunDependencies']) {\n    Module['monitorRunDependencies'](runDependencies);\n  }\n\n  if (id) {\n    assert(!runDependencyTracking[id]);\n    runDependencyTracking[id] = 1;\n    if (runDependencyWatcher === null && typeof setInterval != 'undefined') {\n      // Check for missing dependencies every few seconds\n      runDependencyWatcher = setInterval(() => {\n        if (ABORT) {\n          clearInterval(runDependencyWatcher);\n          runDependencyWatcher = null;\n          return;\n        }\n        var shown = false;\n        for (var dep in runDependencyTracking) {\n          if (!shown) {\n            shown = true;\n            err('still waiting on run dependencies:');\n          }\n          err(`dependency: ${dep}`);\n        }\n        if (shown) {\n          err('(end of list)');\n        }\n      }, 10000);\n    }\n  } else {\n    err('warning: run dependency added without ID');\n  }\n}\n\nfunction removeRunDependency(id) {\n  runDependencies--;\n\n  if (Module['monitorRunDependencies']) {\n    Module['monitorRunDependencies'](runDependencies);\n  }\n\n  if (id) {\n    assert(runDependencyTracking[id]);\n    delete runDependencyTracking[id];\n  } else {\n    err('warning: run dependency removed without ID');\n  }\n  if (runDependencies == 0) {\n    if (runDependencyWatcher !== null) {\n      clearInterval(runDependencyWatcher);\n      runDependencyWatcher = null;\n    }\n    if (dependenciesFulfilled) {\n      var callback = dependenciesFulfilled;\n      dependenciesFulfilled = null;\n      callback(); // can add another dependenciesFulfilled\n    }\n  }\n}\n\n/** @param {string|number=} what */\nfunction abort(what) {\n  if (Module['onAbort']) {\n    Module['onAbort'](what);\n  }\n\n  what = 'Aborted(' + what + ')';\n  // TODO(sbc): Should we remove printing and leave it up to whoever\n  // catches the exception?\n  err(what);\n\n  ABORT = true;\n  EXITSTATUS = 1;\n\n  // Use a wasm runtime error, because a JS error might be seen as a foreign\n  // exception, which means we'd run destructors on it. We need the error to\n  // simply make the program stop.\n  // FIXME This approach does not work in Wasm EH because it currently does not assume\n  // all RuntimeErrors are from traps; it decides whether a RuntimeError is from\n  // a trap or not based on a hidden field within the object. So at the moment\n  // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that\n  // allows this in the wasm spec.\n\n  // Suppress closure compiler warning here. Closure compiler's builtin extern\n  // defintion for WebAssembly.RuntimeError claims it takes no arguments even\n  // though it can.\n  // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.\n  /** @suppress {checkTypes} */\n  var e = new WebAssembly.RuntimeError(what);\n\n  readyPromiseReject(e);\n  // Throw the error whether or not MODULARIZE is set because abort is used\n  // in code paths apart from instantiation where an exception is expected\n  // to be thrown when abort is called.\n  throw e;\n}\n\n// include: memoryprofiler.js\n// end include: memoryprofiler.js\n// show errors on likely calls to FS when it was not included\nvar FS = {\n  error() {\n    abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM');\n  },\n  init() { FS.error() },\n  createDataFile() { FS.error() },\n  createPreloadedFile() { FS.error() },\n  createLazyFile() { FS.error() },\n  open() { FS.error() },\n  mkdev() { FS.error() },\n  registerDevice() { FS.error() },\n  analyzePath() { FS.error() },\n\n  ErrnoError() { FS.error() },\n};\nModule['FS_createDataFile'] = FS.createDataFile;\nModule['FS_createPreloadedFile'] = FS.createPreloadedFile;\n\n// include: URIUtils.js\n// Prefix of data URIs emitted by SINGLE_FILE and related options.\nvar dataURIPrefix = 'data:application/octet-stream;base64,';\n\n/**\n * Indicates whether filename is a base64 data URI.\n * @noinline\n */\nvar isDataURI = (filename) => filename.startsWith(dataURIPrefix);\n\n/**\n * Indicates whether filename is delivered via file protocol (as opposed to http/https)\n * @noinline\n */\nvar isFileURI = (filename) => filename.startsWith('file://');\n// end include: URIUtils.js\nfunction createExportWrapper(name) {\n  return function() {\n    assert(runtimeInitialized, `native function \\`${name}\\` called before runtime initialization`);\n    var f = wasmExports[name];\n    assert(f, `exported native function \\`${name}\\` not found`);\n    return f.apply(null, arguments);\n  };\n}\n\n// include: runtime_exceptions.js\n// Base Emscripten EH error class\nclass EmscriptenEH extends Error {}\n\nclass EmscriptenSjLj extends EmscriptenEH {}\n\nclass CppException extends EmscriptenEH {\n  constructor(excPtr) {\n    super(excPtr);\n    this.excPtr = excPtr;\n    const excInfo = getExceptionMessage(excPtr);\n    this.name = excInfo[0];\n    this.message = excInfo[1];\n  }\n}\n// end include: runtime_exceptions.js\nvar wasmBinaryFile;\n  wasmBinaryFile = 'marchingsquares.wasm';\n  if (!isDataURI(wasmBinaryFile)) {\n    wasmBinaryFile = locateFile(wasmBinaryFile);\n  }\n\nfunction getBinarySync(file) {\n  if (file == wasmBinaryFile && wasmBinary) {\n    return new Uint8Array(wasmBinary);\n  }\n  if (readBinary) {\n    return readBinary(file);\n  }\n  throw \"both async and sync fetching of the wasm failed\";\n}\n\nfunction getBinaryPromise(binaryFile) {\n  // If we don't have the binary yet, try to load it asynchronously.\n  // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.\n  // See https://github.com/github/fetch/pull/92#issuecomment-140665932\n  // Cordova or Electron apps are typically loaded from a file:// url.\n  // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.\n  if (!wasmBinary\n      && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {\n    if (typeof fetch == 'function'\n    ) {\n      return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {\n        if (!response['ok']) {\n          throw \"failed to load wasm binary file at '\" + binaryFile + \"'\";\n        }\n        return response['arrayBuffer']();\n      }).catch(() => getBinarySync(binaryFile));\n    }\n  }\n\n  // Otherwise, getBinarySync should be able to get it synchronously\n  return Promise.resolve().then(() => getBinarySync(binaryFile));\n}\n\nfunction instantiateArrayBuffer(binaryFile, imports, receiver) {\n  return getBinaryPromise(binaryFile).then((binary) => {\n    return WebAssembly.instantiate(binary, imports);\n  }).then((instance) => {\n    return instance;\n  }).then(receiver, (reason) => {\n    err(`failed to asynchronously prepare wasm: ${reason}`);\n\n    // Warn on some common problems.\n    if (isFileURI(wasmBinaryFile)) {\n      err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);\n    }\n    abort(reason);\n  });\n}\n\nfunction instantiateAsync(binary, binaryFile, imports, callback) {\n  if (!binary &&\n      typeof WebAssembly.instantiateStreaming == 'function' &&\n      !isDataURI(binaryFile) &&\n      typeof fetch == 'function') {\n    return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => {\n      // Suppress closure warning here since the upstream definition for\n      // instantiateStreaming only allows Promise<Repsponse> rather than\n      // an actual Response.\n      // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.\n      /** @suppress {checkTypes} */\n      var result = WebAssembly.instantiateStreaming(response, imports);\n\n      return result.then(\n        callback,\n        function(reason) {\n          // We expect the most common failure cause to be a bad MIME type for the binary,\n          // in which case falling back to ArrayBuffer instantiation should work.\n          err(`wasm streaming compile failed: ${reason}`);\n          err('falling back to ArrayBuffer instantiation');\n          return instantiateArrayBuffer(binaryFile, imports, callback);\n        });\n    });\n  }\n  return instantiateArrayBuffer(binaryFile, imports, callback);\n}\n\n// Create the wasm instance.\n// Receives the wasm imports, returns the exports.\nfunction createWasm() {\n  // prepare imports\n  var info = {\n    'env': wasmImports,\n    'wasi_snapshot_preview1': wasmImports,\n  };\n  // Load the wasm module and create an instance of using native support in the JS engine.\n  // handle a generated wasm instance, receiving its exports and\n  // performing other necessary setup\n  /** @param {WebAssembly.Module=} module*/\n  function receiveInstance(instance, module) {\n    wasmExports = instance.exports;\n\n    \n\n    wasmMemory = wasmExports['memory'];\n    \n    assert(wasmMemory, \"memory not found in wasm exports\");\n    // This assertion doesn't hold when emscripten is run in --post-link\n    // mode.\n    // TODO(sbc): Read INITIAL_MEMORY out of the wasm file in post-link mode.\n    //assert(wasmMemory.buffer.byteLength === 16777216);\n    updateMemoryViews();\n\n    wasmTable = wasmExports['__indirect_function_table'];\n    \n    assert(wasmTable, \"table not found in wasm exports\");\n\n    addOnInit(wasmExports['__wasm_call_ctors']);\n\n    removeRunDependency('wasm-instantiate');\n    return wasmExports;\n  }\n  // wait for the pthread pool (if any)\n  addRunDependency('wasm-instantiate');\n\n  // Prefer streaming instantiation if available.\n  // Async compilation can be confusing when an error on the page overwrites Module\n  // (for example, if the order of elements is wrong, and the one defining Module is\n  // later), so we save Module and check it later.\n  var trueModule = Module;\n  function receiveInstantiationResult(result) {\n    // 'result' is a ResultObject object which has both the module and instance.\n    // receiveInstance() will swap in the exports (to Module.asm) so they can be called\n    assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?');\n    trueModule = null;\n    // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.\n    // When the regression is fixed, can restore the above PTHREADS-enabled path.\n    receiveInstance(result['instance']);\n  }\n\n  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback\n  // to manually instantiate the Wasm module themselves. This allows pages to\n  // run the instantiation parallel to any other async startup actions they are\n  // performing.\n  // Also pthreads and wasm workers initialize the wasm instance through this\n  // path.\n  if (Module['instantiateWasm']) {\n\n    try {\n      return Module['instantiateWasm'](info, receiveInstance);\n    } catch(e) {\n      err(`Module.instantiateWasm callback failed with error: ${e}`);\n        // If instantiation fails, reject the module ready promise.\n        readyPromiseReject(e);\n    }\n  }\n\n  // If instantiation fails, reject the module ready promise.\n  instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);\n  return {}; // no exports yet; we'll fill them in later\n}\n\n// Globals used by JS i64 conversions (see makeSetValue)\nvar tempDouble;\nvar tempI64;\n\n// include: runtime_debug.js\nfunction legacyModuleProp(prop, newName, incomming=true) {\n  if (!Object.getOwnPropertyDescriptor(Module, prop)) {\n    Object.defineProperty(Module, prop, {\n      configurable: true,\n      get() {\n        let extra = incomming ? ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' : '';\n        abort(`\\`Module.${prop}\\` has been replaced by \\`${newName}\\`` + extra);\n\n      }\n    });\n  }\n}\n\nfunction ignoredModuleProp(prop) {\n  if (Object.getOwnPropertyDescriptor(Module, prop)) {\n    abort(`\\`Module.${prop}\\` was supplied but \\`${prop}\\` not included in INCOMING_MODULE_JS_API`);\n  }\n}\n\n// forcing the filesystem exports a few things by default\nfunction isExportedByForceFilesystem(name) {\n  return name === 'FS_createPath' ||\n         name === 'FS_createDataFile' ||\n         name === 'FS_createPreloadedFile' ||\n         name === 'FS_unlink' ||\n         name === 'addRunDependency' ||\n         // The old FS has some functionality that WasmFS lacks.\n         name === 'FS_createLazyFile' ||\n         name === 'FS_createDevice' ||\n         name === 'removeRunDependency';\n}\n\nfunction missingGlobal(sym, msg) {\n  if (typeof globalThis !== 'undefined') {\n    Object.defineProperty(globalThis, sym, {\n      configurable: true,\n      get() {\n        warnOnce(`\\`${sym}\\` is not longer defined by emscripten. ${msg}`);\n        return undefined;\n      }\n    });\n  }\n}\n\nmissingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer');\nmissingGlobal('asm', 'Please use wasmExports instead');\n\nfunction missingLibrarySymbol(sym) {\n  if (typeof globalThis !== 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) {\n    Object.defineProperty(globalThis, sym, {\n      configurable: true,\n      get() {\n        // Can't `abort()` here because it would break code that does runtime\n        // checks.  e.g. `if (typeof SDL === 'undefined')`.\n        var msg = `\\`${sym}\\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;\n        // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in\n        // library.js, which means $name for a JS name with no prefix, or name\n        // for a JS name like _name.\n        var librarySymbol = sym;\n        if (!librarySymbol.startsWith('_')) {\n          librarySymbol = '$' + sym;\n        }\n        msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;\n        if (isExportedByForceFilesystem(sym)) {\n          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';\n        }\n        warnOnce(msg);\n        return undefined;\n      }\n    });\n  }\n  // Any symbol that is not included from the JS libary is also (by definition)\n  // not exported on the Module object.\n  unexportedRuntimeSymbol(sym);\n}\n\nfunction unexportedRuntimeSymbol(sym) {\n  if (!Object.getOwnPropertyDescriptor(Module, sym)) {\n    Object.defineProperty(Module, sym, {\n      configurable: true,\n      get() {\n        var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;\n        if (isExportedByForceFilesystem(sym)) {\n          msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';\n        }\n        abort(msg);\n      }\n    });\n  }\n}\n\n// Used by XXXXX_DEBUG settings to output debug messages.\nfunction dbg(text) {\n  // TODO(sbc): Make this configurable somehow.  Its not always convenient for\n  // logging to show up as warnings.\n  console.warn.apply(console, arguments);\n}\n// end include: runtime_debug.js\n// === Body ===\n\n// end include: preamble.js\n\n  /** @constructor */\n  function ExitStatus(status) {\n      this.name = 'ExitStatus';\n      this.message = `Program terminated with exit(${status})`;\n      this.status = status;\n    }\n\n  var callRuntimeCallbacks = (callbacks) => {\n      while (callbacks.length > 0) {\n        // Pass the module as the first argument.\n        callbacks.shift()(Module);\n      }\n    };\n\n  var decrementExceptionRefcount = (ptr) => ___cxa_decrement_exception_refcount(ptr);\n\n  \n  \n  var withStackSave = (f) => {\n      var stack = stackSave();\n      var ret = f();\n      stackRestore(stack);\n      return ret;\n    };\n  \n  var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;\n  \n    /**\n     * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given\n     * array that contains uint8 values, returns a copy of that string as a\n     * Javascript String object.\n     * heapOrArray is either a regular array, or a JavaScript typed array view.\n     * @param {number} idx\n     * @param {number=} maxBytesToRead\n     * @return {string}\n     */\n  var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {\n      var endIdx = idx + maxBytesToRead;\n      var endPtr = idx;\n      // TextDecoder needs to know the byte length in advance, it doesn't stop on\n      // null terminator by itself.  Also, use the length info to avoid running tiny\n      // strings through TextDecoder, since .subarray() allocates garbage.\n      // (As a tiny code save trick, compare endPtr against endIdx using a negation,\n      // so that undefined means Infinity)\n      while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;\n  \n      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {\n        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));\n      }\n      var str = '';\n      // If building with TextDecoder, we have already computed the string length\n      // above, so test loop end condition against that\n      while (idx < endPtr) {\n        // For UTF8 byte structure, see:\n        // http://en.wikipedia.org/wiki/UTF-8#Description\n        // https://www.ietf.org/rfc/rfc2279.txt\n        // https://tools.ietf.org/html/rfc3629\n        var u0 = heapOrArray[idx++];\n        if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }\n        var u1 = heapOrArray[idx++] & 63;\n        if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }\n        var u2 = heapOrArray[idx++] & 63;\n        if ((u0 & 0xF0) == 0xE0) {\n          u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;\n        } else {\n          if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!');\n          u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);\n        }\n  \n        if (u0 < 0x10000) {\n          str += String.fromCharCode(u0);\n        } else {\n          var ch = u0 - 0x10000;\n          str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\n        }\n      }\n      return str;\n    };\n  \n    /**\n     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the\n     * emscripten HEAP, returns a copy of that string as a Javascript String object.\n     *\n     * @param {number} ptr\n     * @param {number=} maxBytesToRead - An optional length that specifies the\n     *   maximum number of bytes to read. You can omit this parameter to scan the\n     *   string until the first 0 byte. If maxBytesToRead is passed, and the string\n     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the\n     *   string will cut short at that byte index (i.e. maxBytesToRead will not\n     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing\n     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw\n     *   JS JIT optimizations off, so it is worth to consider consistently using one\n     * @return {string}\n     */\n  var UTF8ToString = (ptr, maxBytesToRead) => {\n      assert(typeof ptr == 'number', `UTF8ToString expects a number (got ${typeof ptr})`);\n      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';\n    };\n  var getExceptionMessageCommon = (ptr) => withStackSave(() => {\n      var type_addr_addr = stackAlloc(4);\n      var message_addr_addr = stackAlloc(4);\n      ___get_exception_message(ptr, type_addr_addr, message_addr_addr);\n      var type_addr = HEAPU32[((type_addr_addr)>>2)];\n      var message_addr = HEAPU32[((message_addr_addr)>>2)];\n      var type = UTF8ToString(type_addr);\n      _free(type_addr);\n      var message;\n      if (message_addr) {\n        message = UTF8ToString(message_addr);\n        _free(message_addr);\n      }\n      return [type, message];\n    });\n  var getExceptionMessage = (ptr) => getExceptionMessageCommon(ptr);\n  Module['getExceptionMessage'] = getExceptionMessage;\n\n  \n    /**\n     * @param {number} ptr\n     * @param {string} type\n     */\n  function getValue(ptr, type = 'i8') {\n    if (type.endsWith('*')) type = '*';\n    switch (type) {\n      case 'i1': return HEAP8[((ptr)>>0)];\n      case 'i8': return HEAP8[((ptr)>>0)];\n      case 'i16': return HEAP16[((ptr)>>1)];\n      case 'i32': return HEAP32[((ptr)>>2)];\n      case 'i64': abort('to do getValue(i64) use WASM_BIGINT');\n      case 'float': return HEAPF32[((ptr)>>2)];\n      case 'double': return HEAPF64[((ptr)>>3)];\n      case '*': return HEAPU32[((ptr)>>2)];\n      default: abort(`invalid type for getValue: ${type}`);\n    }\n  }\n\n  var incrementExceptionRefcount = (ptr) => ___cxa_increment_exception_refcount(ptr);\n\n  var noExitRuntime = Module['noExitRuntime'] || true;\n\n  var ptrToString = (ptr) => {\n      assert(typeof ptr === 'number');\n      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.\n      ptr >>>= 0;\n      return '0x' + ptr.toString(16).padStart(8, '0');\n    };\n\n  \n    /**\n     * @param {number} ptr\n     * @param {number} value\n     * @param {string} type\n     */\n  function setValue(ptr, value, type = 'i8') {\n    if (type.endsWith('*')) type = '*';\n    switch (type) {\n      case 'i1': HEAP8[((ptr)>>0)] = value; break;\n      case 'i8': HEAP8[((ptr)>>0)] = value; break;\n      case 'i16': HEAP16[((ptr)>>1)] = value; break;\n      case 'i32': HEAP32[((ptr)>>2)] = value; break;\n      case 'i64': abort('to do setValue(i64) use WASM_BIGINT');\n      case 'float': HEAPF32[((ptr)>>2)] = value; break;\n      case 'double': HEAPF64[((ptr)>>3)] = value; break;\n      case '*': HEAPU32[((ptr)>>2)] = value; break;\n      default: abort(`invalid type for setValue: ${type}`);\n    }\n  }\n\n  var warnOnce = (text) => {\n      if (!warnOnce.shown) warnOnce.shown = {};\n      if (!warnOnce.shown[text]) {\n        warnOnce.shown[text] = 1;\n        err(text);\n      }\n    };\n\n  var ___assert_fail = (condition, filename, line, func) => {\n      abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);\n    };\n\n  var exceptionCaught =  [];\n  \n  \n  var uncaughtExceptionCount = 0;\n  var ___cxa_begin_catch = (ptr) => {\n      var info = new ExceptionInfo(ptr);\n      if (!info.get_caught()) {\n        info.set_caught(true);\n        uncaughtExceptionCount--;\n      }\n      info.set_rethrown(false);\n      exceptionCaught.push(info);\n      ___cxa_increment_exception_refcount(info.excPtr);\n      return info.get_exception_ptr();\n    };\n\n  var exceptionLast = 0;\n  \n  /** @constructor */\n  function ExceptionInfo(excPtr) {\n      this.excPtr = excPtr;\n      this.ptr = excPtr - 24;\n  \n      this.set_type = function(type) {\n        HEAPU32[(((this.ptr)+(4))>>2)] = type;\n      };\n  \n      this.get_type = function() {\n        return HEAPU32[(((this.ptr)+(4))>>2)];\n      };\n  \n      this.set_destructor = function(destructor) {\n        HEAPU32[(((this.ptr)+(8))>>2)] = destructor;\n      };\n  \n      this.get_destructor = function() {\n        return HEAPU32[(((this.ptr)+(8))>>2)];\n      };\n  \n      this.set_caught = function(caught) {\n        caught = caught ? 1 : 0;\n        HEAP8[(((this.ptr)+(12))>>0)] = caught;\n      };\n  \n      this.get_caught = function() {\n        return HEAP8[(((this.ptr)+(12))>>0)] != 0;\n      };\n  \n      this.set_rethrown = function(rethrown) {\n        rethrown = rethrown ? 1 : 0;\n        HEAP8[(((this.ptr)+(13))>>0)] = rethrown;\n      };\n  \n      this.get_rethrown = function() {\n        return HEAP8[(((this.ptr)+(13))>>0)] != 0;\n      };\n  \n      // Initialize native structure fields. Should be called once after allocated.\n      this.init = function(type, destructor) {\n        this.set_adjusted_ptr(0);\n        this.set_type(type);\n        this.set_destructor(destructor);\n      }\n  \n      this.set_adjusted_ptr = function(adjustedPtr) {\n        HEAPU32[(((this.ptr)+(16))>>2)] = adjustedPtr;\n      };\n  \n      this.get_adjusted_ptr = function() {\n        return HEAPU32[(((this.ptr)+(16))>>2)];\n      };\n  \n      // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted\n      // when the pointer is casted to some of the exception object base classes (e.g. when virtual\n      // inheritance is used). When a pointer is thrown this method should return the thrown pointer\n      // itself.\n      this.get_exception_ptr = function() {\n        // Work around a fastcomp bug, this code is still included for some reason in a build without\n        // exceptions support.\n        var isPointer = ___cxa_is_pointer_type(this.get_type());\n        if (isPointer) {\n          return HEAPU32[((this.excPtr)>>2)];\n        }\n        var adjusted = this.get_adjusted_ptr();\n        if (adjusted !== 0) return adjusted;\n        return this.excPtr;\n      };\n    }\n  \n  var ___resumeException = (ptr) => {\n      if (!exceptionLast) {\n        exceptionLast = new CppException(ptr);\n      }\n      throw exceptionLast;\n    };\n  \n  \n  var findMatchingCatch = (args) => {\n      var thrown =\n        exceptionLast && exceptionLast.excPtr;\n      if (!thrown) {\n        // just pass through the null ptr\n        setTempRet0(0);\n        return 0;\n      }\n      var info = new ExceptionInfo(thrown);\n      info.set_adjusted_ptr(thrown);\n      var thrownType = info.get_type();\n      if (!thrownType) {\n        // just pass through the thrown ptr\n        setTempRet0(0);\n        return thrown;\n      }\n  \n      // can_catch receives a **, add indirection\n      // The different catch blocks are denoted by different types.\n      // Due to inheritance, those types may not precisely match the\n      // type of the thrown object. Find one which matches, and\n      // return the type of the catch block which should be called.\n      for (var arg in args) {\n        var caughtType = args[arg];\n  \n        if (caughtType === 0 || caughtType === thrownType) {\n          // Catch all clause matched or exactly the same type is caught\n          break;\n        }\n        var adjusted_ptr_addr = info.ptr + 16;\n        if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {\n          setTempRet0(caughtType);\n          return thrown;\n        }\n      }\n      setTempRet0(thrownType);\n      return thrown;\n    };\n  var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);\n\n  var ___cxa_find_matching_catch_3 = (arg0) => findMatchingCatch([arg0]);\n\n  \n  \n  var ___cxa_throw = (ptr, type, destructor) => {\n      var info = new ExceptionInfo(ptr);\n      // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception.\n      info.init(type, destructor);\n      exceptionLast = new CppException(ptr);\n      uncaughtExceptionCount++;\n      throw exceptionLast;\n    };\n\n\n  var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {};\n\n  var embind_init_charCodes = () => {\n      var codes = new Array(256);\n      for (var i = 0; i < 256; ++i) {\n          codes[i] = String.fromCharCode(i);\n      }\n      embind_charCodes = codes;\n    };\n  var embind_charCodes;\n  var readLatin1String = (ptr) => {\n      var ret = \"\";\n      var c = ptr;\n      while (HEAPU8[c]) {\n          ret += embind_charCodes[HEAPU8[c++]];\n      }\n      return ret;\n    };\n  \n  var awaitingDependencies = {\n  };\n  \n  var registeredTypes = {\n  };\n  \n  var typeDependencies = {\n  };\n  \n  var BindingError;\n  var throwBindingError = (message) => { throw new BindingError(message); };\n  \n  \n  \n  \n  var InternalError;\n  var throwInternalError = (message) => { throw new InternalError(message); };\n  var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {\n      myTypes.forEach(function(type) {\n          typeDependencies[type] = dependentTypes;\n      });\n  \n      function onComplete(typeConverters) {\n          var myTypeConverters = getTypeConverters(typeConverters);\n          if (myTypeConverters.length !== myTypes.length) {\n              throwInternalError('Mismatched type converter count');\n          }\n          for (var i = 0; i < myTypes.length; ++i) {\n              registerType(myTypes[i], myTypeConverters[i]);\n          }\n      }\n  \n      var typeConverters = new Array(dependentTypes.length);\n      var unregisteredTypes = [];\n      var registered = 0;\n      dependentTypes.forEach((dt, i) => {\n        if (registeredTypes.hasOwnProperty(dt)) {\n          typeConverters[i] = registeredTypes[dt];\n        } else {\n          unregisteredTypes.push(dt);\n          if (!awaitingDependencies.hasOwnProperty(dt)) {\n            awaitingDependencies[dt] = [];\n          }\n          awaitingDependencies[dt].push(() => {\n            typeConverters[i] = registeredTypes[dt];\n            ++registered;\n            if (registered === unregisteredTypes.length) {\n              onComplete(typeConverters);\n            }\n          });\n        }\n      });\n      if (0 === unregisteredTypes.length) {\n        onComplete(typeConverters);\n      }\n    };\n  /** @param {Object=} options */\n  function sharedRegisterType(rawType, registeredInstance, options = {}) {\n      var name = registeredInstance.name;\n      if (!rawType) {\n        throwBindingError(`type \"${name}\" must have a positive integer typeid pointer`);\n      }\n      if (registeredTypes.hasOwnProperty(rawType)) {\n        if (options.ignoreDuplicateRegistrations) {\n          return;\n        } else {\n          throwBindingError(`Cannot register type '${name}' twice`);\n        }\n      }\n  \n      registeredTypes[rawType] = registeredInstance;\n      delete typeDependencies[rawType];\n  \n      if (awaitingDependencies.hasOwnProperty(rawType)) {\n        var callbacks = awaitingDependencies[rawType];\n        delete awaitingDependencies[rawType];\n        callbacks.forEach((cb) => cb());\n      }\n    }\n  /** @param {Object=} options */\n  function registerType(rawType, registeredInstance, options = {}) {\n      if (!('argPackAdvance' in registeredInstance)) {\n        throw new TypeError('registerType registeredInstance requires argPackAdvance');\n      }\n      return sharedRegisterType(rawType, registeredInstance, options);\n    }\n  \n  var GenericWireTypeSize = 8;\n  /** @suppress {globalThis} */\n  var __embind_register_bool = (rawType, name, trueValue, falseValue) => {\n      name = readLatin1String(name);\n      registerType(rawType, {\n          name,\n          'fromWireType': function(wt) {\n              // ambiguous emscripten ABI: sometimes return values are\n              // true or false, and sometimes integers (0 or 1)\n              return !!wt;\n          },\n          'toWireType': function(destructors, o) {\n              return o ? trueValue : falseValue;\n          },\n          'argPackAdvance': GenericWireTypeSize,\n          'readValueFromPointer': function(pointer) {\n              return this['fromWireType'](HEAPU8[pointer]);\n          },\n          destructorFunction: null, // This type does not need a destructor\n      });\n    };\n\n  function handleAllocatorInit() {\n      Object.assign(HandleAllocator.prototype, /** @lends {HandleAllocator.prototype} */ {\n        get(id) {\n          assert(this.allocated[id] !== undefined, `invalid handle: ${id}`);\n          return this.allocated[id];\n        },\n        has(id) {\n          return this.allocated[id] !== undefined;\n        },\n        allocate(handle) {\n          var id = this.freelist.pop() || this.allocated.length;\n          this.allocated[id] = handle;\n          return id;\n        },\n        free(id) {\n          assert(this.allocated[id] !== undefined);\n          // Set the slot to `undefined` rather than using `delete` here since\n          // apparently arrays with holes in them can be less efficient.\n          this.allocated[id] = undefined;\n          this.freelist.push(id);\n        }\n      });\n    }\n  /** @constructor */\n  function HandleAllocator() {\n      // Reserve slot 0 so that 0 is always an invalid handle\n      this.allocated = [undefined];\n      this.freelist = [];\n    }\n  var emval_handles = new HandleAllocator();;\n  var __emval_decref = (handle) => {\n      if (handle >= emval_handles.reserved && 0 === --emval_handles.get(handle).refcount) {\n        emval_handles.free(handle);\n      }\n    };\n  \n  \n  \n  var count_emval_handles = () => {\n      var count = 0;\n      for (var i = emval_handles.reserved; i < emval_handles.allocated.length; ++i) {\n        if (emval_handles.allocated[i] !== undefined) {\n          ++count;\n        }\n      }\n      return count;\n    };\n  \n  var init_emval = () => {\n      // reserve some special values. These never get de-allocated.\n      // The HandleAllocator takes care of reserving zero.\n      emval_handles.allocated.push(\n        {value: undefined},\n        {value: null},\n        {value: true},\n        {value: false},\n      );\n      emval_handles.reserved = emval_handles.allocated.length\n      Module['count_emval_handles'] = count_emval_handles;\n    };\n  var Emval = {\n  toValue:(handle) => {\n        if (!handle) {\n            throwBindingError('Cannot use deleted val. handle = ' + handle);\n        }\n        return emval_handles.get(handle).value;\n      },\n  toHandle:(value) => {\n        switch (value) {\n          case undefined: return 1;\n          case null: return 2;\n          case true: return 3;\n          case false: return 4;\n          default:{\n            return emval_handles.allocate({refcount: 1, value: value});\n          }\n        }\n      },\n  };\n  \n  \n  \n  /** @suppress {globalThis} */\n  function simpleReadValueFromPointer(pointer) {\n      return this['fromWireType'](HEAP32[((pointer)>>2)]);\n    }\n  var __embind_register_emval = (rawType, name) => {\n      name = readLatin1String(name);\n      registerType(rawType, {\n        name,\n        'fromWireType': (handle) => {\n          var rv = Emval.toValue(handle);\n          __emval_decref(handle);\n          return rv;\n        },\n        'toWireType': (destructors, value) => Emval.toHandle(value),\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': simpleReadValueFromPointer,\n        destructorFunction: null, // This type does not need a destructor\n  \n        // TODO: do we need a deleteObject here?  write a test where\n        // emval is passed into JS via an interface\n      });\n    };\n\n  var embindRepr = (v) => {\n      if (v === null) {\n          return 'null';\n      }\n      var t = typeof v;\n      if (t === 'object' || t === 'array' || t === 'function') {\n          return v.toString();\n      } else {\n          return '' + v;\n      }\n    };\n  \n  var floatReadValueFromPointer = (name, width) => {\n      switch (width) {\n          case 4: return function(pointer) {\n              return this['fromWireType'](HEAPF32[((pointer)>>2)]);\n          };\n          case 8: return function(pointer) {\n              return this['fromWireType'](HEAPF64[((pointer)>>3)]);\n          };\n          default:\n              throw new TypeError(`invalid float width (${width}): ${name}`);\n      }\n    };\n  \n  \n  var __embind_register_float = (rawType, name, size) => {\n      name = readLatin1String(name);\n      registerType(rawType, {\n        name,\n        'fromWireType': (value) => value,\n        'toWireType': (destructors, value) => {\n          if (typeof value != \"number\" && typeof value != \"boolean\") {\n            throw new TypeError(`Cannot convert ${embindRepr(value)} to ${this.name}`);\n          }\n          // The VM will perform JS to Wasm value conversion, according to the spec:\n          // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue\n          return value;\n        },\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': floatReadValueFromPointer(name, size),\n        destructorFunction: null, // This type does not need a destructor\n      });\n    };\n\n  var createNamedFunction = (name, body) => Object.defineProperty(body, 'name', {\n      value: name\n    });\n  \n  var runDestructors = (destructors) => {\n      while (destructors.length) {\n        var ptr = destructors.pop();\n        var del = destructors.pop();\n        del(ptr);\n      }\n    };\n  \n  \n  function newFunc(constructor, argumentList) {\n      if (!(constructor instanceof Function)) {\n        throw new TypeError(`new_ called with constructor type ${typeof(constructor)} which is not a function`);\n      }\n      /*\n       * Previously, the following line was just:\n       *   function dummy() {};\n       * Unfortunately, Chrome was preserving 'dummy' as the object's name, even\n       * though at creation, the 'dummy' has the correct constructor name.  Thus,\n       * objects created with IMVU.new would show up in the debugger as 'dummy',\n       * which isn't very helpful.  Using IMVU.createNamedFunction addresses the\n       * issue.  Doublely-unfortunately, there's no way to write a test for this\n       * behavior.  -NRD 2013.02.22\n       */\n      var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function(){});\n      dummy.prototype = constructor.prototype;\n      var obj = new dummy;\n  \n      var r = constructor.apply(obj, argumentList);\n      return (r instanceof Object) ? r : obj;\n    }\n  function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) {\n      // humanName: a human-readable string name for the function to be generated.\n      // argTypes: An array that contains the embind type objects for all types in the function signature.\n      //    argTypes[0] is the type object for the function return value.\n      //    argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method.\n      //    argTypes[2...] are the actual function parameters.\n      // classType: The embind type object for the class to be bound, or null if this is not a method of a class.\n      // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code.\n      // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling.\n      // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI.\n      var argCount = argTypes.length;\n  \n      if (argCount < 2) {\n        throwBindingError(\"argTypes array size mismatch! Must at least get return value and 'this' types!\");\n      }\n  \n      assert(!isAsync, 'Async bindings are only supported with JSPI.');\n  \n      var isClassMethodFunc = (argTypes[1] !== null && classType !== null);\n  \n      // Free functions with signature \"void function()\" do not need an invoker that marshalls between wire types.\n  // TODO: This omits argument count check - enable only at -O3 or similar.\n  //    if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == \"void\" && !isClassMethodFunc) {\n  //       return FUNCTION_TABLE[fn];\n  //    }\n  \n      // Determine if we need to use a dynamic stack to store the destructors for the function parameters.\n      // TODO: Remove this completely once all function invokers are being dynamically generated.\n      var needsDestructorStack = false;\n  \n      for (var i = 1; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here.\n        if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { // The type does not define a destructor function - must use dynamic stack\n          needsDestructorStack = true;\n          break;\n        }\n      }\n  \n      var returns = (argTypes[0].name !== \"void\");\n  \n      var argsList = \"\";\n      var argsListWired = \"\";\n      for (var i = 0; i < argCount - 2; ++i) {\n        argsList += (i!==0?\", \":\"\")+\"arg\"+i;\n        argsListWired += (i!==0?\", \":\"\")+\"arg\"+i+\"Wired\";\n      }\n  \n      var invokerFnBody = `\n        return function (${argsList}) {\n        if (arguments.length !== ${argCount - 2}) {\n          throwBindingError('function ${humanName} called with ' + arguments.length + ' arguments, expected ${argCount - 2}');\n        }`;\n  \n      if (needsDestructorStack) {\n        invokerFnBody += \"var destructors = [];\\n\";\n      }\n  \n      var dtorStack = needsDestructorStack ? \"destructors\" : \"null\";\n      var args1 = [\"throwBindingError\", \"invoker\", \"fn\", \"runDestructors\", \"retType\", \"classParam\"];\n      var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];\n  \n      if (isClassMethodFunc) {\n        invokerFnBody += \"var thisWired = classParam.toWireType(\"+dtorStack+\", this);\\n\";\n      }\n  \n      for (var i = 0; i < argCount - 2; ++i) {\n        invokerFnBody += \"var arg\"+i+\"Wired = argType\"+i+\".toWireType(\"+dtorStack+\", arg\"+i+\"); // \"+argTypes[i+2].name+\"\\n\";\n        args1.push(\"argType\"+i);\n        args2.push(argTypes[i+2]);\n      }\n  \n      if (isClassMethodFunc) {\n        argsListWired = \"thisWired\" + (argsListWired.length > 0 ? \", \" : \"\") + argsListWired;\n      }\n  \n      invokerFnBody +=\n          (returns || isAsync ? \"var rv = \":\"\") + \"invoker(fn\"+(argsListWired.length>0?\", \":\"\")+argsListWired+\");\\n\";\n  \n      if (needsDestructorStack) {\n        invokerFnBody += \"runDestructors(destructors);\\n\";\n      } else {\n        for (var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.\n          var paramName = (i === 1 ? \"thisWired\" : (\"arg\"+(i - 2)+\"Wired\"));\n          if (argTypes[i].destructorFunction !== null) {\n            invokerFnBody += paramName+\"_dtor(\"+paramName+\"); // \"+argTypes[i].name+\"\\n\";\n            args1.push(paramName+\"_dtor\");\n            args2.push(argTypes[i].destructorFunction);\n          }\n        }\n      }\n  \n      if (returns) {\n        invokerFnBody += \"var ret = retType.fromWireType(rv);\\n\" +\n                         \"return ret;\\n\";\n      } else {\n      }\n  \n      invokerFnBody += \"}\\n\";\n  \n      args1.push(invokerFnBody);\n  \n      var invokerFn = newFunc(Function, args1).apply(null, args2);\n      return createNamedFunction(humanName, invokerFn);\n    }\n  \n  var ensureOverloadTable = (proto, methodName, humanName) => {\n      if (undefined === proto[methodName].overloadTable) {\n        var prevFunc = proto[methodName];\n        // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments.\n        proto[methodName] = function() {\n          // TODO This check can be removed in -O3 level \"unsafe\" optimizations.\n          if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {\n              throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`);\n          }\n          return proto[methodName].overloadTable[arguments.length].apply(this, arguments);\n        };\n        // Move the previous function into the overload table.\n        proto[methodName].overloadTable = [];\n        proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;\n      }\n    };\n  \n  /** @param {number=} numArguments */\n  var exposePublicSymbol = (name, value, numArguments) => {\n      if (Module.hasOwnProperty(name)) {\n        if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) {\n          throwBindingError(`Cannot register public name '${name}' twice`);\n        }\n  \n        // We are exposing a function with the same name as an existing function. Create an overload table and a function selector\n        // that routes between the two.\n        ensureOverloadTable(Module, name, name);\n        if (Module.hasOwnProperty(numArguments)) {\n          throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);\n        }\n        // Add the new function into the overload table.\n        Module[name].overloadTable[numArguments] = value;\n      }\n      else {\n        Module[name] = value;\n        if (undefined !== numArguments) {\n          Module[name].numArguments = numArguments;\n        }\n      }\n    };\n  \n  var heap32VectorToArray = (count, firstElement) => {\n      var array = [];\n      for (var i = 0; i < count; i++) {\n          // TODO(https://github.com/emscripten-core/emscripten/issues/17310):\n          // Find a way to hoist the `>> 2` or `>> 3` out of this loop.\n          array.push(HEAPU32[(((firstElement)+(i * 4))>>2)]);\n      }\n      return array;\n    };\n  \n  \n  /** @param {number=} numArguments */\n  var replacePublicSymbol = (name, value, numArguments) => {\n      if (!Module.hasOwnProperty(name)) {\n        throwInternalError('Replacing nonexistant public symbol');\n      }\n      // If there's an overload table for this symbol, replace the symbol in the overload table instead.\n      if (undefined !== Module[name].overloadTable && undefined !== numArguments) {\n        Module[name].overloadTable[numArguments] = value;\n      }\n      else {\n        Module[name] = value;\n        Module[name].argCount = numArguments;\n      }\n    };\n  \n  \n  \n  var dynCallLegacy = (sig, ptr, args) => {\n      assert(('dynCall_' + sig) in Module, `bad function pointer type - dynCall function not found for sig '${sig}'`);\n      if (args && args.length) {\n        // j (64-bit integer) must be passed in as two numbers [low 32, high 32].\n        assert(args.length === sig.substring(1).replace(/j/g, '--').length);\n      } else {\n        assert(sig.length == 1);\n      }\n      var f = Module['dynCall_' + sig];\n      return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);\n    };\n  \n  var wasmTableMirror = [];\n  \n  var wasmTable;\n  var getWasmTableEntry = (funcPtr) => {\n      var func = wasmTableMirror[funcPtr];\n      if (!func) {\n        if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;\n        wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);\n      }\n      assert(wasmTable.get(funcPtr) == func, \"JavaScript-side Wasm function table mirror is out of date!\");\n      return func;\n    };\n  \n  /** @param {Object=} args */\n  var dynCall = (sig, ptr, args) => {\n      // Without WASM_BIGINT support we cannot directly call function with i64 as\n      // part of thier signature, so we rely the dynCall functions generated by\n      // wasm-emscripten-finalize\n      if (sig.includes('j')) {\n        return dynCallLegacy(sig, ptr, args);\n      }\n      assert(getWasmTableEntry(ptr), `missing table entry in dynCall: ${ptr}`);\n      var rtn = getWasmTableEntry(ptr).apply(null, args);\n      return rtn;\n    };\n  var getDynCaller = (sig, ptr) => {\n      assert(sig.includes('j') || sig.includes('p'), 'getDynCaller should only be called with i64 sigs')\n      var argCache = [];\n      return function() {\n        argCache.length = 0;\n        Object.assign(argCache, arguments);\n        return dynCall(sig, ptr, argCache);\n      };\n    };\n  \n  \n  var embind__requireFunction = (signature, rawFunction) => {\n      signature = readLatin1String(signature);\n  \n      function makeDynCaller() {\n        if (signature.includes('j')) {\n          return getDynCaller(signature, rawFunction);\n        }\n        return getWasmTableEntry(rawFunction);\n      }\n  \n      var fp = makeDynCaller();\n      if (typeof fp != \"function\") {\n          throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);\n      }\n      return fp;\n    };\n  \n  \n  \n  var extendError = (baseErrorType, errorName) => {\n      var errorClass = createNamedFunction(errorName, function(message) {\n        this.name = errorName;\n        this.message = message;\n  \n        var stack = (new Error(message)).stack;\n        if (stack !== undefined) {\n          this.stack = this.toString() + '\\n' +\n              stack.replace(/^Error(:[^\\n]*)?\\n/, '');\n        }\n      });\n      errorClass.prototype = Object.create(baseErrorType.prototype);\n      errorClass.prototype.constructor = errorClass;\n      errorClass.prototype.toString = function() {\n        if (this.message === undefined) {\n          return this.name;\n        } else {\n          return `${this.name}: ${this.message}`;\n        }\n      };\n  \n      return errorClass;\n    };\n  var UnboundTypeError;\n  \n  \n  \n  var getTypeName = (type) => {\n      var ptr = ___getTypeName(type);\n      var rv = readLatin1String(ptr);\n      _free(ptr);\n      return rv;\n    };\n  var throwUnboundTypeError = (message, types) => {\n      var unboundTypes = [];\n      var seen = {};\n      function visit(type) {\n        if (seen[type]) {\n          return;\n        }\n        if (registeredTypes[type]) {\n          return;\n        }\n        if (typeDependencies[type]) {\n          typeDependencies[type].forEach(visit);\n          return;\n        }\n        unboundTypes.push(type);\n        seen[type] = true;\n      }\n      types.forEach(visit);\n  \n      throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([', ']));\n    };\n  \n  \n  var getFunctionName = (signature) => {\n      signature = signature.trim();\n      const argsIndex = signature.indexOf(\"(\");\n      if (argsIndex !== -1) {\n        assert(signature[signature.length - 1] == \")\", \"Parentheses for argument names should match.\");\n        return signature.substr(0, argsIndex);\n      } else {\n        return signature;\n      }\n    };\n  var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) => {\n      var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);\n      name = readLatin1String(name);\n      name = getFunctionName(name);\n  \n      rawInvoker = embind__requireFunction(signature, rawInvoker);\n  \n      exposePublicSymbol(name, function() {\n        throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);\n      }, argCount - 1);\n  \n      whenDependentTypesAreResolved([], argTypes, function(argTypes) {\n        var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */);\n        replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1);\n        return [];\n      });\n    };\n\n  \n  var integerReadValueFromPointer = (name, width, signed) => {\n      // integers are quite common, so generate very specialized functions\n      switch (width) {\n          case 1: return signed ?\n              (pointer) => HEAP8[((pointer)>>0)] :\n              (pointer) => HEAPU8[((pointer)>>0)];\n          case 2: return signed ?\n              (pointer) => HEAP16[((pointer)>>1)] :\n              (pointer) => HEAPU16[((pointer)>>1)]\n          case 4: return signed ?\n              (pointer) => HEAP32[((pointer)>>2)] :\n              (pointer) => HEAPU32[((pointer)>>2)]\n          default:\n              throw new TypeError(`invalid integer width (${width}): ${name}`);\n      }\n    };\n  \n  \n  /** @suppress {globalThis} */\n  var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {\n      name = readLatin1String(name);\n      // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come\n      // out as 'i32 -1'. Always treat those as max u32.\n      if (maxRange === -1) {\n        maxRange = 4294967295;\n      }\n  \n      var fromWireType = (value) => value;\n  \n      if (minRange === 0) {\n        var bitshift = 32 - 8*size;\n        fromWireType = (value) => (value << bitshift) >>> bitshift;\n      }\n  \n      var isUnsignedType = (name.includes('unsigned'));\n      var checkAssertions = (value, toTypeName) => {\n        if (typeof value != \"number\" && typeof value != \"boolean\") {\n          throw new TypeError(`Cannot convert \"${embindRepr(value)}\" to ${toTypeName}`);\n        }\n        if (value < minRange || value > maxRange) {\n          throw new TypeError(`Passing a number \"${embindRepr(value)}\" from JS side to C/C++ side to an argument of type \"${name}\", which is outside the valid range [${minRange}, ${maxRange}]!`);\n        }\n      }\n      var toWireType;\n      if (isUnsignedType) {\n        toWireType = function(destructors, value) {\n          checkAssertions(value, this.name);\n          return value >>> 0;\n        }\n      } else {\n        toWireType = function(destructors, value) {\n          checkAssertions(value, this.name);\n          // The VM will perform JS to Wasm value conversion, according to the spec:\n          // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue\n          return value;\n        }\n      }\n      registerType(primitiveType, {\n        name,\n        'fromWireType': fromWireType,\n        'toWireType': toWireType,\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': integerReadValueFromPointer(name, size, minRange !== 0),\n        destructorFunction: null, // This type does not need a destructor\n      });\n    };\n\n  \n  var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {\n      var typeMapping = [\n        Int8Array,\n        Uint8Array,\n        Int16Array,\n        Uint16Array,\n        Int32Array,\n        Uint32Array,\n        Float32Array,\n        Float64Array,\n      ];\n  \n      var TA = typeMapping[dataTypeIndex];\n  \n      function decodeMemoryView(handle) {\n        var size = HEAPU32[((handle)>>2)];\n        var data = HEAPU32[(((handle)+(4))>>2)];\n        return new TA(HEAP8.buffer, data, size);\n      }\n  \n      name = readLatin1String(name);\n      registerType(rawType, {\n        name,\n        'fromWireType': decodeMemoryView,\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': decodeMemoryView,\n      }, {\n        ignoreDuplicateRegistrations: true,\n      });\n    };\n\n  \n  \n  /** @suppress {globalThis} */\n  function readPointer(pointer) {\n      return this['fromWireType'](HEAPU32[((pointer)>>2)]);\n    }\n  \n  \n  var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {\n      assert(typeof str === 'string', `stringToUTF8Array expects a string (got ${typeof str})`);\n      // Parameter maxBytesToWrite is not optional. Negative values, 0, null,\n      // undefined and false each don't write out any bytes.\n      if (!(maxBytesToWrite > 0))\n        return 0;\n  \n      var startIdx = outIdx;\n      var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.\n      for (var i = 0; i < str.length; ++i) {\n        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code\n        // unit, not a Unicode code point of the character! So decode\n        // UTF16->UTF32->UTF8.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description\n        // and https://www.ietf.org/rfc/rfc2279.txt\n        // and https://tools.ietf.org/html/rfc3629\n        var u = str.charCodeAt(i); // possibly a lead surrogate\n        if (u >= 0xD800 && u <= 0xDFFF) {\n          var u1 = str.charCodeAt(++i);\n          u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);\n        }\n        if (u <= 0x7F) {\n          if (outIdx >= endIdx) break;\n          heap[outIdx++] = u;\n        } else if (u <= 0x7FF) {\n          if (outIdx + 1 >= endIdx) break;\n          heap[outIdx++] = 0xC0 | (u >> 6);\n          heap[outIdx++] = 0x80 | (u & 63);\n        } else if (u <= 0xFFFF) {\n          if (outIdx + 2 >= endIdx) break;\n          heap[outIdx++] = 0xE0 | (u >> 12);\n          heap[outIdx++] = 0x80 | ((u >> 6) & 63);\n          heap[outIdx++] = 0x80 | (u & 63);\n        } else {\n          if (outIdx + 3 >= endIdx) break;\n          if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).');\n          heap[outIdx++] = 0xF0 | (u >> 18);\n          heap[outIdx++] = 0x80 | ((u >> 12) & 63);\n          heap[outIdx++] = 0x80 | ((u >> 6) & 63);\n          heap[outIdx++] = 0x80 | (u & 63);\n        }\n      }\n      // Null-terminate the pointer to the buffer.\n      heap[outIdx] = 0;\n      return outIdx - startIdx;\n    };\n  var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {\n      assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');\n      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);\n    };\n  \n  var lengthBytesUTF8 = (str) => {\n      var len = 0;\n      for (var i = 0; i < str.length; ++i) {\n        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code\n        // unit, not a Unicode code point of the character! So decode\n        // UTF16->UTF32->UTF8.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        var c = str.charCodeAt(i); // possibly a lead surrogate\n        if (c <= 0x7F) {\n          len++;\n        } else if (c <= 0x7FF) {\n          len += 2;\n        } else if (c >= 0xD800 && c <= 0xDFFF) {\n          len += 4; ++i;\n        } else {\n          len += 3;\n        }\n      }\n      return len;\n    };\n  \n  \n  \n  var __embind_register_std_string = (rawType, name) => {\n      name = readLatin1String(name);\n      var stdStringIsUTF8\n      //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string<unsigned char>\n      = (name === \"std::string\");\n  \n      registerType(rawType, {\n        name,\n        // For some method names we use string keys here since they are part of\n        // the public/external API and/or used by the runtime-generated code.\n        'fromWireType'(value) {\n          var length = HEAPU32[((value)>>2)];\n          var payload = value + 4;\n  \n          var str;\n          if (stdStringIsUTF8) {\n            var decodeStartPtr = payload;\n            // Looping here to support possible embedded '0' bytes\n            for (var i = 0; i <= length; ++i) {\n              var currentBytePtr = payload + i;\n              if (i == length || HEAPU8[currentBytePtr] == 0) {\n                var maxRead = currentBytePtr - decodeStartPtr;\n                var stringSegment = UTF8ToString(decodeStartPtr, maxRead);\n                if (str === undefined) {\n                  str = stringSegment;\n                } else {\n                  str += String.fromCharCode(0);\n                  str += stringSegment;\n                }\n                decodeStartPtr = currentBytePtr + 1;\n              }\n            }\n          } else {\n            var a = new Array(length);\n            for (var i = 0; i < length; ++i) {\n              a[i] = String.fromCharCode(HEAPU8[payload + i]);\n            }\n            str = a.join('');\n          }\n  \n          _free(value);\n  \n          return str;\n        },\n        'toWireType'(destructors, value) {\n          if (value instanceof ArrayBuffer) {\n            value = new Uint8Array(value);\n          }\n  \n          var length;\n          var valueIsOfTypeString = (typeof value == 'string');\n  \n          if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {\n            throwBindingError('Cannot pass non-string to std::string');\n          }\n          if (stdStringIsUTF8 && valueIsOfTypeString) {\n            length = lengthBytesUTF8(value);\n          } else {\n            length = value.length;\n          }\n  \n          // assumes 4-byte alignment\n          var base = _malloc(4 + length + 1);\n          var ptr = base + 4;\n          HEAPU32[((base)>>2)] = length;\n          if (stdStringIsUTF8 && valueIsOfTypeString) {\n            stringToUTF8(value, ptr, length + 1);\n          } else {\n            if (valueIsOfTypeString) {\n              for (var i = 0; i < length; ++i) {\n                var charCode = value.charCodeAt(i);\n                if (charCode > 255) {\n                  _free(ptr);\n                  throwBindingError('String has UTF-16 code units that do not fit in 8 bits');\n                }\n                HEAPU8[ptr + i] = charCode;\n              }\n            } else {\n              for (var i = 0; i < length; ++i) {\n                HEAPU8[ptr + i] = value[i];\n              }\n            }\n          }\n  \n          if (destructors !== null) {\n            destructors.push(_free, base);\n          }\n          return base;\n        },\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': readPointer,\n        destructorFunction(ptr) {\n          _free(ptr);\n        },\n      });\n    };\n\n  \n  \n  \n  var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;;\n  var UTF16ToString = (ptr, maxBytesToRead) => {\n      assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!');\n      var endPtr = ptr;\n      // TextDecoder needs to know the byte length in advance, it doesn't stop on\n      // null terminator by itself.\n      // Also, use the length info to avoid running tiny strings through\n      // TextDecoder, since .subarray() allocates garbage.\n      var idx = endPtr >> 1;\n      var maxIdx = idx + maxBytesToRead / 2;\n      // If maxBytesToRead is not passed explicitly, it will be undefined, and this\n      // will always evaluate to true. This saves on code size.\n      while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;\n      endPtr = idx << 1;\n  \n      if (endPtr - ptr > 32 && UTF16Decoder)\n        return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));\n  \n      // Fallback: decode without UTF16Decoder\n      var str = '';\n  \n      // If maxBytesToRead is not passed explicitly, it will be undefined, and the\n      // for-loop's condition will always evaluate to true. The loop is then\n      // terminated on the first null char.\n      for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {\n        var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];\n        if (codeUnit == 0) break;\n        // fromCharCode constructs a character from a UTF-16 code unit, so we can\n        // pass the UTF16 string right through.\n        str += String.fromCharCode(codeUnit);\n      }\n  \n      return str;\n    };\n  \n  var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {\n      assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!');\n      assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');\n      // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.\n      if (maxBytesToWrite === undefined) {\n        maxBytesToWrite = 0x7FFFFFFF;\n      }\n      if (maxBytesToWrite < 2) return 0;\n      maxBytesToWrite -= 2; // Null terminator.\n      var startPtr = outPtr;\n      var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length;\n      for (var i = 0; i < numCharsToWrite; ++i) {\n        // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.\n        var codeUnit = str.charCodeAt(i); // possibly a lead surrogate\n        HEAP16[((outPtr)>>1)] = codeUnit;\n        outPtr += 2;\n      }\n      // Null-terminate the pointer to the HEAP.\n      HEAP16[((outPtr)>>1)] = 0;\n      return outPtr - startPtr;\n    };\n  \n  var lengthBytesUTF16 = (str) => {\n      return str.length*2;\n    };\n  \n  var UTF32ToString = (ptr, maxBytesToRead) => {\n      assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!');\n      var i = 0;\n  \n      var str = '';\n      // If maxBytesToRead is not passed explicitly, it will be undefined, and this\n      // will always evaluate to true. This saves on code size.\n      while (!(i >= maxBytesToRead / 4)) {\n        var utf32 = HEAP32[(((ptr)+(i*4))>>2)];\n        if (utf32 == 0) break;\n        ++i;\n        // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        if (utf32 >= 0x10000) {\n          var ch = utf32 - 0x10000;\n          str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\n        } else {\n          str += String.fromCharCode(utf32);\n        }\n      }\n      return str;\n    };\n  \n  var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {\n      assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!');\n      assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');\n      // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.\n      if (maxBytesToWrite === undefined) {\n        maxBytesToWrite = 0x7FFFFFFF;\n      }\n      if (maxBytesToWrite < 4) return 0;\n      var startPtr = outPtr;\n      var endPtr = startPtr + maxBytesToWrite - 4;\n      for (var i = 0; i < str.length; ++i) {\n        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        var codeUnit = str.charCodeAt(i); // possibly a lead surrogate\n        if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {\n          var trailSurrogate = str.charCodeAt(++i);\n          codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);\n        }\n        HEAP32[((outPtr)>>2)] = codeUnit;\n        outPtr += 4;\n        if (outPtr + 4 > endPtr) break;\n      }\n      // Null-terminate the pointer to the HEAP.\n      HEAP32[((outPtr)>>2)] = 0;\n      return outPtr - startPtr;\n    };\n  \n  var lengthBytesUTF32 = (str) => {\n      var len = 0;\n      for (var i = 0; i < str.length; ++i) {\n        // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.\n        // See http://unicode.org/faq/utf_bom.html#utf16-3\n        var codeUnit = str.charCodeAt(i);\n        if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate.\n        len += 4;\n      }\n  \n      return len;\n    };\n  var __embind_register_std_wstring = (rawType, charSize, name) => {\n      name = readLatin1String(name);\n      var decodeString, encodeString, getHeap, lengthBytesUTF, shift;\n      if (charSize === 2) {\n        decodeString = UTF16ToString;\n        encodeString = stringToUTF16;\n        lengthBytesUTF = lengthBytesUTF16;\n        getHeap = () => HEAPU16;\n        shift = 1;\n      } else if (charSize === 4) {\n        decodeString = UTF32ToString;\n        encodeString = stringToUTF32;\n        lengthBytesUTF = lengthBytesUTF32;\n        getHeap = () => HEAPU32;\n        shift = 2;\n      }\n      registerType(rawType, {\n        name,\n        'fromWireType': (value) => {\n          // Code mostly taken from _embind_register_std_string fromWireType\n          var length = HEAPU32[((value)>>2)];\n          var HEAP = getHeap();\n          var str;\n  \n          var decodeStartPtr = value + 4;\n          // Looping here to support possible embedded '0' bytes\n          for (var i = 0; i <= length; ++i) {\n            var currentBytePtr = value + 4 + i * charSize;\n            if (i == length || HEAP[currentBytePtr >> shift] == 0) {\n              var maxReadBytes = currentBytePtr - decodeStartPtr;\n              var stringSegment = decodeString(decodeStartPtr, maxReadBytes);\n              if (str === undefined) {\n                str = stringSegment;\n              } else {\n                str += String.fromCharCode(0);\n                str += stringSegment;\n              }\n              decodeStartPtr = currentBytePtr + charSize;\n            }\n          }\n  \n          _free(value);\n  \n          return str;\n        },\n        'toWireType': (destructors, value) => {\n          if (!(typeof value == 'string')) {\n            throwBindingError(`Cannot pass non-string to C++ string type ${name}`);\n          }\n  \n          // assumes 4-byte alignment\n          var length = lengthBytesUTF(value);\n          var ptr = _malloc(4 + length + charSize);\n          HEAPU32[ptr >> 2] = length >> shift;\n  \n          encodeString(value, ptr + 4, length + charSize);\n  \n          if (destructors !== null) {\n            destructors.push(_free, ptr);\n          }\n          return ptr;\n        },\n        'argPackAdvance': GenericWireTypeSize,\n        'readValueFromPointer': simpleReadValueFromPointer,\n        destructorFunction(ptr) {\n          _free(ptr);\n        }\n      });\n    };\n\n  \n  var __embind_register_void = (rawType, name) => {\n      name = readLatin1String(name);\n      registerType(rawType, {\n        isVoid: true, // void return values can be optimized out sometimes\n        name,\n        'argPackAdvance': 0,\n        'fromWireType': () => undefined,\n        // TODO: assert if anything else is given?\n        'toWireType': (destructors, o) => undefined,\n      });\n    };\n\n  var nowIsMonotonic = 1;\n  var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;\n\n  \n  \n  \n  var requireRegisteredType = (rawType, humanName) => {\n      var impl = registeredTypes[rawType];\n      if (undefined === impl) {\n          throwBindingError(humanName + \" has unknown type \" + getTypeName(rawType));\n      }\n      return impl;\n    };\n  \n  var emval_returnValue = (returnType, destructorsRef, handle) => {\n      var destructors = [];\n      var result = returnType['toWireType'](destructors, handle);\n      if (destructors.length) {\n        // void, primitives and any other types w/o destructors don't need to allocate a handle\n        HEAPU32[((destructorsRef)>>2)] = Emval.toHandle(destructors);\n      }\n      return result;\n    };\n  var __emval_as = (handle, returnType, destructorsRef) => {\n      handle = Emval.toValue(handle);\n      returnType = requireRegisteredType(returnType, 'emval::as');\n      return emval_returnValue(returnType, destructorsRef, handle);\n    };\n\n  var emval_methodCallers = [];\n  \n  var __emval_call = (caller, handle, destructorsRef, args) => {\n      caller = emval_methodCallers[caller];\n      handle = Emval.toValue(handle);\n      return caller(null, handle, destructorsRef, args);\n    };\n\n  var emval_symbols = {\n  };\n  \n  var getStringOrSymbol = (address) => {\n      var symbol = emval_symbols[address];\n      if (symbol === undefined) {\n        return readLatin1String(address);\n      }\n      return symbol;\n    };\n  \n  \n  var __emval_call_method = (caller, objHandle, methodName, destructorsRef, args) => {\n      caller = emval_methodCallers[caller];\n      objHandle = Emval.toValue(objHandle);\n      methodName = getStringOrSymbol(methodName);\n      return caller(objHandle, objHandle[methodName], destructorsRef, args);\n    };\n\n\n  var emval_addMethodCaller = (caller) => {\n      var id = emval_methodCallers.length;\n      emval_methodCallers.push(caller);\n      return id;\n    };\n  \n  var emval_lookupTypes = (argCount, argTypes) => {\n      var a = new Array(argCount);\n      for (var i = 0; i < argCount; ++i) {\n        a[i] = requireRegisteredType(HEAPU32[(((argTypes)+(i * 4))>>2)],\n                                     \"parameter \" + i);\n      }\n      return a;\n    };\n  \n  \n  var reflectConstruct = Reflect.construct;\n  \n  \n  var __emval_get_method_caller = (argCount, argTypes, kind) => {\n      var types = emval_lookupTypes(argCount, argTypes);\n      var retType = types.shift();\n      argCount--; // remove the shifted off return type\n  \n      var functionBody =\n        `return function (obj, func, destructorsRef, args) {\\n`;\n  \n      var offset = 0;\n      var argsList = []; // 'obj?, arg0, arg1, arg2, ... , argN'\n      if (kind === /* FUNCTION */ 0) {\n        argsList.push(\"obj\");\n      }\n      var params = [\"retType\"];\n      var args = [retType];\n      for (var i = 0; i < argCount; ++i) {\n        argsList.push(\"arg\" + i);\n        params.push(\"argType\" + i);\n        args.push(types[i]);\n        functionBody +=\n          `  var arg${i} = argType${i}.readValueFromPointer(args${offset ? \"+\" + offset : \"\"});\\n`;\n        offset += types[i]['argPackAdvance'];\n      }\n      var invoker = kind === /* CONSTRUCTOR */ 1 ? 'new func' : 'func.call';\n      functionBody +=\n        `  var rv = ${invoker}(${argsList.join(\", \")});\\n`;\n      for (var i = 0; i < argCount; ++i) {\n        if (types[i]['deleteObject']) {\n          functionBody +=\n            `  argType${i}.deleteObject(arg${i});\\n`;\n        }\n      }\n      if (!retType.isVoid) {\n        params.push(\"emval_returnValue\");\n        args.push(emval_returnValue);\n        functionBody +=\n          \"  return emval_returnValue(retType, destructorsRef, rv);\\n\";\n      }\n      functionBody +=\n        \"};\\n\";\n  \n      params.push(functionBody);\n      var invokerFunction = newFunc(Function, params).apply(null, args);\n      var functionName = `methodCaller<(${types.map(t => t.name).join(', ')}) => ${retType.name}>`;\n      return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));\n    };\n\n  \n  var __emval_get_module_property = (name) => {\n      name = getStringOrSymbol(name);\n      return Emval.toHandle(Module[name]);\n    };\n\n  var __emval_get_property = (handle, key) => {\n      handle = Emval.toValue(handle);\n      key = Emval.toValue(key);\n      return Emval.toHandle(handle[key]);\n    };\n\n  var __emval_incref = (handle) => {\n      if (handle > 4) {\n        emval_handles.get(handle).refcount += 1;\n      }\n    };\n\n  var __emval_new_array = () => Emval.toHandle([]);\n\n  \n  var __emval_new_cstring = (v) => Emval.toHandle(getStringOrSymbol(v));\n\n  var __emval_new_object = () => Emval.toHandle({});\n\n  \n  \n  var __emval_run_destructors = (handle) => {\n      var destructors = Emval.toValue(handle);\n      runDestructors(destructors);\n      __emval_decref(handle);\n    };\n\n  var __emval_set_property = (handle, key, value) => {\n      handle = Emval.toValue(handle);\n      key = Emval.toValue(key);\n      value = Emval.toValue(value);\n      handle[key] = value;\n    };\n\n  \n  var __emval_take_value = (type, arg) => {\n      type = requireRegisteredType(type, '_emval_take_value');\n      var v = type['readValueFromPointer'](arg);\n      return Emval.toHandle(v);\n    };\n\n  var _abort = () => {\n      abort('native code called abort()');\n    };\n\n  var _emscripten_date_now = () => Date.now();\n\n  var _emscripten_get_now;\n      // Modern environment where performance.now() is supported:\n      // N.B. a shorter form \"_emscripten_get_now = performance.now;\" is\n      // unfortunately not allowed even in current browsers (e.g. FF Nightly 75).\n      _emscripten_get_now = () => performance.now();\n  ;\n\n  var _emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);\n\n  var getHeapMax = () =>\n      // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate\n      // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side\n      // for any code that deals with heap sizes, which would require special\n      // casing all heap size related code to treat 0 specially.\n      2147483648;\n  \n  var growMemory = (size) => {\n      var b = wasmMemory.buffer;\n      var pages = (size - b.byteLength + 65535) / 65536;\n      try {\n        // round size grow request up to wasm page size (fixed 64KB per spec)\n        wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size\n        updateMemoryViews();\n        return 1 /*success*/;\n      } catch(e) {\n        err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`);\n      }\n      // implicit 0 return to save code size (caller will cast \"undefined\" into 0\n      // anyhow)\n    };\n  var _emscripten_resize_heap = (requestedSize) => {\n      var oldSize = HEAPU8.length;\n      // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.\n      requestedSize >>>= 0;\n      // With multithreaded builds, races can happen (another thread might increase the size\n      // in between), so return a failure, and let the caller retry.\n      assert(requestedSize > oldSize);\n  \n      // Memory resize rules:\n      // 1.  Always increase heap size to at least the requested size, rounded up\n      //     to next page multiple.\n      // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap\n      //     geometrically: increase the heap size according to\n      //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most\n      //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).\n      // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap\n      //     linearly: increase the heap size by at least\n      //     MEMORY_GROWTH_LINEAR_STEP bytes.\n      // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by\n      //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest\n      // 4.  If we were unable to allocate as much memory, it may be due to\n      //     over-eager decision to excessively reserve due to (3) above.\n      //     Hence if an allocation fails, cut down on the amount of excess\n      //     growth, in an attempt to succeed to perform a smaller allocation.\n  \n      // A limit is set for how much we can grow. We should not exceed that\n      // (the wasm binary specifies it, so if we tried, we'd fail anyhow).\n      var maxHeapSize = getHeapMax();\n      if (requestedSize > maxHeapSize) {\n        err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);\n        return false;\n      }\n  \n      var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;\n  \n      // Loop through potential heap size increases. If we attempt a too eager\n      // reservation that fails, cut down on the attempted size and reserve a\n      // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)\n      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {\n        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth\n        // but limit overreserving (default to capping at +96MB overgrowth at most)\n        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );\n  \n        var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));\n  \n        var replacement = growMemory(newSize);\n        if (replacement) {\n  \n          return true;\n        }\n      }\n      err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);\n      return false;\n    };\n\n  var SYSCALLS = {\n  varargs:undefined,\n  get() {\n        assert(SYSCALLS.varargs != undefined);\n        // the `+` prepended here is necessary to convince the JSCompiler that varargs is indeed a number.\n        var ret = HEAP32[((+SYSCALLS.varargs)>>2)];\n        SYSCALLS.varargs += 4;\n        return ret;\n      },\n  getp() { return SYSCALLS.get() },\n  getStr(ptr) {\n        var ret = UTF8ToString(ptr);\n        return ret;\n      },\n  };\n  var _fd_close = (fd) => {\n      abort('fd_close called without SYSCALLS_REQUIRE_FILESYSTEM');\n    };\n\n  \n  var convertI32PairToI53Checked = (lo, hi) => {\n      assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32\n      assert(hi === (hi|0));                    // hi should be a i32\n      return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN;\n    };\n  function _fd_seek(fd,offset_low, offset_high,whence,newOffset) {\n    var offset = convertI32PairToI53Checked(offset_low, offset_high);;\n  \n    \n      return 70;\n    ;\n  }\n\n  var printCharBuffers = [null,[],[]];\n  \n  var printChar = (stream, curr) => {\n      var buffer = printCharBuffers[stream];\n      assert(buffer);\n      if (curr === 0 || curr === 10) {\n        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));\n        buffer.length = 0;\n      } else {\n        buffer.push(curr);\n      }\n    };\n  \n  var flush_NO_FILESYSTEM = () => {\n      // flush anything remaining in the buffers during shutdown\n      _fflush(0);\n      if (printCharBuffers[1].length) printChar(1, 10);\n      if (printCharBuffers[2].length) printChar(2, 10);\n    };\n  \n  \n  var _fd_write = (fd, iov, iovcnt, pnum) => {\n      // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0\n      var num = 0;\n      for (var i = 0; i < iovcnt; i++) {\n        var ptr = HEAPU32[((iov)>>2)];\n        var len = HEAPU32[(((iov)+(4))>>2)];\n        iov += 8;\n        for (var j = 0; j < len; j++) {\n          printChar(fd, HEAPU8[ptr+j]);\n        }\n        num += len;\n      }\n      HEAPU32[((pnum)>>2)] = num;\n      return 0;\n    };\n\nembind_init_charCodes();\nBindingError = Module['BindingError'] = class BindingError extends Error { constructor(message) { super(message); this.name = 'BindingError'; }};\nInternalError = Module['InternalError'] = class InternalError extends Error { constructor(message) { super(message); this.name = 'InternalError'; }};\nhandleAllocatorInit();\ninit_emval();;\nUnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');;\nfunction checkIncomingModuleAPI() {\n  ignoredModuleProp('fetchSettings');\n}\nvar wasmImports = {\n  /** @export */\n  __assert_fail: ___assert_fail,\n  /** @export */\n  __cxa_begin_catch: ___cxa_begin_catch,\n  /** @export */\n  __cxa_find_matching_catch_2: ___cxa_find_matching_catch_2,\n  /** @export */\n  __cxa_find_matching_catch_3: ___cxa_find_matching_catch_3,\n  /** @export */\n  __cxa_throw: ___cxa_throw,\n  /** @export */\n  __resumeException: ___resumeException,\n  /** @export */\n  _embind_register_bigint: __embind_register_bigint,\n  /** @export */\n  _embind_register_bool: __embind_register_bool,\n  /** @export */\n  _embind_register_emval: __embind_register_emval,\n  /** @export */\n  _embind_register_float: __embind_register_float,\n  /** @export */\n  _embind_register_function: __embind_register_function,\n  /** @export */\n  _embind_register_integer: __embind_register_integer,\n  /** @export */\n  _embind_register_memory_view: __embind_register_memory_view,\n  /** @export */\n  _embind_register_std_string: __embind_register_std_string,\n  /** @export */\n  _embind_register_std_wstring: __embind_register_std_wstring,\n  /** @export */\n  _embind_register_void: __embind_register_void,\n  /** @export */\n  _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,\n  /** @export */\n  _emval_as: __emval_as,\n  /** @export */\n  _emval_call: __emval_call,\n  /** @export */\n  _emval_call_method: __emval_call_method,\n  /** @export */\n  _emval_decref: __emval_decref,\n  /** @export */\n  _emval_get_method_caller: __emval_get_method_caller,\n  /** @export */\n  _emval_get_module_property: __emval_get_module_property,\n  /** @export */\n  _emval_get_property: __emval_get_property,\n  /** @export */\n  _emval_incref: __emval_incref,\n  /** @export */\n  _emval_new_array: __emval_new_array,\n  /** @export */\n  _emval_new_cstring: __emval_new_cstring,\n  /** @export */\n  _emval_new_object: __emval_new_object,\n  /** @export */\n  _emval_run_destructors: __emval_run_destructors,\n  /** @export */\n  _emval_set_property: __emval_set_property,\n  /** @export */\n  _emval_take_value: __emval_take_value,\n  /** @export */\n  abort: _abort,\n  /** @export */\n  emscripten_date_now: _emscripten_date_now,\n  /** @export */\n  emscripten_get_now: _emscripten_get_now,\n  /** @export */\n  emscripten_memcpy_js: _emscripten_memcpy_js,\n  /** @export */\n  emscripten_resize_heap: _emscripten_resize_heap,\n  /** @export */\n  fd_close: _fd_close,\n  /** @export */\n  fd_seek: _fd_seek,\n  /** @export */\n  fd_write: _fd_write,\n  /** @export */\n  invoke_ii: invoke_ii,\n  /** @export */\n  invoke_iii: invoke_iii,\n  /** @export */\n  invoke_iiii: invoke_iiii,\n  /** @export */\n  invoke_j: invoke_j,\n  /** @export */\n  invoke_v: invoke_v,\n  /** @export */\n  invoke_vi: invoke_vi,\n  /** @export */\n  invoke_vii: invoke_vii,\n  /** @export */\n  invoke_viii: invoke_viii,\n  /** @export */\n  invoke_viiii: invoke_viiii\n};\nvar wasmExports = createWasm();\nvar ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors');\nvar ___getTypeName = createExportWrapper('__getTypeName');\nvar ___errno_location = createExportWrapper('__errno_location');\nvar _fflush = Module['_fflush'] = createExportWrapper('fflush');\nvar _malloc = createExportWrapper('malloc');\nvar _free = Module['_free'] = createExportWrapper('free');\nvar _setThrew = createExportWrapper('setThrew');\nvar setTempRet0 = createExportWrapper('setTempRet0');\nvar _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports['emscripten_stack_init'])();\nvar _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])();\nvar _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])();\nvar _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])();\nvar stackSave = createExportWrapper('stackSave');\nvar stackRestore = createExportWrapper('stackRestore');\nvar stackAlloc = createExportWrapper('stackAlloc');\nvar _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'])();\nvar ___cxa_free_exception = createExportWrapper('__cxa_free_exception');\nvar ___cxa_increment_exception_refcount = createExportWrapper('__cxa_increment_exception_refcount');\nvar ___cxa_decrement_exception_refcount = createExportWrapper('__cxa_decrement_exception_refcount');\nvar ___get_exception_message = Module['___get_exception_message'] = createExportWrapper('__get_exception_message');\nvar ___cxa_can_catch = createExportWrapper('__cxa_can_catch');\nvar ___cxa_is_pointer_type = createExportWrapper('__cxa_is_pointer_type');\nvar dynCall_j = Module['dynCall_j'] = createExportWrapper('dynCall_j');\nvar dynCall_jiji = Module['dynCall_jiji'] = createExportWrapper('dynCall_jiji');\n\nfunction invoke_iiii(index,a1,a2,a3) {\n  var sp = stackSave();\n  try {\n    return getWasmTableEntry(index)(a1,a2,a3);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_iii(index,a1,a2) {\n  var sp = stackSave();\n  try {\n    return getWasmTableEntry(index)(a1,a2);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_ii(index,a1) {\n  var sp = stackSave();\n  try {\n    return getWasmTableEntry(index)(a1);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_v(index) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)();\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_vi(index,a1) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)(a1);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_viii(index,a1,a2,a3) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)(a1,a2,a3);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_viiii(index,a1,a2,a3,a4) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)(a1,a2,a3,a4);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_vii(index,a1,a2) {\n  var sp = stackSave();\n  try {\n    getWasmTableEntry(index)(a1,a2);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\nfunction invoke_j(index) {\n  var sp = stackSave();\n  try {\n    return dynCall_j(index);\n  } catch(e) {\n    stackRestore(sp);\n    if (!(e instanceof EmscriptenEH)) throw e;\n    _setThrew(1, 0);\n  }\n}\n\n\n// include: postamble.js\n// === Auto-generated postamble setup entry stuff ===\n\nvar missingLibrarySymbols = [\n  'writeI53ToI64',\n  'writeI53ToI64Clamped',\n  'writeI53ToI64Signaling',\n  'writeI53ToU64Clamped',\n  'writeI53ToU64Signaling',\n  'readI53FromI64',\n  'readI53FromU64',\n  'convertI32PairToI53',\n  'convertU32PairToI53',\n  'zeroMemory',\n  'exitJS',\n  'isLeapYear',\n  'ydayFromDate',\n  'arraySum',\n  'addDays',\n  'setErrNo',\n  'inetPton4',\n  'inetNtop4',\n  'inetPton6',\n  'inetNtop6',\n  'readSockaddr',\n  'writeSockaddr',\n  'getHostByName',\n  'initRandomFill',\n  'randomFill',\n  'getCallstack',\n  'emscriptenLog',\n  'convertPCtoSourceLocation',\n  'readEmAsmArgs',\n  'jstoi_q',\n  'jstoi_s',\n  'getExecutableName',\n  'listenOnce',\n  'autoResumeAudioContext',\n  'handleException',\n  'keepRuntimeAlive',\n  'runtimeKeepalivePush',\n  'runtimeKeepalivePop',\n  'callUserCallback',\n  'maybeExit',\n  'asmjsMangle',\n  'asyncLoad',\n  'alignMemory',\n  'mmapAlloc',\n  'getNativeTypeSize',\n  'STACK_SIZE',\n  'STACK_ALIGN',\n  'POINTER_SIZE',\n  'ASSERTIONS',\n  'getCFunc',\n  'ccall',\n  'cwrap',\n  'uleb128Encode',\n  'sigToWasmTypes',\n  'generateFuncType',\n  'convertJsFunctionToWasm',\n  'getEmptyTableSlot',\n  'updateTableMap',\n  'getFunctionAddress',\n  'addFunction',\n  'removeFunction',\n  'reallyNegative',\n  'unSign',\n  'strLen',\n  'reSign',\n  'formatString',\n  'intArrayFromString',\n  'intArrayToString',\n  'AsciiToString',\n  'stringToAscii',\n  'stringToNewUTF8',\n  'stringToUTF8OnStack',\n  'writeArrayToMemory',\n  'registerKeyEventCallback',\n  'maybeCStringToJsString',\n  'findEventTarget',\n  'findCanvasEventTarget',\n  'getBoundingClientRect',\n  'fillMouseEventData',\n  'registerMouseEventCallback',\n  'registerWheelEventCallback',\n  'registerUiEventCallback',\n  'registerFocusEventCallback',\n  'fillDeviceOrientationEventData',\n  'registerDeviceOrientationEventCallback',\n  'fillDeviceMotionEventData',\n  'registerDeviceMotionEventCallback',\n  'screenOrientation',\n  'fillOrientationChangeEventData',\n  'registerOrientationChangeEventCallback',\n  'fillFullscreenChangeEventData',\n  'registerFullscreenChangeEventCallback',\n  'JSEvents_requestFullscreen',\n  'JSEvents_resizeCanvasForFullscreen',\n  'registerRestoreOldStyle',\n  'hideEverythingExceptGivenElement',\n  'restoreHiddenElements',\n  'setLetterbox',\n  'softFullscreenResizeWebGLRenderTarget',\n  'doRequestFullscreen',\n  'fillPointerlockChangeEventData',\n  'registerPointerlockChangeEventCallback',\n  'registerPointerlockErrorEventCallback',\n  'requestPointerLock',\n  'fillVisibilityChangeEventData',\n  'registerVisibilityChangeEventCallback',\n  'registerTouchEventCallback',\n  'fillGamepadEventData',\n  'registerGamepadEventCallback',\n  'registerBeforeUnloadEventCallback',\n  'fillBatteryEventData',\n  'battery',\n  'registerBatteryEventCallback',\n  'setCanvasElementSize',\n  'getCanvasElementSize',\n  'demangle',\n  'demangleAll',\n  'jsStackTrace',\n  'stackTrace',\n  'getEnvStrings',\n  'checkWasiClock',\n  'wasiRightsToMuslOFlags',\n  'wasiOFlagsToMuslOFlags',\n  'createDyncallWrapper',\n  'safeSetTimeout',\n  'setImmediateWrapped',\n  'clearImmediateWrapped',\n  'polyfillSetImmediate',\n  'getPromise',\n  'makePromise',\n  'idsToPromises',\n  'makePromiseCallback',\n  'setMainLoop',\n  'getSocketFromFD',\n  'getSocketAddress',\n  'FS_createPreloadedFile',\n  'FS_modeStringToFlags',\n  'FS_getMode',\n  'FS_stdin_getChar',\n  'FS_createDataFile',\n  'FS_unlink',\n  'FS_mkdirTree',\n  '_setNetworkCallback',\n  'heapObjectForWebGLType',\n  'heapAccessShiftForWebGLHeap',\n  'webgl_enable_ANGLE_instanced_arrays',\n  'webgl_enable_OES_vertex_array_object',\n  'webgl_enable_WEBGL_draw_buffers',\n  'webgl_enable_WEBGL_multi_draw',\n  'emscriptenWebGLGet',\n  'computeUnpackAlignedImageSize',\n  'colorChannelsInGlTextureFormat',\n  'emscriptenWebGLGetTexPixelData',\n  '__glGenObject',\n  'emscriptenWebGLGetUniform',\n  'webglGetUniformLocation',\n  'webglPrepareUniformLocationsBeforeFirstUse',\n  'webglGetLeftBracePos',\n  'emscriptenWebGLGetVertexAttrib',\n  '__glGetActiveAttribOrUniform',\n  'writeGLArray',\n  'registerWebGlEventCallback',\n  'runAndAbortIfError',\n  'SDL_unicode',\n  'SDL_ttfContext',\n  'SDL_audio',\n  'ALLOC_NORMAL',\n  'ALLOC_STACK',\n  'allocate',\n  'writeStringToMemory',\n  'writeAsciiToMemory',\n  'getFunctionArgsName',\n  'init_embind',\n  'getBasestPointer',\n  'registerInheritedInstance',\n  'unregisterInheritedInstance',\n  'getInheritedInstance',\n  'getInheritedInstanceCount',\n  'getLiveInheritedInstances',\n  'enumReadValueFromPointer',\n  'genericPointerToWireType',\n  'constNoSmartPtrRawPointerToWireType',\n  'nonConstNoSmartPtrRawPointerToWireType',\n  'init_RegisteredPointer',\n  'RegisteredPointer',\n  'RegisteredPointer_fromWireType',\n  'runDestructor',\n  'releaseClassHandle',\n  'detachFinalizer',\n  'attachFinalizer',\n  'makeClassHandle',\n  'init_ClassHandle',\n  'ClassHandle',\n  'throwInstanceAlreadyDeleted',\n  'flushPendingDeletes',\n  'setDelayFunction',\n  'RegisteredClass',\n  'shallowCopyInternalPointer',\n  'downcastPointer',\n  'upcastPointer',\n  'validateThis',\n  'char_0',\n  'char_9',\n  'makeLegalFunctionName',\n  'emval_get_global',\n];\nmissingLibrarySymbols.forEach(missingLibrarySymbol)\n\nvar unexportedSymbols = [\n  'run',\n  'addOnPreRun',\n  'addOnInit',\n  'addOnPreMain',\n  'addOnExit',\n  'addOnPostRun',\n  'addRunDependency',\n  'removeRunDependency',\n  'FS_createFolder',\n  'FS_createPath',\n  'FS_createLazyFile',\n  'FS_createLink',\n  'FS_createDevice',\n  'FS_readFile',\n  'out',\n  'err',\n  'callMain',\n  'abort',\n  'wasmMemory',\n  'wasmExports',\n  'stackAlloc',\n  'stackSave',\n  'stackRestore',\n  'getTempRet0',\n  'setTempRet0',\n  'writeStackCookie',\n  'checkStackCookie',\n  'convertI32PairToI53Checked',\n  'ptrToString',\n  'getHeapMax',\n  'growMemory',\n  'ENV',\n  'MONTH_DAYS_REGULAR',\n  'MONTH_DAYS_LEAP',\n  'MONTH_DAYS_REGULAR_CUMULATIVE',\n  'MONTH_DAYS_LEAP_CUMULATIVE',\n  'ERRNO_CODES',\n  'ERRNO_MESSAGES',\n  'DNS',\n  'Protocols',\n  'Sockets',\n  'timers',\n  'warnOnce',\n  'UNWIND_CACHE',\n  'readEmAsmArgsArray',\n  'dynCallLegacy',\n  'getDynCaller',\n  'dynCall',\n  'handleAllocatorInit',\n  'HandleAllocator',\n  'wasmTable',\n  'noExitRuntime',\n  'freeTableIndexes',\n  'functionsInTableMap',\n  'setValue',\n  'getValue',\n  'PATH',\n  'PATH_FS',\n  'UTF8Decoder',\n  'UTF8ArrayToString',\n  'UTF8ToString',\n  'stringToUTF8Array',\n  'stringToUTF8',\n  'lengthBytesUTF8',\n  'UTF16Decoder',\n  'UTF16ToString',\n  'stringToUTF16',\n  'lengthBytesUTF16',\n  'UTF32ToString',\n  'stringToUTF32',\n  'lengthBytesUTF32',\n  'JSEvents',\n  'specialHTMLTargets',\n  'currentFullscreenStrategy',\n  'restoreOldWindowedStyle',\n  'ExitStatus',\n  'flush_NO_FILESYSTEM',\n  'promiseMap',\n  'uncaughtExceptionCount',\n  'exceptionLast',\n  'exceptionCaught',\n  'ExceptionInfo',\n  'findMatchingCatch',\n  'getExceptionMessageCommon',\n  'incrementExceptionRefcount',\n  'decrementExceptionRefcount',\n  'getExceptionMessage',\n  'Browser',\n  'wget',\n  'SYSCALLS',\n  'preloadPlugins',\n  'FS_stdin_getChar_buffer',\n  'FS',\n  'MEMFS',\n  'TTY',\n  'PIPEFS',\n  'SOCKFS',\n  'tempFixedLengthArray',\n  'miniTempWebGLFloatBuffers',\n  'miniTempWebGLIntBuffers',\n  'GL',\n  'emscripten_webgl_power_preferences',\n  'AL',\n  'GLUT',\n  'EGL',\n  'GLEW',\n  'IDBStore',\n  'SDL',\n  'SDL_gfx',\n  'allocateUTF8',\n  'allocateUTF8OnStack',\n  'InternalError',\n  'BindingError',\n  'throwInternalError',\n  'throwBindingError',\n  'registeredTypes',\n  'awaitingDependencies',\n  'typeDependencies',\n  'tupleRegistrations',\n  'structRegistrations',\n  'sharedRegisterType',\n  'whenDependentTypesAreResolved',\n  'embind_charCodes',\n  'embind_init_charCodes',\n  'readLatin1String',\n  'getTypeName',\n  'getFunctionName',\n  'heap32VectorToArray',\n  'requireRegisteredType',\n  'UnboundTypeError',\n  'PureVirtualError',\n  'GenericWireTypeSize',\n  'throwUnboundTypeError',\n  'ensureOverloadTable',\n  'exposePublicSymbol',\n  'replacePublicSymbol',\n  'extendError',\n  'createNamedFunction',\n  'embindRepr',\n  'registeredInstances',\n  'registeredPointers',\n  'registerType',\n  'integerReadValueFromPointer',\n  'floatReadValueFromPointer',\n  'simpleReadValueFromPointer',\n  'readPointer',\n  'runDestructors',\n  'newFunc',\n  'craftInvokerFunction',\n  'embind__requireFunction',\n  'finalizationRegistry',\n  'detachFinalizer_deps',\n  'deletionQueue',\n  'delayFunction',\n  'emval_handles',\n  'emval_symbols',\n  'init_emval',\n  'count_emval_handles',\n  'getStringOrSymbol',\n  'Emval',\n  'emval_returnValue',\n  'emval_lookupTypes',\n  'emval_methodCallers',\n  'emval_addMethodCaller',\n  'reflectConstruct',\n];\nunexportedSymbols.forEach(unexportedRuntimeSymbol);\n\n\n\nvar calledRun;\n\ndependenciesFulfilled = function runCaller() {\n  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)\n  if (!calledRun) run();\n  if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled\n};\n\nfunction stackCheckInit() {\n  // This is normally called automatically during __wasm_call_ctors but need to\n  // get these values before even running any of the ctors so we call it redundantly\n  // here.\n  _emscripten_stack_init();\n  // TODO(sbc): Move writeStackCookie to native to to avoid this.\n  writeStackCookie();\n}\n\nfunction run() {\n\n  if (runDependencies > 0) {\n    return;\n  }\n\n    stackCheckInit();\n\n  preRun();\n\n  // a preRun added a dependency, run will be called later\n  if (runDependencies > 0) {\n    return;\n  }\n\n  function doRun() {\n    // run may have just been called through dependencies being fulfilled just in this very frame,\n    // or while the async setStatus time below was happening\n    if (calledRun) return;\n    calledRun = true;\n    Module['calledRun'] = true;\n\n    if (ABORT) return;\n\n    initRuntime();\n\n    readyPromiseResolve(Module);\n    if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();\n\n    assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module[\"onRuntimeInitialized\"]');\n\n    postRun();\n  }\n\n  if (Module['setStatus']) {\n    Module['setStatus']('Running...');\n    setTimeout(function() {\n      setTimeout(function() {\n        Module['setStatus']('');\n      }, 1);\n      doRun();\n    }, 1);\n  } else\n  {\n    doRun();\n  }\n  checkStackCookie();\n}\n\nfunction checkUnflushedContent() {\n  // Compiler settings do not allow exiting the runtime, so flushing\n  // the streams is not possible. but in ASSERTIONS mode we check\n  // if there was something to flush, and if so tell the user they\n  // should request that the runtime be exitable.\n  // Normally we would not even include flush() at all, but in ASSERTIONS\n  // builds we do so just for this check, and here we see if there is any\n  // content to flush, that is, we check if there would have been\n  // something a non-ASSERTIONS build would have not seen.\n  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0\n  // mode (which has its own special function for this; otherwise, all\n  // the code is inside libc)\n  var oldOut = out;\n  var oldErr = err;\n  var has = false;\n  out = err = (x) => {\n    has = true;\n  }\n  try { // it doesn't matter if it fails\n    flush_NO_FILESYSTEM();\n  } catch(e) {}\n  out = oldOut;\n  err = oldErr;\n  if (has) {\n    warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.');\n    warnOnce('(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)');\n  }\n}\n\nif (Module['preInit']) {\n  if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];\n  while (Module['preInit'].length > 0) {\n    Module['preInit'].pop()();\n  }\n}\n\nrun();\n\n\n// end include: postamble.js\n\n\n  return moduleArg.ready\n}\n);\n})();\n;\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = Module;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => Module);\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \".autumnplot-gl.js\";\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript)\n\t\tscriptUrl = document.currentScript.src\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) scriptUrl = scripts[scripts.length - 1].src\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","__webpack_require__.b = document.baseURI || self.location.href;\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t179: 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// no jsonp function","/**\r\n * Copyright 2019 Google Inc. All Rights Reserved.\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *     http://www.apache.org/licenses/LICENSE-2.0\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\nconst proxyMarker = Symbol(\"Comlink.proxy\");\r\nconst createEndpoint = Symbol(\"Comlink.endpoint\");\r\nconst releaseProxy = Symbol(\"Comlink.releaseProxy\");\r\nconst throwMarker = Symbol(\"Comlink.thrown\");\r\nconst isObject = (val) => (typeof val === \"object\" && val !== null) || typeof val === \"function\";\r\n/**\r\n * Internal transfer handle to handle objects marked to proxy.\r\n */\r\nconst proxyTransferHandler = {\r\n    canHandle: (val) => isObject(val) && val[proxyMarker],\r\n    serialize(obj) {\r\n        const { port1, port2 } = new MessageChannel();\r\n        expose(obj, port1);\r\n        return [port2, [port2]];\r\n    },\r\n    deserialize(port) {\r\n        port.start();\r\n        return wrap(port);\r\n    },\r\n};\r\n/**\r\n * Internal transfer handler to handle thrown exceptions.\r\n */\r\nconst throwTransferHandler = {\r\n    canHandle: (value) => isObject(value) && throwMarker in value,\r\n    serialize({ value }) {\r\n        let serialized;\r\n        if (value instanceof Error) {\r\n            serialized = {\r\n                isError: true,\r\n                value: {\r\n                    message: value.message,\r\n                    name: value.name,\r\n                    stack: value.stack,\r\n                },\r\n            };\r\n        }\r\n        else {\r\n            serialized = { isError: false, value };\r\n        }\r\n        return [serialized, []];\r\n    },\r\n    deserialize(serialized) {\r\n        if (serialized.isError) {\r\n            throw Object.assign(new Error(serialized.value.message), serialized.value);\r\n        }\r\n        throw serialized.value;\r\n    },\r\n};\r\n/**\r\n * Allows customizing the serialization of certain values.\r\n */\r\nconst transferHandlers = new Map([\r\n    [\"proxy\", proxyTransferHandler],\r\n    [\"throw\", throwTransferHandler],\r\n]);\r\nfunction expose(obj, ep = self) {\r\n    ep.addEventListener(\"message\", function callback(ev) {\r\n        if (!ev || !ev.data) {\r\n            return;\r\n        }\r\n        const { id, type, path } = Object.assign({ path: [] }, ev.data);\r\n        const argumentList = (ev.data.argumentList || []).map(fromWireValue);\r\n        let returnValue;\r\n        try {\r\n            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);\r\n            const rawValue = path.reduce((obj, prop) => obj[prop], obj);\r\n            switch (type) {\r\n                case \"GET\" /* GET */:\r\n                    {\r\n                        returnValue = rawValue;\r\n                    }\r\n                    break;\r\n                case \"SET\" /* SET */:\r\n                    {\r\n                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);\r\n                        returnValue = true;\r\n                    }\r\n                    break;\r\n                case \"APPLY\" /* APPLY */:\r\n                    {\r\n                        returnValue = rawValue.apply(parent, argumentList);\r\n                    }\r\n                    break;\r\n                case \"CONSTRUCT\" /* CONSTRUCT */:\r\n                    {\r\n                        const value = new rawValue(...argumentList);\r\n                        returnValue = proxy(value);\r\n                    }\r\n                    break;\r\n                case \"ENDPOINT\" /* ENDPOINT */:\r\n                    {\r\n                        const { port1, port2 } = new MessageChannel();\r\n                        expose(obj, port2);\r\n                        returnValue = transfer(port1, [port1]);\r\n                    }\r\n                    break;\r\n                case \"RELEASE\" /* RELEASE */:\r\n                    {\r\n                        returnValue = undefined;\r\n                    }\r\n                    break;\r\n                default:\r\n                    return;\r\n            }\r\n        }\r\n        catch (value) {\r\n            returnValue = { value, [throwMarker]: 0 };\r\n        }\r\n        Promise.resolve(returnValue)\r\n            .catch((value) => {\r\n            return { value, [throwMarker]: 0 };\r\n        })\r\n            .then((returnValue) => {\r\n            const [wireValue, transferables] = toWireValue(returnValue);\r\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\r\n            if (type === \"RELEASE\" /* RELEASE */) {\r\n                // detach and deactive after sending release response above.\r\n                ep.removeEventListener(\"message\", callback);\r\n                closeEndPoint(ep);\r\n            }\r\n        });\r\n    });\r\n    if (ep.start) {\r\n        ep.start();\r\n    }\r\n}\r\nfunction isMessagePort(endpoint) {\r\n    return endpoint.constructor.name === \"MessagePort\";\r\n}\r\nfunction closeEndPoint(endpoint) {\r\n    if (isMessagePort(endpoint))\r\n        endpoint.close();\r\n}\r\nfunction wrap(ep, target) {\r\n    return createProxy(ep, [], target);\r\n}\r\nfunction throwIfProxyReleased(isReleased) {\r\n    if (isReleased) {\r\n        throw new Error(\"Proxy has been released and is not useable\");\r\n    }\r\n}\r\nfunction createProxy(ep, path = [], target = function () { }) {\r\n    let isProxyReleased = false;\r\n    const proxy = new Proxy(target, {\r\n        get(_target, prop) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            if (prop === releaseProxy) {\r\n                return () => {\r\n                    return requestResponseMessage(ep, {\r\n                        type: \"RELEASE\" /* RELEASE */,\r\n                        path: path.map((p) => p.toString()),\r\n                    }).then(() => {\r\n                        closeEndPoint(ep);\r\n                        isProxyReleased = true;\r\n                    });\r\n                };\r\n            }\r\n            if (prop === \"then\") {\r\n                if (path.length === 0) {\r\n                    return { then: () => proxy };\r\n                }\r\n                const r = requestResponseMessage(ep, {\r\n                    type: \"GET\" /* GET */,\r\n                    path: path.map((p) => p.toString()),\r\n                }).then(fromWireValue);\r\n                return r.then.bind(r);\r\n            }\r\n            return createProxy(ep, [...path, prop]);\r\n        },\r\n        set(_target, prop, rawValue) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a\r\n            // boolean. To show good will, we return true asynchronously ¯\\_(ツ)_/¯\r\n            const [value, transferables] = toWireValue(rawValue);\r\n            return requestResponseMessage(ep, {\r\n                type: \"SET\" /* SET */,\r\n                path: [...path, prop].map((p) => p.toString()),\r\n                value,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n        apply(_target, _thisArg, rawArgumentList) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            const last = path[path.length - 1];\r\n            if (last === createEndpoint) {\r\n                return requestResponseMessage(ep, {\r\n                    type: \"ENDPOINT\" /* ENDPOINT */,\r\n                }).then(fromWireValue);\r\n            }\r\n            // We just pretend that `bind()` didn’t happen.\r\n            if (last === \"bind\") {\r\n                return createProxy(ep, path.slice(0, -1));\r\n            }\r\n            const [argumentList, transferables] = processArguments(rawArgumentList);\r\n            return requestResponseMessage(ep, {\r\n                type: \"APPLY\" /* APPLY */,\r\n                path: path.map((p) => p.toString()),\r\n                argumentList,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n        construct(_target, rawArgumentList) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            const [argumentList, transferables] = processArguments(rawArgumentList);\r\n            return requestResponseMessage(ep, {\r\n                type: \"CONSTRUCT\" /* CONSTRUCT */,\r\n                path: path.map((p) => p.toString()),\r\n                argumentList,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n    });\r\n    return proxy;\r\n}\r\nfunction myFlat(arr) {\r\n    return Array.prototype.concat.apply([], arr);\r\n}\r\nfunction processArguments(argumentList) {\r\n    const processed = argumentList.map(toWireValue);\r\n    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];\r\n}\r\nconst transferCache = new WeakMap();\r\nfunction transfer(obj, transfers) {\r\n    transferCache.set(obj, transfers);\r\n    return obj;\r\n}\r\nfunction proxy(obj) {\r\n    return Object.assign(obj, { [proxyMarker]: true });\r\n}\r\nfunction windowEndpoint(w, context = self, targetOrigin = \"*\") {\r\n    return {\r\n        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),\r\n        addEventListener: context.addEventListener.bind(context),\r\n        removeEventListener: context.removeEventListener.bind(context),\r\n    };\r\n}\r\nfunction toWireValue(value) {\r\n    for (const [name, handler] of transferHandlers) {\r\n        if (handler.canHandle(value)) {\r\n            const [serializedValue, transferables] = handler.serialize(value);\r\n            return [\r\n                {\r\n                    type: \"HANDLER\" /* HANDLER */,\r\n                    name,\r\n                    value: serializedValue,\r\n                },\r\n                transferables,\r\n            ];\r\n        }\r\n    }\r\n    return [\r\n        {\r\n            type: \"RAW\" /* RAW */,\r\n            value,\r\n        },\r\n        transferCache.get(value) || [],\r\n    ];\r\n}\r\nfunction fromWireValue(value) {\r\n    switch (value.type) {\r\n        case \"HANDLER\" /* HANDLER */:\r\n            return transferHandlers.get(value.name).deserialize(value.value);\r\n        case \"RAW\" /* RAW */:\r\n            return value.value;\r\n    }\r\n}\r\nfunction requestResponseMessage(ep, msg, transfers) {\r\n    return new Promise((resolve) => {\r\n        const id = generateUUID();\r\n        ep.addEventListener(\"message\", function l(ev) {\r\n            if (!ev.data || !ev.data.id || ev.data.id !== id) {\r\n                return;\r\n            }\r\n            ep.removeEventListener(\"message\", l);\r\n            resolve(ev.data);\r\n        });\r\n        if (ep.start) {\r\n            ep.start();\r\n        }\r\n        ep.postMessage(Object.assign({ id }, msg), transfers);\r\n    });\r\n}\r\nfunction generateUUID() {\r\n    return new Array(4)\r\n        .fill(0)\r\n        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))\r\n        .join(\"-\");\r\n}\n\nexport { createEndpoint, expose, proxy, proxyMarker, releaseProxy, transfer, transferHandlers, windowEndpoint, wrap };\n//# sourceMappingURL=comlink.mjs.map\n","\nfunction getMinZoom(jlat: number, ilon: number, thin_fac_base: number) {\n    const zoom_base = 1;\n\n    let zoom = zoom_base;\n    let thin_fac = thin_fac_base;\n\n    while (((jlat % thin_fac) != 0) || ((ilon % thin_fac) != 0)) {\n        zoom += 1;\n        thin_fac /= 2;\n    }\n\n    return zoom;\n}\n\nfunction* zip(...args: any[]) {\n\tconst iterators = args.map(x => x[Symbol.iterator]());\n\twhile (true) {\n\t\tconst current = iterators.map(x => x.next());\n\t\tif (current.some(x => x.done)) {\n\t\t\tbreak;\n\t\t}\n\t\tyield current.map(x => x.value);\n\t}\n}\n\nfunction getOS() {\n    const userAgent = window.navigator.userAgent,\n        platform = window.navigator.platform,\n        macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'],\n        windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'],\n        iosPlatforms = ['iPhone', 'iPad', 'iPod'];\n    let os = null;\n\n    if (macosPlatforms.indexOf(platform) !== -1 && navigator.maxTouchPoints <= 1) {\n        os = 'Mac OS';\n    } \n    else if (iosPlatforms.indexOf(platform) !== -1 || (macosPlatforms.indexOf(platform) !== -1 && navigator.maxTouchPoints > 1)) { \n        os = 'iOS';\n    } \n    else if (windowsPlatforms.indexOf(platform) !== -1) {\n        os = 'Windows';\n    } \n    else if (/Android/.test(userAgent)) {\n        os = 'Android';\n    } \n    else if (/Linux/.test(platform)) {\n        os = 'Linux';\n    }\n\n    return os;\n}\n\nclass Cache<A extends unknown[], R> {\n    private cached_values: Record<string, R>;\n    private readonly compute_value: (...args: A) => R;\n    private readonly make_key: (...args: A) => string;\n\n    constructor(compute_value: (...args: A) => R, make_key?: (...args: A) => string) {\n        this.cached_values = {};\n        this.compute_value = compute_value;\n        this.make_key = make_key === undefined ? (...args: A) => JSON.stringify(args) : make_key;\n    }\n\n    public getValue(...args: A) {\n        const key = this.make_key(...args);\n\n        if (!(key in this.cached_values)) {\n            this.cached_values[key] = this.compute_value(...args);\n        }\n\n        return this.cached_values[key];\n    }\n}\n\n\nfunction normalizeOptions<Type extends Record<string, any>>(opts: Type | undefined, defaults: Required<Type>) {\n    const ret = {...defaults} as Required<Type>;\n\n    if (opts !== undefined) {\n        Object.entries(opts).forEach(([k, v]: [keyof Type, any]) => {\n            ret[k] = v;\n        });\n    }\n\n    return ret;\n}\n\nexport {zip, getMinZoom, getOS, Cache, normalizeOptions};\n","\nimport { Float16Array } from \"@petamoriken/float16\";\n\ninterface WindProfile {\n    lat: number;\n    lon: number;\n    jlat: number;\n    ilon: number;\n    smu: number;\n    smv: number;\n    u: Float32Array;\n    v: Float32Array;\n    z: Float32Array\n}\n\ninterface BillboardSpec {\n    BB_WIDTH: number;\n    BB_HEIGHT: number;\n    BB_TEX_WIDTH: number;\n    BB_TEX_HEIGHT: number;\n    BB_MAG_BIN_SIZE: number;\n    BB_MAG_WRAP: number;\n    BB_MAG_MAX: number;\n}\n\ntype LineData = {\n    vertices: [number, number][];\n    offsets?: [number, number][];\n    data?: number[];\n    zoom?: number;\n}\n\ntype Polyline = {\n    extrusion: Float32Array;\n    vertices: Float32Array;\n    offsets?: Float32Array;\n    data?: Float32Array;\n    zoom?: Float32Array;\n};\n\ntype WebGLAnyRenderingContext = WebGLRenderingContext | WebGL2RenderingContext;\n\nfunction isWebGL2Ctx(gl: WebGLAnyRenderingContext) : gl is WebGL2RenderingContext {\n    return gl.getParameter(gl.VERSION).includes('WebGL 2.0');\n}\n\ntype TypedArray = Float16Array | Float32Array;\n\ntype ContourData = Record<number, [number, number][][]>;\n\nexport {isWebGL2Ctx};\nexport type {WindProfile, BillboardSpec, Polyline, LineData, WebGLAnyRenderingContext, TypedArray, ContourData};","\nimport * as Comlink from 'comlink';\n\nimport { getOS } from \"./utils\";\nimport { PlotLayerWorker } from './PlotLayer.worker';\nimport { MapLikeType } from './Map';\nimport { WebGLAnyRenderingContext, isWebGL2Ctx } from './AutumnTypes';\n\nconst worker = new Worker(new URL('./PlotLayer.worker', import.meta.url));\nconst layer_worker = Comlink.wrap<PlotLayerWorker>(worker);\n\nabstract class PlotComponent<MapType extends MapLikeType> {\n    public abstract onAdd(map: MapType, gl: WebGLAnyRenderingContext) : Promise<void>;\n    public abstract render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) : void;\n}\n\nfunction getGLFormatTypeAlignment(gl: WebGLAnyRenderingContext, is_float16: boolean) {\n    let format, type, row_alignment;\n    const is_webgl2 = isWebGL2Ctx(gl);\n\n    if (is_float16) {\n        const ext = gl.getExtension('OES_texture_half_float');\n        const ext_lin = gl.getExtension('OES_texture_half_float_linear');\n\n        if (is_webgl2) {\n            format = gl.R16F;\n            type = gl.HALF_FLOAT;\n        }\n        else {\n            if (ext === null || ext_lin === null)\n                throw \"Float16 data are not supported on this hardware. Try Float32 data instead.\";\n\n            format = gl.LUMINANCE;\n            type = ext.HALF_FLOAT_OES;\n        }\n\n        row_alignment = 2;\n    }\n    else {\n        const ext = gl.getExtension('OES_texture_float');\n        const ext_lin = gl.getExtension('OES_texture_float_linear');\n\n\t\t// As of 11/3/2023, Safari/WebKit on iOS reports as supporting float textures,\n\t\t// but really doesn't. It just silently fails. In WebGL 1, Safari/Webkit returns\n\t\t// null for ext_lin here, but in WebGL2, both ext vars are null because they were \n\t\t// merged into the standard. This means that to properly fail for iOS devices using\n\t\t// WebGL2, we have to hard code an OS check... this OS check also works when uers\n\t\t// request desktop-mode websites.\n\t\tif ((!is_webgl2 && ext === null) || (!is_webgl2 && ext_lin === null) || (getOS() === 'iOS')) {\t\n            throw \"Float32 data are not supported on this hardware. Try Float16 data instead.\";\n        }\n\n        format = is_webgl2 ? gl.R32F : gl.LUMINANCE;\n        type = gl.FLOAT;\n        row_alignment = 4;\n    }\n\n    return {format: format, type: type, row_alignment: row_alignment};\n}\n\nexport { PlotComponent, layer_worker, getGLFormatTypeAlignment };\n","\n\n// Stub in required method and property types for the mapping library. God help me if these start to diverge between Mapbox and MapLibre.\ntype StyleSpecification = {\n    glyphs?: string;\n}\n\ntype MapLikeType = {\n    triggerRepaint: () => void;\n    getCanvas: () => HTMLCanvasElement;\n    getStyle: () => StyleSpecification;\n\n    getZoom: () => number;\n    getMaxZoom: () => number;\n    getBearing: () => number;\n    getPitch: () => number;\n};\n\ninterface LambertConformalConicParameters {\n    lon_0: number,\n    lat_0: number,\n    lat_std: [number, number] | number;\n}\n\nfunction lambertConformalConic(params: LambertConformalConicParameters) {\n    // Formulas from https://pubs.usgs.gov/pp/1395/report.pdf\n\n    const compute_t = (lat: number) => {\n        const sin_lat = Math.sin(lat);\n        return Math.tan(Math.PI / 4 - lat / 2) * Math.pow((1 + eccen * sin_lat) / (1 - eccen * sin_lat), eccen / 2);\n    };\n    const compute_m = (lat: number) => {\n        const sin_lat = Math.sin(lat);\n        return Math.cos(lat) / Math.sqrt(1 - eccen * eccen * sin_lat * sin_lat);\n    }\n\n    // WGS 84 spheroid\n    const semimajor = 6378137.0;\n    const semiminor = 6356752.314245;\n    const eccen = Math.sqrt(1 - (semiminor * semiminor) / (semimajor * semimajor));\n    const radians = Math.PI / 180;\n\n    let {lon_0, lat_0, lat_std} = params;\n    lat_std = Array.isArray(lat_std) && lat_std[0] == lat_std[1] ? lat_std[0] : lat_std;\n\n    lon_0 *= radians;\n    lat_0 *= radians;\n\n    let F: number, n: number;\n    const t_0 = compute_t(lat_0);\n\n    if (Array.isArray(lat_std)) {\n        let [lat_1, lat_2] = lat_std;\n        lat_1 *= radians;\n        lat_2 *= radians;\n\n        const t_1 = compute_t(lat_1);\n        const t_2 = compute_t(lat_2);\n        const m_1 = compute_m(lat_1);\n        const m_2 = compute_m(lat_2);\n\n        n = Math.log(m_1 / m_2) / Math.log(t_1 / t_2);\n        F = m_1 / (n * Math.pow(t_1, n));\n    }\n    else {\n        let lat_1 = lat_std;\n        lat_1 *= radians;\n\n        const t_1 = compute_t(lat_1);\n        const m_1 = compute_m(lat_1);\n        n = Math.sin(lat_1);\n        F = m_1 / (n * Math.pow(t_1, n));\n    }\n\n    const rho_0 = semimajor * F * Math.pow(t_0, n);\n\n    const compute_lcc = (lon: number, lat: number) : [number, number] => {\n        lon *= radians;\n        lat *= radians;\n\n        const t = compute_t(lat);\n        const rho = semimajor * F * Math.pow(t, n);\n        const theta = n * (lon - lon_0);\n        const x = rho * Math.sin(theta);\n        const y = rho_0 - rho * Math.cos(theta);\n\n        return [x, y];\n    }\n\n    const eccen2 = eccen * eccen;\n    const eccen4 = eccen2 * eccen2;\n    const eccen6 = eccen4 * eccen2;\n    const eccen8 = eccen6 * eccen2;\n\n/*\n    const A = eccen2 / 2 + 5 * eccen4 / 24 + eccen6 / 12 + 13 * eccen8 / 360;\n    const B = 7 * eccen4 / 48 + 29 * eccen6 / 240 + 811 * eccen8 / 11520;\n    const C = 7 * eccen6 / 120 + 81 * eccen8 / 1120;\n    const D = 4279 * eccen8 / 161280;\n    const Ap = A - C;\n    const Bp = 2 * B - 4 * D;\n    const Cp = 4 * C;\n    const Dp = 8 * D;\n*/\n\n    const Ap = eccen2 / 2 + 5 * eccen4 / 24 + 3 * eccen6 / 120 - 73 * eccen8 / 2016;\n    const Bp = 7 * eccen4 / 24 + 29 * eccen6 / 120 + 233 * eccen8 / 6720;\n    const Cp = 7 * eccen6 / 30 + 81 * eccen8 / 280;\n    const Dp = 4729 * eccen8 / 20160;\n\n    const compute_lcc_inverse = (x: number, y: number) : [number, number] => {\n        const theta = Math.atan2(x, rho_0 - y); // These arguments are backwards from what I'd expect ...\n        const lon = theta / n + lon_0;\n        const rho = Math.hypot(x, rho_0 - y) * Math.sign(n);\n        const t = Math.pow(rho / (semimajor * F), 1 / n);\n\n        const chi = Math.PI / 2 - 2 * Math.atan(t);\n        const sin_2chi = Math.sin(2 * chi);\n        const cos_2chi = Math.cos(2 * chi);\n\n        const lat = chi + sin_2chi * (Ap + cos_2chi * (Bp + cos_2chi * (Cp + Dp * cos_2chi)));\n\n        return [lon / radians, lat / radians];\n    }\n\n    return (a: number, b: number, opts?: {inverse: boolean}) : [number, number] => {\n        opts = opts === undefined ? {inverse: false} : opts;\n        return opts.inverse ? compute_lcc_inverse(a, b) : compute_lcc(a, b);\n    }\n}\n\ninterface RotateSphereParams {\n    np_lon: number,\n    np_lat: number,\n    lon_shift: number,\n}\n\nfunction rotateSphere(params: RotateSphereParams) {\n    const radians = Math.PI / 180;\n    const np_lat = params.np_lat * radians;\n    const np_lon = params.np_lon * radians;\n    const lon_shift = params.lon_shift * radians;\n\n    const sin_np_lat = Math.sin(np_lat);\n    const cos_np_lat = Math.cos(np_lat);\n\n    const compute_rotation = (lon: number, lat: number) : [number, number] => {\n        lon *= radians;\n        lat *= radians;\n\n        const sin_lat = Math.sin(lat);\n        const cos_lat = Math.cos(lat);\n        const sin_lon_diff = Math.sin(lon - lon_shift);\n        const cos_lon_diff = Math.cos(lon - lon_shift);\n\n        const lat_p = Math.asin(sin_np_lat * sin_lat - cos_np_lat * cos_lat * cos_lon_diff);\n        let lon_p = np_lon + Math.atan2((cos_lat * sin_lon_diff), (sin_np_lat * cos_lat * cos_lon_diff + cos_np_lat * sin_lat));\n\n        if (lon_p > Math.PI) lon_p -= 2 * Math.PI;\n\n        return [lon_p / radians, lat_p / radians];\n    }\n\n    const compute_rotation_inverse = (lon_p: number, lat_p: number) : [number, number] => {\n        lon_p *= radians;\n        lat_p *= radians;\n\n        const sin_lat_p = Math.sin(lat_p);\n        const cos_lat_p = Math.cos(lat_p);\n        const sin_lon_p_diff = Math.sin(lon_p - np_lon);\n        const cos_lon_p_diff = Math.cos(lon_p - np_lon);\n\n        const lat = Math.asin(sin_np_lat * sin_lat_p + cos_np_lat * cos_lat_p * cos_lon_p_diff);\n        let lon = lon_shift + Math.atan2((cos_lat_p * sin_lon_p_diff), (sin_np_lat * cos_lat_p * cos_lon_p_diff - cos_np_lat * sin_lat_p));\n\n        if (lon_p > Math.PI) lon_p -= 2 * Math.PI;\n\n        return [lon / radians, lat / radians];\n    }\n\n    return (a: number, b: number, opts?: {inverse: boolean}) => {\n        opts = opts === undefined ? {inverse: false} : opts;\n        return opts.inverse ? compute_rotation_inverse(a, b) : compute_rotation(a, b);\n    }\n}\n\nfunction mercatorXfromLng(lng: number) {\n    return (180 + lng) / 360;\n}\n\nfunction lngFromMercatorX(x: number) {\n    return 360 * x - 180;\n}\n\nfunction mercatorYfromLat(lat: number) {\n    const sin_lat = Math.sin(lat * Math.PI / 180);\n    const y = (180 - (90 / Math.PI * Math.log((1 + sin_lat) / (1 - sin_lat)))) / 360;\n    return Math.min(2, Math.max(-2, y));\n}\n\nfunction latFromMercatorY(y: number) {\n    return Math.atan(Math.sinh((180 - y * 360) * Math.PI / 180)) * 180 / Math.PI;\n}\n\n/**\n * A `LngLat` object represents a given longitude and latitude coordinate, measured in degrees.\n * These coordinates are based on the [WGS84 (EPSG:4326) standard](https://en.wikipedia.org/wiki/World_Geodetic_System#WGS84).\n *\n * MapLibre GL uses longitude, latitude coordinate order (as opposed to latitude, longitude) to match the\n * [GeoJSON specification](https://tools.ietf.org/html/rfc7946).\n *\n * @param {number} lng Longitude, measured in degrees.\n * @param {number} lat Latitude, measured in degrees.\n * @example\n * var ll = new LngLat(-123.9749, 40.7736);\n * ll.lng; // = -123.9749\n */\n class LngLat {\n    public lng: number;\n    public lat: number;\n\n    constructor(lng: number, lat: number) {\n        if (isNaN(lng) || isNaN(lat)) {\n            throw new Error(`Invalid LngLat object: (${lng}, ${lat})`);\n        }\n        this.lng = +lng;\n        this.lat = +lat;\n        if (this.lat > 90 || this.lat < -90) {\n            throw new Error('Invalid LngLat latitude value: must be between -90 and 90');\n        }\n    }\n\n    public toMercatorCoord() {\n        return {x: mercatorXfromLng(this.lng), y: mercatorYfromLat(this.lat)};\n    }\n\n    public static fromMercatorCoord(x: number, y: number) {\n        return new LngLat(lngFromMercatorX(x), latFromMercatorY(y));\n    }\n}\n\nexport {LngLat, lambertConformalConic, rotateSphere};\nexport type {MapLikeType};","/**\n * @module wgl/WebGLBuffer\n * Module containing a helper class for WebGL data buffers\n */\nconst getGLDtype = (gl, ary) => {\n    const DTYPES = {\n        'Float32Array': gl.FLOAT,\n        'Uint8Array': gl.UNSIGNED_BYTE,\n        'Uint16Array': gl.UNSIGNED_SHORT,\n        'Uint32Array': gl.UNSIGNED_INT,\n    };\n    return DTYPES[ary.constructor.name];\n};\nclass WGLBufferBase {\n    constructor(gl, verts, n_coords_per_vert, draw_mode, bind_target) {\n        this.gl = gl;\n        this.n_coords_per_vert = n_coords_per_vert;\n        this.dtype = getGLDtype(gl, verts);\n        this.n_verts = verts.length / n_coords_per_vert;\n        this.draw_mode = draw_mode;\n        const buffer = gl.createBuffer();\n        if (buffer === null) {\n            throw \"Could not create WebGL buffer\";\n        }\n        this.buffer = buffer;\n        gl.bindBuffer(bind_target, this.buffer);\n        gl.bufferData(bind_target, verts, gl.STATIC_DRAW);\n    }\n}\n/** A class representing a WebGL data buffer */\nclass WGLBuffer extends WGLBufferBase {\n    /**\n     * Create a WebGL buffer and put some data in it\n     * @param gl                 - The WebGL rendering context\n     * @param verts              - The vertex data to use for this buffer\n     * @param n_coords_per_vert  - The number of coordinates for each vertex in the data buffer\n     * @param draw_mode          - The draw mode to use for this buffer. Should be one of gl.TRIANGLE_STRIP, etc.\n     */\n    constructor(gl, verts, n_coords_per_vert, draw_mode) {\n        super(gl, verts, n_coords_per_vert, draw_mode, gl.ARRAY_BUFFER);\n    }\n    /**\n     * Bind this buffer to a location in a shader program\n     * @internal\n     * @param prog_attr_location - The location of the variable in the shader program (returned from gl.getAttribLocation())\n     */\n    bindToProgram(prog_attr_location) {\n        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.buffer);\n        this.gl.enableVertexAttribArray(prog_attr_location);\n        this.gl.vertexAttribPointer(prog_attr_location, this.n_coords_per_vert, this.dtype, false, 0, 0);\n    }\n}\n/** A class representing a WebGL data buffer for array indices */\nclass WGLIndexBuffer extends WGLBufferBase {\n    /**\n     *\n     * @param gl         - The WebGL rendering context\n     * @param indices    - The index data\n     * @param draw_mode  - The draw mode to use for this buffer. Should be one of gl.TRIANGLE_STRIP, etc.\n     */\n    constructor(gl, indices, draw_mode) {\n        super(gl, indices, 1, draw_mode, gl.ELEMENT_ARRAY_BUFFER);\n    }\n    /**\n     * Bind this buffer to the ELEMENT_ARRAY_BUFFER target\n     * @internal\n     */\n    bind() {\n        this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, this.buffer);\n    }\n}\nexport { WGLBuffer, WGLIndexBuffer };\n","function isWebGL2Ctx(gl) {\n    return gl.getParameter(gl.VERSION).includes('WebGL 2.0');\n}\nexport { isWebGL2Ctx };\n","/**\n * @module wgl/WebGLTexture\n * A module containing a helper class for WebGL textures\n */\nimport { isWebGL2Ctx } from \"./utils\";\nfunction getWebGL2Format(gl, internal_format, data_type) {\n    switch (data_type) {\n        case (gl.UNSIGNED_BYTE):\n            switch (internal_format) {\n                case (gl.RGBA8): return gl.RGBA;\n                case (gl.RGB5_A1): return gl.RGBA;\n                case (gl.RGBA4): return gl.RGBA;\n                case (gl.SRGB8_ALPHA8): return gl.RGBA;\n                case (gl.RGBA8UI): return gl.RGBA_INTEGER;\n                case (gl.RGB8): return gl.RGB;\n                case (gl.RGB565): return gl.RGB;\n                case (gl.SRGB8): return gl.RGB;\n                case (gl.RGB8UI): return gl.RGB_INTEGER;\n                case (gl.RG8): return gl.RG;\n                case (gl.RG8UI): return gl.RG_INTEGER;\n                case (gl.R8): return gl.RED;\n                case (gl.R8UI): return gl.RED_INTEGER;\n                case (gl.RGBA): return gl.RGBA;\n                case (gl.RGB): return gl.RGB;\n                case (gl.LUMINANCE_ALPHA): return gl.LUMINANCE_ALPHA;\n                case (gl.LUMINANCE): return gl.LUMINANCE;\n                case (gl.ALPHA): return gl.ALPHA;\n            }\n            break;\n        case (gl.BYTE):\n            switch (internal_format) {\n                case (gl.RGBA8_SNORM): return gl.RGBA;\n                case (gl.RGBA8I): return gl.RGBA_INTEGER;\n                case (gl.RGB8_SNORM): return gl.RGB;\n                case (gl.RGB8I): return gl.RGB_INTEGER;\n                case (gl.RG8_SNORM): return gl.RG;\n                case (gl.RG8I): return gl.RG_INTEGER;\n                case (gl.R8_SNORM): return gl.RED;\n                case (gl.R8I): return gl.RED_INTEGER;\n            }\n            break;\n        case (gl.UNSIGNED_SHORT_4_4_4_4):\n            switch (internal_format) {\n                case (gl.RGBA4): return gl.RGBA;\n                case (gl.RGBA): return gl.RGBA;\n            }\n            break;\n        case (gl.UNSIGNED_SHORT_5_5_5_1):\n            switch (internal_format) {\n                case (gl.RGB5_A1): return gl.RGBA;\n                case (gl.RGBA): return gl.RGBA;\n            }\n            break;\n        case (gl.UNSIGNED_INT_2_10_10_10_REV):\n            switch (internal_format) {\n                case (gl.RGB10_A2): return gl.RGBA;\n                case (gl.RGB5_A1): return gl.RGBA;\n                case (gl.RGB10_A2UI): return gl.RGBA_INTEGER;\n            }\n            break;\n        case (gl.HALF_FLOAT):\n            switch (internal_format) {\n                case (gl.RGBA16F): return gl.RGBA;\n                case (gl.RGB16F): return gl.RGB;\n                case (gl.R11F_G11F_B10F): return gl.RGB;\n                case (gl.RGB9_E5): return gl.RGB;\n                case (gl.RG16F): return gl.RG;\n                case (gl.R16F): return gl.RED;\n            }\n            break;\n        case (gl.FLOAT):\n            switch (internal_format) {\n                case (gl.RGBA32F): return gl.RGBA;\n                case (gl.RGBA16F): return gl.RGBA;\n                case (gl.RGB32F): return gl.RGB;\n                case (gl.RGB16F): return gl.RGB;\n                case (gl.R11F_G11F_B10F): return gl.RGB;\n                case (gl.RGB9_E5): return gl.RGB;\n                case (gl.RG32F): return gl.RG;\n                case (gl.RG16F): return gl.RG;\n                case (gl.R32F): return gl.RED;\n                case (gl.R16F): return gl.RED;\n                case (gl.DEPTH_COMPONENT32F): return gl.DEPTH_COMPONENT;\n            }\n            break;\n        case (gl.UNSIGNED_SHORT):\n            switch (internal_format) {\n                case (gl.RGBA16UI): return gl.RGBA_INTEGER;\n                case (gl.RGB16UI): return gl.RGB_INTEGER;\n                case (gl.RG16UI): return gl.RG_INTEGER;\n                case (gl.R16UI): return gl.RED_INTEGER;\n                case (gl.DEPTH_COMPONENT16): return gl.DEPTH_COMPONENT;\n            }\n            break;\n        case (gl.SHORT):\n            switch (internal_format) {\n                case (gl.RGBA16I): return gl.RGBA_INTEGER;\n                case (gl.RGB16I): return gl.RGB_INTEGER;\n                case (gl.RG16I): return gl.RG_INTEGER;\n                case (gl.R16I): return gl.RED_INTEGER;\n            }\n            break;\n        case (gl.UNSIGNED_INT):\n            switch (internal_format) {\n                case (gl.RGBA32UI): return gl.RGBA_INTEGER;\n                case (gl.RGB32UI): return gl.RGB_INTEGER;\n                case (gl.RG32UI): return gl.RG_INTEGER;\n                case (gl.R32UI): return gl.RED_INTEGER;\n                case (gl.DEPTH_COMPONENT24): return gl.DEPTH_COMPONENT;\n                case (gl.DEPTH_COMPONENT16): return gl.DEPTH_COMPONENT;\n            }\n            break;\n        case (gl.INT):\n            switch (internal_format) {\n                case (gl.RGBA32I): return gl.RGBA_INTEGER;\n                case (gl.RGB32I): return gl.RGB_INTEGER;\n                case (gl.RG32I): return gl.RG_INTEGER;\n                case (gl.R32I): return gl.RED_INTEGER;\n            }\n            break;\n        case (gl.UNSIGNED_SHORT_5_6_5):\n            switch (internal_format) {\n                case (gl.RGB565): return gl.RGB;\n                case (gl.RGB): return gl.RGB;\n            }\n            break;\n        case (gl.UNSIGNED_INT_10F_11F_11F_REV):\n            switch (internal_format) {\n                case (gl.R11F_G11F_B10F): return gl.RGB;\n            }\n            break;\n        case (gl.UNSIGNED_INT_5_9_9_9_REV):\n            switch (internal_format) {\n                case (gl.RGB9_E5): return gl.RGB;\n            }\n            break;\n        case (gl.UNSIGNED_INT_24_8):\n            switch (internal_format) {\n                case (gl.DEPTH24_STENCIL8): return gl.DEPTH_STENCIL;\n            }\n            break;\n        case (gl.FLOAT_32_UNSIGNED_INT_24_8_REV):\n            switch (internal_format) {\n                case (gl.DEPTH32F_STENCIL8): return gl.DEPTH_STENCIL;\n            }\n            break;\n        default:\n            throw `Unknown format in getWebGL2InternalFormat`;\n    }\n    throw `Invalid combination of internal format and data type`;\n}\n/** Class representing a WebGL texture */\nclass WGLTexture {\n    /**\n     *\n     * @param gl               - The WebGL rendering context\n     * @param image            - The specification for the image\n     * @param image.format     - The format for the image (e.g., which color channels are present?). Should be one of gl.RGBA, gl.RGB, etc.\n     * @param image.type       - The data type for the image. Should be one of gl.FLOAT, gl.UNSIGNED_BYTE, etc.\n     * @param image.width      - The width of the texture\n     * @param image.height     - The height of the texture\n     * @param image.mag_filter - The magnification filter to use for the texture. Should be one of gl.LINEAR, gl.NEAREST, etc.\n     * @param image.image      - The image to use for the texture. Can be null to allocate space without filling it.\n     */\n    constructor(gl, image) {\n        this.gl = gl;\n        const texture = gl.createTexture();\n        if (texture === null) {\n            throw \"Could not create WebGL texture\";\n        }\n        this.texture = texture;\n        this.tex_num = null;\n        this.setImageData(image);\n        const mag_filter = image['mag_filter'] === undefined ? gl.LINEAR : image['mag_filter'];\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, mag_filter);\n    }\n    /**\n     * Set image data in this texture\n     * @param image        - The specification for the image\n     * @param image.format - The format for the image (e.g., which color channels are present?). Should be one of gl.RGBA, gl.RGB, etc.\n     * @param image.type   - The data type for the image. Should be one of gl.FLOAT, gl.UNSIGNED_BYTE, etc.\n     * @param image.width  - The width of the texture\n     * @param image.height - The height of the texture\n     * @param image.image  - The image to use for the texture. Can be null to allocate space without filling it.\n     */\n    setImageData(image) {\n        const gl = this.gl;\n        gl.bindTexture(gl.TEXTURE_2D, this.texture);\n        const format = isWebGL2Ctx(gl) ? getWebGL2Format(gl, image['format'], image['type']) : image['format'];\n        const row_alignment = image['row_alignment'] === undefined ? 4 : image['row_alignment'];\n        gl.pixelStorei(gl.UNPACK_ALIGNMENT, row_alignment);\n        if (image['width'] !== undefined && image['height'] !== undefined) {\n            gl.texImage2D(gl.TEXTURE_2D, 0, image['format'], image['width'], image['height'], 0, format, image['type'], image['image']);\n        }\n        else {\n            gl.texImage2D(gl.TEXTURE_2D, 0, image['format'], format, image['type'], image['image']);\n        }\n    }\n    /**\n     * Bind this texture to a location in a shader program\n     * @internal\n     * @param prog_uni_location - The location of the sampler uniform value (returned from gl.getUniform()) in the shader program.\n     * @param gl_tex_num        - The texture number to bind this texture to.\n     */\n    bindToProgram(prog_uni_location, gl_tex_num) {\n        this.activate(gl_tex_num);\n        this.gl.uniform1i(prog_uni_location, gl_tex_num);\n    }\n    /**\n     * Bind this texture to a given texture number\n     * @param gl_tex_num - The texture number to bind this texture to.\n     */\n    activate(gl_tex_num) {\n        this.tex_num = gl_tex_num;\n        this.gl.activeTexture(this.gl.TEXTURE0 + this.tex_num);\n        this.gl.bindTexture(this.gl.TEXTURE_2D, this.texture);\n    }\n    /**\n     * Unbind this texture from the texture number it was most recently bound to.\n     */\n    deactivate() {\n        if (this.tex_num === null) {\n            return;\n        }\n        this.gl.activeTexture(this.gl.TEXTURE0 + this.tex_num);\n        this.gl.bindTexture(this.gl.TEXTURE_2D, null);\n        this.tex_num = null;\n    }\n    /**\n     * Delete this texture.\n     */\n    delete() {\n        this.gl.deleteTexture(this.texture);\n        this.tex_num = null;\n    }\n}\nexport { WGLTexture };\n","import { isWebGL2Ctx } from \"./utils\";\n/**\n * @module wgl/WebGLProgram\n * Module containing a helper class for WebGL programs\n */\nfunction preprocessShader(shader_src, opts) {\n    opts = opts === undefined ? {} : opts;\n    const defines = opts.define === undefined ? [] : [...opts.define];\n    const current_defines = [];\n    const define_truth = {};\n    const processed_shader_src = shader_src.split(\"\\n\").map(line => {\n        const match_define = line.match(/#define\\s+([\\w\\d_]+)/i);\n        if (match_define !== null) {\n            defines.push(match_define[1]);\n        }\n        const match_ifdef = line.match(/#ifdef\\s+([\\w\\d_]+)/i);\n        if (match_ifdef !== null) {\n            current_defines.push(match_ifdef[1]);\n            define_truth[match_ifdef[1]] = true;\n            return \"\";\n        }\n        const match_ifndef = line.match(/#ifndef\\s+([\\w\\d_]+)/i);\n        if (match_ifndef !== null) {\n            current_defines.push(match_ifndef[1]);\n            define_truth[match_ifndef[1]] = false;\n            return \"\";\n        }\n        const match_else = line.match(/#else/i);\n        if (match_else !== null) {\n            const def = current_defines[current_defines.length - 1];\n            define_truth[def] = !define_truth[def];\n            return \"\";\n        }\n        const match_endif = line.match(/#endif/i);\n        if (match_endif !== null) {\n            const def = current_defines.pop();\n            define_truth[def] = undefined;\n            return \"\";\n        }\n        const keep_line = current_defines.map(def => defines.includes(def) == define_truth[def]).reduce((a, b) => a && b, true);\n        return keep_line ? line : \"\";\n    }).join(\"\\n\");\n    if (current_defines.length > 0) {\n        throw `Unterminated #ifdef/#ifndef block in shader`;\n    }\n    return processed_shader_src;\n}\n/**\n * Compile and link a shader program\n * @param gl                - The WebGL rendering context\n * @param vertex_shader_src - The source code for the vertex shader\n * @param frag_shader_src   - The source code for the fragment shader\n * @returns                   A compiled and linked WebGL program\n */\nconst compileAndLinkShaders = (gl, vertex_shader_src, frag_shader_src) => {\n    // create a vertex shader\n    const vertexShader = gl.createShader(gl.VERTEX_SHADER);\n    if (vertexShader === null) {\n        throw \"Could not create vertex shader\";\n    }\n    gl.shaderSource(vertexShader, vertex_shader_src);\n    gl.compileShader(vertexShader);\n    const vertexCompiled = gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS);\n    if (!vertexCompiled) {\n        const compilationLog = gl.getShaderInfoLog(vertexShader);\n        console.log('Vertex shader compiler log: ' + compilationLog);\n    }\n    // create a fragment shader\n    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);\n    if (fragmentShader === null) {\n        throw \"Could not create fragment shader\";\n    }\n    gl.shaderSource(fragmentShader, frag_shader_src);\n    gl.compileShader(fragmentShader);\n    const fragmentCompiled = gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS);\n    if (!fragmentCompiled) {\n        const compilationLog = gl.getShaderInfoLog(fragmentShader);\n        console.log('Fragment shader compiler log: ' + compilationLog);\n    }\n    // link the two shaders into a WebGL program\n    const program = gl.createProgram();\n    if (program === null) {\n        throw \"Could not create shader program\";\n    }\n    gl.attachShader(program, vertexShader);\n    gl.attachShader(program, fragmentShader);\n    gl.linkProgram(program);\n    const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n    if (!linked) {\n        const linkLog = gl.getProgramInfoLog(program);\n        console.log('Linker log: ' + linkLog);\n    }\n    return program;\n};\n/** Class representing a WebGL shader program */\nclass WGLProgram {\n    /**\n     * Create and compile a shader program from source\n     * @param gl                  - The WebGL rendering context\n     * @param vertex_shader_src   - The vertex shader source code\n     * @param fragment_shader_src - The fragment shader source code\n     * @param opts.define         - Preprocessor macros to define (like -D when running gcc)\n     */\n    constructor(gl, vertex_shader_src, fragment_shader_src, opts) {\n        vertex_shader_src = preprocessShader(vertex_shader_src, opts);\n        fragment_shader_src = preprocessShader(fragment_shader_src, opts);\n        this.gl = gl;\n        this.prog = compileAndLinkShaders(gl, vertex_shader_src, fragment_shader_src);\n        this.attributes = {};\n        this.uniforms = {};\n        this.n_verts = null;\n        this.draw_mode = null;\n        this.index_buffer = null;\n        this.sampler_names = [];\n        const remove_comments = (line) => {\n            const comment_idx = line.indexOf('//');\n            if (comment_idx >= 0) {\n                line = line.slice(0, comment_idx);\n            }\n            return line;\n        };\n        vertex_shader_src = vertex_shader_src.split('\\n').map(remove_comments).join('\\n');\n        fragment_shader_src = fragment_shader_src.split('\\n').map(remove_comments).join('\\n');\n        // safety check the vertex shader source\n        const is_webgl2 = isWebGL2Ctx(this.gl);\n        if (!is_webgl2 &&\n            (vertex_shader_src.includes('#version 300 es') || fragment_shader_src.includes('#version 300 es'))) {\n            throw `WebGL2 context required for shader source containing '#version 300 es'`;\n        }\n        // in WebGL2 shaders (gl 300 es), attribute just become the keyword 'in'\n        let vtx_shader_match = is_webgl2 ?\n            /\\b(?:in|attribute)+([\\w ]+?) +([\\w_]+);[\\s]*$/mg : /attribute +([\\w ]+?) +([\\w_]+);[\\s]*$/mg;\n        for (const match of vertex_shader_src.matchAll(vtx_shader_match)) {\n            const [full_match, type, a_name] = match;\n            this.attributes[a_name] = { 'type': type, 'location': gl.getAttribLocation(this.prog, a_name) };\n        }\n        for (const match of vertex_shader_src.matchAll(/uniform +([\\w ]+?) +([\\w_]+)(?:[\\s]*\\[.*\\])?;[\\s]*$/mg)) {\n            const [full_match, type, u_name] = match;\n            const type_parts = type.split(' ');\n            const uniform_loc = gl.getUniformLocation(this.prog, u_name);\n            if (uniform_loc === null) {\n                throw `Could not get vertex shader uniform location for '${u_name}'`;\n            }\n            this.uniforms[u_name] = { 'type': type_parts[type_parts.length - 1], 'location': uniform_loc };\n        }\n        for (const match of fragment_shader_src.matchAll(/uniform +([\\w ]+?) +([\\w_]+)(?:[\\s]*\\[.*\\])?;[\\s]*$/mg)) {\n            const [full_match, type, u_name] = match;\n            const type_parts = type.split(' ');\n            const uniform_loc = gl.getUniformLocation(this.prog, u_name);\n            if (uniform_loc === null) {\n                throw `Could not get fragment shader uniform location for '${u_name}'`;\n            }\n            this.uniforms[u_name] = { 'type': type_parts[type_parts.length - 1], 'location': uniform_loc };\n        }\n        Object.entries(this.uniforms).forEach(([u_name, uniform]) => {\n            if (uniform.type.toLowerCase() == 'sampler2d') {\n                this.sampler_names.push(u_name);\n            }\n        });\n    }\n    /**\n     * Enable this program for rendering and optionally bind attribute, uniform, and texture values. This function should be called before calling\n     * {@link WGLProgram.bindAttributes}, {@link WGLProgram.setUniforms}, or {@link WGLProgram.bindTextures} on a given rendering pass.\n     * @param attribute_buffers - An object with the keys being the attribute variable names and the values being the buffers to associate with each variable\n     * @param uniform_values    - An object with the keys being the uniform variable names and the values being the uniform values\n     * @param textures          - An object with the keys being the sampler names in the source code and the values being the textures to associate with each sampler\n     * @param index_buffer      - A WGLIndexBuffer specifying which indices to draw in which order\n     */\n    use(attribute_buffers, uniform_values, textures, index_buffer) {\n        this.gl.useProgram(this.prog);\n        if (index_buffer !== undefined) {\n            index_buffer.bind();\n            this.index_buffer = index_buffer;\n        }\n        else {\n            this.index_buffer = null;\n        }\n        this.draw_mode = null;\n        this.n_verts = null;\n        if (attribute_buffers !== undefined) {\n            this.bindAttributes(attribute_buffers);\n        }\n        if (uniform_values !== undefined) {\n            this.setUniforms(uniform_values);\n        }\n        if (textures !== undefined) {\n            this.bindTextures(textures);\n        }\n    }\n    /**\n     * Bind attribute buffers to variables in this shader program. When rendring, call {@link WGLProgram.use} before calling this function.\n     * @param attribute_buffers - An object with the keys being the attribute variable names and the values being the buffers to associate with each variable\n     */\n    bindAttributes(attribute_buffers) {\n        Object.entries(attribute_buffers).forEach(([a_name, buffer]) => {\n            if (this.attributes[a_name] === undefined) {\n                console.warn(`Skipping attribute buffer provided for '${a_name}' because the attribute was not found in the program.`);\n                return;\n            }\n            this.n_verts = this.n_verts === null ? buffer.n_verts : this.n_verts;\n            this.draw_mode = this.draw_mode === null ? buffer.draw_mode : this.draw_mode;\n            if (this.draw_mode != buffer.draw_mode) {\n                throw `Unexpected draw mode for attribute buffer ${a_name} (expected ${this.draw_mode}, got ${buffer.draw_mode}).`;\n            }\n            if (this.n_verts != buffer.n_verts) {\n                throw `Unexpected number of vertices for attribute buffer ${a_name} (expected ${this.n_verts}, got ${buffer.n_verts}).`;\n            }\n            const { type, location } = this.attributes[a_name];\n            buffer.bindToProgram(location);\n        });\n    }\n    /**\n     * Set uniform values in this shader program. When rendering, call {@link WGLProgram.use} before calling this function.\n     * @param uniform_values - An object with the keys being the uniform variable names and the values being the uniform values\n     */\n    setUniforms(uniform_values) {\n        Object.entries(uniform_values).forEach(([u_name, value]) => {\n            if (this.uniforms[u_name] === undefined) {\n                console.warn(`Skipping uniform value provided for '${u_name}' because the uniform was not found in the program.`);\n                return;\n            }\n            const { type, location } = this.uniforms[u_name];\n            if (type === 'int' && typeof value == 'number') {\n                this.gl.uniform1i(location, value);\n            }\n            else if (type === 'float' && typeof value == 'number') {\n                this.gl.uniform1f(location, value);\n            }\n            else if (type === 'float' && value instanceof Array) {\n                this.gl.uniform1fv(location, value);\n            }\n            else if (type === 'vec2' && value instanceof Array) {\n                this.gl.uniform2fv(location, value);\n            }\n            else if (type === 'vec3' && value instanceof Array) {\n                this.gl.uniform3fv(location, value);\n            }\n            else if (type === 'vec4' && value instanceof Array) {\n                this.gl.uniform4fv(location, value);\n            }\n            else if (type === 'mat4' && value instanceof Array) {\n                this.gl.uniformMatrix4fv(location, false, value);\n            }\n            else {\n                throw `Could not figure out uniform function for type '${type}' and value '${String(value)}'`;\n            }\n        });\n    }\n    /**\n     * Bind textures to samplers in this shader program. When rendring, call {@link WGLProgram.use} before calling this function.\n     * @param textures - An object with the keys being the sampler names in the source code and the values being the textures to associate with each sampler\n     */\n    bindTextures(textures) {\n        Object.entries(textures).forEach(([sampler_name, texture]) => {\n            if (this.uniforms[sampler_name] === undefined) {\n                console.warn(`Skipping texture provided for sampler '${sampler_name}' because the sampler was not found in the program.`);\n                return;\n            }\n            const gl_tex_num = this.sampler_names.indexOf(sampler_name);\n            const { type, location } = this.uniforms[sampler_name];\n            texture.bindToProgram(location, gl_tex_num);\n        });\n    }\n    /**\n     * Run this shader program.\n     */\n    draw() {\n        if (this.draw_mode === null || this.n_verts === null) {\n            throw \"Cannot draw without binding attribute buffers\";\n        }\n        if (this.index_buffer === null) {\n            this.gl.drawArrays(this.draw_mode, 0, this.n_verts);\n        }\n        else {\n            this.gl.drawElements(this.draw_mode, this.index_buffer.n_verts, this.index_buffer.dtype, 0);\n        }\n    }\n}\nexport { WGLProgram };\n","/**\n * @module wgl/WebGLFramebuffer\n * Module containing helper classes for WebGL Framebuffers\n */\n/**\n * Base class for WebGL framebuffers\n */\nclass WGLFramebufferBase {\n    constructor(gl, framebuffer) {\n        this.gl = gl;\n        this.framebuffer = framebuffer;\n    }\n    /**\n     * Clear the framebuffer to a particular color\n     * @param color - The color to use when clearing the framebuffer as a float RGBA tuple\n     */\n    clear(color) {\n        const gl = this.gl;\n        if (gl === null) {\n            throw \"Register WebGL drawing context using registerGLContext() first\";\n        }\n        gl.clearColor(...color);\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n        gl.clear(gl.COLOR_BUFFER_BIT);\n    }\n    /**\n     * Render to a portion of this framebuffer\n     * @param x      - The x coordinate of the starting point for the viewport\n     * @param y      - The y coordinate of the starting point for the viewport\n     * @param width  - The width of the viewport\n     * @param height - The height of the viewport\n     */\n    renderTo(x, y, width, height) {\n        const gl = this.gl;\n        if (gl === null) {\n            throw \"Register WebGL drawing context using registerGLContext() first\";\n        }\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n        gl.viewport(x, y, width, height);\n    }\n    /**\n     * Copy the contents of this framebuffer to another texture\n     * @param texture - The destination texture for the copy\n     * @param x       - The x coordinate of the start of the source rectangle\n     * @param y       - The y coordinate of the start of the source rectangle\n     * @param width   - The width of the source rectangle\n     * @param height  - The height of the source rectangle\n     */\n    copyToTexture(texture, x, y, width, height) {\n        const gl = this.gl;\n        if (gl === null) {\n            throw \"Register WebGL drawing context using registerGLContext() first\";\n        }\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n        texture.activate(0);\n        gl.copyTexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, x, y, width, height, 0);\n    }\n}\n/**\n * Class representing the screen buffer\n * @extends WGLFramebufferBase\n */\nclass WGLScreenbuffer extends WGLFramebufferBase {\n    /**\n     * Create the screen buffer. Use the {@link WGLFramebuffer.screen} static variable of {@link WGLFramebuffer} instead of creating your own screenbuffer.\n     */\n    constructor() {\n        super(null, null);\n    }\n    /**\n     * Register the WebGL rendering context for later use\n     * @param gl - The WebGL rendering context\n     */\n    registerGLContext(gl) {\n        this.gl = gl;\n    }\n}\nconst SCREEN = new WGLScreenbuffer();\n/**\n * Class representing a WebGL framebuffer\n * @extends WGLFramebufferBase\n */\nclass WGLFramebuffer extends WGLFramebufferBase {\n    /**\n     * Create a framebuffer associated with a texture\n     * @param gl      - The WebGL rendering context\n     * @param texture - The texture object to associate with this framebuffer\n     */\n    constructor(gl, texture) {\n        const framebuffer = gl.createFramebuffer();\n        if (framebuffer === null) {\n            throw \"Could not create WebGL Framebuffer\";\n        }\n        super(gl, framebuffer);\n        this.texture = texture;\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture['texture'], 0);\n    }\n    /**\n     * Get a screen buffer object for interacting with the screen\n     * @static\n     * @param gl - The WebGL rendering context to use\n     */\n    static screen(gl) {\n        SCREEN.registerGLContext(gl);\n        return SCREEN;\n    }\n}\n/**\n * Perform several rendering passes, flip-flopping between two framebuffers\n * @param n_passes  - The number of rendering passes to do\n * @param source_fb - The framebuffer containing the initial data for the rendering\n * @param aux_fb    - The auxilary rendering framebuffers (should be 2 of them)\n * @param do_render - A method that does the actual rendering pass\n */\nconst flipFlopBuffers = (n_passes, source_fb, aux_fb, do_render) => {\n    // fb1 is the source and fb2 is the target for each pass\n    let fb1 = source_fb, fb2 = aux_fb[0];\n    for (let ipass = 0; ipass < n_passes; ipass++) {\n        // Clear and unbind destination texture\n        fb2.clear([0., 0., 0., 1.]);\n        fb2.texture.deactivate();\n        // Do whatever rendering task we want to do\n        do_render(fb1, fb2, ipass);\n        if (ipass > 0) {\n            // Flip the framebuffers so the destination on this pass becomes the source on the next pass and vice-versa\n            aux_fb.reverse();\n        }\n        [fb1, fb2] = aux_fb;\n    }\n    // The most recent target is fb2, but the two framebuffers got flipped at the end of the loop, so the data we want are in fb1.\n    return fb1;\n};\nexport { WGLFramebuffer, flipFlopBuffers };\n","export const THIS_IS_NOT_AN_OBJECT = \"This is not an object\";\nexport const THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = \"This is not a Float16Array object\";\nexport const THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY =\n  \"This constructor is not a subclass of Float16Array\";\nexport const THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT =\n  \"The constructor property value is not an object\";\nexport const SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT =\n  \"Species constructor didn't return TypedArray object\";\nexport const DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH =\n  \"Derived constructor created TypedArray object which was too small length\";\nexport const ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER =\n  \"Attempting to access detached ArrayBuffer\";\nexport const CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT =\n  \"Cannot convert undefined or null to object\";\nexport const CANNOT_MIX_BIGINT_AND_OTHER_TYPES =\n  \"Cannot mix BigInt and other types, use explicit conversions\";\nexport const ITERATOR_PROPERTY_IS_NOT_CALLABLE = \"@@iterator property is not callable\";\nexport const REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE =\n  \"Reduce of empty array with no initial value\";\nexport const THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED =\n  \"The comparison function must be either a function or undefined\";\nexport const OFFSET_IS_OUT_OF_BOUNDS = \"Offset is out of bounds\";\n","/* eslint-disable no-restricted-globals, no-restricted-syntax */\n/* global SharedArrayBuffer */\n\nimport { CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT } from \"./messages.mjs\";\n\n/** @type {<T extends (...args: any) => any>(target: T) => (thisArg: ThisType<T>, ...args: any[]) => any} */\nfunction uncurryThis(target) {\n  return (thisArg, ...args) => {\n    return ReflectApply(target, thisArg, args);\n  };\n}\n\n/** @type {(target: any, key: string | symbol) => (thisArg: any, ...args: any[]) => any} */\nfunction uncurryThisGetter(target, key) {\n  return uncurryThis(\n    ReflectGetOwnPropertyDescriptor(\n      target,\n      key\n    ).get\n  );\n}\n\n// Reflect\nexport const {\n  apply: ReflectApply,\n  construct: ReflectConstruct,\n  defineProperty: ReflectDefineProperty,\n  get: ReflectGet,\n  getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,\n  getPrototypeOf: ReflectGetPrototypeOf,\n  has: ReflectHas,\n  ownKeys: ReflectOwnKeys,\n  set: ReflectSet,\n  setPrototypeOf: ReflectSetPrototypeOf,\n} = Reflect;\n\n// Proxy\nexport const NativeProxy = Proxy;\n\n// Number\nexport const {\n  EPSILON,\n  MAX_SAFE_INTEGER,\n  isFinite: NumberIsFinite,\n  isNaN: NumberIsNaN,\n} = Number;\n\n// Symbol\nexport const {\n  iterator: SymbolIterator,\n  species: SymbolSpecies,\n  toStringTag: SymbolToStringTag,\n  for: SymbolFor,\n} = Symbol;\n\n// Object\nexport const NativeObject = Object;\nexport const {\n  create: ObjectCreate,\n  defineProperty: ObjectDefineProperty,\n  freeze: ObjectFreeze,\n  is: ObjectIs,\n} = NativeObject;\nconst ObjectPrototype = NativeObject.prototype;\n/** @type {(object: object, key: PropertyKey) => Function | undefined} */\nexport const ObjectPrototype__lookupGetter__ = /** @type {any} */ (ObjectPrototype).__lookupGetter__\n  ? uncurryThis(/** @type {any} */ (ObjectPrototype).__lookupGetter__)\n  : (object, key) => {\n    if (object == null) {\n      throw NativeTypeError(\n        CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n      );\n    }\n\n    let target = NativeObject(object);\n    do {\n      const descriptor = ReflectGetOwnPropertyDescriptor(target, key);\n      if (descriptor !== undefined) {\n        if (ObjectHasOwn(descriptor, \"get\")) {\n          return descriptor.get;\n        }\n\n        return;\n      }\n    } while ((target = ReflectGetPrototypeOf(target)) !== null);\n  };\n/** @type {(object: object, key: PropertyKey) => boolean} */\nexport const ObjectHasOwn = /** @type {any} */ (NativeObject).hasOwn ||\n  uncurryThis(ObjectPrototype.hasOwnProperty);\n\n// Array\nconst NativeArray = Array;\nexport const ArrayIsArray = NativeArray.isArray;\nconst ArrayPrototype = NativeArray.prototype;\n/** @type {(array: ArrayLike<unknown>, separator?: string) => string} */\nexport const ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join);\n/** @type {<T>(array: T[], ...items: T[]) => number} */\nexport const ArrayPrototypePush = uncurryThis(ArrayPrototype.push);\n/** @type {(array: ArrayLike<unknown>, ...opts: any[]) => string} */\nexport const ArrayPrototypeToLocaleString = uncurryThis(\n  ArrayPrototype.toLocaleString\n);\nexport const NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator];\n/** @type {<T>(array: T[]) => IterableIterator<T>} */\nexport const ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator);\n\n// Math\nexport const {\n  abs: MathAbs,\n  trunc: MathTrunc,\n} = Math;\n\n// ArrayBuffer\nexport const NativeArrayBuffer = ArrayBuffer;\nexport const ArrayBufferIsView = NativeArrayBuffer.isView;\nconst ArrayBufferPrototype = NativeArrayBuffer.prototype;\n/** @type {(buffer: ArrayBuffer, begin?: number, end?: number) => number} */\nexport const ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice);\n/** @type {(buffer: ArrayBuffer) => ArrayBuffer} */\nexport const ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, \"byteLength\");\n\n// SharedArrayBuffer\nexport const NativeSharedArrayBuffer = typeof SharedArrayBuffer !== \"undefined\" ? SharedArrayBuffer : null;\n/** @type {(buffer: SharedArrayBuffer) => SharedArrayBuffer} */\nexport const SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer\n  && uncurryThisGetter(NativeSharedArrayBuffer.prototype, \"byteLength\");\n\n// TypedArray\n/** @typedef {Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array|BigUint64Array|BigInt64Array} TypedArray */\n/** @type {any} */\nexport const TypedArray = ReflectGetPrototypeOf(Uint8Array);\nconst TypedArrayFrom = TypedArray.from;\nexport const TypedArrayPrototype = TypedArray.prototype;\nexport const NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator];\n/** @type {(typedArray: TypedArray) => IterableIterator<number>} */\nexport const TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys);\n/** @type {(typedArray: TypedArray) => IterableIterator<number>} */\nexport const TypedArrayPrototypeValues = uncurryThis(\n  TypedArrayPrototype.values\n);\n/** @type {(typedArray: TypedArray) => IterableIterator<[number, number]>} */\nexport const TypedArrayPrototypeEntries = uncurryThis(\n  TypedArrayPrototype.entries\n);\n/** @type {(typedArray: TypedArray, array: ArrayLike<number>, offset?: number) => void} */\nexport const TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set);\n/** @type {<T extends TypedArray>(typedArray: T) => T} */\nexport const TypedArrayPrototypeReverse = uncurryThis(\n  TypedArrayPrototype.reverse\n);\n/** @type {<T extends TypedArray>(typedArray: T, value: number, start?: number, end?: number) => T} */\nexport const TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill);\n/** @type {<T extends TypedArray>(typedArray: T, target: number, start: number, end?: number) => T} */\nexport const TypedArrayPrototypeCopyWithin = uncurryThis(\n  TypedArrayPrototype.copyWithin\n);\n/** @type {<T extends TypedArray>(typedArray: T, compareFn?: (a: number, b: number) => number) => T} */\nexport const TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort);\n/** @type {<T extends TypedArray>(typedArray: T, start?: number, end?: number) => T} */\nexport const TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice);\n/** @type {<T extends TypedArray>(typedArray: T, start?: number, end?: number) => T} */\nexport const TypedArrayPrototypeSubarray = uncurryThis(\n  TypedArrayPrototype.subarray\n);\n/** @type {((typedArray: TypedArray) => ArrayBuffer)} */\nexport const TypedArrayPrototypeGetBuffer = uncurryThisGetter(\n  TypedArrayPrototype,\n  \"buffer\"\n);\n/** @type {((typedArray: TypedArray) => number)} */\nexport const TypedArrayPrototypeGetByteOffset = uncurryThisGetter(\n  TypedArrayPrototype,\n  \"byteOffset\"\n);\n/** @type {((typedArray: TypedArray) => number)} */\nexport const TypedArrayPrototypeGetLength = uncurryThisGetter(\n  TypedArrayPrototype,\n  \"length\"\n);\n/** @type {(target: unknown) => string} */\nexport const TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter(\n  TypedArrayPrototype,\n  SymbolToStringTag\n);\n\n// Uint8Array\nexport const NativeUint8Array = Uint8Array;\n\n// Uint16Array\nexport const NativeUint16Array = Uint16Array;\n/** @type {Uint16ArrayConstructor[\"from\"]} */\nexport const Uint16ArrayFrom = (...args) => {\n  return ReflectApply(TypedArrayFrom, NativeUint16Array, args);\n};\n\n// Uint32Array\nexport const NativeUint32Array = Uint32Array;\n\n// Float32Array\nexport const NativeFloat32Array = Float32Array;\n\n// ArrayIterator\n/** @type {any} */\nexport const ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]());\n/** @type {<T>(arrayIterator: IterableIterator<T>) => IteratorResult<T>} */\nexport const ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next);\n\n// Generator\n/** @type {<T = unknown, TReturn = any, TNext = unknown>(generator: Generator<T, TReturn, TNext>, value?: TNext) => T} */\nexport const GeneratorPrototypeNext = uncurryThis((function* () {})().next);\n\n// Iterator\nexport const IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype);\n\n// DataView\nconst DataViewPrototype = DataView.prototype;\n/** @type {(dataView: DataView, byteOffset: number, littleEndian?: boolean) => number} */\nexport const DataViewPrototypeGetUint16 = uncurryThis(\n  DataViewPrototype.getUint16\n);\n/** @type {(dataView: DataView, byteOffset: number, value: number, littleEndian?: boolean) => void} */\nexport const DataViewPrototypeSetUint16 = uncurryThis(\n  DataViewPrototype.setUint16\n);\n\n// Error\nexport const NativeTypeError = TypeError;\nexport const NativeRangeError = RangeError;\n\n// WeakSet\n/**\n * Do not construct with arguments to avoid calling the \"add\" method\n * @type {{new <T extends {}>(): WeakSet<T>}}\n */\nexport const NativeWeakSet = WeakSet;\nconst WeakSetPrototype = NativeWeakSet.prototype;\n/** @type {<T extends {}>(set: WeakSet<T>, value: T) => Set<T>} */\nexport const WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add);\n/** @type {<T extends {}>(set: WeakSet<T>, value: T) => boolean} */\nexport const WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has);\n\n// WeakMap\n/**\n * Do not construct with arguments to avoid calling the \"set\" method\n * @type {{new <K extends {}, V>(): WeakMap<K, V>}}\n */\nexport const NativeWeakMap = WeakMap;\nconst WeakMapPrototype = NativeWeakMap.prototype;\n/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K) => V} */\nexport const WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get);\n/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K) => boolean} */\nexport const WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has);\n/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K, value: V) => WeakMap} */\nexport const WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set);\n","import {\n  ArrayIteratorPrototype,\n  ArrayIteratorPrototypeNext,\n  ArrayPrototypeSymbolIterator,\n  GeneratorPrototypeNext,\n  IteratorPrototype,\n  NativeArrayPrototypeSymbolIterator,\n  NativeWeakMap,\n  ObjectCreate,\n  ObjectDefineProperty,\n  ReflectGetOwnPropertyDescriptor,\n  ReflectOwnKeys,\n  SymbolIterator,\n  WeakMapPrototypeGet,\n  WeakMapPrototypeSet,\n} from \"./primordials.mjs\";\n\n/** @type {WeakMap<{}, IterableIterator<any>>} */\nconst arrayIterators = new NativeWeakMap();\n\nconst SafeIteratorPrototype = ObjectCreate(null, {\n  next: {\n    value: function next() {\n      const arrayIterator = WeakMapPrototypeGet(arrayIterators, this);\n      return ArrayIteratorPrototypeNext(arrayIterator);\n    },\n  },\n\n  [SymbolIterator]: {\n    value: function values() {\n      return this;\n    },\n  },\n});\n\n/**\n * Wrap the Array around the SafeIterator If Array.prototype [@@iterator] has been modified\n * @type {<T>(array: T[]) => Iterable<T>}\n */\nexport function safeIfNeeded(array) {\n  if (\n    array[SymbolIterator] === NativeArrayPrototypeSymbolIterator &&\n    ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext\n  ) {\n    return array;\n  }\n\n  const safe = ObjectCreate(SafeIteratorPrototype);\n  WeakMapPrototypeSet(arrayIterators, safe, ArrayPrototypeSymbolIterator(array));\n  return safe;\n}\n\n/** @type {WeakMap<{}, Generator<any>>} */\nconst generators = new NativeWeakMap();\n\n/** @see https://tc39.es/ecma262/#sec-%arrayiteratorprototype%-object */\nconst DummyArrayIteratorPrototype = ObjectCreate(IteratorPrototype, {\n  next: {\n    value: function next() {\n      const generator = WeakMapPrototypeGet(generators, this);\n      return GeneratorPrototypeNext(generator);\n    },\n    writable: true,\n    configurable: true,\n  },\n});\n\nfor (const key of ReflectOwnKeys(ArrayIteratorPrototype)) {\n  // next method has already defined\n  if (key === \"next\") {\n    continue;\n  }\n\n  // Copy ArrayIteratorPrototype descriptors to DummyArrayIteratorPrototype\n  ObjectDefineProperty(DummyArrayIteratorPrototype, key, ReflectGetOwnPropertyDescriptor(ArrayIteratorPrototype, key));\n}\n\n/**\n * Wrap the Generator around the dummy ArrayIterator\n * @type {<T>(generator: Generator<T>) => IterableIterator<T>}\n */\nexport function wrap(generator) {\n  const dummy = ObjectCreate(DummyArrayIteratorPrototype);\n  WeakMapPrototypeSet(generators, dummy, generator);\n  return dummy;\n}\n","import {\n  ArrayBufferPrototypeGetByteLength,\n  ArrayIsArray,\n  ArrayIteratorPrototype,\n  ArrayIteratorPrototypeNext,\n  MathTrunc,\n  NativeArrayPrototypeSymbolIterator,\n  NativeSharedArrayBuffer,\n  NativeTypedArrayPrototypeSymbolIterator,\n  NumberIsFinite,\n  SharedArrayBufferPrototypeGetByteLength,\n  SymbolIterator,\n  TypedArrayPrototypeGetSymbolToStringTag,\n} from \"./primordials.mjs\";\n\n/**\n * @param {unknown} value\n * @returns {value is {}}\n */\nexport function isObject(value) {\n  return (\n    (value !== null && typeof value === \"object\") ||\n    typeof value === \"function\"\n  );\n}\n\n/**\n * @param {unknown} value\n * @returns {value is {}}\n */\nexport function isObjectLike(value) {\n  return value !== null && typeof value === \"object\";\n}\n\n// Inspired by util.types implementation of Node.js\n/** @typedef {Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array|BigUint64Array|BigInt64Array} TypedArray */\n\n/**\n * @param {unknown} value\n * @returns {value is TypedArray}\n */\nexport function isNativeTypedArray(value) {\n  return TypedArrayPrototypeGetSymbolToStringTag(value) !== undefined;\n}\n\n/**\n * @param {unknown} value\n * @returns {value is BigInt64Array|BigUint64Array}\n */\nexport function isNativeBigIntTypedArray(value) {\n  const typedArrayName = TypedArrayPrototypeGetSymbolToStringTag(value);\n  return (\n    typedArrayName === \"BigInt64Array\" ||\n    typedArrayName === \"BigUint64Array\"\n  );\n}\n\n/**\n * @param {unknown} value\n * @returns {value is ArrayBuffer}\n */\nfunction isArrayBuffer(value) {\n  try {\n    ArrayBufferPrototypeGetByteLength(/** @type {any} */ (value));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * @param {unknown} value\n * @returns {value is SharedArrayBuffer}\n */\nexport function isSharedArrayBuffer(value) {\n  if (NativeSharedArrayBuffer === null) {\n    return false;\n  }\n\n  try {\n    SharedArrayBufferPrototypeGetByteLength(/** @type {any} */ (value));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * @param {unknown} value\n * @returns {value is ArrayBuffer|SharedArrayBuffer}\n */\nexport function isAnyArrayBuffer(value) {\n  return isArrayBuffer(value) || isSharedArrayBuffer(value);\n}\n\n/**\n * @param {unknown} value\n * @returns {value is unknown[]}\n */\nexport function isOrdinaryArray(value) {\n  if (!ArrayIsArray(value)) {\n    return false;\n  }\n\n  // Verify that there are no changes in ArrayIterator\n  return (\n    value[SymbolIterator] === NativeArrayPrototypeSymbolIterator &&\n    ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext\n  );\n}\n\n/**\n * @param {unknown} value\n * @returns {value is TypedArray}\n */\nexport function isOrdinaryNativeTypedArray(value) {\n  if (!isNativeTypedArray(value)) {\n    return false;\n  }\n\n  // Verify that there are no changes in ArrayIterator\n  return (\n    value[SymbolIterator] === NativeTypedArrayPrototypeSymbolIterator &&\n    ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext\n  );\n}\n\n/**\n * @param {unknown} value\n * @returns {value is string}\n */\nexport function isCanonicalIntegerIndexString(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n\n  const number = +value;\n  if (value !== number + \"\") {\n    return false;\n  }\n\n  if (!NumberIsFinite(number)) {\n    return false;\n  }\n\n  return number === MathTrunc(number);\n}\n","import { isObject, isObjectLike } from \"./is.mjs\";\nimport { THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT } from \"./messages.mjs\";\nimport { NativeTypeError, ReflectGetPrototypeOf, ReflectHas, SymbolFor } from \"./primordials.mjs\";\n\nexport const brand = SymbolFor(\"__Float16Array__\");\n\n/**\n * @param {unknown} target\n * @throws {TypeError}\n * @returns {boolean}\n */\nexport function hasFloat16ArrayBrand(target) {\n  if (!isObjectLike(target)) {\n    return false;\n  }\n\n  const prototype = ReflectGetPrototypeOf(target);\n  if (!isObjectLike(prototype)) {\n    return false;\n  }\n\n  const constructor = prototype.constructor;\n  if (constructor === undefined) {\n    return false;\n  }\n  if (!isObject(constructor)) {\n    throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);\n  }\n\n  return ReflectHas(constructor, brand);\n}\n","import {\n  EPSILON,\n  MathAbs,\n  NativeArrayBuffer,\n  NativeFloat32Array,\n  NativeUint16Array,\n  NativeUint32Array,\n  NativeUint8Array,\n  NumberIsFinite,\n  NumberIsNaN,\n} from \"./primordials.mjs\";\n\nconst INVERSE_OF_EPSILON = 1 / EPSILON;\n\n/**\n * rounds to the nearest value;\n * if the number falls midway, it is rounded to the nearest value with an even least significant digit\n * @param {number} num\n * @returns {number}\n */\nfunction roundTiesToEven(num) {\n  return (num + INVERSE_OF_EPSILON) - INVERSE_OF_EPSILON;\n}\n\nconst FLOAT16_MIN_VALUE = 6.103515625e-05;\nconst FLOAT16_MAX_VALUE = 65504;\nconst FLOAT16_EPSILON = 0.0009765625;\n\nconst FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE = FLOAT16_EPSILON * FLOAT16_MIN_VALUE;\nconst FLOAT16_EPSILON_DEVIDED_BY_EPSILON = FLOAT16_EPSILON * INVERSE_OF_EPSILON;\n\n/**\n * round a number to a half float number\n * @param {unknown} num - double float\n * @returns {number} half float number bits\n */\nexport function roundToFloat16(num) {\n  const number = +num;\n\n  // NaN, Infinity, -Infinity, 0, -0\n  if (!NumberIsFinite(number) || number === 0) {\n    return number;\n  }\n\n  // finite except 0, -0\n  const sign = number > 0 ? 1 : -1;\n  const absolute = MathAbs(number);\n\n  // small number\n  if (absolute < FLOAT16_MIN_VALUE) {\n    return sign * roundTiesToEven(absolute / FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE) * FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE;\n  }\n\n  const temp = (1 + FLOAT16_EPSILON_DEVIDED_BY_EPSILON) * absolute;\n  const result = temp - (temp - absolute);\n\n  // large number\n  if (result > FLOAT16_MAX_VALUE || NumberIsNaN(result)) {\n    return sign * Infinity;\n  }\n\n  return sign * result;\n}\n\n// base algorithm: http://fox-toolkit.org/ftp/fasthalffloatconversion.pdf\n\nconst buffer = new NativeArrayBuffer(4);\nconst floatView = new NativeFloat32Array(buffer);\nconst uint32View = new NativeUint32Array(buffer);\n\nconst baseTable = new NativeUint16Array(512);\nconst shiftTable = new NativeUint8Array(512);\n\nfor (let i = 0; i < 256; ++i) {\n  const e = i - 127;\n\n  // very small number (0, -0)\n  if (e < -27) {\n    baseTable[i]         = 0x0000;\n    baseTable[i | 0x100] = 0x8000;\n    shiftTable[i]         = 24;\n    shiftTable[i | 0x100] = 24;\n\n  // small number (denorm)\n  } else if (e < -14) {\n    baseTable[i]         =  0x0400 >> (-e - 14);\n    baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;\n    shiftTable[i]         = -e - 1;\n    shiftTable[i | 0x100] = -e - 1;\n\n  // normal number\n  } else if (e <= 15) {\n    baseTable[i]         =  (e + 15) << 10;\n    baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;\n    shiftTable[i]         = 13;\n    shiftTable[i | 0x100] = 13;\n\n  // large number (Infinity, -Infinity)\n  } else if (e < 128) {\n    baseTable[i]         = 0x7c00;\n    baseTable[i | 0x100] = 0xfc00;\n    shiftTable[i]         = 24;\n    shiftTable[i | 0x100] = 24;\n\n  // stay (NaN, Infinity, -Infinity)\n  } else {\n    baseTable[i]         = 0x7c00;\n    baseTable[i | 0x100] = 0xfc00;\n    shiftTable[i]         = 13;\n    shiftTable[i | 0x100] = 13;\n  }\n}\n\n/**\n * round a number to a half float number bits\n * @param {unknown} num - double float\n * @returns {number} half float number bits\n */\nexport function roundToFloat16Bits(num) {\n  floatView[0] = roundToFloat16(num);\n  const f = uint32View[0];\n  const e = (f >> 23) & 0x1ff;\n  return baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);\n}\n\nconst mantissaTable = new NativeUint32Array(2048);\nfor (let i = 1; i < 1024; ++i) {\n  let m = i << 13; // zero pad mantissa bits\n  let e = 0; // zero exponent\n\n  // normalized\n  while ((m & 0x00800000) === 0) {\n    m <<= 1;\n    e -= 0x00800000; // decrement exponent\n  }\n\n  m &= ~0x00800000; // clear leading 1 bit\n  e += 0x38800000; // adjust bias\n\n  mantissaTable[i] = m | e;\n}\nfor (let i = 1024; i < 2048; ++i) {\n  mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);\n}\n\nconst exponentTable = new NativeUint32Array(64);\nfor (let i = 1; i < 31; ++i) {\n  exponentTable[i] = i << 23;\n}\nexponentTable[31] = 0x47800000;\nexponentTable[32] = 0x80000000;\nfor (let i = 33; i < 63; ++i) {\n  exponentTable[i] = 0x80000000 + ((i - 32) << 23);\n}\nexponentTable[63] = 0xc7800000;\n\nconst offsetTable = new NativeUint16Array(64);\nfor (let i = 1; i < 64; ++i) {\n  if (i !== 32) {\n    offsetTable[i] = 1024;\n  }\n}\n\n/**\n * convert a half float number bits to a number\n * @param {number} float16bits - half float number bits\n * @returns {number} double float\n */\nexport function convertToNumber(float16bits) {\n  const i = float16bits >> 10;\n  uint32View[0] = mantissaTable[offsetTable[i] + (float16bits & 0x3ff)] + exponentTable[i];\n  return floatView[0];\n}\n","import { isObject, isSharedArrayBuffer } from \"./is.mjs\";\nimport {\n  THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT,\n  THIS_IS_NOT_AN_OBJECT,\n} from \"./messages.mjs\";\nimport {\n  ArrayBufferPrototypeSlice,\n  MAX_SAFE_INTEGER,\n  MathTrunc,\n  NativeTypeError,\n  NumberIsNaN,\n  ObjectIs,\n  SymbolSpecies,\n} from \"./primordials.mjs\";\n\n/**\n * @see https://tc39.es/ecma262/#sec-tointegerorinfinity\n * @param {unknown} target\n * @returns {number}\n */\nexport function ToIntegerOrInfinity(target) {\n  const number = +target;\n\n  if (NumberIsNaN(number) || number === 0) {\n    return 0;\n  }\n\n  return MathTrunc(number);\n}\n\n/**\n * @see https://tc39.es/ecma262/#sec-tolength\n * @param {unknown} target\n * @returns {number}\n */\nexport function ToLength(target) {\n  const length = ToIntegerOrInfinity(target);\n  if (length < 0) {\n    return 0;\n  }\n\n  return length < MAX_SAFE_INTEGER\n    ? length\n    : MAX_SAFE_INTEGER;\n}\n\n/**\n * @see https://tc39.es/ecma262/#sec-speciesconstructor\n * @param {object} target\n * @param {{ new(...args: any[]): any; }} defaultConstructor\n * @returns {{ new(...args: any[]): any; }}\n */\nexport function SpeciesConstructor(target, defaultConstructor) {\n  if (!isObject(target)) {\n    throw NativeTypeError(THIS_IS_NOT_AN_OBJECT);\n  }\n\n  const constructor = target.constructor;\n  if (constructor === undefined) {\n    return defaultConstructor;\n  }\n  if (!isObject(constructor)) {\n    throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);\n  }\n\n  const species = constructor[SymbolSpecies];\n  if (species == null) {\n    return defaultConstructor;\n  }\n\n  return species;\n}\n\n/**\n * @see https://tc39.es/ecma262/#sec-isdetachedbuffer\n * @param {ArrayBufferLike} buffer\n * @returns {boolean}\n */\nexport function IsDetachedBuffer(buffer) {\n  if (isSharedArrayBuffer(buffer)) {\n    return false;\n  }\n\n  try {\n    ArrayBufferPrototypeSlice(buffer, 0, 0);\n    return false;\n  } catch (e) {/* empty */}\n\n  return true;\n}\n\n/**\n * bigint comparisons are not supported\n * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort\n * @param {number} x\n * @param {number} y\n * @returns {-1 | 0 | 1}\n */\nexport function defaultCompare(x, y) {\n  const isXNaN = NumberIsNaN(x);\n  const isYNaN = NumberIsNaN(y);\n\n  if (isXNaN && isYNaN) {\n    return 0;\n  }\n\n  if (isXNaN) {\n    return 1;\n  }\n\n  if (isYNaN) {\n    return -1;\n  }\n\n  if (x < y) {\n    return -1;\n  }\n\n  if (x > y) {\n    return 1;\n  }\n\n  if (x === 0 && y === 0) {\n    const isXPlusZero = ObjectIs(x, 0);\n    const isYPlusZero = ObjectIs(y, 0);\n\n    if (!isXPlusZero && isYPlusZero) {\n      return -1;\n    }\n\n    if (isXPlusZero && !isYPlusZero) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n","import { safeIfNeeded, wrap } from \"./_util/arrayIterator.mjs\";\nimport { brand, hasFloat16ArrayBrand } from \"./_util/brand.mjs\";\nimport { convertToNumber, roundToFloat16Bits } from \"./_util/converter.mjs\";\nimport {\n  isAnyArrayBuffer,\n  isCanonicalIntegerIndexString,\n  isNativeBigIntTypedArray,\n  isNativeTypedArray,\n  isObject,\n  isOrdinaryArray,\n  isOrdinaryNativeTypedArray,\n} from \"./_util/is.mjs\";\nimport {\n  ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER,\n  CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT,\n  CANNOT_MIX_BIGINT_AND_OTHER_TYPES,\n  DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH,\n  ITERATOR_PROPERTY_IS_NOT_CALLABLE,\n  OFFSET_IS_OUT_OF_BOUNDS,\n  REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE,\n  SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT,\n  THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED,\n  THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY,\n  THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT,\n} from \"./_util/messages.mjs\";\nimport {\n  ArrayBufferIsView,\n  ArrayPrototypeJoin,\n  ArrayPrototypePush,\n  ArrayPrototypeToLocaleString,\n  NativeArrayBuffer,\n  NativeObject,\n  NativeProxy,\n  NativeRangeError,\n  NativeTypeError,\n  NativeUint16Array,\n  NativeWeakMap,\n  NativeWeakSet,\n  NumberIsNaN,\n  ObjectDefineProperty,\n  ObjectFreeze,\n  ObjectHasOwn,\n  ObjectPrototype__lookupGetter__,\n  ReflectApply,\n  ReflectConstruct,\n  ReflectDefineProperty,\n  ReflectGet,\n  ReflectGetOwnPropertyDescriptor,\n  ReflectHas,\n  ReflectOwnKeys,\n  ReflectSet,\n  ReflectSetPrototypeOf,\n  SymbolIterator,\n  SymbolToStringTag,\n  TypedArray,\n  TypedArrayPrototype,\n  TypedArrayPrototypeCopyWithin,\n  TypedArrayPrototypeEntries,\n  TypedArrayPrototypeFill,\n  TypedArrayPrototypeGetBuffer,\n  TypedArrayPrototypeGetByteOffset,\n  TypedArrayPrototypeGetLength,\n  TypedArrayPrototypeKeys,\n  TypedArrayPrototypeReverse,\n  TypedArrayPrototypeSet,\n  TypedArrayPrototypeSlice,\n  TypedArrayPrototypeSort,\n  TypedArrayPrototypeSubarray,\n  TypedArrayPrototypeValues,\n  Uint16ArrayFrom,\n  WeakMapPrototypeGet,\n  WeakMapPrototypeHas,\n  WeakMapPrototypeSet,\n  WeakSetPrototypeAdd,\n  WeakSetPrototypeHas,\n} from \"./_util/primordials.mjs\";\nimport {\n  IsDetachedBuffer,\n  SpeciesConstructor,\n  ToIntegerOrInfinity,\n  ToLength,\n  defaultCompare,\n} from \"./_util/spec.mjs\";\n\nconst BYTES_PER_ELEMENT = 2;\n\n/** @typedef {Uint16Array & { __float16bits: never }} Float16BitsArray */\n\n/** @type {WeakMap<Float16Array, Float16BitsArray>} */\nconst float16bitsArrays = new NativeWeakMap();\n\n/**\n * @param {unknown} target\n * @returns {target is Float16Array}\n */\nexport function isFloat16Array(target) {\n  return WeakMapPrototypeHas(float16bitsArrays, target) ||\n    (!ArrayBufferIsView(target) && hasFloat16ArrayBrand(target));\n}\n\n/**\n * @param {unknown} target\n * @throws {TypeError}\n * @returns {asserts target is Float16Array}\n */\nfunction assertFloat16Array(target) {\n  if (!isFloat16Array(target)) {\n    throw NativeTypeError(THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT);\n  }\n}\n\n/**\n * @param {unknown} target\n * @param {number=} count\n * @throws {TypeError}\n * @returns {asserts target is Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float16Array|Float32Array|Float64Array}\n */\nfunction assertSpeciesTypedArray(target, count) {\n  const isTargetFloat16Array = isFloat16Array(target);\n  const isTargetTypedArray = isNativeTypedArray(target);\n\n  if (!isTargetFloat16Array && !isTargetTypedArray) {\n    throw NativeTypeError(SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT);\n  }\n\n  if (typeof count === \"number\") {\n    let length;\n    if (isTargetFloat16Array) {\n      const float16bitsArray = getFloat16BitsArray(target);\n      length = TypedArrayPrototypeGetLength(float16bitsArray);\n    } else {\n      length = TypedArrayPrototypeGetLength(target);\n    }\n\n    if (length < count) {\n      throw NativeTypeError(\n        DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH\n      );\n    }\n  }\n\n  if (isNativeBigIntTypedArray(target)) {\n    throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);\n  }\n}\n\n/**\n * @param {Float16Array} float16\n * @throws {TypeError}\n * @returns {Float16BitsArray}\n */\nfunction getFloat16BitsArray(float16) {\n  const float16bitsArray = WeakMapPrototypeGet(float16bitsArrays, float16);\n  if (float16bitsArray !== undefined) {\n    const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray);\n\n    if (IsDetachedBuffer(buffer)) {\n      throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n    }\n\n    return float16bitsArray;\n  }\n\n  // from another Float16Array instance (a different version?)\n  const buffer = /** @type {any} */ (float16).buffer;\n\n  if (IsDetachedBuffer(buffer)) {\n    throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n  }\n\n  const cloned = ReflectConstruct(Float16Array, [\n    buffer,\n    /** @type {any} */ (float16).byteOffset,\n    /** @type {any} */ (float16).length,\n  ], float16.constructor);\n  return WeakMapPrototypeGet(float16bitsArrays, cloned);\n}\n\n/**\n * @param {Float16BitsArray} float16bitsArray\n * @returns {number[]}\n */\nfunction copyToArray(float16bitsArray) {\n  const length = TypedArrayPrototypeGetLength(float16bitsArray);\n\n  const array = [];\n  for (let i = 0; i < length; ++i) {\n    array[i] = convertToNumber(float16bitsArray[i]);\n  }\n\n  return array;\n}\n\n/** @type {WeakSet<Function>} */\nconst TypedArrayPrototypeGetters = new NativeWeakSet();\nfor (const key of ReflectOwnKeys(TypedArrayPrototype)) {\n  // @@toStringTag getter property is defined in Float16Array.prototype\n  if (key === SymbolToStringTag) {\n    continue;\n  }\n\n  const descriptor = ReflectGetOwnPropertyDescriptor(TypedArrayPrototype, key);\n  if (ObjectHasOwn(descriptor, \"get\") && typeof descriptor.get === \"function\") {\n    WeakSetPrototypeAdd(TypedArrayPrototypeGetters, descriptor.get);\n  }\n}\n\nconst handler = ObjectFreeze(/** @type {ProxyHandler<Float16BitsArray>} */ ({\n  get(target, key, receiver) {\n    if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n      return convertToNumber(ReflectGet(target, key));\n    }\n\n    // %TypedArray%.prototype getter properties cannot called by Proxy receiver\n    if (WeakSetPrototypeHas(TypedArrayPrototypeGetters, ObjectPrototype__lookupGetter__(target, key))) {\n      return ReflectGet(target, key);\n    }\n\n    return ReflectGet(target, key, receiver);\n  },\n\n  set(target, key, value, receiver) {\n    if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n      return ReflectSet(target, key, roundToFloat16Bits(value));\n    }\n\n    return ReflectSet(target, key, value, receiver);\n  },\n\n  getOwnPropertyDescriptor(target, key) {\n    if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n      const descriptor = ReflectGetOwnPropertyDescriptor(target, key);\n      descriptor.value = convertToNumber(descriptor.value);\n      return descriptor;\n    }\n\n    return ReflectGetOwnPropertyDescriptor(target, key);\n  },\n\n  defineProperty(target, key, descriptor) {\n    if (\n      isCanonicalIntegerIndexString(key) &&\n      ObjectHasOwn(target, key) &&\n      ObjectHasOwn(descriptor, \"value\")\n    ) {\n      descriptor.value = roundToFloat16Bits(descriptor.value);\n      return ReflectDefineProperty(target, key, descriptor);\n    }\n\n    return ReflectDefineProperty(target, key, descriptor);\n  },\n}));\n\nexport class Float16Array {\n  /** @see https://tc39.es/ecma262/#sec-typedarray */\n  constructor(input, _byteOffset, _length) {\n    /** @type {Float16BitsArray} */\n    let float16bitsArray;\n\n    if (isFloat16Array(input)) {\n      float16bitsArray = ReflectConstruct(NativeUint16Array, [getFloat16BitsArray(input)], new.target);\n    } else if (isObject(input) && !isAnyArrayBuffer(input)) { // object without ArrayBuffer, SharedArrayBuffer\n      /** @type {ArrayLike<unknown>} */\n      let list;\n      /** @type {number} */\n      let length;\n\n      if (isNativeTypedArray(input)) { // TypedArray\n        list = input;\n        length = TypedArrayPrototypeGetLength(input);\n\n        const buffer = TypedArrayPrototypeGetBuffer(input);\n\n        if (IsDetachedBuffer(buffer)) {\n          throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n        }\n\n        if (isNativeBigIntTypedArray(input)) {\n          throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);\n        }\n\n        const data = new NativeArrayBuffer(\n          length * BYTES_PER_ELEMENT\n        );\n        float16bitsArray = ReflectConstruct(NativeUint16Array, [data], new.target);\n      } else {\n        const iterator = input[SymbolIterator];\n        if (iterator != null && typeof iterator !== \"function\") {\n          throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE);\n        }\n\n        if (iterator != null) { // Iterable (Array)\n          // for optimization\n          if (isOrdinaryArray(input)) {\n            list = input;\n            length = input.length;\n          } else {\n            // eslint-disable-next-line no-restricted-syntax\n            list = [... /** @type {Iterable<unknown>} */ (input)];\n            length = list.length;\n          }\n        } else { // ArrayLike\n          list = /** @type {ArrayLike<unknown>} */ (input);\n          length = ToLength(list.length);\n        }\n        float16bitsArray = ReflectConstruct(NativeUint16Array, [length], new.target);\n      }\n\n      // set values\n      for (let i = 0; i < length; ++i) {\n        float16bitsArray[i] = roundToFloat16Bits(list[i]);\n      }\n    } else { // primitive, ArrayBuffer, SharedArrayBuffer\n      float16bitsArray = ReflectConstruct(NativeUint16Array, arguments, new.target);\n    }\n\n    /** @type {Float16Array} */\n    const proxy = /** @type {any} */ (new NativeProxy(float16bitsArray, handler));\n\n    // proxy private storage\n    WeakMapPrototypeSet(float16bitsArrays, proxy, float16bitsArray);\n\n    return proxy;\n  }\n\n  /**\n   * limitation: `Object.getOwnPropertyNames(Float16Array)` or `Reflect.ownKeys(Float16Array)` include this key\n   * @see https://tc39.es/ecma262/#sec-%typedarray%.from\n   */\n  static from(src, ...opts) {\n    const Constructor = this;\n\n    if (!ReflectHas(Constructor, brand)) {\n      throw NativeTypeError(\n        THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY\n      );\n    }\n\n    // for optimization\n    if (Constructor === Float16Array) {\n      if (isFloat16Array(src) && opts.length === 0) {\n        const float16bitsArray = getFloat16BitsArray(src);\n        const uint16 = new NativeUint16Array(\n          TypedArrayPrototypeGetBuffer(float16bitsArray),\n          TypedArrayPrototypeGetByteOffset(float16bitsArray),\n          TypedArrayPrototypeGetLength(float16bitsArray)\n        );\n        return new Float16Array(\n          TypedArrayPrototypeGetBuffer(TypedArrayPrototypeSlice(uint16))\n        );\n      }\n\n      if (opts.length === 0) {\n        return new Float16Array(\n          TypedArrayPrototypeGetBuffer(\n            Uint16ArrayFrom(src, roundToFloat16Bits)\n          )\n        );\n      }\n\n      const mapFunc = opts[0];\n      const thisArg = opts[1];\n\n      return new Float16Array(\n        TypedArrayPrototypeGetBuffer(\n          Uint16ArrayFrom(src, function (val, ...args) {\n            return roundToFloat16Bits(\n              ReflectApply(mapFunc, this, [val, ...safeIfNeeded(args)])\n            );\n          }, thisArg)\n        )\n      );\n    }\n\n    /** @type {ArrayLike<unknown>} */\n    let list;\n    /** @type {number} */\n    let length;\n\n    const iterator = src[SymbolIterator];\n    if (iterator != null && typeof iterator !== \"function\") {\n      throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE);\n    }\n\n    if (iterator != null) { // Iterable (TypedArray, Array)\n      // for optimization\n      if (isOrdinaryArray(src)) {\n        list = src;\n        length = src.length;\n      } else if (isOrdinaryNativeTypedArray(src)) {\n        list = src;\n        length = TypedArrayPrototypeGetLength(src);\n      } else {\n        // eslint-disable-next-line no-restricted-syntax\n        list = [...src];\n        length = list.length;\n      }\n    } else { // ArrayLike\n      if (src == null) {\n        throw NativeTypeError(\n          CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n        );\n      }\n      list = NativeObject(src);\n      length = ToLength(list.length);\n    }\n\n    const array = new Constructor(length);\n\n    if (opts.length === 0) {\n      for (let i = 0; i < length; ++i) {\n        array[i] = /** @type {number} */ (list[i]);\n      }\n    } else {\n      const mapFunc = opts[0];\n      const thisArg = opts[1];\n      for (let i = 0; i < length; ++i) {\n        array[i] = ReflectApply(mapFunc, thisArg, [list[i], i]);\n      }\n    }\n\n    return array;\n  }\n\n  /**\n   * limitation: `Object.getOwnPropertyNames(Float16Array)` or `Reflect.ownKeys(Float16Array)` include this key\n   * @see https://tc39.es/ecma262/#sec-%typedarray%.of\n   */\n  static of(...items) {\n    const Constructor = this;\n\n    if (!ReflectHas(Constructor, brand)) {\n      throw NativeTypeError(\n        THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY\n      );\n    }\n\n    const length = items.length;\n\n    // for optimization\n    if (Constructor === Float16Array) {\n      const proxy = new Float16Array(length);\n      const float16bitsArray = getFloat16BitsArray(proxy);\n\n      for (let i = 0; i < length; ++i) {\n        float16bitsArray[i] = roundToFloat16Bits(items[i]);\n      }\n\n      return proxy;\n    }\n\n    const array = new Constructor(length);\n\n    for (let i = 0; i < length; ++i) {\n      array[i] = items[i];\n    }\n\n    return array;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.keys */\n  keys() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    return TypedArrayPrototypeKeys(float16bitsArray);\n  }\n\n  /**\n   * limitation: returns a object whose prototype is not `%ArrayIteratorPrototype%`\n   * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.values\n   */\n  values() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    return wrap((function* () {\n      // eslint-disable-next-line no-restricted-syntax\n      for (const val of TypedArrayPrototypeValues(float16bitsArray)) {\n        yield convertToNumber(val);\n      }\n    })());\n  }\n\n  /**\n   * limitation: returns a object whose prototype is not `%ArrayIteratorPrototype%`\n   * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.entries\n   */\n  entries() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    return wrap((function* () {\n      // eslint-disable-next-line no-restricted-syntax\n      for (const [i, val] of TypedArrayPrototypeEntries(float16bitsArray)) {\n        yield /** @type {[number, number]} */ ([i, convertToNumber(val)]);\n      }\n    })());\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.at */\n  at(index) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const relativeIndex = ToIntegerOrInfinity(index);\n    const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;\n\n    if (k < 0 || k >= length) {\n      return;\n    }\n\n    return convertToNumber(float16bitsArray[k]);\n  }\n\n  /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.with */\n  with(index, value) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const relativeIndex = ToIntegerOrInfinity(index);\n    const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;\n\n    const number = +value;\n\n    if (k < 0 || k >= length) {\n      throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);\n    }\n\n    // don't use SpeciesConstructor\n    const uint16 = new NativeUint16Array(\n      TypedArrayPrototypeGetBuffer(float16bitsArray),\n      TypedArrayPrototypeGetByteOffset(float16bitsArray),\n      TypedArrayPrototypeGetLength(float16bitsArray)\n    );\n    const cloned = new Float16Array(\n      TypedArrayPrototypeGetBuffer(\n        TypedArrayPrototypeSlice(uint16)\n      )\n    );\n    const array = getFloat16BitsArray(cloned);\n\n    array[k] = roundToFloat16Bits(number);\n\n    return cloned;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.map */\n  map(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n\n    // for optimization\n    if (Constructor === Float16Array) {\n      const proxy = new Float16Array(length);\n      const array = getFloat16BitsArray(proxy);\n\n      for (let i = 0; i < length; ++i) {\n        const val = convertToNumber(float16bitsArray[i]);\n        array[i] = roundToFloat16Bits(\n          ReflectApply(callback, thisArg, [val, i, this])\n        );\n      }\n\n      return proxy;\n    }\n\n    const array = new Constructor(length);\n    assertSpeciesTypedArray(array, length);\n\n    for (let i = 0; i < length; ++i) {\n      const val = convertToNumber(float16bitsArray[i]);\n      array[i] = ReflectApply(callback, thisArg, [val, i, this]);\n    }\n\n    return /** @type {any} */ (array);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.filter */\n  filter(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    const kept = [];\n    for (let i = 0; i < length; ++i) {\n      const val = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [val, i, this])) {\n        ArrayPrototypePush(kept, val);\n      }\n    }\n\n    const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n    const array = new Constructor(kept);\n    assertSpeciesTypedArray(array);\n\n    return /** @type {any} */ (array);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduce */\n  reduce(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    if (length === 0 && opts.length === 0) {\n      throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);\n    }\n\n    let accumulator, start;\n    if (opts.length === 0) {\n      accumulator = convertToNumber(float16bitsArray[0]);\n      start = 1;\n    } else {\n      accumulator = opts[0];\n      start = 0;\n    }\n\n    for (let i = start; i < length; ++i) {\n      accumulator = callback(\n        accumulator,\n        convertToNumber(float16bitsArray[i]),\n        i,\n        this\n      );\n    }\n\n    return accumulator;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduceright */\n  reduceRight(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    if (length === 0 && opts.length === 0) {\n      throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);\n    }\n\n    let accumulator, start;\n    if (opts.length === 0) {\n      accumulator = convertToNumber(float16bitsArray[length - 1]);\n      start = length - 2;\n    } else {\n      accumulator = opts[0];\n      start = length - 1;\n    }\n\n    for (let i = start; i >= 0; --i) {\n      accumulator = callback(\n        accumulator,\n        convertToNumber(float16bitsArray[i]),\n        i,\n        this\n      );\n    }\n\n    return accumulator;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.foreach */\n  forEach(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      ReflectApply(callback, thisArg, [\n        convertToNumber(float16bitsArray[i]),\n        i,\n        this,\n      ]);\n    }\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.find */\n  find(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      const value = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [value, i, this])) {\n        return value;\n      }\n    }\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.findindex */\n  findIndex(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      const value = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [value, i, this])) {\n        return i;\n      }\n    }\n\n    return -1;\n  }\n\n  /** @see https://tc39.es/proposal-array-find-from-last/index.html#sec-%typedarray%.prototype.findlast */\n  findLast(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = length - 1; i >= 0; --i) {\n      const value = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [value, i, this])) {\n        return value;\n      }\n    }\n  }\n\n  /** @see https://tc39.es/proposal-array-find-from-last/index.html#sec-%typedarray%.prototype.findlastindex */\n  findLastIndex(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = length - 1; i >= 0; --i) {\n      const value = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [value, i, this])) {\n        return i;\n      }\n    }\n\n    return -1;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.every */\n  every(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      if (\n        !ReflectApply(callback, thisArg, [\n          convertToNumber(float16bitsArray[i]),\n          i,\n          this,\n        ])\n      ) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.some */\n  some(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      if (\n        ReflectApply(callback, thisArg, [\n          convertToNumber(float16bitsArray[i]),\n          i,\n          this,\n        ])\n      ) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.set */\n  set(input, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const targetOffset = ToIntegerOrInfinity(opts[0]);\n    if (targetOffset < 0) {\n      throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);\n    }\n\n    if (input == null) {\n      throw NativeTypeError(\n        CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n      );\n    }\n\n    if (isNativeBigIntTypedArray(input)) {\n      throw NativeTypeError(\n        CANNOT_MIX_BIGINT_AND_OTHER_TYPES\n      );\n    }\n\n    // for optimization\n    if (isFloat16Array(input)) {\n      // peel off Proxy\n      return TypedArrayPrototypeSet(\n        getFloat16BitsArray(this),\n        getFloat16BitsArray(input),\n        targetOffset\n      );\n    }\n\n    if (isNativeTypedArray(input)) {\n      const buffer = TypedArrayPrototypeGetBuffer(input);\n      if (IsDetachedBuffer(buffer)) {\n        throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n      }\n    }\n\n    const targetLength = TypedArrayPrototypeGetLength(float16bitsArray);\n\n    const src = NativeObject(input);\n    const srcLength = ToLength(src.length);\n\n    if (targetOffset === Infinity || srcLength + targetOffset > targetLength) {\n      throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);\n    }\n\n    for (let i = 0; i < srcLength; ++i) {\n      float16bitsArray[i + targetOffset] = roundToFloat16Bits(src[i]);\n    }\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reverse */\n  reverse() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    TypedArrayPrototypeReverse(float16bitsArray);\n\n    return this;\n  }\n\n  /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toReversed */\n  toReversed() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    // don't use SpeciesConstructor\n    const uint16 = new NativeUint16Array(\n      TypedArrayPrototypeGetBuffer(float16bitsArray),\n      TypedArrayPrototypeGetByteOffset(float16bitsArray),\n      TypedArrayPrototypeGetLength(float16bitsArray)\n    );\n    const cloned = new Float16Array(\n      TypedArrayPrototypeGetBuffer(\n        TypedArrayPrototypeSlice(uint16)\n      )\n    );\n\n    const clonedFloat16bitsArray = getFloat16BitsArray(cloned);\n    TypedArrayPrototypeReverse(clonedFloat16bitsArray);\n\n    return cloned;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill */\n  fill(value, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    TypedArrayPrototypeFill(\n      float16bitsArray,\n      roundToFloat16Bits(value),\n      ...safeIfNeeded(opts)\n    );\n\n    return this;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.copywithin */\n  copyWithin(target, start, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    TypedArrayPrototypeCopyWithin(float16bitsArray, target, start, ...safeIfNeeded(opts));\n\n    return this;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort */\n  sort(compareFn) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const sortCompare = compareFn !== undefined ? compareFn : defaultCompare;\n    TypedArrayPrototypeSort(float16bitsArray, (x, y) => {\n      return sortCompare(convertToNumber(x), convertToNumber(y));\n    });\n\n    return this;\n  }\n\n  /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toSorted */\n  toSorted(compareFn) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    if (compareFn !== undefined && typeof compareFn !== \"function\") {\n      throw new NativeTypeError(THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED);\n    }\n    const sortCompare = compareFn !== undefined ? compareFn : defaultCompare;\n\n    // don't use SpeciesConstructor\n    const uint16 = new NativeUint16Array(\n      TypedArrayPrototypeGetBuffer(float16bitsArray),\n      TypedArrayPrototypeGetByteOffset(float16bitsArray),\n      TypedArrayPrototypeGetLength(float16bitsArray)\n    );\n    const cloned = new Float16Array(\n      TypedArrayPrototypeGetBuffer(\n        TypedArrayPrototypeSlice(uint16)\n      )\n    );\n\n    const clonedFloat16bitsArray = getFloat16BitsArray(cloned);\n    TypedArrayPrototypeSort(clonedFloat16bitsArray, (x, y) => {\n      return sortCompare(convertToNumber(x), convertToNumber(y));\n    });\n\n    return cloned;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.slice */\n  slice(start, end) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n\n    // for optimization\n    if (Constructor === Float16Array) {\n      const uint16 = new NativeUint16Array(\n        TypedArrayPrototypeGetBuffer(float16bitsArray),\n        TypedArrayPrototypeGetByteOffset(float16bitsArray),\n        TypedArrayPrototypeGetLength(float16bitsArray)\n      );\n      return new Float16Array(\n        TypedArrayPrototypeGetBuffer(\n          TypedArrayPrototypeSlice(uint16, start, end)\n        )\n      );\n    }\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const relativeStart = ToIntegerOrInfinity(start);\n    const relativeEnd = end === undefined ? length : ToIntegerOrInfinity(end);\n\n    let k;\n    if (relativeStart === -Infinity) {\n      k = 0;\n    } else if (relativeStart < 0) {\n      k = length + relativeStart > 0 ? length + relativeStart : 0;\n    } else {\n      k = length < relativeStart ? length : relativeStart;\n    }\n\n    let final;\n    if (relativeEnd === -Infinity) {\n      final = 0;\n    } else if (relativeEnd < 0) {\n      final = length + relativeEnd > 0 ? length + relativeEnd : 0;\n    } else {\n      final = length < relativeEnd ? length : relativeEnd;\n    }\n\n    const count = final - k > 0 ? final - k : 0;\n    const array = new Constructor(count);\n    assertSpeciesTypedArray(array, count);\n\n    if (count === 0) {\n      return array;\n    }\n\n    const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray);\n    if (IsDetachedBuffer(buffer)) {\n      throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n    }\n\n    let n = 0;\n    while (k < final) {\n      array[n] = convertToNumber(float16bitsArray[k]);\n      ++k;\n      ++n;\n    }\n\n    return /** @type {any} */ (array);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.subarray */\n  subarray(begin, end) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n\n    const uint16 = new NativeUint16Array(\n      TypedArrayPrototypeGetBuffer(float16bitsArray),\n      TypedArrayPrototypeGetByteOffset(float16bitsArray),\n      TypedArrayPrototypeGetLength(float16bitsArray)\n    );\n    const uint16Subarray = TypedArrayPrototypeSubarray(uint16, begin, end);\n\n    const array = new Constructor(\n      TypedArrayPrototypeGetBuffer(uint16Subarray),\n      TypedArrayPrototypeGetByteOffset(uint16Subarray),\n      TypedArrayPrototypeGetLength(uint16Subarray)\n    );\n    assertSpeciesTypedArray(array);\n\n    return /** @type {any} */ (array);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.indexof */\n  indexOf(element, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n\n    let from = ToIntegerOrInfinity(opts[0]);\n    if (from === Infinity) {\n      return -1;\n    }\n\n    if (from < 0) {\n      from += length;\n      if (from < 0) {\n        from = 0;\n      }\n    }\n\n    for (let i = from; i < length; ++i) {\n      if (\n        ObjectHasOwn(float16bitsArray, i) &&\n        convertToNumber(float16bitsArray[i]) === element\n      ) {\n        return i;\n      }\n    }\n\n    return -1;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.lastindexof */\n  lastIndexOf(element, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n\n    let from = opts.length >= 1 ? ToIntegerOrInfinity(opts[0]) : length - 1;\n    if (from === -Infinity) {\n      return -1;\n    }\n\n    if (from >= 0) {\n      from = from < length - 1 ? from : length - 1;\n    } else {\n      from += length;\n    }\n\n    for (let i = from; i >= 0; --i) {\n      if (\n        ObjectHasOwn(float16bitsArray, i) &&\n        convertToNumber(float16bitsArray[i]) === element\n      ) {\n        return i;\n      }\n    }\n\n    return -1;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.includes */\n  includes(element, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n\n    let from = ToIntegerOrInfinity(opts[0]);\n    if (from === Infinity) {\n      return false;\n    }\n\n    if (from < 0) {\n      from += length;\n      if (from < 0) {\n        from = 0;\n      }\n    }\n\n    const isNaN = NumberIsNaN(element);\n    for (let i = from; i < length; ++i) {\n      const value = convertToNumber(float16bitsArray[i]);\n\n      if (isNaN && NumberIsNaN(value)) {\n        return true;\n      }\n\n      if (value === element) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.join */\n  join(separator) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const array = copyToArray(float16bitsArray);\n\n    return ArrayPrototypeJoin(array, separator);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.tolocalestring */\n  toLocaleString(...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const array = copyToArray(float16bitsArray);\n\n    return ArrayPrototypeToLocaleString(array, ...safeIfNeeded(opts));\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-get-%typedarray%.prototype-@@tostringtag */\n  get [SymbolToStringTag]() {\n    if (isFloat16Array(this)) {\n      return /** @type {any} */ (\"Float16Array\");\n    }\n  }\n}\n\n/** @see https://tc39.es/ecma262/#sec-typedarray.bytes_per_element */\nObjectDefineProperty(Float16Array, \"BYTES_PER_ELEMENT\", {\n  value: BYTES_PER_ELEMENT,\n});\n\n// limitation: It is peaked by `Object.getOwnPropertySymbols(Float16Array)` and `Reflect.ownKeys(Float16Array)`\nObjectDefineProperty(Float16Array, brand, {});\n\n/** @see https://tc39.es/ecma262/#sec-properties-of-the-typedarray-constructors */\nReflectSetPrototypeOf(Float16Array, TypedArray);\n\nconst Float16ArrayPrototype = Float16Array.prototype;\n\n/** @see https://tc39.es/ecma262/#sec-typedarray.prototype.bytes_per_element */\nObjectDefineProperty(Float16ArrayPrototype, \"BYTES_PER_ELEMENT\", {\n  value: BYTES_PER_ELEMENT,\n});\n\n/** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype-@@iterator */\nObjectDefineProperty(Float16ArrayPrototype, SymbolIterator, {\n  value: Float16ArrayPrototype.values,\n  writable: true,\n  configurable: true,\n});\n\nReflectSetPrototypeOf(Float16ArrayPrototype, TypedArrayPrototype);\n","\nconst hex2rgba = (hexstr: string, out_type?: string) : [number, number, number, number] => {\n    out_type = out_type === undefined ? 'float' : out_type;\n\n    const match = hexstr.match(/#([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})?/i);\n    if (match === null) {\n        throw `Got '${hexstr}' in hex2rgba, which does not look like a hex color`;\n    }\n\n    let rgba = match.slice(1).filter(c => c !== undefined).map(c => parseInt(c, 16));\n\n    if (out_type == 'float') {\n        rgba = rgba.map(c => c / 255);\n    }\n\n    return rgba[3] === undefined ? [rgba[0], rgba[1], rgba[2], 1] : [rgba[0], rgba[1], rgba[2], rgba[3]];\n}\n\nconst rgba2hex = (rgba: [number, number, number, number], in_type?: string) : string => {\n    in_type = in_type === undefined ? 'float' : in_type;\n\n    let rgba_ = rgba as number[];\n    if (in_type == 'float') {\n        rgba_ = rgba_.map(c => Math.round(c * 255));\n    }\n\n    return '#' + rgba_.map(c => c.toString(16).padStart(2, '0').toUpperCase()).join('');\n}\n\nconst rgb2hsv = (rgb: [number, number, number]) : [number, number, number] => {\n    const [r, g, b] = rgb;\n\n    const Cmax = Math.max(r, g, b);\n    const Cmin = Math.min(r, g, b);\n    const Delta = Cmax - Cmin;\n    \n    let H: number;\n    if (Delta == 0) {\n        H = 0;\n    }\n    else if (Cmax == r) {\n        H = 60 * ((g - b) / Delta) % 6;\n    }\n    else if (Cmax == g) {\n        H = 60 * ((b - r) / Delta + 2);\n    }\n    else if (Cmax == b) {\n        H = 60 * ((r - g) / Delta + 4);\n    }\n    else {\n        throw \"You've messed something up in rgb2hsv()\";\n    }\n\n    let S = Cmax == 0 ? 0 : Delta / Cmax;\n    let V = Cmax;\n\n    return [H, S, V];\n}\n\nconst hsv2rgb = (hsv: [number, number, number]) : [number, number, number] => {\n    const [H, S, V] = hsv;\n\n    const C = V * S;\n    const X = C * (1 - Math.abs(H / 60 % 2 - 1));\n    const m = V - C;\n\n    let r_prime, g_prime, b_prime;\n    if (0 <= H && H < 60) {\n        r_prime = C; g_prime = X, b_prime = 0;\n    }\n    else if (60 <= H && H < 120) {\n        r_prime = X; g_prime = C, b_prime = 0;\n    }\n    else if (120 <= H && H < 180) {\n        r_prime = 0; g_prime = C, b_prime = X;\n    }\n    else if (180 <= H && H < 240) {\n        r_prime = 0; g_prime = X, b_prime = C;\n    }\n    else if (240 <= H && H < 300) {\n        r_prime = X; g_prime = 0, b_prime = C;\n    }\n    else if (300 <= H && H < 360) {\n        r_prime = C; g_prime = 0, b_prime = X;\n    }\n    else {\n        throw \"H is out of bounds in hsv2rgb\";\n    }\n\n    return [r_prime + m, g_prime + m, b_prime + m];\n}\n\nclass Color {\n    private rgba: [number, number, number, number];\n\n    /**\n     * Create a new color object\n     * @param rgba - An RGBA tuple of floats between 0 and 1\n     */\n    constructor(rgba: [number, number, number, number]) {\n        this.rgba = rgba;\n    }\n\n    /**\n     * The red component of the color as a float value between 0 and 1\n     */\n    get r() {\n        return this.rgba[0];\n    }\n\n    /**\n     * The green component of the color as a float value between 0 and 1\n     */\n    get g() {\n        return this.rgba[1];\n    }\n\n    /**\n     * The blue component of the color as a float value between 0 and 1\n     */\n    get b() {\n        return this.rgba[2];\n    }\n\n    /**\n     * The alpha component (opacity) of the color as a float value between 0 and 1\n     */\n    get a() {\n        return this.rgba[3];\n    }\n\n    /**\n     * @param opacity - The new alpha component (opacity)\n     * @returns A new color with the alpha component set to opacity.\n     */\n    withOpacity(opacity: number) {\n        return new Color([this.r, this.g, this.b, opacity]);\n    }\n\n    /**\n     * @returns The color as an RGB hex string (e.g., '#dedbef')\n     */\n    toRGBHex() {\n        return this.toRGBAHex().slice(0, -2);\n    }\n\n    /**\n     * @returns The color as an RGBA hex string (e.g., '#dedbefff')\n     */\n    toRGBAHex() {\n        return rgba2hex(this.rgba);\n    }\n\n    /**\n     * @returns The color as an RGBA float tuple\n     */\n    toRGBATuple() {\n        return this.rgba;\n    }\n\n    /**\n     * @returns The color as a tuple of HSV values\n     */\n    toHSVTuple() {\n        return rgb2hsv([this.r, this.g, this.b]);\n    }\n\n    /**\n     * @param hex - An RGB or RGBA hex string to parse\n     * @returns a new Color object\n     */\n    static fromHex(hex: string) {\n        return new Color(hex2rgba(hex));\n    }\n\n    /**\n     * @param hsv - A tuple of HSV values\n     * @returns a new Color object\n     */\n    static fromHSVTuple(hsv: [number, number, number]) {\n        const rgb = hsv2rgb(hsv);\n        return new Color([rgb[0], rgb[1], rgb[2], 1]);\n    }\n}\n\nexport {Color};","\nimport spd500_colormap_data from \"./json/pw500speed_colormap.json\";\nimport spd850_colormap_data from \"./json/pw850speed_colormap.json\";\nimport cape_colormap_data from \"./json/pwcape_colormap.json\";\nimport t2m_colormap_data from \"./json/pwt2m_colormap.json\";\nimport td2m_colormap_data from \"./json/pwtd2m_colormap.json\";\nimport nws_storm_clear_refl_colormap_data from \"./json/nws_storm_clear_refl_colormap.json\";\nimport { Float16Array } from \"@petamoriken/float16\";\nimport { WGLProgram, WGLTexture } from \"autumn-wgl\";\nimport { WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { getGLFormatTypeAlignment } from \"./PlotComponent\";\nimport { Color } from \"./Color\";\n\nconst colormap_shader_src = require('./glsl/colormap.glsl');\n\ninterface ColorMapOptions {\n    /** The color to use for areas where the value is above the highest value in the color map */\n    overflow_color?: Color | string;\n\n    /** The color to use for areas where the value is below the lowest value in the color map */\n    underflow_color?: Color | string;\n}\n\n/** A mapping from values to colors */\nclass ColorMap {\n    public readonly levels: number[];\n    public readonly colors: Color[];\n    public readonly overflow_color: Color | null;\n    public readonly underflow_color: Color | null;\n\n    /**\n     * Create a color map\n     * @param levels - The list of levels. The number of levels should always be one more than the number of colors.\n     * @param colors - A list of colors\n     * @param opts   - Options for the color map\n     */\n    constructor(levels: number[], colors: Color[] | string[], opts?: ColorMapOptions) {\n        if (levels.length != colors.length + 1) {\n            throw `Mismatch between number of levels (${levels.length}) and number of colors (${colors.length}; expected ${levels.length - 1})`;\n        }\n\n        const normalizeColor = (c: Color | string) => c instanceof Color ? c : Color.fromHex(c);\n\n        this.levels = levels;\n        this.colors = colors.map(c => normalizeColor(c));\n\n        opts = opts === undefined ? {} : opts;\n        this.overflow_color = opts.overflow_color === undefined ? null : normalizeColor(opts.overflow_color);\n        this.underflow_color = opts.underflow_color === undefined ? null : normalizeColor(opts.underflow_color);\n    }\n\n    /**\n     * @returns an array of hex color strings\n     */\n    public getColors() : string[] {\n        return this.colors.map(s => s.toRGBHex());\n    }\n\n    /**\n     * @returns an array of opacities, one for each color in the color map\n     */\n    public getOpacities() : number[] {\n        return this.colors.map(s => s.a);\n    }\n\n    /**\n     * Make a new color map with different opacities. The opacities are set by func.\n     * @param func - A function which takes the two levels associated with a color (an upper and lower bound) and returns an opacity in the range from 0 to 1.\n     * @returns A new color map\n     */\n    public withOpacity(func: (level_lower: number, level_upper: number) => number) {\n        const new_colors: Color[] = [];\n        const new_levels: number[] = [];\n        const opts: ColorMapOptions = {};\n\n        for (let ic = 0 ; ic < this.colors.length ; ic++) {\n            const color = this.colors[ic];\n            const level_lower = this.levels[ic];\n            const level_upper = this.levels[ic + 1];\n\n            const new_opacity = func(level_lower, level_upper)\n            const new_color = color.withOpacity(new_opacity);\n            if (new_opacity > 0) {\n                if (new_levels[new_levels.length - 1] != level_lower)\n                    new_levels.push(level_lower)\n                new_levels.push(level_upper);\n                new_colors.push(new_color);\n            }\n        }\n\n        if (this.underflow_color !== null) {\n            const underflow_opacity = func(this.levels[0], this.levels[0]);\n            if (underflow_opacity > 0) {\n                opts.underflow_color = this.underflow_color.withOpacity(underflow_opacity);\n            }\n        }\n\n        if (this.overflow_color !== null) {\n            const overflow_opacity = func(this.levels[this.levels.length - 1], this.levels[this.levels.length - 1]);\n            if (overflow_opacity > 0) {\n                opts.overflow_color = this.overflow_color.withOpacity(overflow_opacity);\n            }\n        }\n        \n        return new ColorMap(new_levels, new_colors, opts);\n    }\n\n    /**\n     * Create a diverging color map using two input colors\n     * @param color1    - The color corresponding to the lowest value in the color map\n     * @param color2    - The color corresponding to the highest value in the color map\n     * @param level_min - The lowest value in the color map\n     * @param level_max - The highest value in the color map\n     * @param n_colors  - The number of colors to use\n     * @returns a Colormap object\n     */\n    public static diverging(color1: string, color2: string, level_min: number, level_max: number, n_colors: number) {\n        const stops: Color[] = [];\n        const levels: number[] = [];\n\n        const level_step = (level_max - level_min) / (n_colors - 1);\n        const crossover = (level_max + level_min) / 2;\n        const crossover_hsv: [number, number, number] = [0, 0, 0.9];\n\n        const color1_hsv = Color.fromHex(color1).toHSVTuple();\n        const color2_hsv = Color.fromHex(color2).toHSVTuple();\n        const interp_fac_power = 1.5;\n\n        for (let istop = 0; istop < n_colors; istop++) {\n            const level = level_min + istop * level_step;\n            let h, s, v;\n            let interp_fac;\n            if (level < crossover) {\n                interp_fac = Math.pow((crossover - level) / (crossover - level_min), interp_fac_power);\n\n                [h, s, v] = [\n                    color1_hsv[0], \n                    crossover_hsv[1] + (color1_hsv[1] - crossover_hsv[1]) * interp_fac,\n                    crossover_hsv[2] + (color1_hsv[2] - crossover_hsv[2]) * interp_fac]\n            }\n            else {\n                interp_fac = Math.pow((level - crossover) / (level_max - crossover), interp_fac_power);\n                \n                [h, s, v] = [\n                    color2_hsv[0], \n                    crossover_hsv[1] + (color2_hsv[1] - crossover_hsv[1]) * interp_fac,\n                    crossover_hsv[2] + (color2_hsv[2] - crossover_hsv[2]) * interp_fac]\n            }\n\n            stops.push(Color.fromHSVTuple([h, s, v]).withOpacity(Math.min(2 * interp_fac, 1)));\n        }\n\n        for (let ilev = 0; ilev <= n_colors; ilev++) {\n            const level_step = (level_max - level_min) / n_colors;\n            levels.push(level_min + ilev * level_step);\n        }\n\n        return new ColorMap(levels, stops);\n    }\n}\n\nfunction buildColormap(cm_data: {levels: number[], colors: string[]}, overflow: 'under' | 'over' | 'both' | 'neither') {\n    const n_colors = cm_data.colors.length;\n    const opts: ColorMapOptions = {};\n\n    if (overflow == 'over' || overflow == 'both') {\n        opts.overflow_color = cm_data.colors[n_colors - 1];\n    }\n    if (overflow == 'under' || overflow == 'both') {\n        opts.underflow_color = cm_data.colors[0];\n    }\n\n    return new ColorMap(cm_data.levels, cm_data.colors, opts);\n}\n\n// Some built-in colormaps\nconst pw_speed500mb = buildColormap(spd500_colormap_data, 'over').withOpacity((levl, levu) => Math.min((levu - 20) / 10, 1.));\nconst pw_speed850mb = buildColormap(spd850_colormap_data, 'over').withOpacity((levl, levu) => Math.min((levu - 20) / 10, 1.));\nconst pw_cape = buildColormap(cape_colormap_data, 'over').withOpacity((levl, levu) => Math.min(levu / 1000., 1.));\nconst pw_t2m = buildColormap(t2m_colormap_data, 'both');\nconst pw_td2m = buildColormap(td2m_colormap_data, 'both');\nconst nws_storm_clear_refl = buildColormap(nws_storm_clear_refl_colormap_data, 'over');\n\n/**\n * Create a diverging red/blue colormap, where red corresponds to the lowest value and blue corresponds to the highest value\n * @param level_min - The lowest value in the color map\n * @param level_max - The highest value in the color map\n * @param n_colors  - The number of colors\n * @returns a Colormap object\n */\nconst redblue = (level_min: number, level_max: number, n_colors: number) => {\n    return ColorMap.diverging('#ff0000', '#0000ff', level_min, level_max, n_colors);\n}\n\n/**\n * Create a diverging blue/red colormap, where blue corresponds to the lowest value and red corresponds to the highest value\n * @param level_min - The lowest value in the color map\n * @param level_max - The highest value in the color map\n * @param n_colors  - The number of colors\n * @returns a Colormap object\n */\nconst bluered = (level_min: number, level_max: number, n_colors: number) => {\n    return ColorMap.diverging('#0000ff', '#ff0000', level_min, level_max, n_colors);\n}\n\n\ninterface ColorMapGLElems {\n    cmap_texture: WGLTexture;\n    cmap_nonlin_texture: WGLTexture;\n}\n\nconst N_INDEX_MAP = 101;\n\nclass ColorMapGPUInterface {\n    public readonly colormap: ColorMap;\n    public gl_elems: ColorMapGLElems | null;\n\n    constructor(colormap: ColorMap) {\n        this.colormap = colormap;\n        this.gl_elems = null;\n    }\n\n    public static applyShader(shader_src: string) {\n        return colormap_shader_src + \"\\n\" + shader_src;\n    }\n\n    public setupShaderVariables(gl: WebGLAnyRenderingContext, mag_filter: number) {\n        const index_map = makeIndexMap(this.colormap);\n        const cmap_image = makeTextureImage(this.colormap);\n\n        const {format: format_nonlin, type: type_nonlin, row_alignment: row_alignment_nonlin} = getGLFormatTypeAlignment(gl, true);\n\n        const cmap_image_spec = {'format': gl.RGBA, 'type': gl.UNSIGNED_BYTE, 'image': cmap_image, 'mag_filter': mag_filter};\n        const cmap_texture = new WGLTexture(gl, cmap_image_spec);\n\n        const cmap_nonlin_image = {'format': format_nonlin, 'type': type_nonlin, \n            'width': index_map.length, 'height': 1,\n            'image': new Uint16Array(index_map.buffer), \n            'mag_filter': gl.LINEAR, 'row_alignment': row_alignment_nonlin,\n        };\n\n        const cmap_nonlin_texture = new WGLTexture(gl, cmap_nonlin_image);\n        this.gl_elems = {cmap_texture: cmap_texture, cmap_nonlin_texture: cmap_nonlin_texture};\n    }\n\n    public bindShaderVariables(program: WGLProgram) {\n        if (this.gl_elems === null) return;\n\n        const cmap = this.colormap;\n        const underflow_color = cmap.underflow_color === null ? [0, 0, 0, 0] : cmap.underflow_color.toRGBATuple();\n        const overflow_color = cmap.overflow_color === null ? [0, 0, 0, 0] : cmap.overflow_color.toRGBATuple();\n\n        program.setUniforms({'u_cmap_min': cmap.levels[0], 'u_cmap_max': cmap.levels[cmap.levels.length - 1],\n                             'u_n_index': N_INDEX_MAP, 'u_underflow_color': underflow_color, 'u_overflow_color': overflow_color});\n        program.bindTextures({'u_cmap_sampler': this.gl_elems.cmap_texture, 'u_cmap_nonlin_sampler': this.gl_elems.cmap_nonlin_texture});\n    }\n}\n\n/**\n * Make a canvas image corresponding to a color map\n * @param colormap - The color map to use\n * @returns A canvas element containing each color of the color map\n */\nfunction makeTextureImage(colormap: ColorMap) {\n    const cmap_image = document.createElement('canvas');\n    cmap_image.width = colormap.colors.length;\n    cmap_image.height = 1;\n\n    let ctx = cmap_image.getContext('2d');\n\n    colormap.colors.forEach((stop, istop) => {\n        if (ctx === null) {\n            throw \"Could not get rendering context for colormap image canvas\";\n        }\n\n        ctx.fillStyle = stop.toRGBAHex();\n        ctx.fillRect(istop, 0, 1, 1);\n    });\n\n    return cmap_image;\n}\n\nfunction makeIndexMap(colormap: ColorMap) {\n    // Build a texture to account for nonlinear colormaps (basically inverts the relationship between\n    //  the normalized index and the normalized level)\n    const n_nonlin = N_INDEX_MAP;\n    const map_norm = [];\n    for (let i = 0; i < n_nonlin; i++) {\n        map_norm.push(i / (n_nonlin - 1));\n    }\n\n    const levels = colormap.levels;\n    const n_lev = levels.length - 1;\n\n    const input_norm = levels.map((lev, ilev) => ilev / n_lev);\n    const cmap_norm = levels.map(lev => (lev - levels[0]) / (levels[n_lev] - levels[0]));\n    const inv_cmap_norm = map_norm.map(lev => {\n        let jlev;\n        for (jlev = 0; !(cmap_norm[jlev] <= lev && lev <= cmap_norm[jlev + 1]); jlev++) {}\n\n        const alpha = (lev - cmap_norm[jlev]) / (cmap_norm[jlev + 1] - cmap_norm[jlev]);\n        return input_norm[jlev] * (1 - alpha) + input_norm[jlev + 1] * alpha;\n    });\n\n    return new Float16Array(inv_cmap_norm);\n}\n\nexport {ColorMap, ColorMapGPUInterface, bluered, redblue, pw_speed500mb, pw_speed850mb, pw_cape, pw_t2m, pw_td2m, nws_storm_clear_refl}\nexport type {ColorMapOptions};","\nimport { WGLBuffer, WGLProgram, WGLTexture } from \"autumn-wgl\";\nimport { Polyline, LineData, WebGLAnyRenderingContext, isWebGL2Ctx } from \"./AutumnTypes\";\nimport { ColorMap, ColorMapGPUInterface } from \"./Colormap\";\nimport { Color } from \"./Color\";\nimport { layer_worker } from \"./PlotComponent\";\n\nconst polyline_vertex_src = require('./glsl/polyline_vertex.glsl');\nconst polyline_fragment_src = require('./glsl/polyline_fragment.glsl');\n\n/**\n * A style to use to draw lines. The possible options are '-' for a solid line, '--' for a dashed line, ':' for a\n *  dotted line, '-.' for a dash-dot line, or you could pass a list of numbers (e.g., [1, 1, 1, 0, 1, 0]) to\n *  specify a custom dash scheme.\n */\ntype LineStyle = \"-\" | \"--\" | \":\" | \"-.\" | number[];\n\nconst dash_arrays: Record<Exclude<LineStyle, number[]>, number[]> = {\n    \"-\": [1],\n    \"--\": [1, 1, 1, 1, 0, 0],\n    \":\": [1, 0],\n    \"-.\": [1, 1, 1, 0, 1, 0],\n}\n\nfunction isLineStyle(obj: any) : obj is LineStyle {\n    return obj in dash_arrays || Array.isArray(obj) && obj.length > 0 && obj.map(e => typeof e === 'number').reduce((a, b) => a && b, true);\n}\n\ninterface PolylineCollectionOpts {\n    offset_scale?: number;\n    color?: string;\n    cmap?: ColorMap;\n    line_width?: number;\n    line_style?: LineStyle | number[];\n}\n\nfunction makeDashTexture(gl: WebGLAnyRenderingContext, line_style: LineStyle) {\n\n    const dash_array = Array.isArray(line_style) ? line_style : dash_arrays[line_style];\n\n    const is_webgl2 = isWebGL2Ctx(gl);\n    const format = is_webgl2 ? gl.R8 : gl.LUMINANCE;\n    const type = gl.UNSIGNED_BYTE;\n    const row_alignment = 1;\n\n    const fill_image = {'format': format, 'type': type,\n        'width': dash_array.length, 'height': 1, 'image': new Uint8Array(dash_array.map(d => d > 0 ? 255 : 0)),\n        'mag_filter': gl.NEAREST, 'row_alignment': row_alignment,\n    };\n\n    return [dash_array.length, new WGLTexture(gl, fill_image)] as [number, WGLTexture];\n}\n\nclass PolylineCollection {\n    public readonly width: number;\n    public readonly scale: number | null;\n\n    private readonly program: WGLProgram;\n\n    private readonly vertices: WGLBuffer;\n    private readonly extrusion: WGLBuffer;\n\n    private readonly offset: WGLBuffer | null;\n    private readonly min_zoom: WGLBuffer | null;\n    private readonly line_data: WGLBuffer | null;\n    private readonly color: Color;\n    private readonly cmap_gpu: ColorMapGPUInterface | null;\n    private readonly dash_texture: WGLTexture;\n    private readonly n_dash: number;\n\n    private constructor(gl: WebGLAnyRenderingContext, polyline: Polyline, opts?: PolylineCollectionOpts) {\n        opts = opts === undefined ? {} : opts;\n        const color_hex = opts.color === undefined ? '#000000' : opts.color;\n        this.color = Color.fromHex(color_hex);\n\n        const line_width = opts.line_width === undefined ? 1 : opts.line_width;\n        const line_style = opts.line_style === undefined ? '-' : opts.line_style;\n\n        this.width = line_width;\n\n        const shader_defines = [];\n\n        this.vertices = new WGLBuffer(gl, polyline['vertices'], 3, gl.TRIANGLE_STRIP);\n        this.extrusion = new WGLBuffer(gl, polyline['extrusion'], 2, gl.TRIANGLE_STRIP);\n\n        if (polyline.offsets !== undefined) {\n            this.offset = new WGLBuffer(gl, polyline.offsets, 2, gl.TRIANGLE_STRIP);\n            this.scale = opts.offset_scale === undefined ? 1 : opts.offset_scale;\n            shader_defines.push('OFFSET');\n        }\n        else {\n            this.offset = null;\n            this.scale = null;\n        }\n\n        if (polyline.zoom !== undefined) {\n            this.min_zoom = new WGLBuffer(gl, polyline.zoom, 1, gl.TRIANGLE_STRIP);\n            shader_defines.push('ZOOM');\n        }\n        else {\n            this.min_zoom = null;\n        }\n\n        let fragment_src = polyline_fragment_src;\n        if (polyline.data !== undefined) {\n            shader_defines.push('DATA');\n\n            this.line_data = new WGLBuffer(gl, polyline.data, 1, gl.TRIANGLE_STRIP);\n\n            const cmap = opts.cmap === undefined ? new ColorMap([0, 1], [color_hex], {overflow_color: color_hex, underflow_color: color_hex}) : opts.cmap;\n            this.cmap_gpu = new ColorMapGPUInterface(cmap);\n            this.cmap_gpu.setupShaderVariables(gl, gl.NEAREST);\n\n            fragment_src = ColorMapGPUInterface.applyShader(fragment_src);\n        }\n        else {\n            this.line_data = null;\n            this.cmap_gpu = null;\n        }\n\n        [this.n_dash, this.dash_texture] = makeDashTexture(gl, line_style);\n\n        this.program = new WGLProgram(gl, polyline_vertex_src, fragment_src, {define: shader_defines});\n    }\n\n    static async make(gl: WebGLAnyRenderingContext, lines: LineData[], opts?: PolylineCollectionOpts) {\n        const polylines = await layer_worker.makePolyLines(lines);\n        return new PolylineCollection(gl, polylines, opts);\n    }\n\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array, [map_width, map_height]: [number, number], map_zoom: number, map_bearing: number, map_pitch: number) {\n        if (matrix instanceof Float32Array)\n            matrix = [...matrix];\n\n        const attributes: Record<string, WGLBuffer> = {'a_pos': this.vertices, 'a_extrusion': this.extrusion};\n        const uniforms: Record<string, number | number[]> = {\n            'u_matrix': matrix, 'u_line_width': this.width, 'u_map_width': map_width, 'u_map_height': map_height, 'u_map_bearing': map_bearing, 'u_offset': 0, 'u_zoom': map_zoom,\n            'u_dash_pattern_length': this.n_dash\n        };\n        const textures: Record<string, WGLTexture> = {'u_dash_sampler': this.dash_texture};\n\n        if (this.offset !== null && this.scale !== null) {\n            attributes['a_offset'] = this.offset;\n            uniforms['u_offset_scale'] = this.scale * (map_height / map_width);\n        }\n\n        if (this.min_zoom !== null) {\n            attributes['a_min_zoom'] = this.min_zoom;\n        }\n\n        if (this.line_data !== null) {\n            attributes['a_data'] = this.line_data;\n        }\n        else {\n            uniforms['u_color'] = this.color.toRGBATuple();\n        }\n\n        this.program.use(attributes, uniforms, textures);\n\n        if (this.cmap_gpu !== null) {\n            this.cmap_gpu.bindShaderVariables(this.program);\n        }\n\n        gl.enable(gl.BLEND);\n        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n        this.program.draw();\n\n        this.program.setUniforms({'u_offset': -2});\n        this.program.draw();\n\n        this.program.setUniforms({'u_offset': -1});\n        this.program.draw();\n\n        this.program.setUniforms({'u_offset': 1});\n        this.program.draw();\n    }\n}\n\nexport {PolylineCollection, isLineStyle};\nexport type {PolylineCollectionOpts, LineStyle};","import { isWebGL2Ctx, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { Color } from \"./Color\";\nimport { LngLat } from \"./Map\";\nimport { Cache, normalizeOptions } from \"./utils\";\n\nimport { WGLBuffer, WGLProgram, WGLTexture } from \"autumn-wgl\";\n\nimport Protobuf from 'pbf';\nimport potpack, {PotpackBox} from \"potpack\";\n\nconst text_vertex_shader_src = require('./glsl/text_vertex.glsl');\nconst text_fragment_shader_src = require('./glsl/text_fragment.glsl');\nconst program_cache = new Cache((gl: WebGLAnyRenderingContext) => new WGLProgram(gl, text_vertex_shader_src, text_fragment_shader_src));\n\nconst PADDING = 3\n\ninterface PBFGlyph {\n    id: number;\n    data: Uint8Array;\n    width: number;\n    height: number;\n    left: number;\n    top: number;\n    advance: number;\n}\n\ninterface Glyph {\n    id: number;\n    width: number;\n    height: number;\n    left: number;\n    top: number;\n    atlas_i: number;\n    atlas_j: number;\n    advance: number;\n}\n\nfunction parseFontPBF(data: Uint8Array) {\n    const readGlyph = (tag: number, glyph: any, pbf?: Protobuf) => {\n        if (pbf === undefined)\n            return;\n\n        switch (tag) {\n            case 1:\n                glyph.id = pbf.readVarint();\n                break;\n            case 2:\n                glyph.data = pbf.readBytes();\n                break;\n            case 3:\n                glyph.width = pbf.readVarint() + 2 * PADDING;\n                break;\n            case 4:\n                glyph.height = pbf.readVarint() + 2 * PADDING;\n                break;\n            case 5:\n                glyph.left = pbf.readSVarint();\n                break;\n            case 6:\n                glyph.top = pbf.readSVarint();\n                break;\n            case 7:\n                glyph.advance = pbf.readVarint();\n                break;\n        }\n    }\n\n    const readFontStack = (tag: number, glyphs?: PBFGlyph[], pbf?: Protobuf) => {\n        if (glyphs === undefined || pbf === undefined)\n            return;\n        \n        if (tag == 3) {\n            const glyph = pbf.readMessage(readGlyph, {} as PBFGlyph);\n            glyphs.push(glyph);\n        }\n    }\n\n    const readFontStacks = (tag: number, glyphs?: PBFGlyph[], pbf?: Protobuf) => {\n        if (pbf === undefined) \n            return;\n\n        if (tag == 1) {\n            pbf.readMessage(readFontStack, glyphs);\n        }\n    }\n\n    return new Protobuf(data).readFields(readFontStacks, []);\n}\n\ninterface FontAtlas {\n    atlas: Uint8Array;\n    atlas_width: number;\n    atlas_height: number;\n    baseline: number;\n    top: number;\n    glyph_info: Record<number, Glyph>;\n}\n\nfunction createAtlas(pbf_glyphs: PBFGlyph[]): FontAtlas {\n    const pbf_glyphs_filtered = pbf_glyphs.filter(glyph => glyph.data !== undefined);\n\n    const glyph_bins: {glyph: PBFGlyph, bin: PotpackBox}[] = [];\n\n    const bins = pbf_glyphs_filtered.map(glyph => {\n        const bin = {x: 0, y: 0, w: glyph.width, h: glyph.height} as PotpackBox;\n        glyph_bins.push({glyph: glyph, bin: bin});\n\n        return bin;\n    });\n\n    const {w: img_width, h: img_height} = potpack(bins);\n\n    const atlas_data = new Uint8Array(img_width * img_height);\n    const glyphs: Record<number, Glyph> = {}\n    glyph_bins.forEach(glyph_bin => {\n        const {bin, glyph} = glyph_bin;\n\n        if (bin.x === undefined || bin.y === undefined)\n            throw `Potpack couldn't pack this pot, I guess?`;\n\n        glyphs[glyph.id] = {\n            id: glyph.id, width: glyph.width, height: glyph.height, left: glyph.left, top: glyph.top,\n            atlas_i: bin.x, atlas_j: bin.y, advance: glyph.advance\n        };\n\n        for (let i = 0; i < glyph.width; i++) {\n            for (let j = 0; j < glyph.height; j++) {\n                const glyph_idx = i + glyph.width * j;\n                const atlas_idx = (i + bin.x) + img_width * (j + bin.y);\n                atlas_data[atlas_idx] = glyph.data[glyph_idx];\n            }\n        }\n    });\n\n    const glyph_M = glyphs['M'.charCodeAt(0)];\n    const baseline = glyph_M.height - glyph_M.top;\n    const top = -glyph_M.top;\n\n    return {atlas: atlas_data, atlas_width: img_width, atlas_height: img_height, baseline: baseline, top: top, glyph_info: glyphs};\n}\n\nasync function getFontAtlas(url: string) {\n    const resp = await fetch(url);\n    const blob = await resp.blob();\n    const data_buffer = await blob.arrayBuffer();\n\n    // Parse the PBF and get the glyph data\n    const glyphs = parseFontPBF(new Uint8Array(data_buffer));\n\n    // Create an atlas for the glyphs\n    return createAtlas(glyphs);\n}\n\ninterface TextSpec {\n    lat: number;\n    lon: number;\n    text: string;\n    min_zoom?: number;\n}\n\ntype HorizontalAlign = 'left' | 'center' | 'right';\ntype VerticalAlign = 'baseline' | 'middle' | 'top';\n\ninterface TextCollectionOptions {\n    horizontal_align?: HorizontalAlign;\n    vertical_align?: VerticalAlign;\n    font_size?: number;\n    text_color?: Color;\n    halo_color?: Color;\n    halo?: boolean;\n}\n\nconst text_collection_opt_defaults: Required<TextCollectionOptions> = {\n    horizontal_align: 'left',\n    vertical_align: 'baseline',\n    font_size: 12,\n    text_color: new Color([0, 0, 0, 1]),\n    halo_color: new Color([0, 0, 0, 1]),\n    halo: false\n}\n\nclass TextCollection {\n    readonly program: WGLProgram;\n    readonly anchors: WGLBuffer;\n    readonly offsets: WGLBuffer;\n    readonly texcoords: WGLBuffer;\n    readonly texture: WGLTexture;\n\n    readonly opts: Required<TextCollectionOptions>;\n\n    private constructor(gl: WebGLAnyRenderingContext, text_locs: TextSpec[], font_atlas: FontAtlas, opts?: TextCollectionOptions) {\n        this.program = program_cache.getValue(gl);\n\n        this.opts = normalizeOptions(opts, text_collection_opt_defaults);\n        \n        const is_webgl2 = isWebGL2Ctx(gl);\n        const format = is_webgl2 ? gl.R8 : gl.LUMINANCE;\n        const type = gl.UNSIGNED_BYTE;\n        const row_alignment = 1;\n\n        const image = {\n            'format': format, 'type': type, 'width': font_atlas.atlas_width, 'height': font_atlas.atlas_height, \n            'image': font_atlas.atlas, 'row_alignment': row_alignment, 'mag_filter': gl.LINEAR\n        };\n\n        this.texture = new WGLTexture(gl, image);\n\n        const n_verts = text_locs.map(tl => tl.text.length).reduce((a, b) => a + b, 0) * 6;\n\n        const anchor_data = new Float32Array(n_verts * 3);\n        const offset_data = new Float32Array(n_verts * 2);\n        const tc_data = new Float32Array(n_verts * 2);\n\n        let i_anch = 0, i_off = 0, i_tc = 0;\n\n        text_locs.forEach(loc => {\n            const {lat, lon, text} = loc;\n            const min_zoom = loc.min_zoom === undefined ? 0 : loc.min_zoom;\n            const {x: anchor_x, y: anchor_y} = new LngLat(lon, lat).toMercatorCoord();\n            \n            let x_offset = 0;\n            const init_i_off = i_off;\n\n            for (let i = 0; i < text.length; i++) {\n                const glyph_code = text.charCodeAt(i);\n                const glyph_info = font_atlas.glyph_info[glyph_code];\n\n                if (glyph_info === undefined) {\n                    x_offset += 7;\n                    continue;\n                }\n\n                x_offset += glyph_info.left;\n\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                \n                offset_data[i_off++] = x_offset;                    offset_data[i_off++] = font_atlas.baseline + glyph_info.top - glyph_info.height;\n                offset_data[i_off++] = x_offset;                    offset_data[i_off++] = font_atlas.baseline + glyph_info.top - glyph_info.height;\n                offset_data[i_off++] = x_offset + glyph_info.width; offset_data[i_off++] = font_atlas.baseline + glyph_info.top - glyph_info.height;\n                offset_data[i_off++] = x_offset;                    offset_data[i_off++] = font_atlas.baseline + glyph_info.top;\n                offset_data[i_off++] = x_offset + glyph_info.width; offset_data[i_off++] = font_atlas.baseline + glyph_info.top;\n                offset_data[i_off++] = x_offset + glyph_info.width; offset_data[i_off++] = font_atlas.baseline + glyph_info.top;\n                \n                tc_data[i_tc++] = glyph_info.atlas_i / font_atlas.atlas_width;                      tc_data[i_tc++] = (glyph_info.atlas_j + glyph_info.height) / font_atlas.atlas_height;\n                tc_data[i_tc++] = glyph_info.atlas_i / font_atlas.atlas_width;                      tc_data[i_tc++] = (glyph_info.atlas_j + glyph_info.height) / font_atlas.atlas_height;\n                tc_data[i_tc++] = (glyph_info.atlas_i + glyph_info.width) / font_atlas.atlas_width; tc_data[i_tc++] = (glyph_info.atlas_j + glyph_info.height) / font_atlas.atlas_height;\n                tc_data[i_tc++] = glyph_info.atlas_i / font_atlas.atlas_width;                      tc_data[i_tc++] = glyph_info.atlas_j / font_atlas.atlas_height;\n                tc_data[i_tc++] = (glyph_info.atlas_i + glyph_info.width) / font_atlas.atlas_width; tc_data[i_tc++] = glyph_info.atlas_j / font_atlas.atlas_height;\n                tc_data[i_tc++] = (glyph_info.atlas_i + glyph_info.width) / font_atlas.atlas_width; tc_data[i_tc++] = glyph_info.atlas_j / font_atlas.atlas_height;\n\n                x_offset += glyph_info.advance - glyph_info.left;\n            }\n\n            if (this.opts.horizontal_align == 'center') {\n                for (let i = init_i_off; i < init_i_off + text.length * 12; i += 2) {\n                    offset_data[i] -= x_offset / 2;\n                }\n            }\n            else if (this.opts.horizontal_align == 'right') {\n                for (let i = init_i_off; i < init_i_off + text.length * 12; i += 2) {\n                    offset_data[i] -= x_offset;\n                }\n            }\n\n            if (this.opts.vertical_align == 'top') {\n                for (let i = init_i_off + 1; i < init_i_off + text.length * 12; i += 2) {\n                    offset_data[i] -= (font_atlas.baseline - font_atlas.top);\n                }\n            }\n            else if (this.opts.vertical_align == 'middle') {\n                for (let i = init_i_off + 1; i < init_i_off + text.length * 12; i += 2) {\n                    offset_data[i] -= (font_atlas.baseline - font_atlas.top) / 2;\n                }\n            }\n        });\n\n        this.anchors = new WGLBuffer(gl, anchor_data, 3, gl.TRIANGLE_STRIP);\n        this.offsets = new WGLBuffer(gl, offset_data, 2, gl.TRIANGLE_STRIP);\n        this.texcoords = new WGLBuffer(gl, tc_data, 2, gl.TRIANGLE_STRIP);\n    }\n\n    static async make(gl: WebGLAnyRenderingContext, text_locs: TextSpec[], fontstack_url: string, opts?: TextCollectionOptions) {\n        const atlas = await getFontAtlas(fontstack_url);\n        return new TextCollection(gl, text_locs, atlas, opts);\n    }\n\n    render(gl: WebGLAnyRenderingContext, matrix: number[], [map_width, map_height]: [number, number], map_zoom: number) {\n        const uniforms: Record<string, any> = {\n            'u_matrix': matrix, 'u_map_width': map_width, 'u_map_height': map_height, 'u_map_zoom': map_zoom, 'u_font_size': this.opts.font_size,\n            'u_text_color': this.opts.text_color.toRGBATuple(), 'u_halo_color': this.opts.halo_color.toRGBATuple(), 'u_offset': 0\n        }\n\n        uniforms['u_is_halo'] = this.opts.halo ? 1 : 0;\n\n        this.program.use(\n            {'a_pos': this.anchors, 'a_offset': this.offsets, 'a_tex_coord': this.texcoords},\n            uniforms,\n            {'u_sdf_sampler': this.texture}\n        );\n\n        gl.enable(gl.BLEND);\n        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n        this.program.draw();\n\n        if (this.opts.halo) {\n            this.program.setUniforms({'u_is_halo': 0});\n            this.program.draw();\n        }\n\n        this.program.setUniforms({'u_offset': -2, 'u_is_halo': this.opts.halo ? 1 : 0});\n        this.program.draw();\n\n        if (this.opts.halo) {\n            this.program.setUniforms({'u_is_halo': 0});\n            this.program.draw();\n        }\n\n        this.program.setUniforms({'u_offset': -1, 'u_is_halo': this.opts.halo ? 1 : 0});\n        this.program.draw();\n\n        if (this.opts.halo) {\n            this.program.setUniforms({'u_is_halo': 0});\n            this.program.draw();\n        }\n\n        this.program.setUniforms({'u_offset': 1, 'u_is_halo': this.opts.halo ? 1 : 0});\n        this.program.draw();\n\n        if (this.opts.halo) {\n            this.program.setUniforms({'u_is_halo': 0});\n            this.program.draw();\n        }\n    }\n}\n\nexport {TextCollection};\nexport type {TextSpec, TextCollectionOptions};","\nexport default function potpack(boxes) {\n\n    // calculate total box area and maximum box width\n    let area = 0;\n    let maxWidth = 0;\n\n    for (const box of boxes) {\n        area += box.w * box.h;\n        maxWidth = Math.max(maxWidth, box.w);\n    }\n\n    // sort the boxes for insertion by height, descending\n    boxes.sort((a, b) => b.h - a.h);\n\n    // aim for a squarish resulting container,\n    // slightly adjusted for sub-100% space utilization\n    const startWidth = Math.max(Math.ceil(Math.sqrt(area / 0.95)), maxWidth);\n\n    // start with a single empty space, unbounded at the bottom\n    const spaces = [{x: 0, y: 0, w: startWidth, h: Infinity}];\n\n    let width = 0;\n    let height = 0;\n\n    for (const box of boxes) {\n        // look through spaces backwards so that we check smaller spaces first\n        for (let i = spaces.length - 1; i >= 0; i--) {\n            const space = spaces[i];\n\n            // look for empty spaces that can accommodate the current box\n            if (box.w > space.w || box.h > space.h) continue;\n\n            // found the space; add the box to its top-left corner\n            // |-------|-------|\n            // |  box  |       |\n            // |_______|       |\n            // |         space |\n            // |_______________|\n            box.x = space.x;\n            box.y = space.y;\n\n            height = Math.max(height, box.y + box.h);\n            width = Math.max(width, box.x + box.w);\n\n            if (box.w === space.w && box.h === space.h) {\n                // space matches the box exactly; remove it\n                const last = spaces.pop();\n                if (i < spaces.length) spaces[i] = last;\n\n            } else if (box.h === space.h) {\n                // space matches the box height; update it accordingly\n                // |-------|---------------|\n                // |  box  | updated space |\n                // |_______|_______________|\n                space.x += box.w;\n                space.w -= box.w;\n\n            } else if (box.w === space.w) {\n                // space matches the box width; update it accordingly\n                // |---------------|\n                // |      box      |\n                // |_______________|\n                // | updated space |\n                // |_______________|\n                space.y += box.h;\n                space.h -= box.h;\n\n            } else {\n                // otherwise the box splits the space into two spaces\n                // |-------|-----------|\n                // |  box  | new space |\n                // |_______|___________|\n                // | updated space     |\n                // |___________________|\n                spaces.push({\n                    x: space.x + box.w,\n                    y: space.y,\n                    w: space.w - box.w,\n                    h: box.h\n                });\n                space.y += box.h;\n                space.h -= box.h;\n            }\n            break;\n        }\n    }\n\n    return {\n        w: width, // container width\n        h: height, // container height\n        fill: (area / (width * height)) || 0 // space utilization\n    };\n}\n","\nimport { LineData, TypedArray, WebGLAnyRenderingContext} from './AutumnTypes';\nimport { LngLat, MapLikeType } from './Map';\nimport { PlotComponent } from './PlotComponent';\nimport { RawScalarField } from './RawField';\nimport { LineStyle, PolylineCollection, PolylineCollectionOpts, isLineStyle } from './PolylineCollection';\nimport { TextCollection, TextCollectionOptions, TextSpec } from './TextCollection';\nimport { Color } from './Color';\n\nimport { normalizeOptions } from './utils';\nimport { kdTree } from 'kd-tree-javascript';\nimport { ColorMap } from './Colormap';\n\ninterface ContourOptions {\n    /** \n     * The color of the contours as a hex color string \n     * @default '#000000'\n     */\n    color?: string;\n\n    /**\n     * A color map to use to color the contours. Specifying a colormap overrides the color option.\n     * @default null\n     */\n    cmap?: ColorMap | null;\n\n    /** \n     * The contour interval for drawing contours at regular intervals\n     * @default 1\n     */\n    interval?: number;\n\n    /**\n     * A list of arbitrary levels to contour. This overrides the `interval` option.\n     * @default null\n     */\n    levels?: number[] | null;\n\n    /**\n     * The width of the line in pixels. This could be either a number or a function that takes a contour level as a number and returns a line width. This\n     *  can be used to vary the width of the contours by value.\n     * @example level => level >= 100 ? 3 : 1.5\n     * @default 2\n     */\n    line_width?: number | ((level: number) => number);\n\n    /**\n     * The style to use for the line. This can be either a LineStyle or a function that takes a contour level as a number and returns a LineStyle. This \n     *  can be used to vary the contours by value.\n     * @example level => level < 0 ? '--' : '-'\n     * @default '-'\n     */\n    line_style?: LineStyle | ((level: number) => LineStyle);\n}\n\nconst contour_opt_defaults: Required<ContourOptions> = {\n    color: '#000000',\n    cmap: null,\n    interval: 1,\n    levels: null,\n    line_width: 2,\n    line_style: '-'\n}\n\ninterface ContourGLElems<MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n}\n\n/** \n * A field of contoured data.\n * @example\n * // Create a contoured height field, with black contours every 30 m (assuming the height field is in \n * // meters).\n * const contours = new Contour(height_field, {color: '#000000', interval: 30});\n */\nclass Contour<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private field: RawScalarField<ArrayType>;\n    public readonly opts: Required<ContourOptions>;\n\n    private gl_elems: ContourGLElems<MapType> | null;\n    private contours: PolylineCollection[] | null;\n\n    /**\n     * Create a contoured field\n     * @param field - The field to contour\n     * @param opts  - Options for creating the contours\n     */\n    constructor(field: RawScalarField<ArrayType>, opts: ContourOptions) {\n        super();\n\n        this.field = field;\n        this.opts = normalizeOptions(opts, contour_opt_defaults);\n\n        this.gl_elems = null;\n        this.contours = null;\n    }\n\n    /**\n     * Update the data displayed as contours\n     * @param field - The new field to contour\n     */\n    public async updateField(field: RawScalarField<ArrayType>) {\n        this.field = field;\n        if (this.gl_elems === null) return;\n\n        const gl = this.gl_elems.gl;\n\n        const contour_data = await this.getContours();\n\n        type LineDataStyleWidth = {data: LineData[], line_width: number, line_style: LineStyle};\n        const line_data: LineDataStyleWidth[] = [];\n\n        // Make contour data and sort them by line width and line style\n        Object.entries(contour_data).forEach(([cv, cd]) => {\n            const cv_ = parseFloat(cv);\n            const contour_style = isLineStyle(this.opts.line_style) ? this.opts.line_style : this.opts.line_style(cv_);\n            const contour_width = typeof this.opts.line_width === 'number' ? this.opts.line_width : this.opts.line_width(cv_);\n\n            const polyline_data = cd.map(c => {\n                const ld: LineData = {vertices: c};\n                if (this.opts.cmap !== null){\n                    ld.data = c.map(() => cv_)\n                }\n                return ld;\n            });\n\n            const line_data_filtered = line_data.filter(ld => ld.line_style == contour_style && ld.line_width == contour_width);\n            let contour_line_data: LineDataStyleWidth;\n            if (line_data_filtered.length == 0) {\n                contour_line_data = {data: [], line_width: contour_width, line_style: contour_style};\n                line_data.push(contour_line_data);\n            }\n            else {\n                contour_line_data = line_data_filtered[0];\n            }\n\n            contour_line_data.data = contour_line_data.data.concat(polyline_data);\n        });\n\n        // Make one PolylineCollection for each combination of line width and line style\n        const promises = line_data.map(async ld => {\n            const plc_opts: PolylineCollectionOpts = {line_width: ld.line_width, line_style: ld.line_style};\n            if (this.opts.cmap !== null) {\n                plc_opts.cmap = this.opts.cmap;\n            }\n            else {\n                plc_opts.color = this.opts.color;\n            }\n\n            return await PolylineCollection.make(gl, ld.data, plc_opts);\n        });\n\n        Promise.all(promises).then(values => {\n            if (this.gl_elems === null) return;\n\n            this.contours = values;\n            this.gl_elems.map.triggerRepaint();\n        });\n    }\n\n    public async getContours() {\n        const levels = this.opts.levels === null ? undefined : this.opts.levels;\n        return await this.field.getContours({interval: this.opts.interval, levels: levels});\n    }\n\n    /**\n     * @internal\n     * Add the contours to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n\n        this.gl_elems = {\n            gl: gl, map: map\n        };\n\n        await this.updateField(this.field);\n    }\n\n    /**\n     * @internal\n     * Render the contours\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        if (this.gl_elems === null || this.contours === null) return;\n        const gl_elems = this.gl_elems;\n\n        if (matrix instanceof Float32Array)\n            matrix = [...matrix];\n\n        const zoom = gl_elems.map.getZoom();\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const bearing = gl_elems.map.getBearing();\n        const pitch = gl_elems.map.getPitch();\n\n        this.contours.forEach(cnt => cnt.render(gl, matrix, [map_width, map_height], zoom, bearing, pitch));\n    }\n}\n\ninterface ContourLabelGLElems<MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n}\n\ninterface ContourLabelOptions {\n    /**\n     * Number of decimal places to use in the contour labels\n     * @default 0\n     */\n    n_decimal_places?: number;\n\n    /**\n     * Font face to use for the contour labels\n     * @default 'Trebuchet MS'\n     */\n    font_face?: string;\n\n    /**\n     * Font size in points to use for the contour labels\n     * @default 12\n     */\n    font_size?: number;\n\n    /**\n     * URL template to use in retrieving the font data for the labels. The default is to use the template from the map style.\n     */\n    font_url_template?: string;\n\n    /**\n     * Text color for the contour labels\n     * @default '#000000'\n     */\n    text_color?: string;\n\n    /**\n     * Halo (outline) color for the contour labels\n     * @default '#000000'\n     */\n    halo_color?: string;\n\n    /**\n     * Whether to draw the halo (outline) on the contour labels\n     * @default false\n     */\n    halo?: boolean;\n}\n\nconst contour_label_opt_defaults: Required<ContourLabelOptions> = {\n    n_decimal_places: 0,\n    font_face: 'Trebuchet MS',\n    font_size: 12,\n    font_url_template: '',\n    text_color: '#000000',\n    halo_color: '#000000',\n    halo: false\n}\n\nclass ContourLabels<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private readonly contours: Contour<ArrayType, MapType>;\n    private gl_elems: ContourLabelGLElems<MapType> | null;\n    private text_collection: TextCollection | null;\n    private readonly opts: Required<ContourLabelOptions>;\n\n    constructor(contours: Contour<ArrayType, MapType>, opts?: ContourLabelOptions) {\n        super();\n\n        this.opts = normalizeOptions(opts, contour_label_opt_defaults);\n\n        this.contours = contours;\n        this.text_collection = null;\n        this.gl_elems = null;\n    }\n\n    /**\n     * Update contour labels when the field for the associated Contour object has been changed.\n     */\n    public async updateField() {\n        if (this.gl_elems === null) return;\n\n        const map = this.gl_elems.map;\n        const gl = this.gl_elems.gl;\n\n        const map_style = map.getStyle();\n\n        const font_url_template = this.opts.font_url_template == '' ? map_style.glyphs : this.opts.font_url_template;\n        if (font_url_template === undefined)\n            throw \"The map style doesn't have any glyph information. Please pass the font_url_template option to ContourLabels\";\n\n        const font_url = font_url_template.replace('{range}', '0-255').replace('{fontstack}', this.opts.font_face);\n\n        const label_pos: TextSpec[] = [];\n\n        const contour_data = await this.contours.getContours();\n        const contour_levels = Object.keys(contour_data).map(parseFloat);\n        contour_levels.sort((a, b) => a - b);\n\n        const map_max_zoom = map.getMaxZoom();\n        const contour_label_spacing = 0.01 * Math.pow(2, 7 - map_max_zoom);\n        let min_label_lat: number | null = null, max_label_lat: number | null = null, min_label_lon: number | null = null, max_label_lon: number | null = null;\n\n        Object.entries(contour_data).forEach(([level, contours]) => {\n            const icntr = (parseFloat(level) - contour_levels[0]);\n            const level_str = level.toString();\n\n            contours.forEach(contour => {\n                const c_map = contour.map(v => {\n                    const v_ll = new LngLat(...v).toMercatorCoord();\n                    return [v_ll.x, v_ll.y] as [number, number];\n                });\n        \n                const dist: number[] = [];\n                c_map.forEach((v, i) => {\n                    if (i == 0) {\n                        dist.push(0);\n                    }\n                    else {\n                        const v_last = c_map[i - 1];\n                        const this_dist = Math.hypot(v_last[0] - v[0], v_last[1] - v[1]);\n                        dist.push(dist[i - 1] + this_dist);\n                    }\n                });\n\n                let n_labels_placed = 0;\n                for (let idist = 1; idist < dist.length; idist++) {\n                    const target_dist = contour_label_spacing * (n_labels_placed + (icntr / 2) % 1);\n                    if (dist[idist - 1] <= target_dist && target_dist < dist[idist]) {\n                        const pt1 = contour[idist - 1];\n                        const pt2 = contour[idist];\n\n                        const alpha = (target_dist - dist[idist - 1]) / (dist[idist] - dist[idist - 1]);\n                        const pt_lon = (1 - alpha) * pt1[0] + alpha * pt2[0];\n                        const pt_lat = (1 - alpha) * pt1[1] + alpha * pt2[1];\n\n                        if (min_label_lon === null || pt_lon < min_label_lon) min_label_lon = pt_lon;\n                        if (max_label_lon === null || pt_lon > max_label_lon) max_label_lon = pt_lon;\n                        if (min_label_lat === null || pt_lat < min_label_lat) min_label_lat = pt_lat;\n                        if (max_label_lat === null || pt_lat > max_label_lat) max_label_lat = pt_lat;\n\n                        label_pos.push({lon: pt_lon, lat: pt_lat, min_zoom: map_max_zoom, text: level_str});\n                        n_labels_placed++;\n                    }\n                }\n            });\n        });\n\n        const tree = new kdTree(label_pos, (a, b) => Math.hypot(a.lon - b.lon, a.lat - b.lat), ['lon', 'lat']);\n\n        if (min_label_lon === null || min_label_lat === null || max_label_lon === null || max_label_lat === null) {\n            return;\n        }\n\n        const {x: min_label_x, y: max_label_y} = new LngLat(min_label_lon, min_label_lat).toMercatorCoord();\n        const {x: max_label_x, y: min_label_y} = new LngLat(max_label_lon, max_label_lat).toMercatorCoord();\n        const thin_grid_width = max_label_x - min_label_x;\n        const thin_grid_height = max_label_y - min_label_y;\n        const ni_thin_grid = Math.round(4 * thin_grid_width / contour_label_spacing);\n        const nj_thin_grid = Math.round(4 * thin_grid_height / contour_label_spacing);\n        const thin_grid_xs = [];\n        const thin_grid_ys = [];\n\n        for (let idx = 0; idx < ni_thin_grid; idx++) {\n            thin_grid_xs.push(min_label_x + (idx / ni_thin_grid) * thin_grid_width);\n        }\n\n        for (let jdy = 0; jdy < nj_thin_grid; jdy++) {\n            thin_grid_ys.push(min_label_y + (jdy / nj_thin_grid) * thin_grid_height);\n        }\n\n        let skip = 1;\n        for (let zoom = map_max_zoom - 1; zoom >= 0; zoom--) {        \n            for (let idx = 0; idx < ni_thin_grid; idx += skip) {\n                for (let jdy = 0; jdy < nj_thin_grid; jdy += skip) {\n                    const grid_x = thin_grid_xs[idx];\n                    const grid_y = thin_grid_ys[jdy];\n                    const ll = LngLat.fromMercatorCoord(grid_x, grid_y);\n\n                    const [label, dist] = tree.nearest({lon: ll.lng, lat: ll.lat, min_zoom: 0, text: \"\"}, 1)[0];\n                    label.min_zoom = zoom;\n                }\n            }\n\n            skip *= 2;\n        }\n\n        const tc_opts: TextCollectionOptions = {\n            horizontal_align: 'center', vertical_align: 'middle', font_size: this.opts.font_size,\n            halo: this.opts.halo, \n            text_color: Color.fromHex(this.opts.text_color), halo_color: Color.fromHex(this.opts.halo_color),\n        };\n\n        this.text_collection = await TextCollection.make(gl, label_pos, font_url, tc_opts);\n        map.triggerRepaint();\n    }\n\n    /** \n     * @internal \n     * Add the contour labels to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.gl_elems = {\n            gl: gl, map: map,\n        }\n\n        this.updateField();\n    }\n\n    /** \n     * @internal \n     * Render the contour labels\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[]) {\n        if (this.gl_elems === null || this.text_collection === null) return;\n        const gl_elems = this.gl_elems;\n\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const map_zoom = gl_elems.map.getZoom();\n\n        this.text_collection.render(gl, matrix, [map_width, map_height], map_zoom);\n    }\n}\n\nexport default Contour;\nexport {ContourLabels};\nexport type {ContourOptions, ContourLabelOptions};","\nimport { PlotComponent, getGLFormatTypeAlignment } from './PlotComponent';\nimport { ColorMap, ColorMapGPUInterface} from './Colormap';\nimport { WGLBuffer, WGLProgram, WGLTexture } from 'autumn-wgl';\nimport { RawScalarField } from './RawField';\nimport { MapLikeType } from './Map';\nimport { TypedArray, WebGLAnyRenderingContext } from './AutumnTypes';\nimport { normalizeOptions } from './utils';\n\nconst contourfill_vertex_shader_src = require('./glsl/contourfill_vertex.glsl');\nconst contourfill_fragment_shader_src = require('./glsl/contourfill_fragment.glsl');\n\ninterface ContourFillOptions {\n    /** The color map to use when creating the fills */\n    cmap: ColorMap;\n\n    /** \n     * The opacity for the filled contours \n     * @default 1\n     */\n    opacity?: number;\n}\n\nconst default_cmap = new ColorMap([0, 1], ['#000000'], {overflow_color: '#000000', underflow_color: '#000000'})\n\nconst contour_fill_opt_defaults: Required<ContourFillOptions> = {\n    cmap: default_cmap,\n    opacity: 1,\n}\n\ninterface RasterOptions {\n    /** The color map to use when creating the raster plot */\n    cmap: ColorMap;\n\n    /** \n     * The opacity for the raster plot\n     * @default 1\n     */\n    opacity?: number;\n}\n\nconst raster_opt_defaults: Required<RasterOptions> = {\n    cmap: default_cmap,\n    opacity: 1,\n}\n\ninterface PlotComponentFillGLElems<MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n    program: WGLProgram;\n    vertices: WGLBuffer;\n\n    texcoords: WGLBuffer;\n}\n\nclass PlotComponentFill<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private field: RawScalarField<ArrayType>;\n    public readonly opts: Required<ContourFillOptions>;\n\n    private readonly cmap_gpu: ColorMapGPUInterface;\n\n    private gl_elems: PlotComponentFillGLElems<MapType> | null;\n    private fill_texture: WGLTexture | null;\n    protected image_mag_filter: number | null;\n    protected cmap_mag_filter: number | null;\n\n    constructor(field: RawScalarField<ArrayType>, opts: ContourFillOptions) {\n        super();\n\n        this.field = field;\n        this.opts = normalizeOptions(opts, contour_fill_opt_defaults);\n\n        this.cmap_gpu = new ColorMapGPUInterface(this.opts.cmap);\n\n        this.gl_elems = null;\n        this.fill_texture = null;\n        this.image_mag_filter = null;\n        this.cmap_mag_filter = null;\n    }\n\n    public async updateField(field: RawScalarField<ArrayType>) {\n        this.field = field;\n\n        if (this.image_mag_filter === null || this.cmap_mag_filter === null) {\n            throw `Implement magnification filtes in a subclass`;\n        }\n\n        if (this.gl_elems === null) return;\n\n        const gl = this.gl_elems.gl;\n        const map = this.gl_elems.map;\n        \n        const tex_data = this.field.getTextureData();\n        const {format, type, row_alignment} = getGLFormatTypeAlignment(gl, !(tex_data instanceof Float32Array));\n    \n        const fill_image = {'format': format, 'type': type,\n            'width': this.field.grid.ni, 'height': this.field.grid.nj, 'image': tex_data,\n            'mag_filter': this.image_mag_filter, 'row_alignment': row_alignment,\n        };\n\n        if (this.fill_texture === null) {\n            this.fill_texture = new WGLTexture(gl, fill_image);\n        }\n        else {\n            this.fill_texture.setImageData(fill_image);\n        }\n\n        map.triggerRepaint();\n    }\n\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        // Basic procedure for the filled contours inspired by https://blog.mbq.me/webgl-weather-globe/\n        \n        if (this.image_mag_filter === null || this.cmap_mag_filter === null) {\n            throw `Implement magnification filtes in a subclass`;\n        }\n        \n        const program = new WGLProgram(gl, contourfill_vertex_shader_src, ColorMapGPUInterface.applyShader(contourfill_fragment_shader_src));\n\n        const {vertices: vertices, texcoords: texcoords} = await this.field.grid.getWGLBuffers(gl);\n\n        this.cmap_gpu.setupShaderVariables(gl, this.cmap_mag_filter);\n\n        this.gl_elems = {\n            gl: gl, map: map, program: program, vertices: vertices, texcoords: texcoords,\n        };\n\n        this.updateField(this.field);\n    }\n\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        if (this.gl_elems === null || this.fill_texture === null) return;\n        const gl_elems = this.gl_elems;\n\n        if (matrix instanceof Float32Array) \n            matrix = [...matrix];\n\n        gl_elems.program.use(\n            {'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords},\n            {'u_matrix': matrix, 'u_opacity': this.opts.opacity, 'u_offset': 0},\n            {'u_fill_sampler': this.fill_texture}\n        );\n\n        this.cmap_gpu.bindShaderVariables(gl_elems.program);\n\n        gl.enable(gl.BLEND);\n        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': -2});\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': -1});\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': 1});\n        gl_elems.program.draw();\n    }\n}\n\n/** \n * A raster (i.e. pixel) plot \n * @example\n * // Create a raster plot with the provided color map\n * const raster = new Raster(wind_speed_field, {cmap: color_map});\n */\nclass Raster<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponentFill<ArrayType, MapType> {\n\n    /**\n     * Create a raster plot\n     * @param field - The field to create the raster plot from\n     * @param opts  - Options for creating the raster plot\n     */\n    constructor(field: RawScalarField<ArrayType>, opts: RasterOptions) {\n        super(field, opts);\n    }\n\n    /**\n     * Update the data displayed as a raster plot\n     * @param field - The new field to display as a raster plot\n     */\n    public async updateField(field: RawScalarField<ArrayType>) {\n        await super.updateField(field);\n    }\n\n    /**\n     * @internal\n     * Add the raster plot to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.image_mag_filter = gl.NEAREST;\n        this.cmap_mag_filter = gl.LINEAR;\n        await super.onAdd(map, gl);\n    }\n\n    /**\n     * @internal\n     * Render the raster plot\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        super.render(gl, matrix);\n    }\n}\n\n/** \n * A filled contoured field \n * @example\n * // Create a field of filled contours with the provided color map\n * const fill = new ContourFill(wind_speed_field, {cmap: color_map});\n */\nclass ContourFill<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponentFill<ArrayType, MapType> {\n\n    /**\n     * Create a filled contoured field\n     * @param field - The field to create filled contours from\n     * @param opts  - Options for creating the filled contours\n     */\n    constructor(field: RawScalarField<ArrayType>, opts: ContourFillOptions) {\n        super(field, opts);\n    }\n\n    /**\n     * Update the data displayed as filled contours\n     * @param field - The new field to display as filled contours\n     */\n    public async updateField(field: RawScalarField<ArrayType>) {\n        await super.updateField(field);\n    }\n\n    /**\n     * @internal\n     * Add the filled contours to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.image_mag_filter = gl.LINEAR;\n        this.cmap_mag_filter = gl.NEAREST;\n        await super.onAdd(map, gl);\n    }\n\n    /**\n     * @internal\n     * Render the filled contours\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        super.render(gl, matrix);\n    }\n}\n\nexport {ContourFill, Raster};\nexport type {ContourFillOptions, RasterOptions};","\nimport { BillboardSpec, TypedArray, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { Color } from \"./Color\";\nimport { ColorMap, ColorMapGPUInterface } from \"./Colormap\";\nimport { getGLFormatTypeAlignment } from \"./PlotComponent\";\nimport { RawVectorField } from \"./RawField\";\nimport { WGLBuffer, WGLProgram, WGLTexture, WGLTextureSpec } from \"autumn-wgl\";\n\nconst billboard_vertex_shader_src = require('./glsl/billboard_vertex.glsl');\nconst billboard_fragment_shader_src = require('./glsl/billboard_fragment.glsl');\n\ninterface BillboardCollectionOpts {\n    color?: Color;\n    cmap?: ColorMap;\n}\n\ninterface BillboardCollectionGLElems {\n    gl: WebGLAnyRenderingContext;\n    program: WGLProgram;\n    vertices: WGLBuffer;\n    texcoords: WGLBuffer;\n    texture: WGLTexture;\n    proj_rot_texture: WGLTexture;\n    cmap_gpu: ColorMapGPUInterface | null;\n}\n\nclass BillboardCollection<ArrayType extends TypedArray> {\n    private field: RawVectorField<ArrayType>;\n    public readonly spec: BillboardSpec;\n    public readonly color: Color;\n    public readonly cmap: ColorMap | null;\n    public readonly size_multiplier: number;\n    public readonly thin_fac: number;\n    public readonly max_zoom: number;\n    public readonly billboard_image: WGLTextureSpec;\n\n    private gl_elems: BillboardCollectionGLElems | null;\n    private wind_textures: {u: WGLTexture, v: WGLTexture} | null;\n    private readonly trim_inaccessible: number;\n    private show_field: boolean;\n\n    constructor(field: RawVectorField<ArrayType>, thin_fac: number, max_zoom: number, \n                billboard_image: WGLTextureSpec, billboard_spec: BillboardSpec, billboard_size_mult: number, opts?: BillboardCollectionOpts) {\n\n        opts = opts === undefined ? {} : opts;\n        this.color = opts.color === undefined ? new Color([0, 0, 0, 1]) : opts.color;\n        this.cmap = opts.cmap === undefined ? null : opts.cmap;\n\n        this.field = field;\n        this.spec = billboard_spec;\n        this.size_multiplier = billboard_size_mult;\n        this.thin_fac = thin_fac;\n        this.max_zoom = max_zoom;\n        this.billboard_image = billboard_image;\n        this.gl_elems = null;\n        this.wind_textures = null;\n\n        const n_density_tiers = Math.log2(thin_fac);\n        const n_inaccessible_tiers = Math.max(n_density_tiers + 1 - max_zoom, 0);\n        this.trim_inaccessible = Math.pow(2, n_inaccessible_tiers);\n        this.show_field = true;\n    }\n\n    public updateField(field: RawVectorField<ArrayType>) {\n        this.field = field;\n\n        if (this.gl_elems === null) return;\n\n        const gl = this.gl_elems.gl;\n        const data = this.field.getThinnedField(this.trim_inaccessible, this.trim_inaccessible);\n\n        const {u: u_thin, v: v_thin} = data.getTextureData();\n        this.show_field = u_thin !== null;\n        const {format, type, row_alignment} = getGLFormatTypeAlignment(gl, !(u_thin instanceof Float32Array));\n\n        const u_image = {'format': format, 'type': type,\n            'width': data.grid.ni, 'height': data.grid.nj, 'image': u_thin,\n            'mag_filter': gl.NEAREST, 'row_alignment': row_alignment,\n        };\n\n        const v_image = {'format': format, 'type': type,\n            'width': data.grid.ni, 'height': data.grid.nj, 'image': v_thin,\n            'mag_filter': gl.NEAREST, 'row_alignment': row_alignment,\n        };\n\n        if (this.wind_textures === null) {\n            this.wind_textures = {u: new WGLTexture(gl, u_image), v: new WGLTexture(gl, v_image)};\n        }\n        else {\n            this.wind_textures.u.setImageData(u_image);\n            this.wind_textures.v.setImageData(v_image);\n        }\n    }\n\n    public async setup(gl: WebGLAnyRenderingContext) {\n\n        const thinned_field = this.field.getThinnedField(this.trim_inaccessible, this.trim_inaccessible);\n        const {vertices, texcoords} = await thinned_field.grid.getWGLBillboardBuffers(gl, this.thin_fac / this.trim_inaccessible, this.max_zoom);\n        const {rotation: proj_rotation_tex} = thinned_field.grid.getVectorRotationTexture(gl);\n\n        const texture = new WGLTexture(gl, this.billboard_image);\n\n        const shader_defines: string[] = [];\n        let fragment_src = billboard_fragment_shader_src;\n        let cmap_gpu = null;\n        if (this.cmap !== null) {\n            fragment_src = ColorMapGPUInterface.applyShader(fragment_src);\n\n            cmap_gpu = new ColorMapGPUInterface(this.cmap);\n            cmap_gpu.setupShaderVariables(gl, gl.NEAREST);\n\n            shader_defines.push('COLORMAP');\n        }\n\n        const program = new WGLProgram(gl, billboard_vertex_shader_src, fragment_src, {define: shader_defines});\n\n        this.gl_elems = {gl: gl, program: program, vertices: vertices, texcoords: texcoords, texture: texture, proj_rot_texture: proj_rotation_tex, cmap_gpu: cmap_gpu};\n    }\n\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array, [map_width, map_height]: [number, number], map_zoom: number, map_bearing: number, map_pitch: number) {\n        if (this.gl_elems === null || this.wind_textures === null || !this.show_field) return;\n\n        if (matrix instanceof Float32Array)\n            matrix = [...matrix];\n\n        const gl_elems = this.gl_elems;\n\n        const bb_size = this.spec.BB_HEIGHT * (map_height / map_width) * this.size_multiplier;\n        const bb_width = this.spec.BB_WIDTH / this.spec.BB_TEX_WIDTH;\n        const bb_height = this.spec.BB_HEIGHT / this.spec.BB_TEX_HEIGHT;\n\n        gl_elems.program.use(\n            {'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords},\n            {'u_bb_size': bb_size, 'u_bb_width': bb_width, 'u_bb_height': bb_height,\n             'u_bb_mag_bin_size': this.spec.BB_MAG_BIN_SIZE, 'u_bb_mag_wrap': this.spec.BB_MAG_WRAP, 'u_offset': 0,\n             'u_matrix': matrix, 'u_map_aspect': map_height / map_width, 'u_zoom': map_zoom, 'u_map_bearing': map_bearing},\n            {'u_sampler': gl_elems.texture, 'u_u_sampler': this.wind_textures.u, 'u_v_sampler': this.wind_textures.v, 'u_rot_sampler': gl_elems.proj_rot_texture}\n        );\n\n        if (gl_elems.cmap_gpu !== null) {\n            gl_elems.cmap_gpu.bindShaderVariables(gl_elems.program);\n        }\n        else {\n            gl_elems.program.setUniforms({'u_bb_color': this.color.toRGBATuple()});\n        }\n\n        gl.enable(gl.BLEND);\n        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': -2});\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': -1});\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': 1});\n        gl_elems.program.draw();\n    }\n}\n\nexport {BillboardCollection};","\nimport { PlotComponent } from \"./PlotComponent\";\nimport { BillboardCollection } from './BillboardCollection';\nimport { normalizeOptions } from './utils';\nimport { RawVectorField } from \"./RawField\";\nimport { MapLikeType } from \"./Map\";\nimport { BillboardSpec, TypedArray, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { Color } from \"./Color\";\nimport { ColorMap } from \"./Colormap\";\n\nconst BASE_BARB_DIMS: BillboardSpec = {\n    BB_WIDTH: 85,\n    BB_HEIGHT: 256,\n    BB_TEX_WIDTH: 1024,\n    BB_TEX_HEIGHT: 1024,\n    BB_MAG_MAX: 235,\n    BB_MAG_WRAP: 60,\n    BB_MAG_BIN_SIZE: 5,\n}\n\nconst LINE_WIDTH_MULTIPLIER = 4;\n\nfunction createBarbTexture(dimensions: BillboardSpec, line_width: number) : HTMLCanvasElement {\n    let canvas = document.createElement('canvas');\n\n    canvas.width = dimensions.BB_TEX_WIDTH;\n    canvas.height = dimensions.BB_TEX_HEIGHT;\n    \n    function drawWindBarb(ctx: CanvasRenderingContext2D, tipx: number, tipy: number, mag: number) : void {\n        const elem_full_size = dimensions.BB_WIDTH / 2 - 4;\n        const elem_spacing = elem_full_size / 2;\n        \n        if (mag < 2.5) {\n            ctx.beginPath();\n            ctx.arc(tipx, tipy, elem_full_size / 2, 0, 2 * Math.PI);\n            ctx.stroke();\n        }\n        else {\n            let elem_pos = 0;\n            let mag_countdown = mag;\n\n            let staff_length = 0;\n            const n_flags = Math.floor((mag_countdown + 2.5) / 50)\n            staff_length += n_flags * elem_full_size / 2 + elem_spacing \n                                   + (n_flags - 1) * elem_spacing / 2;\n            mag_countdown -= n_flags * 50;\n            const n_full_barbs = Math.floor((mag_countdown + 2.5) / 10)\n            staff_length += n_full_barbs * elem_spacing;\n            mag_countdown -= n_full_barbs * 10;\n            const n_half_barbs = Math.floor((mag_countdown + 2.5) / 5);\n            staff_length += n_half_barbs * elem_spacing;\n            \n            if (mag < 7.5) {\n                staff_length += elem_spacing;\n            }\n            \n            staff_length = Math.max(120, staff_length);\n            \n            // staff\n            ctx.beginPath();\n            ctx.moveTo(tipx, tipy);\n            ctx.lineTo(tipx, tipy + staff_length);\n\n            mag_countdown = mag;\n\n            elem_pos = tipy + staff_length;\n            let last_was_flag = false;\n            let first_elem = true;\n        \n            while (mag_countdown > 47.5) {\n                if (last_was_flag) elem_pos += elem_spacing / 2;\n                // flag\n                if (!first_elem) {\n                    ctx.moveTo(tipx, elem_pos);\n                }\n                ctx.lineTo(tipx - elem_full_size, elem_pos);\n                ctx.lineTo(tipx, elem_pos - elem_full_size / 2)\n\n                elem_pos -= elem_full_size / 2 + elem_spacing;\n                mag_countdown -= 50;\n                last_was_flag = true;\n                first_elem = false;\n            }\n        \n            while (mag_countdown > 7.5) {\n                // full barb\n                if (!first_elem) {\n                    ctx.moveTo(tipx, elem_pos);\n                }\n                ctx.lineTo(tipx - elem_full_size, elem_pos + elem_full_size / 2);\n            \n                elem_pos -= elem_spacing;\n                mag_countdown -= 10;\n                first_elem = false;\n            }\n            \n            if (mag < 7.5) {\n                elem_pos -= elem_spacing;\n            }\n        \n            while (mag_countdown > 2.5) {\n                // half barb\n                ctx.moveTo(tipx, elem_pos);\n                ctx.lineTo(tipx - elem_full_size / 2, elem_pos + elem_full_size / 4);\n                mag_countdown -= 5;\n            }\n\n            ctx.stroke();\n        }\n    }\n    \n    let ctx = canvas.getContext('2d');\n    if (ctx === null) {\n        throw \"Could not get rendering context for the wind barb canvas\";\n    }\n\n    ctx.lineWidth = line_width;\n    ctx.miterLimit = 4;\n    \n    for (let ibarb = 0; ibarb <= dimensions.BB_MAG_MAX; ibarb += dimensions.BB_MAG_BIN_SIZE) {\n        const x_pos = (ibarb % dimensions.BB_MAG_WRAP) / dimensions.BB_MAG_BIN_SIZE * dimensions.BB_WIDTH + dimensions.BB_WIDTH / 2;\n        const y_pos = Math.floor(ibarb / dimensions.BB_MAG_WRAP) * dimensions.BB_HEIGHT + dimensions.BB_WIDTH / 2;\n        drawWindBarb(ctx, x_pos, y_pos, ibarb);\n    }\n\n    return canvas;\n}\n\ninterface BarbsOptions {\n    /** \n     * The color to use for the barbs as a hex color string;.\n     * @default '#000000'\n     */\n    color?: string;\n\n    /**\n     * A color map to use to color the barbs by magnitude. Specifying cmap overrides the color argument.\n     */\n    cmap?: ColorMap | null;\n\n    /**\n     * The width of the lines to use for the barbs\n     * @default 2\n     */\n    line_width?: number;\n\n    /**\n     * A multiplier for the barb size\n     * @default 1\n     */\n    barb_size_multiplier?: number;\n\n    /** \n     * How much to thin the barbs at zoom level 1 on the map. This effectively means to plot every `n`th barb in the i and j directions, where `n` = \n     * `thin_fac`. `thin_fac` should be a power of 2. \n     * @default 1\n     */\n    thin_fac?: number;\n}\n\nconst barb_opt_defaults: Required<BarbsOptions> = {\n    color: '#000000',\n    cmap: null,\n    line_width: 2,\n    barb_size_multiplier: 1, \n    thin_fac: 1\n}\n\ninterface BarbsGLElems<ArrayType extends TypedArray, MapType extends MapLikeType> {\n    map: MapType;\n    barb_billboards: BillboardCollection<ArrayType>;\n}\n\n/** \n * A class representing a field of wind barbs. The barbs are automatically thinned based on the zoom level on the map; the user only has to provide a\n * thinning factor at zoom level 1.\n * @example\n * // Create a barb field with black barbs and plotting every 16th wind barb in both i and j at zoom level 1\n * const vector_field = new RawVectorField(grid, u_data, v_data);\n * const barbs = new Barbs(vector_field, {color: '#000000', thin_fac: 16});\n */\nclass Barbs<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    /** The vector field */\n    private fields: RawVectorField<ArrayType>;\n    public readonly opts: Required<BarbsOptions>;\n    private readonly color: Color;\n\n    private gl_elems: BarbsGLElems<ArrayType, MapType> | null;\n    private barb_texture: HTMLCanvasElement;\n\n    /**\n     * Create a field of wind barbs\n     * @param fields - The vector field to plot as barbs\n     * @param opts   - Options for creating the wind barbs\n     */\n    constructor(fields: RawVectorField<ArrayType>, opts: BarbsOptions) {\n        super();\n\n        this.fields = fields;\n\n        this.opts = normalizeOptions(opts, barb_opt_defaults);\n        this.color = Color.fromHex(this.opts.color);\n        this.barb_texture = createBarbTexture(BASE_BARB_DIMS, this.opts.line_width / this.opts.barb_size_multiplier * LINE_WIDTH_MULTIPLIER);\n\n        this.gl_elems = null;\n    }\n\n    /**\n     * Update the field displayed as barbs\n     * @param fields - The new field to display as barbs\n     */\n    public async updateField(fields: RawVectorField<ArrayType>) {\n        this.fields = fields;\n        if (this.gl_elems === null) return;\n        this.gl_elems.barb_billboards.updateField(fields);\n        this.gl_elems.map.triggerRepaint();\n    }\n\n    /**\n     * @internal \n     * Add the barb field to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        gl.getExtension('OES_texture_float');\n        gl.getExtension('OES_texture_float_linear');\n        \n        const map_max_zoom = map.getMaxZoom();\n\n        const barb_image = {format: gl.RGBA, type: gl.UNSIGNED_BYTE, image: this.barb_texture, mag_filter: gl.NEAREST};\n\n        const cmap = this.opts.cmap === null ? undefined : this.opts.cmap;\n        const barb_billboards = new BillboardCollection(this.fields, this.opts.thin_fac, map_max_zoom, barb_image, \n            BASE_BARB_DIMS, 0.1 * this.opts.barb_size_multiplier, {color: this.color, cmap: cmap});\n        await barb_billboards.setup(gl);\n\n        this.gl_elems = {\n            map: map, barb_billboards: barb_billboards\n        }\n\n        this.updateField(this.fields);\n    }\n\n    /**\n     * @internal \n     * Render the barb field\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        if (this.gl_elems === null) return;\n        const gl_elems = this.gl_elems\n\n        const zoom = gl_elems.map.getZoom();\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const bearing = gl_elems.map.getBearing();\n        const pitch = gl_elems.map.getPitch();\n\n        gl_elems.barb_billboards.render(gl, matrix, [map_width, map_height], zoom, bearing, pitch);\n    }\n}\n\nexport default Barbs;\nexport type {BarbsOptions};","\nimport { TypedArray, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { Color } from \"./Color\";\nimport { MapLikeType } from \"./Map\";\nimport { PlotComponent, getGLFormatTypeAlignment } from \"./PlotComponent\";\nimport { RawScalarField } from \"./RawField\";\nimport { normalizeOptions } from \"./utils\";\nimport { WGLBuffer, WGLProgram, WGLTexture } from \"autumn-wgl\";\n\nconst paintball_vertex_shader_src = require('./glsl/paintball_vertex.glsl');\nconst paintball_fragment_shader_src = require('./glsl/paintball_fragment.glsl');\n\ninterface PaintballOptions {\n    /**\n     * The list of colors (as hex strings) to use for each member in the paintball plot. The first color corresponds to member 1, the second to member 2, etc.\n     */\n    colors?: string[];\n\n    /**\n     * The opacity of the paintball plot\n     * @default 1\n     */\n    opacity?: number;\n}\n\nconst paintball_opt_defaults: Required<PaintballOptions> = {\n    colors: ['#000000'],\n    opacity: 1\n}\n\ninterface PaintballGLElems {\n    gl: WebGLAnyRenderingContext;\n    program: WGLProgram;\n    vertices: WGLBuffer;\n    texcoords: WGLBuffer;\n}\n\n/** \n * A class representing a paintball plot, which is a plot of objects in every member of an ensemble. Objects are usually defined by a single threshold on\n * a field (such as simulated reflectivity greater than 40 dBZ), but could in theory be defined by any arbitrarily complicated method. In autumnplot-gl,\n * the data for the paintball plot is given as a single field with the objects from each member encoded as \"bits\" in the field. Because the field is made up\n * of single-precision floats, this works for up to 24 members. (Technically speaking, I don't need the quotes around \"bits\", as they're bits of the \n * significand of an IEEE 754 float.)\n */\nclass Paintball<ArrayType extends TypedArray, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private field: RawScalarField<ArrayType>;\n    public readonly opts: Required<PaintballOptions>;\n    private readonly color_components: number[];\n\n    private gl_elems: PaintballGLElems | null;\n    private fill_texture: WGLTexture | null;\n\n    /**\n     * Create a paintball plot\n     * @param field - A scalar field containing the member objects encoded as \"bits.\" The numerical value of each grid point can be constructed like \n     *               `1.0 * M1 + 2.0 * M2 + 4.0 * M3 + 8.0 * M4 ...`, where `M1` is 1 if that grid point is in an object in member 1 and 0 otherwise,\n     *               `M2` is the same thing for member 2, and `M3` and `M4` and up to `Mn` are the same thing for the rest of the members.\n     * @param opts  - Options for creating the paintball plot\n     */\n    constructor(field: RawScalarField<ArrayType>, opts?: PaintballOptions) {\n        super();\n\n        this.field = field;\n\n        this.opts = normalizeOptions(opts, paintball_opt_defaults);\n        this.color_components = [...this.opts.colors].reverse().map(color => Color.fromHex(color).toRGBATuple()).flat();\n        \n        this.gl_elems = null;\n        this.fill_texture = null;\n    }\n\n    /**\n     * Update the field displayed as a paintball plot\n     * @param field - The new field to display as a paintball plot\n     */\n    public async updateField(field: RawScalarField<ArrayType>) {\n        this.field = field;\n\n        if (this.gl_elems === null) return;\n        const gl = this.gl_elems.gl;\n\n        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 2);\n\n        const tex_data = this.field.getTextureData();\n        const {format, type, row_alignment} = getGLFormatTypeAlignment(gl, !(tex_data instanceof Float32Array));\n\n        const fill_image = {'format': format, 'type': type,\n            'width': this.field.grid.ni, 'height': this.field.grid.nj, 'image': tex_data,\n            'mag_filter': gl.NEAREST, 'row_alignment': row_alignment,\n        };\n\n        if (this.fill_texture === null) {\n            this.fill_texture = new WGLTexture(gl, fill_image);\n        }\n        else {\n            this.fill_texture.setImageData(fill_image);\n        }\n    }\n\n    /**\n     * @internal\n     * Add the paintball plot to a map.\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        gl.getExtension('OES_texture_float');\n\n        const program = new WGLProgram(gl, paintball_vertex_shader_src, paintball_fragment_shader_src);\n\n        const {vertices: verts_buf, texcoords: tex_coords_buf} = await this.field.grid.getWGLBuffers(gl);\n        const vertices = verts_buf;\n        const texcoords = tex_coords_buf;\n\n        this.gl_elems = {\n            gl: gl, program: program, vertices: vertices, texcoords: texcoords,\n        };\n\n        this.updateField(this.field);\n    }\n\n    /**\n     * @internal\n     * Render the paintball plot\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        if (this.gl_elems === null || this.fill_texture === null) return;\n        const gl_elems = this.gl_elems;\n\n        if (matrix instanceof Float32Array)\n            matrix = [...matrix];\n\n        // Render to framebuffer\n        gl_elems.program.use(\n            {'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords},\n            {'u_matrix': matrix, 'u_opacity': this.opts.opacity, 'u_colors': this.color_components, 'u_num_colors': this.opts.colors.length, 'u_offset': 0},\n            {'u_fill_sampler': this.fill_texture}\n        );\n\n        gl.enable(gl.BLEND);\n        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': -2});\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': -1});\n        gl_elems.program.draw();\n\n        gl_elems.program.setUniforms({'u_offset': 1});\n        gl_elems.program.draw();\n    }\n}\n\nexport default Paintball;\nexport type {PaintballOptions};","\nimport { PlotComponent } from \"./PlotComponent\";\nimport { PolylineCollection } from \"./PolylineCollection\";\nimport { BillboardCollection } from \"./BillboardCollection\";\nimport { getMinZoom, normalizeOptions } from './utils';\nimport { MapLikeType } from \"./Map\";\nimport { RawProfileField } from \"./RawField\";\nimport { LineData, TypedArray, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { Float16Array } from \"@petamoriken/float16\";\nimport { ColorMap } from \"./Colormap\";\nimport { Color } from \"./Color\";\n\nconst LINE_WIDTH_MULTIPLIER = 2.5;\nconst BG_MAX_RING_MAG = 40;\n\nconst HODO_BG_DIMS = {\n    BB_WIDTH: 256,\n    BB_HEIGHT: 256,\n    BB_TEX_WIDTH: 256,\n    BB_TEX_HEIGHT: 256,\n    BB_MAG_MAX: 1000,\n    BB_MAG_WRAP: 1000,\n    BB_MAG_BIN_SIZE: 1000,\n}\n\nfunction _createHodoBackgroundTexture(line_width: number) {\n    let canvas = document.createElement('canvas');\n\n    canvas.width = HODO_BG_DIMS.BB_TEX_WIDTH;\n    canvas.height = HODO_BG_DIMS.BB_TEX_HEIGHT;\n\n    let ctx = canvas.getContext('2d');\n\n    if (ctx === null) {\n        throw \"Could not get rendering context for the hodograph background canvas\";\n    }\n\n    ctx.lineWidth = line_width;\n\n    for (let irng = HODO_BG_DIMS.BB_TEX_WIDTH / 4; irng <= HODO_BG_DIMS.BB_TEX_WIDTH / 2; irng += HODO_BG_DIMS.BB_TEX_WIDTH / 4) {\n        ctx.beginPath();\n        ctx.arc(HODO_BG_DIMS.BB_TEX_WIDTH / 2, HODO_BG_DIMS.BB_TEX_WIDTH / 2, irng - line_width / 2, 0, 2 * Math.PI);\n        ctx.stroke();\n    }\n\n    const ctr_x = HODO_BG_DIMS.BB_TEX_WIDTH / 2, ctr_y = HODO_BG_DIMS.BB_TEX_WIDTH / 2;\n    const arrow_size = 20\n    ctx.beginPath()\n    ctx.moveTo(ctr_x, ctr_y);\n    ctx.lineTo(ctr_x + arrow_size / 2, ctr_y + arrow_size);\n    ctx.lineTo(ctr_x - arrow_size / 2, ctr_y + arrow_size);\n    ctx.lineTo(ctr_x, ctr_y);\n    ctx.fill()\n\n    return canvas;\n};\n\nconst HODO_CMAP = new ColorMap([0, 1, 3, 6, 9], ['#ffffcc', '#a1dab4', '#41b6c4', '#225ea8']);\n\ninterface HodographOptions {\n    /** \n     * The color of the hodograph plot background as a hex string\n     * @default '#000000'\n     */\n    bgcolor?: string;\n\n    /** \n     * How much to thin the hodographs at zoom level 1 on the map. This effectively means to plot every `n`th hodograph in the i and j directions, where `n` = \n     * `thin_fac`. `thin_fac` should be a power of 2. \n     * @default 1\n     */\n    thin_fac?: number;\n\n    /**\n     * The width of the hodograph line in pixels\n     * @default 2.5\n     */\n    hodo_line_width: number;\n\n    /**\n     * The width of the lines on the background in pixels\n     * @default 1.5\n     */\n    background_line_width: number;\n\n    /**\n     * The colormap to use for the heights on the hodograph. Default is a yellow-blue colormap.\n     */\n    height_cmap: ColorMap;\n}\n\nconst hodograph_opt_defaults: Required<HodographOptions> = {\n    bgcolor: '#000000',\n    thin_fac: 1,\n    hodo_line_width: 2.5,\n    background_line_width: 1.5,\n    height_cmap: HODO_CMAP\n}\n\ninterface HodographGLElems<ArrayType extends TypedArray, MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n    bg_billboard: BillboardCollection<ArrayType>;\n}\n\n/** A class representing a field of hodograph plots */\nclass Hodographs<MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private profile_field: RawProfileField;\n    public readonly opts: Required<HodographOptions>;\n\n    private gl_elems: HodographGLElems<Float16Array, MapType> | null;\n    private line_elems: {hodo_line: PolylineCollection, sm_line: PolylineCollection} | null;\n    private hodo_bg_texture: HTMLCanvasElement;\n    private readonly hodo_scale;\n    private readonly bg_size;\n\n    /**\n     * Create a field of hodographs\n     * @param profile_field - The grid of profiles to plot\n     * @param opts          - Various options to use when creating the hodographs \n     */\n    constructor(profile_field: RawProfileField, opts?: HodographOptions) {\n        super();\n        \n        this.profile_field = profile_field;\n        this.opts = normalizeOptions(opts, hodograph_opt_defaults);\n\n        this.hodo_bg_texture = _createHodoBackgroundTexture(this.opts.background_line_width * LINE_WIDTH_MULTIPLIER);\n        this.hodo_scale = (HODO_BG_DIMS.BB_TEX_WIDTH - this.opts.background_line_width / 2) / (HODO_BG_DIMS.BB_TEX_WIDTH * BG_MAX_RING_MAG);\n        this.bg_size = 140;\n\n        this.gl_elems = null;\n        this.line_elems = null;\n    }\n\n    /**\n     * Update the profiles displayed\n     * @param field - The new profiles to display as hodographs\n     */\n    public async updateField(field: RawProfileField) {\n        this.profile_field = field;\n\n        if (this.gl_elems === null) return;\n        // XXX: This might leak VRAM\n        const gl = this.gl_elems.gl;\n\n        this.gl_elems.bg_billboard.updateField(field.getStormMotionGrid());\n\n        const profiles = this.profile_field.profiles;\n        \n        const hodo_polyline = profiles.map(prof => {\n            const zoom = getMinZoom(prof['jlat'], prof['ilon'], this.opts.thin_fac);\n\n            return {\n                'offsets': [...prof['u']].map((u, ipt) => [u - prof['smu'], prof['v'][ipt] - prof['smv']]),\n                'vertices': [...prof['u']].map(u => [prof['lon'], prof['lat']]),\n                'zoom': zoom,\n                'data': [...prof['z']],\n            } as LineData;\n        });\n\n        const hodo_line = await PolylineCollection.make(gl, hodo_polyline, {line_width: this.opts.hodo_line_width, cmap: this.opts.height_cmap, offset_scale: this.hodo_scale * this.bg_size});\n\n        const sm_polyline = profiles.map(prof => {\n            const zoom = getMinZoom(prof['jlat'], prof['ilon'], this.opts.thin_fac);\n\n            const sm_mag = Math.hypot(prof['smu'], prof['smv']);\n            const sm_ang = Math.PI / 2 - Math.atan2(-prof['smv'], -prof['smu']);\n            const buffer = 2\n\n            return {\n                'offsets': [[buffer * Math.sin(sm_ang), buffer * Math.cos(sm_ang)], \n                              [sm_mag * Math.sin(sm_ang), sm_mag * Math.cos(sm_ang)]],\n                'vertices': [[prof['lon'], prof['lat']], [prof['lon'], prof['lat']]],\n                'zoom': zoom\n            } as LineData;\n        });\n\n        const sm_line = await PolylineCollection.make(gl, sm_polyline, {line_width: this.opts.background_line_width, color: this.opts.bgcolor, offset_scale: this.hodo_scale * this.bg_size});\n\n        this.line_elems = {\n            hodo_line: hodo_line, sm_line: sm_line\n        }\n    }\n\n    /**\n     * @internal\n     * Add the hodographs to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        const bg_image = {'format': gl.RGBA, 'type': gl.UNSIGNED_BYTE, 'image': this.hodo_bg_texture, 'mag_filter': gl.NEAREST};\n        const max_zoom = map.getMaxZoom();\n\n        const bg_billboard = new BillboardCollection(this.profile_field.getStormMotionGrid(), this.opts.thin_fac, max_zoom, bg_image, HODO_BG_DIMS, this.bg_size * 0.004,\n                                                     {color: Color.fromHex(this.opts.bgcolor)});\n        await bg_billboard.setup(gl);\n\n        this.gl_elems = {\n            gl: gl, map: map, bg_billboard: bg_billboard\n        };\n\n        this.updateField(this.profile_field);\n    }\n\n    /**\n     * @internal\n     * Render the hodographs\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        if (this.gl_elems === null || this.line_elems === null) return;\n        const gl_elems = this.gl_elems;\n        const line_elems = this.line_elems;\n\n        const zoom = gl_elems.map.getZoom();\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const bearing = gl_elems.map.getBearing();\n        const pitch = gl_elems.map.getPitch();\n\n        line_elems.hodo_line.render(gl, matrix, [map_width, map_height], zoom, bearing, pitch);\n        line_elems.sm_line.render(gl, matrix, [map_width, map_height], zoom, bearing, bearing);\n        gl_elems.bg_billboard.render(gl, matrix, [map_width, map_height], zoom, bearing, pitch);\n    }\n}\n\nexport default Hodographs;\nexport type {HodographOptions};","\nimport { WebGLAnyRenderingContext } from './AutumnTypes';\nimport { MapLikeType } from './Map';\n\nimport { PlotComponent } from './PlotComponent';\n\nabstract class PlotLayerBase<MapType extends MapLikeType> {\n    public readonly type: 'custom';\n    public readonly id: string;\n    protected map: MapType | null;\n\n    constructor(id: string) {\n        this.type = 'custom';\n        this.id = id;\n        this.map = null;\n    }\n\n    public abstract onAdd(map: MapType, gl: WebGLAnyRenderingContext) : void;\n    public abstract render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) : void;\n\n    protected repaint() {\n        if (this.map !== null) {\n            this.map.triggerRepaint();\n        }\n    }\n}\n\n/** \n * A static map layer. The data are assumed to be static in time. If the data have a time component (e.g., a model forecast), an {@link MultiPlotLayer} \n * may be more appropriate.\n * @example\n * // Create map layers from provided fields\n * const height_layer = new PlotLayer('height-contours', height_contours);\n * const wind_speed_layer = new PlotLayer('wind-speed-fill', wind_speed_fill);\n * const barb_layer = new PlotLayer('barbs', wind_barbs);\n */\nclass PlotLayer<MapType extends MapLikeType> extends PlotLayerBase<MapType> {\n    private readonly field: PlotComponent<MapType>;\n\n    /**\n     * Create a map layer from a field\n     * @param id    - A unique id for this layer\n     * @param field - The field to plot in this layer\n     */\n    constructor(id: string, field: PlotComponent<MapType>) {\n        super(id);\n        this.field = field;\n    }\n\n    /**\n     * @internal\n     * Add this layer to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.map = map;\n        await this.field.onAdd(map, gl);\n    }\n\n    /**\n     * @internal\n     * Render this layer\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        this.field.render(gl, matrix);\n    }\n}\n\n/**\n * A varying map layer. If the data don't have a varying component, such as over time, it might be easier to use an {@link PlotLayer} instead.\n * @example\n * // Create a varying map layer\n * height_layer = new MultiPlotLayer('height-contours');\n * \n * // Add some fields to it\n * height_layer.addField(height_contour_f00, '20230112_1200');\n * height_layer.addField(height_contour_f01, '20230112_1300');\n * height_layer.addField(height_contour_f02, '20230112_1400');\n * \n * // Set the date/time in the map layer\n * height_layer.setActiveKey('20230112_1200');\n */\nclass MultiPlotLayer<MapType extends MapLikeType> extends PlotLayerBase<MapType> {\n    private fields: Record<string, PlotComponent<MapType>>;\n    private field_key: string | null;\n\n    private gl: WebGLAnyRenderingContext | null;\n\n    /**\n     * Create a time-varying map layer\n     * @param id - A unique id for this layer\n     */\n    constructor(id: string) {\n        super(id);\n\n        this.fields = {};\n        this.field_key = null;\n        this.map = null;\n        this.gl = null;\n    }\n\n    /**\n     * @internal\n     * Add this layer to a map\n     */\n    public onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.map = map;\n        this.gl = gl;\n\n        Object.values(this.fields).forEach(field => {\n            field.onAdd(map, gl).then(res => {\n                this.repaint();\n            });\n        });\n\n        this.repaint();\n    }\n\n    /**\n     * @internal\n     * Render this layer\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        if (this.map !== null && this.gl !== null && this.field_key !== null \n            && this.fields.hasOwnProperty(this.field_key) && this.fields[this.field_key] !== null) {\n            this.fields[this.field_key].render(gl, matrix);\n        }\n    }\n\n    /**\n     * Set the active key\n     * @param key - The new key. The field with that key is plotted immediately.\n     */\n    public setActiveKey(key: string) {\n        const old_field_key = this.field_key;\n        this.field_key = key;\n\n        this.repaint();\n    }\n\n    /**\n     * Get a list of all dates/times that have been added to the layer\n     * @returns An array of dates/times\n     */\n    public getKeys() {\n        return Object.keys(this.fields);\n    }\n\n    /**\n     * Add a field with a given key\n     * @param field - The field to add\n     * @param key   - The key to associate with the field\n     */\n    public addField(field: PlotComponent<MapType>, key: string) {\n        const old_field_key = this.field_key;\n\n        if (this.map !== null && this.gl !== null && field !== null) {\n            field.onAdd(this.map, this.gl).then(res => {\n                this.repaint();\n            });\n        }\n\n        this.fields[key] = field;\n        \n        if (this.field_key === null) {\n            this.field_key = key;\n        }\n    }\n}\n\nexport {PlotLayer, MultiPlotLayer};","\nimport { ColorMap } from \"./Colormap\";\nimport { Color } from \"./Color\";\n\ntype ColorbarOrientation = 'horizontal' | 'vertical';\ntype ColorbarTickDirection = 'top' | 'bottom' | 'left' | 'right';\ninterface ColorBarOptions {\n    /** The label to place along the color bar */\n    label?: string;\n\n    /** \n     * An array of numbers to use as the tick locations. \n     * @default Use all the levels in the color map provided to {@link makeColorBar}.\n     */\n    ticks?: number[];\n\n    /** \n     * The direction the ticks should face. Valid values are 'left' and 'right' if orientation is 'vertical' and 'top' and \n     * 'bottom' if orientation is 'horizontal'.\n     * @default 'left' if orientation is 'vertical' and 'bottom' if orientation is 'horizontal'\n     */\n    tick_direction?: ColorbarTickDirection;\n\n    /** \n     * The orientation for the color bar. Valid values are 'horizontal' and 'vertical'.\n     * @default 'vertical'\n     */\n    orientation?: ColorbarOrientation;\n\n    /** \n     * A font face to use for the label and tick values.\n     * @default 'sans-serif'\n     */\n    fontface?: string;\n\n    /**\n     * The font size (in points) to use for the tick labels\n     * @default 12\n     */\n    ticklabelsize?: number;\n};\n\nconst createElement = (tagname: string, attributes?: Record<string, string | number>, parent?: SVGElement) => {\n    const elem = document.createElementNS('http://www.w3.org/2000/svg', tagname);\n\n    if (attributes !== undefined) {\n        Object.entries(attributes).forEach(([k, v]) => {\n            elem.setAttribute(k, v.toString());\n        });\n    }\n\n    if (parent !== undefined) {\n        parent.appendChild(elem);\n    }\n\n    return elem;\n};\n\n/**\n * Make an SVG containing a color bar. The color bar can either be oriented horizontal or vertical, and a label can be provided.\n * @param colormap - The color map to use\n * @param opts     - The options for creating the color bar\n * @returns An SVGElement containing the color bar image.\n * @example\n * // Create the color bar\n * const svg = makeColorBar(color_map, {label: 'Wind Speed (kts)', orientation: 'horizontal', \n *                                      fontface: 'Trebuchet MS'});\n * \n * // Add colorbar to the page\n * document.getElementById('colorbar-container').appendChild(svg);\n */\nfunction makeColorBar(colormap: ColorMap, opts: ColorBarOptions) {\n    const label = opts.label || \"\";\n    const ticks = opts.ticks || colormap.levels;\n    const orientation = opts.orientation || 'vertical';\n    const fontface = opts.fontface || 'sans-serif';\n    const tickfontsize = opts.ticklabelsize || 12;\n\n    const tick_dir = opts.tick_direction || (orientation == 'vertical' ? 'left' : 'bottom');\n\n    if (orientation == 'vertical' && (tick_dir == 'top' || tick_dir == 'bottom') ||\n        orientation == 'horizontal' && (tick_dir == 'left' || tick_dir == 'right')) {\n        throw `tick_direction of '${tick_dir} doesn't match an orientation of ${orientation}`;\n    }\n\n    const getNChar = (n: number) => {\n        return n.toString().length;\n    }\n\n    const chars_left = getNChar(ticks[0]);\n    const chars_right = getNChar(ticks[ticks.length - 1]);\n    const need_overflow = colormap.underflow_color !== null || colormap.overflow_color !== null;\n\n    const bar_long_size = 600;\n    const bar_cross_size = bar_long_size / 9;\n    const bar_long_pad = Math.max(orientation == 'horizontal' ? Math.max(chars_left, chars_right) * 6 : 8, \n                                  need_overflow ? bar_cross_size / (2 * Math.sqrt(3)) : 0);\n    const bar_cross_pad = 3;\n    const bar_thickness = 10;\n\n    let height: number, width: number, bar_left: number, bar_top: number, bar_width: number, bar_height: number, bar_right: number, bar_bottom: number,\n        bar_middle: number, bar_low_arrow: number, bar_high_arrow: number;\n\n    if (orientation == 'vertical') {\n        height = bar_long_size;\n        width = bar_cross_size;\n\n        bar_left = tick_dir == 'left' ? bar_cross_size - bar_cross_pad - bar_thickness : bar_cross_pad;\n        bar_top = bar_long_pad;\n        bar_width = bar_thickness;\n        bar_height = bar_long_size - 2 * bar_long_pad;\n\n        bar_right = bar_left + bar_width;\n        bar_middle = bar_left + bar_width / 2;\n        bar_bottom = bar_top + bar_height;\n        bar_low_arrow = colormap.underflow_color === null ? bar_bottom : bar_bottom + bar_cross_size / (Math.sqrt(3) * 2);\n        bar_high_arrow = colormap.overflow_color === null ? bar_top : bar_top - bar_cross_size / (Math.sqrt(3) * 2);\n    }\n    else {\n        width = bar_long_size;\n        height = bar_cross_size - 6;\n\n        bar_left = bar_long_pad;\n        bar_top = tick_dir == 'bottom' ? bar_cross_pad : bar_cross_size - 6 - bar_cross_pad - bar_thickness;\n        bar_height = bar_thickness;\n        bar_width = bar_long_size - 2 * bar_long_pad;\n\n        bar_right = bar_left + bar_width;\n        bar_middle = bar_top + bar_height / 2;\n        bar_bottom = bar_top + bar_height;\n        bar_low_arrow = colormap.underflow_color === null ? bar_left : bar_left - bar_cross_size / (Math.sqrt(3) * 2);\n        bar_high_arrow = colormap.overflow_color === null ? bar_right : bar_right + bar_cross_size / (Math.sqrt(3) * 2);\n    }\n\n    const n_colors = colormap.colors.length;\n\n    const root = createElement('svg', {width: width, height: height});\n    const gbar = createElement('g', {}, root);\n\n    let gtickattrs;\n    if (orientation == 'vertical') {\n        gtickattrs = tick_dir == 'left' ? {'text-anchor': 'end', transform: `translate(${bar_left}, ${bar_top})`} : \n                                          {transform: `translate(${bar_left + bar_width}, ${bar_top})`}\n    }\n    else {\n        gtickattrs = tick_dir == 'bottom' ? {'text-anchor': 'middle', transform: `translate(${bar_left}, ${bar_top + bar_height})`} : \n                                            {'text-anchor': 'middle', transform: `translate(${bar_left}, ${bar_top})`}\n    }\n    const gticks = createElement('g', gtickattrs, root);\n\n    // Make the colored background\n    colormap.colors.forEach((color, icolor) => {\n        let attrs: Record<string, string | number> = {};\n\n        if (orientation == 'vertical') {\n            attrs = {\n                x: bar_left, y: bar_top + bar_height * (1 - (icolor + 1) / n_colors), width: bar_width, height: bar_height / n_colors};\n        }\n        else {\n            attrs = {x: bar_left + bar_width * icolor / n_colors, y: bar_top, width: bar_width / n_colors, height: bar_height};\n        }\n\n        createElement('rect', {...attrs, fill: color.toRGBHex(), opacity: color.a}, gbar);\n    });\n\n    // Make the overflow and underflow triangles\n    if (colormap.underflow_color !== null) {\n        let point_list: string;\n        if (orientation == 'vertical') {\n            point_list = `${bar_right} ${bar_bottom}, ${bar_middle} ${bar_low_arrow}, ${bar_left} ${bar_bottom}, ${bar_right} ${bar_bottom}`;\n        }\n        else {\n            point_list = `${bar_left} ${bar_bottom}, ${bar_low_arrow} ${bar_middle}, ${bar_left} ${bar_top}, ${bar_left} ${bar_bottom}`;\n        }\n\n        const underflow_attrs = {points: point_list, fill: colormap.underflow_color.toRGBHex(), opacity: colormap.underflow_color.a};\n        createElement('polygon', underflow_attrs, gbar);\n    }\n\n    if (colormap.overflow_color !== null) {\n        let point_list: string;\n        if (orientation == 'vertical') {\n            point_list = `${bar_left} ${bar_top}, ${bar_middle} ${bar_high_arrow}, ${bar_right} ${bar_top}, ${bar_left} ${bar_top}`;\n        }\n        else {\n            point_list = `${bar_right} ${bar_top}, ${bar_high_arrow} ${bar_middle}, ${bar_right} ${bar_bottom}, ${bar_right} ${bar_top}`;\n        }\n\n        const overflow_attrs = {points: point_list, fill: colormap.overflow_color.toRGBHex(), opacity: colormap.overflow_color.a};\n        createElement('polygon', overflow_attrs, gbar);\n    }\n\n    // Make the ticks marks and labels\n    const first_level = colormap.levels[0];\n    const last_level = colormap.levels[colormap.levels.length - 1];\n\n    ticks.filter(level => first_level <= level && level <= last_level).forEach(level => {\n        const diffs = colormap.levels.map(l => Math.abs(l - level));\n        let ilevel = diffs.indexOf(diffs.reduce((a, b) => Math.min(a, b)));\n        if (level <= colormap.levels[ilevel] && ilevel > 0)\n            ilevel -= 1;\n        ilevel += (level - colormap.levels[ilevel]) / (colormap.levels[ilevel + 1] - colormap.levels[ilevel]);\n        const tickattrs = orientation == 'vertical' ? {transform: `translate(0, ${bar_height * (1 - ilevel / n_colors)})`} : \n                                                      {transform: `translate(${bar_width * ilevel / n_colors}, 0)`};\n        const gtick = createElement('g', tickattrs, gticks);\n\n        let lineattrs;\n        if (orientation == 'vertical') {\n            lineattrs = tick_dir == 'left' ? {x2: -6} : {x2: 6};\n        }\n        else {\n            lineattrs = tick_dir == 'bottom' ? {y2 : 6} : {y2: -6};\n        }\n\n        createElement('line', {...lineattrs, stroke: '#000000', 'stroke-width': 1.5}, gtick);\n\n        let textattrs;\n        if (orientation == 'vertical') {\n            textattrs = tick_dir == 'left' ? {x: -9, dy: '0.32em'} : {x: 9, dy: '0.32em'};\n        }\n        else {\n            textattrs = tick_dir == 'bottom' ? {y: 9, dy: '0.8em'} : {y: -9, dy: '0em'};\n        }\n\n        const text = createElement('text', {...textattrs, fill: '#000000', style: `font-family: ${fontface}; font-size: ${tickfontsize}pt`}, gtick);\n        text.textContent = level.toString();\n    });\n\n    // Draw the outline\n    let point_list: string;\n    if (orientation == 'vertical') {\n        point_list = `${bar_left} ${bar_top}, ${bar_middle} ${bar_high_arrow}, ${bar_right} ${bar_top}, ${bar_right} ${bar_bottom}, ` +\n                     `${bar_middle} ${bar_low_arrow}, ${bar_left} ${bar_bottom}, ${bar_left} ${bar_top}`;\n    }\n    else {\n        point_list = `${bar_left} ${bar_top}, ${bar_right} ${bar_top}, ${bar_high_arrow} ${bar_middle}, ${bar_right} ${bar_bottom}, ` +\n                     `${bar_left} ${bar_bottom}, ${bar_low_arrow} ${bar_middle}, ${bar_left} ${bar_top}`;\n    }\n\n    const outline_attrs = {\n        points: point_list,\n        stroke: '#000000',\n        'stroke-width': 1.5,\n        fill: 'none'\n    };\n    createElement('polygon', outline_attrs, root);\n\n    // Draw the colorbar label\n    let labelattrs;\n    if (orientation == 'vertical') {\n        labelattrs = tick_dir == 'left' ? {transform: `translate(15, ${height / 2}) rotate(-90)`} : {transform: `translate(${width - 6}, ${height / 2}) rotate(-90)`};\n    }\n    else {\n        labelattrs = tick_dir == 'bottom' ? {transform: `translate(${width / 2}, ${height - 5})`} : {transform: `translate(${width / 2}, 15)`}\n    }\n    const label_elem = createElement('text', {...labelattrs, fill: '#000000', 'text-anchor': 'middle', style: `font-family: ${fontface};`}, root);\n    label_elem.textContent = label;\n\n    return root;\n}\n\ninterface PaintballKeyOptions {\n    /**\n     * The number of columns of entries in the key\n     * @default 1\n     */\n    n_cols?: number;\n\n    /** \n     * A font face to use for the label and tick values.\n     * @default 'sans-serif'\n     */\n    fontface?: string;\n}\n\n/**\n * Make an SVG containing a color key for a paintball plot. The key can be split over any number of columns.\n * @param colors - A list of colors \n * @param labels - The labels corresponding to each color\n * @param opts   - The options for creating the color key\n * @returns An SVGElement containing the color bar image.\n * @example\n * // Create the color key\n * const svg = makePaintballKey(colors, labels, {n_cols: 2, fontface: 'Trebuchet MS'});\n * \n * // Add the color key to the page\n * document.getElementById('pb-key-container').appendChild(svg);\n */\nfunction makePaintballKey(colors: (Color | string)[], labels: string[], opts?: PaintballKeyOptions) {\n    if (colors.length != labels.length) {\n        throw `Mismatch between the number of colors (${colors.length}) and the number of labels (${labels.length})`;\n    }\n\n    opts = opts === undefined ? {} : opts;\n    const n_cols = opts.n_cols === undefined ? 1: opts.n_cols;\n    const fontface = opts.fontface === undefined ? 'sans-serif' : opts.fontface;\n\n    let height: number, width: number;\n\n    const swatch_width = 20;\n    const swatch_height = 20;\n    const swatch_text_pad = 3;\n    const swatch_text_space = 100;\n    const swatch_width_pad = 5;\n    const swatch_height_pad = 5;\n\n    const n_rows = Math.ceil(colors.length / n_cols);\n\n    width = (swatch_width + swatch_text_pad + swatch_text_space) * n_cols + swatch_width_pad * (n_cols + 1);\n    height = swatch_height * n_rows + swatch_height_pad * (n_rows + 1);\n\n    const root = createElement('svg', {width: width, height: height});\n    const gbar = createElement('g', {}, root);\n\n    colors.forEach((color, icolor) => {\n        const label = labels[icolor];\n\n        const irow = icolor % n_rows;\n        const icol = Math.floor(icolor / n_rows);\n\n        let opacity = 1.;\n        if (typeof color != 'string') {\n            opacity = color.a;\n            color = color.toRGBHex();\n        }\n\n        const x = swatch_width_pad + icol * (swatch_width + swatch_text_pad + swatch_text_space + swatch_width_pad);\n        const y = swatch_height_pad + irow * (swatch_height + swatch_height_pad);\n\n        createElement('rect', {x: x, y: y, fill: color, opacity: opacity, width: swatch_width, height: swatch_height}, gbar);\n\n        let textattrs = {x: x + swatch_width + swatch_text_pad, y: y + swatch_height / 2, dy: '0.32em'};\n\n        const text = createElement('text', {...textattrs, fill: '#000000', style: `font-size: 0.8em; font-family: ${fontface};`}, gbar);\n        text.textContent = label;\n    })\n\n    return root;\n}\n\nexport {makeColorBar, makePaintballKey};\nexport type {ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions};","\nimport Module from './cpp/marchingsquares';\nimport { MarchingSquaresModule } from './cpp/marchingsquares';\nimport './cpp/marchingsquares.wasm';\nimport { Grid } from \"./Grid\";\nimport { ContourData, TypedArray } from \"./AutumnTypes\";\n\nlet msm_promise: Promise<MarchingSquaresModule> | null = null;\n\nfunction initMSModule() {\n    if (msm_promise === null) {\n        msm_promise = Module();\n    }\n\n    return msm_promise;\n}\n\ninterface FieldContourOpts {\n    /**\n     * The interval at which to create contours. The field will be contoured at this interval from its minimum to its maximum.\n     */\n    interval?: number;\n\n    /**\n     * Contour the field at these specific levels.\n     */\n    levels?: number[];\n}\n\nasync function contourCreator<ArrayType extends TypedArray>(data: ArrayType, grid: Grid, opts: FieldContourOpts) {\n    if (opts.interval === undefined && opts.levels === undefined) {\n        throw \"Must supply either an interval or levels to contourCreator()\"\n    }\n\n    const interval = opts.interval === undefined ? 0 : opts.interval;\n\n    const msm = await initMSModule();\n\n    const grid_coords = grid.getGridCoords();\n\n    const getContourLevels = data instanceof Float32Array ? msm.getContourLevelsFloat32 : msm.getContourLevelsFloat16;\n    const makeContours = data instanceof Float32Array ? msm.makeContoursFloat32 : msm.makeContoursFloat16;\n\n    const levels = opts.levels === undefined ? getContourLevels(data, grid.ni, grid.nj, interval) : opts.levels;\n    const contours = makeContours(data, grid_coords.x, grid_coords.y, levels, (x: number, y: number) => grid.transform(x, y, {inverse: true}));\n\n    return contours as ContourData;\n}\n\nexport {contourCreator, initMSModule};\nexport type {FieldContourOpts};","\nimport { Float16Array } from \"@petamoriken/float16\";\nimport { ContourData, TypedArray, WindProfile } from \"./AutumnTypes\";\nimport { contourCreator, FieldContourOpts } from \"./ContourCreator\";\nimport { Grid } from \"./Grid\";\nimport { Cache, zip } from \"./utils\";\n\ntype TextureDataType<ArrayType> = ArrayType extends Float32Array ? Float32Array : Uint16Array;\n\nfunction getArrayConstructor<ArrayType extends TypedArray>(ary: ArrayType) : new(...args: any[]) => ArrayType {\n    return ary.constructor as new(...args: any[]) => ArrayType;\n}\n\n/** A class representing a raw 2D field of gridded data, such as height or u wind. */\nclass RawScalarField<ArrayType extends TypedArray> {\n    public readonly grid: Grid;\n    public readonly data: ArrayType;\n\n    private readonly contour_cache: Cache<[FieldContourOpts], Promise<ContourData>>;\n\n    /**\n     * Create a data field. \n     * @param grid - The grid on which the data are defined\n     * @param data - The data, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid.\n     */\n    constructor(grid: Grid, data: ArrayType) {\n        this.grid = grid;\n        this.data = data;\n\n        if (grid.ni * grid.nj != data.length) {\n            throw `Data size (${data.length}) doesn't match the grid dimensions (${grid.ni} x ${grid.nj}; expected ${grid.ni * grid.nj} points)`;\n        }\n\n        this.contour_cache = new Cache(async (opts: FieldContourOpts) => {\n            return await contourCreator(this.data, this.grid, opts);\n        });\n    }\n\n    /** @internal */\n    public getTextureData() : TextureDataType<ArrayType> {\n        // Need to give float16 data as uint16s to make WebGL happy: https://github.com/petamoriken/float16/issues/105\n        const raw_data = this.data;\n        let data: any;\n        if (raw_data instanceof Float32Array) {\n            data = raw_data;\n        }\n        else {\n            data = new Uint16Array(raw_data.buffer);\n        }\n\n        return data as TextureDataType<ArrayType>;\n    }\n\n    public async getContours(opts: FieldContourOpts) {\n        return await this.contour_cache.getValue(opts);\n    }\n\n    /**\n     * Create a new field by aggregating a number of fields using a specific function\n     * @param func - A function that will be applied each element of the field. It should take the same number of arguments as fields you have and return a single number.\n     * @param args - The RawScalarFields to aggregate\n     * @returns a new gridded field\n     * @example\n     * // Compute wind speed from u and v\n     * wind_speed_field = RawScalarField.aggreateFields(Math.hypot, u_field, v_field);\n     */\n    public static aggregateFields<ArrayType extends TypedArray>(func: (...args: number[]) => number, ...args: RawScalarField<ArrayType>[]) {\n        function* mapGenerator<T, U>(gen: Generator<T>, func: (arg: T) => U) {\n            for (const elem of gen) {\n                yield func(elem);\n            }\n        }\n\n        const arrayType = getArrayConstructor(args[0].data);\n        const zipped_args = zip(...args.map(a => a.data));\n        const agg_data = new arrayType(mapGenerator(zipped_args, (a: number[]): number => func(...a)));\n\n        return new RawScalarField(args[0].grid, agg_data);\n    }\n}\n\ntype VectorRelativeTo = 'earth' | 'grid';\n\ninterface RawVectorFieldOptions {\n    /**\n     * Whether the vectors are relative to the grid ('grid') or Earth ('earth')\n     * @default 'grid'\n     */\n    relative_to?: VectorRelativeTo;\n}\n\n/** A class representing a 2D gridded field of vectors */\nclass RawVectorField<ArrayType extends TypedArray> {\n    public readonly u: RawScalarField<ArrayType>;\n    public readonly v: RawScalarField<ArrayType>;\n    public readonly relative_to: VectorRelativeTo;\n\n    /**\n     * Create a vector field.\n     * @param grid - The grid on which the vector components are defined\n     * @param u    - The u (east/west) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid\n     * @param v    - The v (north/south) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid\n     * @param opts - Options for creating the vector field.\n     */\n    constructor(grid: Grid, u: ArrayType, v: ArrayType, opts?: RawVectorFieldOptions) {\n        opts = opts === undefined ? {}: opts;\n\n        this.u = new RawScalarField(grid, u);\n        this.v = new RawScalarField(grid, v);\n        this.relative_to = opts.relative_to === undefined ? 'grid' : opts.relative_to;\n    }\n\n    public getTextureData() {\n        // Need to give float16 data as uint16s to make WebGL happy: https://github.com/petamoriken/float16/issues/105\n        const raw_u = this.u.data;\n        const raw_v = this.v.data;\n\n        const u: any = raw_u instanceof Float32Array ? raw_u : new Uint16Array(raw_u.buffer);\n        const v: any = raw_v instanceof Float32Array ? raw_v : new Uint16Array(raw_v.buffer);\n\n        return {u: u as TextureDataType<ArrayType>, v: v as TextureDataType<ArrayType>};\n    }\n\n    public getThinnedField(thin_x: number, thin_y: number) {\n        const new_grid = this.grid.getThinnedGrid(thin_x, thin_y);\n\n        const thinGrid = (data: ArrayType) => {\n            const arrayType = getArrayConstructor(data);\n            const new_data = new arrayType(new_grid.ni * new_grid.nj);\n    \n            for (let i = 0; i < new_grid.ni; i++) {\n                for (let j = 0 ; j < new_grid.nj; j++) {\n                    const idx_old = i * thin_x + this.grid.ni * j * thin_y;\n                    const idx = i + new_grid.ni * j;\n    \n                    new_data[idx] = data[idx_old];\n                }\n            }\n\n            return new_data;\n        }\n\n        const thin_u = thinGrid(this.u.data);\n        const thin_v = thinGrid(this.v.data);\n\n        return new RawVectorField(new_grid, thin_u, thin_v, {relative_to: this.relative_to});\n    }\n\n    public get grid() {\n        return this.u.grid\n    }\n}\n\n/** A class grid of wind profiles */\nclass RawProfileField {\n    public readonly profiles: WindProfile[];\n    public readonly grid: Grid;\n\n    /**\n     * Create a grid of wind profiles\n     * @param grid     - The grid on which the profiles are defined\n     * @param profiles - The wind profiles themselves, which should be given as a 1D array in row-major order, with the first profile being at the lower-left corner of the grid\n     */\n    constructor(grid: Grid, profiles: WindProfile[]) {\n        this.profiles = profiles;\n        this.grid = grid;\n    }\n\n    /** Get the gridded storm motion vector field (internal method) */\n    public getStormMotionGrid() {\n        const profiles = this.profiles\n        const u = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));\n        const v = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));\n\n        profiles.forEach(prof => {\n            const idx = prof.ilon + this.grid.ni * prof.jlat;\n            u[idx] = prof.smu;\n            v[idx] = prof.smv;\n        });\n\n        return new RawVectorField(this.grid, u, v, {relative_to: 'grid'});\n    }\n}\n\nexport {RawScalarField, RawVectorField, RawProfileField};\nexport type {RawVectorFieldOptions, VectorRelativeTo, TextureDataType};","import { Float16Array } from \"@petamoriken/float16\";\nimport { WGLBuffer, WGLTexture, WGLTextureSpec } from \"autumn-wgl\";\nimport { WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { lambertConformalConic, rotateSphere } from \"./Map\";\nimport { getGLFormatTypeAlignment, layer_worker } from \"./PlotComponent\";\nimport { Cache } from \"./utils\";\n\ninterface EarthCoords {\n    lons: Float32Array;\n    lats: Float32Array;\n}\n\ninterface GridCoords {\n    x: Float32Array;\n    y: Float32Array;\n}\n\nasync function makeWGLDomainBuffers(gl: WebGLAnyRenderingContext, grid: Grid, native_grid?: Grid) {\n    native_grid = native_grid !== undefined ? native_grid: grid;\n\n    const texcoord_margin_r = 1 / (2 * native_grid.ni);\n    const texcoord_margin_s = 1 / (2 * native_grid.nj);\n\n    const grid_cell_size_multiplier = (grid.ni * grid.nj) / (native_grid.ni * native_grid.nj);\n\n    const {lats: field_lats, lons: field_lons} = grid.getEarthCoords();\n    const domain_coords = await layer_worker.makeDomainVerticesAndTexCoords(field_lats, field_lons, grid.ni, grid.nj, texcoord_margin_r, texcoord_margin_s);\n\n    for (let icd = 0; icd < domain_coords['grid_cell_size'].length; icd++) {\n        domain_coords['grid_cell_size'][icd] *= grid_cell_size_multiplier;\n    }\n\n    const vertices = new WGLBuffer(gl, domain_coords['vertices'], 2, gl.TRIANGLE_STRIP);\n    const texcoords = new WGLBuffer(gl, domain_coords['tex_coords'], 2, gl.TRIANGLE_STRIP);\n    const grid_cell_size = new WGLBuffer(gl, domain_coords['grid_cell_size'], 1, gl.TRIANGLE_STRIP);\n\n    return {'vertices': vertices, 'texcoords': texcoords, 'cellsize': grid_cell_size};\n}\n\nasync function makeWGLBillboardBuffers(gl: WebGLAnyRenderingContext, grid: Grid, thin_fac: number, max_zoom: number) {\n    const {lats: field_lats, lons: field_lons} = grid.getEarthCoords();\n    const bb_elements = await layer_worker.makeBBElements(field_lats, field_lons, grid.ni, grid.nj, thin_fac, max_zoom);\n\n    const vertices = new WGLBuffer(gl, bb_elements['pts'], 3, gl.TRIANGLE_STRIP);\n    const texcoords = new WGLBuffer(gl, bb_elements['tex_coords'], 2, gl.TRIANGLE_STRIP);\n\n    return {'vertices': vertices, 'texcoords': texcoords};\n}\n\nfunction makeVectorRotationTexture(gl: WebGLAnyRenderingContext, grid: Grid) {\n    const coords = grid.getEarthCoords();\n\n    if (!grid.is_conformal) {\n        // If the grid is non-conformal, we need a fully general change of basis from grid coordinates to earth coordinates. This is not supported for now, so warn about it.\n        console.warn('Vector rotations for non-conformal projections are not supported. The output may look incorrect.')\n    }\n\n    const rot_vals = new Float16Array(coords.lats.length);\n\n    for (let icd = 0; icd < coords.lats.length; icd++) {\n        const lon = coords.lons[icd];\n        const lat = coords.lats[icd];\n\n        const [x, y] = grid.transform(lon, lat);\n        const [x_pertlon, y_pertlon] = grid.transform(lon + 0.01, lat);\n        rot_vals[icd] = Math.atan2(y_pertlon - y, x_pertlon - x);\n    }\n\n    const {format, type, row_alignment} = getGLFormatTypeAlignment(gl, true);\n\n    const rot_img: WGLTextureSpec = {\n        format: format, type: type, row_alignment: row_alignment, image: new Uint16Array(rot_vals.buffer),\n        width: grid.ni, height: grid.nj, mag_filter: gl.LINEAR\n    };\n\n    const rot_tex = new WGLTexture(gl, rot_img);\n    return {'rotation': rot_tex};\n}\n\ntype GridType = 'latlon' | 'latlonrot' | 'lcc';\n\nabstract class Grid {\n    public readonly type: GridType;\n    public readonly ni: number;\n    public readonly nj: number;\n    public readonly is_conformal: boolean;\n\n    private readonly buffer_cache: Cache<[WebGLAnyRenderingContext], Promise<{'vertices': WGLBuffer, 'texcoords': WGLBuffer, 'cellsize': WGLBuffer}>>;\n    private readonly billboard_buffer_cache: Cache<[WebGLAnyRenderingContext, number, number], Promise<{'vertices': WGLBuffer, 'texcoords': WGLBuffer}>>;\n    private readonly vector_rotation_cache: Cache<[WebGLAnyRenderingContext], {'rotation': WGLTexture}>\n\n    constructor(type: GridType, is_conformal: boolean, ni: number, nj: number) {\n        this.type = type;\n        this.is_conformal = is_conformal;\n        this.ni = ni;\n        this.nj = nj;\n\n        this.buffer_cache = new Cache((gl: WebGLAnyRenderingContext) => {\n            const new_ni = Math.max(Math.floor(this.ni / 50), 20);\n            const new_nj = Math.max(Math.floor(this.nj / 50), 20);\n            return makeWGLDomainBuffers(gl, this.copy({ni: new_ni, nj: new_nj}), this);\n        });\n\n        this.billboard_buffer_cache = new Cache((gl: WebGLAnyRenderingContext, thin_fac: number, max_zoom: number) => {\n            return makeWGLBillboardBuffers(gl, this, thin_fac, max_zoom);\n        });\n\n        this.vector_rotation_cache = new Cache((gl: WebGLAnyRenderingContext) => {\n            return makeVectorRotationTexture(gl, this);\n        })\n    }\n\n    public abstract copy(opts?: {ni?: number, nj?: number}): Grid;\n\n    public abstract getEarthCoords(): EarthCoords;\n    public abstract getGridCoords(): GridCoords;\n    public abstract transform(x: number, y: number, opts?: {inverse?: boolean}): [number, number];\n    abstract getThinnedGrid(thin_x: number, thin_y: number): Grid;\n    \n    public async getWGLBuffers(gl: WebGLAnyRenderingContext) {\n        return await this.buffer_cache.getValue(gl);\n    }\n\n    public async getWGLBillboardBuffers(gl: WebGLAnyRenderingContext, thin_fac: number, max_zoom: number) {\n        return await this.billboard_buffer_cache.getValue(gl, thin_fac, max_zoom);\n    }\n\n    public getVectorRotationTexture(gl: WebGLAnyRenderingContext) {\n        return this.vector_rotation_cache.getValue(gl);\n    }\n}\n\n/** A plate carree (a.k.a. lat/lon) grid with uniform grid spacing */\nclass PlateCarreeGrid extends Grid {\n    public readonly ll_lon: number;\n    public readonly ll_lat: number;\n    public readonly ur_lon: number;\n    public readonly ur_lat: number;\n\n    private readonly ll_cache: Cache<[], EarthCoords>;\n    private readonly gc_cache: Cache<[], GridCoords>;\n\n    /**\n     * Create a plate carree grid\n     * @param ni     - The number of grid points in the i (longitude) direction\n     * @param nj     - The number of grid points in the j (latitude) direction\n     * @param ll_lon - The longitude of the lower left corner of the grid\n     * @param ll_lat - The latitude of the lower left corner of the grid\n     * @param ur_lon - The longitude of the upper right corner of the grid\n     * @param ur_lat - The latitude of the upper right corner of the grid\n     */\n    constructor(ni: number, nj: number, ll_lon: number, ll_lat: number, ur_lon: number, ur_lat: number) {\n        super('latlon', true, ni, nj);\n\n        this.ll_lon = ll_lon;\n        this.ll_lat = ll_lat;\n        this.ur_lon = ur_lon;\n        this.ur_lat = ur_lat;\n\n        const dlon = (this.ur_lon - this.ll_lon) / (this.ni - 1);\n        const dlat = (this.ur_lat - this.ll_lat) / (this.nj - 1);\n\n        this.ll_cache = new Cache(() => {\n            const lons = new Float32Array(this.ni * this.nj);\n            const lats = new Float32Array(this.ni * this.nj);\n\n            for (let i = 0; i < this.ni; i++) {\n                for (let j = 0; j < this.nj; j++) {\n                    const idx = i + j * this.ni;\n\n                    lons[idx] = this.ll_lon + i * dlon;\n                    lats[idx] = this.ll_lat + j * dlat;\n                }\n            }\n\n            return {'lons': lons, 'lats': lats};\n        });\n\n        this.gc_cache = new Cache(() => {\n            const x = new Float32Array(this.ni);\n            const y = new Float32Array(this.nj);\n\n            for (let i = 0; i < this.ni; i++) {\n                x[i] = this.ll_lon + i * dlon;\n            }\n\n            for (let j = 0; j < this.nj; j++) {\n                y[j] = this.ll_lat + j * dlat;\n            }\n\n            return {x: x, y: y};\n        })\n    }\n\n    public copy(opts?: {ni?: number, nj?: number, ll_lon?: number, ll_lat?: number, ur_lon?: number, ur_lat?: number}) {\n        opts = opts !== undefined ? opts : {};\n        const ni = opts.ni !== undefined ? opts.ni : this.ni;\n        const nj = opts.nj !== undefined ? opts.nj : this.nj;\n        const ll_lon = opts.ll_lon !== undefined ? opts.ll_lon : this.ll_lon;\n        const ll_lat = opts.ll_lat !== undefined ? opts.ll_lat : this.ll_lat;\n        const ur_lon = opts.ur_lon !== undefined ? opts.ur_lon : this.ur_lon;\n        const ur_lat = opts.ur_lat !== undefined ? opts.ur_lat : this.ur_lat;\n\n        return new PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat);\n    }\n\n    /**\n     * Get a list of longitudes and latitudes on the grid (internal method)\n     */\n    public getEarthCoords() {\n        return this.ll_cache.getValue();\n    }\n\n    public getGridCoords() {\n        return this.gc_cache.getValue();\n    }\n\n    public transform(x: number, y: number, opts?: {inverse?: boolean}) {\n        return [x, y] as [number, number];\n    }\n\n    public getThinnedGrid(thin_x: number, thin_y: number) {\n        const dlon = (this.ur_lon - this.ll_lon) / this.ni;\n        const dlat = (this.ur_lat - this.ll_lat) / this.nj;\n\n        const ni = Math.ceil(this.ni / thin_x);\n        const nj = Math.ceil(this.nj / thin_y);\n        const ni_remove = (this.ni - 1) % thin_x;\n        const nj_remove = (this.nj - 1) % thin_y;\n        const ll_lon = this.ll_lon;\n        const ll_lat = this.ll_lat;\n        const ur_lon = this.ur_lon - ni_remove * dlon;\n        const ur_lat = this.ur_lat - nj_remove * dlat;\n\n        return new PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat);\n    }\n}\n\n/** A rotated lat-lon (plate carree) grid with uniform grid spacing */\nclass PlateCarreeRotatedGrid extends Grid {\n    public readonly np_lon: number;\n    public readonly np_lat: number;\n    public readonly lon_shift: number;\n    public readonly ll_lon: number;\n    public readonly ll_lat: number;\n    public readonly ur_lon: number;\n    public readonly ur_lat: number;\n\n    private readonly llrot: (a: number, b: number, opts?: {inverse: boolean}) => [number, number];\n    private readonly ll_cache: Cache<[], EarthCoords>;\n    private readonly gc_cache: Cache<[], GridCoords>;\n\n    /**\n     * Create a Lambert conformal conic grid\n     * @param ni        - The number of grid points in the i (longitude) direction\n     * @param nj        - The number of grid points in the j (latitude) direction\n     * @param np_lon    - The longitude of the north pole for the rotated grid\n     * @param np_lat    - The latitude of the north pole for the rotated grid\n     * @param lon_shift - The angle around the rotated north pole to shift the central meridian\n     * @param ll_lon    - The longitude of the lower left corner of the grid (on the rotated earth)\n     * @param ll_lat    - The latitude of the lower left corner of the grid (on the rotated earth)\n     * @param ur_lon    - The longitude of the upper right corner of the grid (on the rotated earth)\n     * @param ur_lat    - The latitude of the upper right corner of the grid (on the rotated earth)\n     */\n    constructor(ni: number, nj: number, np_lon: number, np_lat: number, lon_shift: number, ll_lon: number, ll_lat: number, ur_lon: number, ur_lat: number) {\n        super('latlonrot', true, ni, nj);\n\n        this.np_lon = np_lon;\n        this.np_lat = np_lat;\n        this.lon_shift = lon_shift;\n        this.ll_lon = ll_lon;\n        this.ll_lat = ll_lat;\n        this.ur_lon = ur_lon;\n        this.ur_lat = ur_lat;\n        this.llrot = rotateSphere({np_lon: np_lon, np_lat: np_lat, lon_shift: lon_shift});\n\n        const dlon = (this.ur_lon - this.ll_lon) / (this.ni - 1);\n        const dlat = (this.ur_lat - this.ll_lat) / (this.nj - 1);\n\n        this.ll_cache = new Cache(() => {\n            const lons = new Float32Array(this.ni * this.nj);\n            const lats = new Float32Array(this.ni * this.nj);\n\n            for (let i = 0; i < this.ni; i++) {\n                const lon_p = this.ll_lon + i * dlon;\n                for (let j = 0; j < this.nj; j++) {\n                    const lat_p = this.ll_lat + j * dlat;\n\n                    const [lon, lat] = this.llrot(lon_p, lat_p);\n                    const idx = i + j * this.ni;\n                    lons[idx] = lon;\n                    lats[idx] = lat;\n                }\n            }\n\n            return {lons: lons, lats: lats};\n        });\n\n        this.gc_cache = new Cache(() => {\n            const x = new Float32Array(this.ni);\n            const y = new Float32Array(this.nj);\n\n            for (let i = 0; i < this.ni; i++) {\n                x[i] = this.ll_lon + i * dlon;\n            }\n\n            for (let j = 0; j < this.nj; j++) {\n                y[j] = this.ll_lat + j * dlat;\n            }\n\n            return {x: x, y: y};\n        })\n    }\n\n    public copy(opts?: {ni?: number, nj?: number, ll_lon?: number, ll_lat?: number, ur_lon?: number, ur_lat?: number}) {\n        opts = opts !== undefined ? opts : {};\n        const ni = opts.ni !== undefined ? opts.ni : this.ni;\n        const nj = opts.nj !== undefined ? opts.nj : this.nj;\n        const ll_lon = opts.ll_lon !== undefined ? opts.ll_lon : this.ll_lon;\n        const ll_lat = opts.ll_lat !== undefined ? opts.ll_lat : this.ll_lat;\n        const ur_lon = opts.ur_lon !== undefined ? opts.ur_lon : this.ur_lon;\n        const ur_lat = opts.ur_lat !== undefined ? opts.ur_lat : this.ur_lat;\n\n        return new PlateCarreeRotatedGrid(ni, nj, this.np_lon, this.np_lat, this.lon_shift, ll_lon, ll_lat, ur_lon, ur_lat);\n    }\n\n    /**\n     * Get a list of longitudes and latitudes on the grid (internal method)\n     */\n    public getEarthCoords() {\n        return this.ll_cache.getValue();\n    }\n\n    public getGridCoords() {\n        return this.gc_cache.getValue();\n    }\n\n    public transform(x: number, y: number, opts?: {inverse?: boolean}) {\n        opts = opts === undefined ? {}: opts;\n        const inverse = 'inverse' in opts ? opts.inverse : false;\n\n        return this.llrot(x, y, {inverse: !inverse});\n    }\n\n    public getThinnedGrid(thin_x: number, thin_y: number) {\n        const dlon = (this.ur_lon - this.ll_lon) / this.ni;\n        const dlat = (this.ur_lat - this.ll_lat) / this.nj;\n\n        const ni = Math.ceil(this.ni / thin_x);\n        const nj = Math.ceil(this.nj / thin_y);\n        const ni_remove = (this.ni - 1) % thin_x;\n        const nj_remove = (this.nj - 1) % thin_y;\n        const ll_lon = this.ll_lon;\n        const ll_lat = this.ll_lat;\n        const ur_lon = this.ur_lon - ni_remove * dlon;\n        const ur_lat = this.ur_lat - nj_remove * dlat;\n\n        return new PlateCarreeRotatedGrid(ni, nj, this.np_lon, this.np_lat, this.lon_shift, ll_lon, ll_lat, ur_lon, ur_lat);\n    }\n}\n\n/** A Lambert conformal conic grid with uniform grid spacing */\nclass LambertGrid extends Grid {\n    public readonly lon_0: number;\n    public readonly lat_0: number;\n    public readonly lat_std: [number, number];\n    public readonly ll_x: number;\n    public readonly ll_y: number;\n    public readonly ur_x: number;\n    public readonly ur_y: number;\n\n    private readonly lcc: (a: number, b: number, opts?: {inverse: boolean}) => [number, number];\n    private readonly ll_cache: Cache<[], EarthCoords>;\n    private readonly gc_cache: Cache<[], GridCoords>;\n\n    /**\n     * Create a Lambert conformal conic grid\n     * @param ni      - The number of grid points in the i (longitude) direction\n     * @param nj      - The number of grid points in the j (latitude) direction\n     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection\n     * @param lat_0   - The center latitude for the projection\n     * @param lat_std - The standard latitudes for the projection\n     * @param ll_x    - The x coordinate in projection space of the lower-left corner of the grid\n     * @param ll_y    - The y coordinate in projection space of the lower-left corner of the grid\n     * @param ur_x    - The x coordinate in projection space of the upper-right corner of the grid\n     * @param ur_y    - The y coordinate in projection space of the upper-right corner of the grid\n     */\n    constructor(ni: number, nj: number, lon_0: number, lat_0: number, lat_std: [number, number], \n                ll_x: number, ll_y: number, ur_x: number, ur_y: number) {\n        super('lcc', true, ni, nj);\n\n        this.lon_0 = lon_0;\n        this.lat_0 = lat_0;\n        this.lat_std = lat_std;\n        this.ll_x = ll_x;\n        this.ll_y = ll_y;\n        this.ur_x = ur_x;\n        this.ur_y = ur_y;\n        this.lcc = lambertConformalConic({lon_0: lon_0, lat_0: lat_0, lat_std: lat_std});\n\n        const dx = (this.ur_x - this.ll_x) / (this.ni - 1);\n        const dy = (this.ur_y - this.ll_y) / (this.nj - 1);\n\n        this.ll_cache = new Cache(() => {\n            const lons = new Float32Array(this.ni * this.nj);\n            const lats = new Float32Array(this.ni * this.nj);\n\n            for (let i = 0; i < this.ni; i++) {\n                const x = this.ll_x + i * dx;\n                for (let j = 0; j < this.nj; j++) {\n                    const y = this.ll_y + j * dy;\n\n                    const [lon, lat] = this.lcc(x, y, {inverse: true});\n                    const idx = i + j * this.ni;\n                    lons[idx] = lon;\n                    lats[idx] = lat;\n                }\n            }\n\n            return {lons: lons, lats: lats};\n        });\n\n        this.gc_cache = new Cache(() => {\n            const x = new Float32Array(this.ni);\n            const y = new Float32Array(this.nj);\n\n            for (let i = 0; i < this.ni; i++) {\n                x[i] = this.ll_x + i * dx;\n            }\n\n            for (let j = 0; j < this.nj; j++) {\n                y[j] = this.ll_y + j * dy;\n            }\n\n            return {x: x, y: y};\n        });\n    }\n\n    public static fromLLCornerLonLat(ni: number, nj: number, lon_0: number, lat_0: number, lat_std: [number, number], \n                                     ll_lon: number, ll_lat: number, dx: number, dy: number) {\n\n        const lcc = lambertConformalConic({lon_0: lon_0, lat_0: lat_0, lat_std: lat_std});\n        const [ll_x, ll_y] = lcc(ll_lon, ll_lat);\n\n        return new LambertGrid(ni, nj, lon_0, lat_0, lat_std, ll_x, ll_y, ll_x + ni * dx, ll_y + nj * dy);\n    }\n\n    public copy(opts?: {ni?: number, nj?: number, ll_x?: number, ll_y?: number, ur_x?: number, ur_y?: number}) {\n        opts = opts !== undefined ? opts : {};\n        const ni = opts.ni !== undefined ? opts.ni : this.ni;\n        const nj = opts.nj !== undefined ? opts.nj : this.nj;\n        const ll_x = opts.ll_x !== undefined ? opts.ll_x : this.ll_x;\n        const ll_y = opts.ll_y !== undefined ? opts.ll_y : this.ll_y;\n        const ur_x = opts.ur_x !== undefined ? opts.ur_x : this.ur_x;\n        const ur_y = opts.ur_y !== undefined ? opts.ur_y : this.ur_y;\n\n        return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y);\n    }\n\n    /**\n     * Get a list of longitudes and latitudes on the grid (internal method)\n     */\n    public getEarthCoords() {\n        return this.ll_cache.getValue();\n    }\n\n    public getGridCoords() {\n        return this.gc_cache.getValue();\n    }\n\n    public transform(x: number, y: number, opts?: {inverse?: boolean}) {\n        opts = opts === undefined ? {}: opts;\n        const inverse = opts.inverse === undefined ? false : opts.inverse;\n\n        return this.lcc(x, y, {inverse: inverse});\n    }\n\n    public getThinnedGrid(thin_x: number, thin_y: number) {\n        const dx = (this.ur_x - this.ll_x) / this.ni;\n        const dy = (this.ur_y - this.ll_y) / this.nj;\n\n        const ni = Math.ceil(this.ni / thin_x);\n        const nj = Math.ceil(this.nj / thin_y);\n        const ni_remove = (this.ni - 1) % thin_x;\n        const nj_remove = (this.nj - 1) % thin_y;\n        const ll_x = this.ll_x;\n        const ll_y = this.ll_y;\n        const ur_x = this.ur_x - ni_remove * dx;\n        const ur_y = this.ur_y - nj_remove * dy;\n\n        return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y);\n    }\n}\n\nexport {Grid, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid};\nexport type {GridType};","\nimport { PlotComponent } from \"./PlotComponent\";\nimport Contour, {ContourOptions, ContourLabels, ContourLabelOptions} from \"./Contour\";\nimport {ContourFill, Raster, ContourFillOptions, RasterOptions} from \"./Fill\";\nimport Barbs, {BarbsOptions} from \"./Barbs\";\nimport Paintball, {PaintballOptions} from \"./Paintball\";\nimport Hodographs, {HodographOptions} from './Hodographs';\n\nimport { PlotLayer, MultiPlotLayer } from './PlotLayer';\nimport { WindProfile, WebGLAnyRenderingContext, TypedArray, ContourData } from \"./AutumnTypes\";\nimport { MapLikeType } from \"./Map\";\nimport { ColorMap, ColorMapOptions, bluered, redblue, pw_speed500mb, pw_speed850mb, pw_cape, pw_t2m, pw_td2m, nws_storm_clear_refl } from './Colormap';\nimport { Color } from \"./Color\";\nimport { makeColorBar, makePaintballKey, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions } from \"./ColorBar\";\nimport { LineStyle } from \"./PolylineCollection\";\nimport { RawScalarField, RawVectorField, RawProfileField, VectorRelativeTo, RawVectorFieldOptions} from \"./RawField\";\nimport { Grid, GridType, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid } from './Grid'\n\nimport { initMSModule, FieldContourOpts } from './ContourCreator';\n\nconst colormaps = {\n    bluered: bluered,\n    redblue: redblue,\n    pw_speed500mb: pw_speed500mb,\n    pw_speed850mb: pw_speed850mb,\n    pw_cape: pw_cape,\n    pw_t2m: pw_t2m,\n    pw_td2m: pw_td2m,\n    nws_storm_clear_refl: nws_storm_clear_refl,\n}\n\n/**\n * Initialize the WebAssembly module in autumnplot-gl. It's not strictly necessary to call it first, but if you call it\n * first, you can prevent races when you contour a bunch of fields at once.\n */\nfunction initAutumnPlot() {\n    initMSModule();\n}\n\nexport {PlotComponent,\n        Barbs, BarbsOptions,\n        Contour, ContourOptions, ContourLabels, ContourLabelOptions,\n        ContourFill, Raster, ContourFillOptions, RasterOptions,\n        Paintball, PaintballOptions,\n        Hodographs, HodographOptions, WindProfile,\n        PlotLayer, MultiPlotLayer, \n        MapLikeType, LineStyle,\n        ColorMap, ColorMapOptions, colormaps, makeColorBar, makePaintballKey, Color, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions,\n        RawScalarField, RawVectorField, RawProfileField,\n        Grid, GridType, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid,\n        WebGLAnyRenderingContext, TypedArray, ContourData,\n        initAutumnPlot, FieldContourOpts};\n"],"names":["root","factory","exports","module","define","amd","this","read","buffer","offset","isLE","mLen","nBytes","e","m","eLen","eMax","eBias","nBits","i","d","s","NaN","Infinity","Math","pow","write","value","c","rt","abs","isNaN","floor","log","LN2","t","n","o","obj","left","right","parent","dimension","content","scoreFunction","prototype","push","bubbleUp","length","pop","sinkDown","peek","remove","Error","size","r","l","u","h","kdTree","Array","isArray","sort","slice","toJSON","insert","nearest","f","a","g","p","min","balanceFactor","max","BinaryHeap","Pbf","ieee754","buf","ArrayBuffer","isView","Uint8Array","pos","type","Varint","Fixed64","Bytes","Fixed32","SHIFT_LEFT_32","SHIFT_RIGHT_32","utf8TextDecoder","TextDecoder","readPackedEnd","pbf","readVarint","toNum","low","high","isSigned","makeRoomForExtraLength","startPos","len","extraLen","realloc","writePackedVarint","arr","writeVarint","writePackedSVarint","writeSVarint","writePackedFloat","writeFloat","writePackedDouble","writeDouble","writePackedBoolean","writeBoolean","writePackedFixed32","writeFixed32","writePackedSFixed32","writeSFixed32","writePackedFixed64","writeFixed64","writePackedSFixed64","writeSFixed64","readUInt32","writeInt32","val","readInt32","destroy","readFields","readField","result","end","tag","skip","readMessage","readFixed32","readSFixed32","readFixed64","readSFixed64","readFloat","readDouble","b","readVarintRemainder","readVarint64","readSVarint","num","readBoolean","Boolean","readString","decode","subarray","readUtf8TextDecoder","str","b1","b2","b3","b0","bytesPerSequence","String","fromCharCode","readUtf8","readBytes","readPackedVarint","readPackedSVarint","readPackedBoolean","readPackedFloat","readPackedDouble","readPackedFixed32","readPackedSFixed32","readPackedFixed64","readPackedSFixed64","writeTag","set","finish","writeBigVarintLow","lsb","writeBigVarintHigh","writeBigVarint","writeString","lead","charCodeAt","writeUtf8","writeBytes","writeRawMessage","fn","writeMessage","writeBytesField","writeFixed32Field","writeSFixed32Field","writeFixed64Field","writeSFixed64Field","writeVarintField","writeSVarintField","writeStringField","writeFloatField","writeDoubleField","writeBooleanField","_scriptDir","Module","document","currentScript","src","undefined","moduleArg","readyPromiseResolve","readyPromiseReject","Promise","resolve","reject","forEach","prop","Object","getOwnPropertyDescriptor","defineProperty","get","abort","moduleOverrides","assign","readBinary","scriptDirectory","indexOf","substr","replace","lastIndexOf","window","importScripts","wasmBinary","wasmMemory","out","console","bind","err","error","legacyModuleProp","assert","WebAssembly","HEAP8","HEAPU8","HEAP16","HEAPU16","HEAP32","HEAPU32","HEAPF32","HEAPF64","ABORT","condition","text","updateMemoryViews","Int8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","checkStackCookie","_emscripten_stack_get_end","cookie1","cookie2","ptrToString","h16","h8","__ATPRERUN__","__ATINIT__","__ATPOSTRUN__","runtimeInitialized","imul","fround","clz32","trunc","runDependencies","runDependencyWatcher","dependenciesFulfilled","runDependencyTracking","what","RuntimeError","FS","init","createDataFile","createPreloadedFile","createLazyFile","open","mkdev","registerDevice","analyzePath","ErrnoError","wasmBinaryFile","path","isDataURI","filename","startsWith","createExportWrapper","name","wasmExports","apply","arguments","EmscriptenEH","CppException","constructor","excPtr","super","excInfo","getExceptionMessage","message","getBinarySync","file","instantiateArrayBuffer","binaryFile","imports","receiver","fetch","then","credentials","response","catch","getBinaryPromise","binary","instantiate","instance","reason","newName","incomming","configurable","isExportedByForceFilesystem","missingGlobal","sym","msg","globalThis","warnOnce","unexportedRuntimeSymbol","callRuntimeCallbacks","callbacks","shift","UTF8Decoder","UTF8ArrayToString","heapOrArray","idx","maxBytesToRead","endIdx","endPtr","u0","u1","u2","ch","UTF8ToString","ptr","getExceptionMessageCommon","withStackSave","type_addr_addr","stackAlloc","message_addr_addr","___get_exception_message","type_addr","message_addr","_free","stack","stackSave","ret","stackRestore","toString","padStart","shown","exceptionCaught","exceptionLast","ExceptionInfo","set_type","get_type","set_destructor","destructor","get_destructor","set_caught","caught","get_caught","set_rethrown","rethrown","get_rethrown","set_adjusted_ptr","adjustedPtr","get_adjusted_ptr","get_exception_ptr","___cxa_is_pointer_type","adjusted","embind_charCodes","BindingError","InternalError","findMatchingCatch","args","thrown","setTempRet0","info","thrownType","arg","caughtType","adjusted_ptr_addr","___cxa_can_catch","readLatin1String","awaitingDependencies","registeredTypes","typeDependencies","throwBindingError","throwInternalError","registerType","rawType","registeredInstance","options","TypeError","hasOwnProperty","ignoreDuplicateRegistrations","cb","sharedRegisterType","HandleAllocator","allocated","freelist","emval_handles","__emval_decref","handle","reserved","refcount","free","count_emval_handles","count","Emval","allocate","simpleReadValueFromPointer","pointer","embindRepr","v","floatReadValueFromPointer","width","createNamedFunction","body","runDestructors","destructors","del","newFunc","argumentList","Function","dummy","wasmTable","UnboundTypeError","ensureOverloadTable","proto","methodName","humanName","overloadTable","prevFunc","argCount","wasmTableMirror","getWasmTableEntry","funcPtr","func","dynCall","sig","includes","substring","concat","call","dynCallLegacy","embind__requireFunction","signature","rawFunction","fp","argCache","getDynCaller","getTypeName","___getTypeName","rv","integerReadValueFromPointer","signed","readPointer","_emscripten_get_now","stringToUTF8","outPtr","maxBytesToWrite","heap","outIdx","startIdx","stringToUTF8Array","UTF16Decoder","UTF16ToString","maxIdx","codeUnit","stringToUTF16","startPtr","numCharsToWrite","lengthBytesUTF16","UTF32ToString","utf32","stringToUTF32","lengthBytesUTF32","requireRegisteredType","impl","emval_returnValue","returnType","destructorsRef","emval_methodCallers","emval_symbols","getStringOrSymbol","address","symbol","__emval_get_method_caller","Reflect","construct","argTypes","kind","types","emval_lookupTypes","retType","functionBody","argsList","params","join","isVoid","caller","id","invokerFunction","functionName","map","performance","now","growMemory","pages","byteLength","grow","baseErrorType","errorName","errorClass","printCharBuffers","codes","embind_init_charCodes","has","create","wasmImports","__assert_fail","line","__cxa_begin_catch","___cxa_increment_exception_refcount","__cxa_find_matching_catch_2","__cxa_find_matching_catch_3","arg0","__cxa_throw","__resumeException","_embind_register_bigint","primitiveType","minRange","maxRange","_embind_register_bool","trueValue","falseValue","wt","destructorFunction","_embind_register_emval","_embind_register_float","_embind_register_function","rawArgTypesAddr","rawInvoker","isAsync","firstElement","array","heap32VectorToArray","argsIndex","trim","getFunctionName","numArguments","exposePublicSymbol","unboundTypes","seen","visit","throwUnboundTypeError","myTypes","dependentTypes","getTypeConverters","onComplete","typeConverters","myTypeConverters","unregisteredTypes","registered","dt","whenDependentTypesAreResolved","invokerArgsArray","replacePublicSymbol","classType","cppInvokerFunc","cppTargetFunc","isClassMethodFunc","needsDestructorStack","returns","argsListWired","invokerFnBody","dtorStack","args1","args2","paramName","invokerFn","craftInvokerFunction","_embind_register_integer","fromWireType","bitshift","isUnsignedType","checkAssertions","toTypeName","_embind_register_memory_view","dataTypeIndex","TA","decodeMemoryView","data","_embind_register_std_string","stdStringIsUTF8","payload","decodeStartPtr","currentBytePtr","stringSegment","valueIsOfTypeString","Uint8ClampedArray","lengthBytesUTF8","base","_malloc","charCode","_embind_register_std_wstring","charSize","decodeString","encodeString","getHeap","lengthBytesUTF","HEAP","_embind_register_void","_emscripten_get_now_is_monotonic","_emval_as","_emval_call","_emval_call_method","objHandle","_emval_decref","_emval_get_method_caller","_emval_get_module_property","_emval_get_property","key","_emval_incref","_emval_new_array","_emval_new_cstring","_emval_new_object","_emval_run_destructors","_emval_set_property","_emval_take_value","emscripten_date_now","Date","emscripten_get_now","emscripten_memcpy_js","dest","copyWithin","emscripten_resize_heap","requestedSize","oldSize","maxHeapSize","x","cutDown","overGrownHeapSize","newSize","fd_close","fd","fd_seek","offset_low","offset_high","whence","newOffset","hi","lo","fd_write","iov","iovcnt","pnum","j","stream","curr","invoke_ii","index","a1","sp","_setThrew","invoke_iii","a2","invoke_iiii","a3","invoke_j","dynCall_j","invoke_v","invoke_vi","invoke_vii","invoke_viii","invoke_viiii","a4","receiveInstance","unshift","clearInterval","callback","removeRunDependency","setInterval","dep","trueModule","instantiateStreaming","createWasm","_emscripten_stack_init","librarySymbol","calledRun","stackCheckInit","run","doRun","postRun","preRun","setTimeout","runCaller","ready","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","definition","enumerable","chunkId","Symbol","toStringTag","scriptUrl","location","scripts","getElementsByTagName","baseURI","self","href","proxyMarker","createEndpoint","releaseProxy","throwMarker","isObject","transferHandlers","Map","canHandle","serialize","port1","port2","MessageChannel","expose","deserialize","port","start","wrap","serialized","isError","ep","addEventListener","ev","fromWireValue","returnValue","reduce","rawValue","proxy","transfers","transferCache","transfer","wireValue","transferables","toWireValue","postMessage","removeEventListener","closeEndPoint","endpoint","isMessagePort","close","target","createProxy","throwIfProxyReleased","isReleased","isProxyReleased","Proxy","_target","requestResponseMessage","_thisArg","rawArgumentList","last","processArguments","processed","WeakMap","handler","serializedValue","fill","random","Number","MAX_SAFE_INTEGER","getMinZoom","jlat","ilon","thin_fac_base","zoom","thin_fac","zip","iterators","iterator","current","next","some","done","compute_value","make_key","cached_values","JSON","stringify","getValue","normalizeOptions","opts","defaults","entries","k","isWebGL2Ctx","gl","getParameter","VERSION","layer_worker","Worker","URL","getGLFormatTypeAlignment","is_float16","format","row_alignment","userAgent","platform","macosPlatforms","os","is_webgl2","ext","getExtension","ext_lin","R16F","HALF_FLOAT","LUMINANCE","HALF_FLOAT_OES","navigator","maxTouchPoints","test","R32F","FLOAT","lambertConformalConic","F","compute_t","lat","sin_lat","sin","tan","PI","eccen","compute_m","cos","sqrt","semimajor","radians","lon_0","lat_0","lat_std","t_0","lat_1","lat_2","t_1","t_2","m_1","m_2","rho_0","eccen2","eccen4","eccen6","eccen8","Ap","Bp","Cp","Dp","inverse","y","lon","atan2","rho","hypot","sign","chi","atan","sin_2chi","cos_2chi","theta","compute_lcc","lng","toMercatorCoord","fromMercatorCoord","LngLat","lngFromMercatorX","sinh","latFromMercatorY","WGLBufferBase","verts","n_coords_per_vert","draw_mode","bind_target","dtype","ary","UNSIGNED_BYTE","UNSIGNED_SHORT","UNSIGNED_INT","getGLDtype","n_verts","createBuffer","bindBuffer","bufferData","STATIC_DRAW","WGLBuffer","ARRAY_BUFFER","bindToProgram","prog_attr_location","enableVertexAttribArray","vertexAttribPointer","WGLTexture","image","texture","createTexture","tex_num","setImageData","mag_filter","LINEAR","texParameteri","TEXTURE_2D","TEXTURE_WRAP_S","CLAMP_TO_EDGE","TEXTURE_WRAP_T","TEXTURE_MIN_FILTER","TEXTURE_MAG_FILTER","bindTexture","internal_format","data_type","RGBA","RGBA_INTEGER","RGB","RGB_INTEGER","RG","RG_INTEGER","RED","RED_INTEGER","LUMINANCE_ALPHA","ALPHA","DEPTH_COMPONENT","DEPTH_STENCIL","getWebGL2Format","pixelStorei","UNPACK_ALIGNMENT","texImage2D","prog_uni_location","gl_tex_num","activate","uniform1i","activeTexture","TEXTURE0","deactivate","delete","deleteTexture","preprocessShader","shader_src","defines","current_defines","define_truth","processed_shader_src","split","match_define","match","match_ifdef","match_ifndef","def","WGLProgram","vertex_shader_src","fragment_shader_src","prog","frag_shader_src","vertexShader","createShader","VERTEX_SHADER","shaderSource","compileShader","getShaderParameter","COMPILE_STATUS","compilationLog","getShaderInfoLog","fragmentShader","FRAGMENT_SHADER","program","createProgram","attachShader","linkProgram","getProgramParameter","LINK_STATUS","linkLog","getProgramInfoLog","compileAndLinkShaders","attributes","uniforms","index_buffer","sampler_names","remove_comments","comment_idx","vtx_shader_match","matchAll","full_match","a_name","getAttribLocation","u_name","type_parts","uniform_loc","getUniformLocation","uniform","toLowerCase","use","attribute_buffers","uniform_values","textures","useProgram","bindAttributes","setUniforms","bindTextures","warn","uniform1f","uniform1fv","uniform2fv","uniform3fv","uniform4fv","uniformMatrix4fv","sampler_name","draw","drawArrays","drawElements","WGLFramebufferBase","framebuffer","clear","color","clearColor","bindFramebuffer","FRAMEBUFFER","COLOR_BUFFER_BIT","renderTo","height","viewport","copyToTexture","copyTexImage2D","registerGLContext","THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY","THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT","ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER","CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT","CANNOT_MIX_BIGINT_AND_OTHER_TYPES","ITERATOR_PROPERTY_IS_NOT_CALLABLE","REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE","OFFSET_IS_OUT_OF_BOUNDS","uncurryThis","thisArg","ReflectApply","uncurryThisGetter","ReflectGetOwnPropertyDescriptor","ReflectConstruct","ReflectDefineProperty","ReflectGet","getPrototypeOf","ReflectGetPrototypeOf","ReflectHas","ownKeys","ReflectOwnKeys","ReflectSet","setPrototypeOf","ReflectSetPrototypeOf","NativeProxy","EPSILON","isFinite","NumberIsFinite","NumberIsNaN","SymbolIterator","species","SymbolSpecies","SymbolToStringTag","for","SymbolFor","NativeObject","ObjectCreate","ObjectDefineProperty","freeze","ObjectFreeze","is","ObjectIs","ObjectPrototype","ObjectPrototype__lookupGetter__","__lookupGetter__","object","NativeTypeError","descriptor","ObjectHasOwn","hasOwn","NativeArray","ArrayIsArray","ArrayPrototype","ArrayPrototypeJoin","ArrayPrototypePush","ArrayPrototypeToLocaleString","toLocaleString","NativeArrayPrototypeSymbolIterator","ArrayPrototypeSymbolIterator","MathAbs","MathTrunc","NativeArrayBuffer","ArrayBufferIsView","ArrayBufferPrototype","ArrayBufferPrototypeSlice","ArrayBufferPrototypeGetByteLength","NativeSharedArrayBuffer","SharedArrayBuffer","SharedArrayBufferPrototypeGetByteLength","TypedArray","TypedArrayFrom","from","TypedArrayPrototype","NativeTypedArrayPrototypeSymbolIterator","TypedArrayPrototypeKeys","keys","TypedArrayPrototypeValues","values","TypedArrayPrototypeEntries","TypedArrayPrototypeSet","TypedArrayPrototypeReverse","reverse","TypedArrayPrototypeFill","TypedArrayPrototypeCopyWithin","TypedArrayPrototypeSort","TypedArrayPrototypeSlice","TypedArrayPrototypeSubarray","TypedArrayPrototypeGetBuffer","TypedArrayPrototypeGetByteOffset","TypedArrayPrototypeGetLength","TypedArrayPrototypeGetSymbolToStringTag","NativeUint8Array","NativeUint16Array","Uint16ArrayFrom","NativeUint32Array","NativeFloat32Array","ArrayIteratorPrototype","ArrayIteratorPrototypeNext","GeneratorPrototypeNext","IteratorPrototype","DataViewPrototype","DataView","getUint16","setUint16","NativeRangeError","RangeError","NativeWeakSet","WeakSet","WeakSetPrototype","WeakSetPrototypeAdd","add","WeakSetPrototypeHas","NativeWeakMap","WeakMapPrototype","WeakMapPrototypeGet","WeakMapPrototypeHas","WeakMapPrototypeSet","arrayIterators","SafeIteratorPrototype","arrayIterator","safeIfNeeded","safe","generators","DummyArrayIteratorPrototype","generator","writable","isObjectLike","isNativeTypedArray","isNativeBigIntTypedArray","typedArrayName","isSharedArrayBuffer","isOrdinaryArray","isCanonicalIntegerIndexString","number","brand","INVERSE_OF_EPSILON","FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE","FLOAT16_EPSILON","FLOAT16_EPSILON_DEVIDED_BY_EPSILON","floatView","uint32View","baseTable","shiftTable","roundToFloat16Bits","absolute","roundTiesToEven","temp","roundToFloat16","mantissaTable","exponentTable","offsetTable","convertToNumber","float16bits","ToIntegerOrInfinity","ToLength","SpeciesConstructor","defaultConstructor","IsDetachedBuffer","defaultCompare","isXNaN","isYNaN","isXPlusZero","isYPlusZero","float16bitsArrays","isFloat16Array","hasFloat16ArrayBrand","assertFloat16Array","assertSpeciesTypedArray","isTargetFloat16Array","isTargetTypedArray","float16bitsArray","getFloat16BitsArray","float16","cloned","Float16Array","byteOffset","copyToArray","TypedArrayPrototypeGetters","input","_byteOffset","_length","isArrayBuffer","list","static","Constructor","uint16","mapFunc","items","at","relativeIndex","with","filter","kept","accumulator","reduceRight","find","findIndex","findLast","findLastIndex","every","targetOffset","targetLength","srcLength","toReversed","clonedFloat16bitsArray","compareFn","sortCompare","toSorted","relativeStart","relativeEnd","final","begin","uint16Subarray","element","separator","Float16ArrayPrototype","rgba","withOpacity","opacity","Color","toRGBHex","toRGBAHex","rgba_","in_type","round","toUpperCase","toRGBATuple","toHSVTuple","rgb","H","Cmax","Delta","rgb2hsv","fromHex","hex","hexstr","out_type","parseInt","hex2rgba","fromHSVTuple","hsv","r_prime","g_prime","b_prime","S","V","C","X","hsv2rgb","colormap_shader_src","levels","colors","normalizeColor","overflow_color","underflow_color","getColors","getOpacities","new_colors","new_levels","ic","level_lower","level_upper","new_opacity","new_color","underflow_opacity","overflow_opacity","ColorMap","diverging","color1","color2","level_min","level_max","n_colors","stops","level_step","crossover","crossover_hsv","color1_hsv","color2_hsv","istop","level","interp_fac","ilev","buildColormap","cm_data","overflow","pw_speed500mb","levl","levu","pw_speed850mb","pw_cape","pw_t2m","pw_td2m","nws_storm_clear_refl","colormap","gl_elems","applyShader","setupShaderVariables","index_map","map_norm","n_lev","input_norm","lev","cmap_norm","inv_cmap_norm","jlev","alpha","makeIndexMap","cmap_image","createElement","ctx","getContext","stop","fillStyle","fillRect","makeTextureImage","format_nonlin","type_nonlin","row_alignment_nonlin","cmap_image_spec","cmap_texture","cmap_nonlin_image","cmap_nonlin_texture","bindShaderVariables","cmap","polyline_vertex_src","polyline_fragment_src","dash_arrays","polyline","color_hex","line_width","line_style","shader_defines","vertices","TRIANGLE_STRIP","extrusion","offsets","scale","offset_scale","min_zoom","fragment_src","line_data","cmap_gpu","ColorMapGPUInterface","NEAREST","dash_array","fill_image","R8","makeDashTexture","n_dash","dash_texture","make","lines","makePolyLines","polylines","PolylineCollection","render","matrix","map_zoom","map_bearing","map_pitch","map_width","map_height","enable","BLEND","blendFuncSeparate","SRC_ALPHA","ONE_MINUS_SRC_ALPHA","ONE","text_vertex_shader_src","text_fragment_shader_src","program_cache","Cache","createAtlas","pbf_glyphs","pbf_glyphs_filtered","glyph","glyph_bins","boxes","area","maxWidth","box","w","spaces","ceil","space","potpack","bin","img_width","img_height","atlas_data","glyphs","glyph_bin","top","atlas_i","atlas_j","advance","glyph_idx","atlas_idx","glyph_M","baseline","atlas","atlas_width","atlas_height","glyph_info","getFontAtlas","url","blob","arrayBuffer","data_buffer","readGlyph","readFontStack","text_collection_opt_defaults","horizontal_align","vertical_align","font_size","text_color","halo_color","halo","text_locs","font_atlas","tl","anchor_data","offset_data","tc_data","i_anch","i_off","i_tc","loc","anchor_x","anchor_y","x_offset","init_i_off","glyph_code","anchors","texcoords","fontstack_url","TextCollection","contour_opt_defaults","interval","field","contours","updateField","getContours","contour_data","contour_line_data","cv","cd","cv_","parseFloat","contour_style","contour_width","polyline_data","ld","line_data_filtered","promises","plc_opts","all","triggerRepaint","onAdd","getZoom","getCanvas","bearing","getBearing","pitch","getPitch","cnt","PlotComponent","contour_label_opt_defaults","n_decimal_places","font_face","font_url_template","text_collection","map_style","getStyle","font_url","label_pos","contour_levels","map_max_zoom","getMaxZoom","contour_label_spacing","min_label_lat","max_label_lat","min_label_lon","max_label_lon","icntr","level_str","contour","c_map","v_ll","dist","v_last","this_dist","n_labels_placed","idist","target_dist","pt1","pt2","pt_lon","pt_lat","tree","min_label_x","max_label_y","max_label_x","min_label_y","thin_grid_width","thin_grid_height","ni_thin_grid","nj_thin_grid","thin_grid_xs","thin_grid_ys","jdy","grid_x","grid_y","ll","label","tc_opts","contourfill_vertex_shader_src","contourfill_fragment_shader_src","contour_fill_opt_defaults","fill_texture","image_mag_filter","cmap_mag_filter","tex_data","getTextureData","grid","ni","nj","getWGLBuffers","PlotComponentFill","billboard_vertex_shader_src","billboard_fragment_shader_src","max_zoom","billboard_image","billboard_spec","billboard_size_mult","spec","size_multiplier","wind_textures","n_density_tiers","log2","n_inaccessible_tiers","trim_inaccessible","show_field","getThinnedField","u_thin","v_thin","u_image","v_image","setup","thinned_field","getWGLBillboardBuffers","proj_rotation_tex","getVectorRotationTexture","proj_rot_texture","bb_size","BB_HEIGHT","bb_width","BB_WIDTH","BB_TEX_WIDTH","bb_height","BB_TEX_HEIGHT","BB_MAG_BIN_SIZE","BB_MAG_WRAP","BASE_BARB_DIMS","BB_MAG_MAX","barb_opt_defaults","barb_size_multiplier","fields","barb_texture","dimensions","canvas","drawWindBarb","tipx","tipy","mag","elem_full_size","elem_spacing","beginPath","arc","stroke","elem_pos","mag_countdown","staff_length","n_flags","n_full_barbs","moveTo","lineTo","last_was_flag","first_elem","lineWidth","miterLimit","ibarb","createBarbTexture","barb_billboards","barb_image","BillboardCollection","paintball_vertex_shader_src","paintball_fragment_shader_src","paintball_opt_defaults","color_components","flat","verts_buf","tex_coords_buf","HODO_BG_DIMS","hodograph_opt_defaults","bgcolor","hodo_line_width","background_line_width","height_cmap","profile_field","hodo_bg_texture","irng","ctr_x","ctr_y","arrow_size","_createHodoBackgroundTexture","hodo_scale","bg_size","line_elems","bg_billboard","getStormMotionGrid","profiles","hodo_polyline","prof","ipt","hodo_line","sm_polyline","sm_mag","sm_ang","sm_line","bg_image","repaint","PlotLayer","PlotLayerBase","field_key","res","setActiveKey","getKeys","addField","tagname","elem","createElementNS","setAttribute","appendChild","makeColorBar","ticks","orientation","fontface","tickfontsize","ticklabelsize","tick_dir","tick_direction","bar_left","bar_top","bar_width","bar_height","bar_right","bar_bottom","bar_middle","bar_low_arrow","bar_high_arrow","getNChar","chars_left","chars_right","need_overflow","bar_long_size","bar_cross_size","bar_long_pad","gtickattrs","gbar","transform","gticks","icolor","underflow_attrs","points","overflow_attrs","point_list","labelattrs","first_level","last_level","diffs","ilevel","tickattrs","gtick","x2","y2","dy","style","textContent","makePaintballKey","labels","n_cols","n_rows","irow","icol","swatch_height","msm_promise","initMSModule","contourCreator","msm","grid_coords","getGridCoords","getContourLevels","getContourLevelsFloat32","getContourLevelsFloat16","makeContours","makeContoursFloat32","makeContoursFloat16","getArrayConstructor","contour_cache","raw_data","aggregateFields","mapGenerator","gen","arrayType","zipped_args","agg_data","RawScalarField","relative_to","raw_u","raw_v","thin_x","thin_y","new_grid","getThinnedGrid","thinGrid","new_data","idx_old","thin_u","thin_v","RawVectorField","smu","smv","is_conformal","buffer_cache","new_ni","new_nj","native_grid","texcoord_margin_r","texcoord_margin_s","grid_cell_size_multiplier","getEarthCoords","field_lats","field_lons","makeDomainVerticesAndTexCoords","domain_coords","icd","grid_cell_size","makeWGLDomainBuffers","copy","billboard_buffer_cache","makeBBElements","bb_elements","makeWGLBillboardBuffers","vector_rotation_cache","coords","rot_vals","lats","lons","x_pertlon","y_pertlon","rot_img","makeVectorRotationTexture","ll_lon","ll_lat","ur_lon","ur_lat","dlon","dlat","ll_cache","gc_cache","PlateCarreeGrid","ni_remove","nj_remove","Grid","np_lon","np_lat","lon_shift","llrot","sin_np_lat","cos_np_lat","lon_p","lat_p","sin_lat_p","cos_lat_p","sin_lon_p_diff","cos_lon_p_diff","asin","compute_rotation_inverse","cos_lat","sin_lon_diff","cos_lon_diff","compute_rotation","rotateSphere","PlateCarreeRotatedGrid","ll_x","ll_y","ur_x","ur_y","lcc","dx","fromLLCornerLonLat","LambertGrid","colormaps","bluered","redblue","initAutumnPlot"],"sourceRoot":""}
+{"version":3,"file":"autumnplot-gl.js","mappings":"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","sources":["webpack://apgl/webpack/universalModuleDefinition","webpack://apgl/./src/glsl/paintball_step1_vertex.glsl","webpack://apgl/./node_modules/ieee754/index.js","webpack://apgl/./src/glsl/billboard_fragment.glsl","webpack://apgl/./src/glsl/contourfill_vertex.glsl","webpack://apgl/./src/glsl/paintball_step2_fragment.glsl","webpack://apgl/./node_modules/kd-tree-javascript/kdTree-min.js","webpack://apgl/./src/glsl/paintball_step1_fragment.glsl","webpack://apgl/./node_modules/pbf/index.js","webpack://apgl/./src/glsl/colormap.glsl","webpack://apgl/./node_modules/geographiclib-geodesic/geographiclib-geodesic.min.js","webpack://apgl/./src/glsl/contourfill_fragment.glsl","webpack://apgl/./src/glsl/billboard_vertex.glsl","webpack://apgl/./src/glsl/paintball_step2_vertex.glsl","webpack://apgl/./src/glsl/polyline_vertex.glsl","webpack://apgl/./src/glsl/text_vertex.glsl","webpack://apgl/./src/glsl/polyline_fragment.glsl","webpack://apgl/./src/glsl/text_fragment.glsl","webpack://apgl/webpack/bootstrap","webpack://apgl/webpack/runtime/compat get default export","webpack://apgl/webpack/runtime/define property getters","webpack://apgl/webpack/runtime/get javascript chunk filename","webpack://apgl/webpack/runtime/global","webpack://apgl/webpack/runtime/hasOwnProperty shorthand","webpack://apgl/webpack/runtime/make namespace object","webpack://apgl/webpack/runtime/publicPath","webpack://apgl/webpack/runtime/jsonp chunk loading","webpack://apgl/./node_modules/comlink/dist/esm/comlink.mjs","webpack://apgl/./src/utils.ts","webpack://apgl/./src/AutumnTypes.ts","webpack://apgl/./src/WorkerPool.ts","webpack://apgl/./src/PlotComponent.ts","webpack://apgl/./src/Map.ts","webpack://apgl/./node_modules/autumn-wgl/lib/utils.js","webpack://apgl/./node_modules/autumn-wgl/lib/WGLBuffer.js","webpack://apgl/./node_modules/autumn-wgl/lib/WGLTexture.js","webpack://apgl/./node_modules/autumn-wgl/lib/WGLProgram.js","webpack://apgl/./node_modules/autumn-wgl/lib/WGLFramebuffer.js","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/messages.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/primordials.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/arrayIterator.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/is.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/brand.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/converter.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/_util/spec.mjs","webpack://apgl/./node_modules/@petamoriken/float16/src/Float16Array.mjs","webpack://apgl/./src/Color.ts","webpack://apgl/./src/Colormap.ts","webpack://apgl/./src/ShaderManager.ts","webpack://apgl/./src/PolylineCollection.ts","webpack://apgl/./src/TextCollection.ts","webpack://apgl/./node_modules/potpack/index.js","webpack://apgl/./src/grids/AutoZoom.ts","webpack://apgl/./src/grids/Grid.ts","webpack://apgl/./src/grids/UnstructuredGrid.ts","webpack://apgl/./src/Contour.ts","webpack://apgl/./src/Fill.ts","webpack://apgl/./src/BillboardCollection.ts","webpack://apgl/./src/Barbs.ts","webpack://apgl/./src/Paintball.ts","webpack://apgl/./src/Hodographs.ts","webpack://apgl/./src/StationPlot.ts","webpack://apgl/./src/PlotLayer.ts","webpack://apgl/./src/ColorBar.ts","webpack://apgl/./src/RawField.ts","webpack://apgl/./src/grids/StructuredGrid.ts","webpack://apgl/./src/grids/DomainBuffer.ts","webpack://apgl/./src/grids/GridCoordinates.ts","webpack://apgl/./src/grids/PlateCarreeGrid.ts","webpack://apgl/./src/grids/PlateCarreeRotatedGrid.ts","webpack://apgl/./src/grids/LambertGrid.ts","webpack://apgl/./src/grids/RadarSweepGrid.ts","webpack://apgl/./src/grids/Geostationary.ts","webpack://apgl/./src/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"apgl\"] = factory();\n\telse\n\t\troot[\"apgl\"] = factory();\n})(this, () => {\nreturn ","module.exports = \"#version 300 es\\n\\nin vec2 a_pos;\\n\\nout highp vec2 v_tex_coord;\\n\\nvoid main() {\\n    gl_Position = vec4(a_pos.xy, 0., 1.);\\n    v_tex_coord = 0.5 * a_pos.xy + vec2(0.5, 0.5);\\n}\"","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","module.exports = \"#version 300 es\\n\\nin highp vec2 v_tex_coord;\\n\\n#ifdef COLORMAP\\nin highp float v_mag;\\n#else\\nuniform lowp vec4 u_bb_color;\\n#endif\\n\\nuniform sampler2D u_sampler;\\n\\nout highp vec4 fragColor;\\n\\nvoid main() {\\n    lowp vec4 tex_color = texture(u_sampler, v_tex_coord);\\n\\n    lowp vec4 color;\\n#ifdef COLORMAP\\n    color = apply_colormap(v_mag);\\n#else\\n    color = u_bb_color;\\n#endif\\n\\n    color.a *= tex_color.a;\\n    fragColor = color; // mix(vec4(1.0, 0.0, 0.0, 0.5), color, tex_color.a);\\n}\"","module.exports = \"#version 300 es\\n\\nuniform int u_offset;\\n\\nin vec2 a_pos;\\nin vec2 a_tex_coord;\\n\\nout highp vec2 v_tex_coord;\\n\\nvoid main() {\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    gl_Position = projectTile(a_pos.xy + globe_offset);\\n    v_tex_coord = a_tex_coord;\\n}\"","module.exports = \"#version 300 es\\n\\nin highp vec2 v_tex_coord;\\n\\nuniform sampler2D u_fill_sampler;\\nuniform lowp vec4 u_color;\\nuniform highp float u_opacity;\\n\\nout highp vec4 fragColor;\\n\\nvoid main() {\\n    highp float fill_val = texture(u_fill_sampler, v_tex_coord).r;\\n    \\n    if (fill_val < 0.4) {\\n        discard;\\n    }\\n\\n    lowp vec4 color = u_color;\\n\\n    color.a = color.a * u_opacity;\\n    fragColor = color;\\n}\"","/**\n * k-d Tree JavaScript - V 1.01\n *\n * https://github.com/ubilabs/kd-tree-javascript\n *\n * @author Mircea Pricop <pricop@ubilabs.net>, 2012\n * @author Martin Kleppe <kleppe@ubilabs.net>, 2012\n * @author Ubilabs http://ubilabs.net, 2012\n * @license MIT License <http://www.opensource.org/licenses/mit-license.php>\n */!function(t,n){\"function\"==typeof define&&define.amd?define([\"exports\"],n):n(\"object\"==typeof exports?exports:t)}(this,function(t){function n(t,n,o){this.obj=t,this.left=null,this.right=null,this.parent=o,this.dimension=n}function o(t){this.content=[],this.scoreFunction=t}o.prototype={push:function(t){this.content.push(t),this.bubbleUp(this.content.length-1)},pop:function(){var t=this.content[0],n=this.content.pop();return this.content.length>0&&(this.content[0]=n,this.sinkDown(0)),t},peek:function(){return this.content[0]},remove:function(t){for(var n=this.content.length,o=0;o<n;o++)if(this.content[o]==t){var i=this.content.pop();return void(o!=n-1&&(this.content[o]=i,this.scoreFunction(i)<this.scoreFunction(t)?this.bubbleUp(o):this.sinkDown(o)))}throw new Error(\"Node not found.\")},size:function(){return this.content.length},bubbleUp:function(t){for(var n=this.content[t];t>0;){var o=Math.floor((t+1)/2)-1,i=this.content[o];if(!(this.scoreFunction(n)<this.scoreFunction(i)))break;this.content[o]=n,this.content[t]=i,t=o}},sinkDown:function(t){for(var n=this.content.length,o=this.content[t],i=this.scoreFunction(o);;){var e=2*(t+1),r=e-1,l=null;if(r<n){var u=this.content[r],h=this.scoreFunction(u);h<i&&(l=r)}if(e<n){var s=this.content[e];this.scoreFunction(s)<(null==l?i:h)&&(l=e)}if(null==l)break;this.content[t]=this.content[l],this.content[l]=o,t=l}}},t.kdTree=function(t,i,e){function r(t,o,i){var l,u,h=o%e.length;return 0===t.length?null:1===t.length?new n(t[0],h,i):(t.sort(function(t,n){return t[e[h]]-n[e[h]]}),l=Math.floor(t.length/2),u=new n(t[l],h,i),u.left=r(t.slice(0,l),o+1,u),u.right=r(t.slice(l+1),o+1,u),u)}var l=this;Array.isArray(t)?this.root=r(t,0,null):function(t){function n(t){t.left&&(t.left.parent=t,n(t.left)),t.right&&(t.right.parent=t,n(t.right))}l.root=t,n(l.root)}(t),this.toJSON=function(t){t||(t=this.root);var o=new n(t.obj,t.dimension,null);return t.left&&(o.left=l.toJSON(t.left)),t.right&&(o.right=l.toJSON(t.right)),o},this.insert=function(t){function o(n,i){if(null===n)return i;var r=e[n.dimension];return t[r]<n.obj[r]?o(n.left,n):o(n.right,n)}var i,r,l=o(this.root,null);null!==l?(i=new n(t,(l.dimension+1)%e.length,l),r=e[l.dimension],t[r]<l.obj[r]?l.left=i:l.right=i):this.root=new n(t,0,null)},this.remove=function(t){function n(o){if(null===o)return null;if(o.obj===t)return o;var i=e[o.dimension];return t[i]<o.obj[i]?n(o.left,o):n(o.right,o)}function o(t){function n(t,o){var i,r,l,u,h;return null===t?null:(i=e[o],t.dimension===o?null!==t.left?n(t.left,o):t:(r=t.obj[i],l=n(t.left,o),u=n(t.right,o),h=t,null!==l&&l.obj[i]<r&&(h=l),null!==u&&u.obj[i]<h.obj[i]&&(h=u),h))}var i,r,u;if(null===t.left&&null===t.right)return null===t.parent?void(l.root=null):(u=e[t.parent.dimension],void(t.obj[u]<t.parent.obj[u]?t.parent.left=null:t.parent.right=null));null!==t.right?(r=(i=n(t.right,t.dimension)).obj,o(i),t.obj=r):(r=(i=n(t.left,t.dimension)).obj,o(i),t.right=t.left,t.left=null,t.obj=r)}var i;null!==(i=n(l.root))&&o(i)},this.nearest=function(t,n,r){function u(o){function r(t,o){f.push([t,o]),f.size()>n&&f.pop()}var l,h,s,c,a=e[o.dimension],g=i(t,o.obj),p={};for(c=0;c<e.length;c+=1)c===o.dimension?p[e[c]]=t[e[c]]:p[e[c]]=o.obj[e[c]];h=i(p,o.obj),null!==o.right||null!==o.left?(u(l=null===o.right?o.left:null===o.left?o.right:t[a]<o.obj[a]?o.left:o.right),(f.size()<n||g<f.peek()[1])&&r(o,g),(f.size()<n||Math.abs(h)<f.peek()[1])&&null!==(s=l===o.left?o.right:o.left)&&u(s)):(f.size()<n||g<f.peek()[1])&&r(o,g)}var h,s,f;if(f=new o(function(t){return-t[1]}),r)for(h=0;h<n;h+=1)f.push([null,r]);for(l.root&&u(l.root),s=[],h=0;h<Math.min(n,f.content.length);h+=1)f.content[h][0]&&s.push([f.content[h][0].obj,f.content[h][1]]);return s},this.balanceFactor=function(){function t(n){return null===n?0:Math.max(t(n.left),t(n.right))+1}function n(t){return null===t?0:n(t.left)+n(t.right)+1}return t(l.root)/(Math.log(n(l.root))/Math.log(2))}},t.BinaryHeap=o});\n","module.exports = \"#version 300 es\\n\\nin highp vec2 v_tex_coord;\\n\\nuniform int u_imem;\\n\\nout highp vec4 fragColor;\\n\\nvoid main() {\\n    uint fill_val = uint(get_field_value(v_tex_coord));\\n    \\n    if (fill_val < uint(1)) {\\n        discard;\\n    }\\n\\n    lowp vec4 off_color = vec4(0., 0., 0., 1.);\\n    lowp vec4 on_color = vec4(1., 1., 1., 1.);\\n\\n    uint mask = uint(1) << u_imem;\\n    lowp float mem_active = float((fill_val & mask) > uint(0));\\n    fragColor = mix(off_color, on_color, mem_active);\\n}\"","'use strict';\n\nmodule.exports = Pbf;\n\nvar ieee754 = require('ieee754');\n\nfunction Pbf(buf) {\n    this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);\n    this.pos = 0;\n    this.type = 0;\n    this.length = this.buf.length;\n}\n\nPbf.Varint  = 0; // varint: int32, int64, uint32, uint64, sint32, sint64, bool, enum\nPbf.Fixed64 = 1; // 64-bit: double, fixed64, sfixed64\nPbf.Bytes   = 2; // length-delimited: string, bytes, embedded messages, packed repeated fields\nPbf.Fixed32 = 5; // 32-bit: float, fixed32, sfixed32\n\nvar SHIFT_LEFT_32 = (1 << 16) * (1 << 16),\n    SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;\n\n// Threshold chosen based on both benchmarking and knowledge about browser string\n// data structures (which currently switch structure types at 12 bytes or more)\nvar TEXT_DECODER_MIN_LENGTH = 12;\nvar utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf8');\n\nPbf.prototype = {\n\n    destroy: function() {\n        this.buf = null;\n    },\n\n    // === READING =================================================================\n\n    readFields: function(readField, result, end) {\n        end = end || this.length;\n\n        while (this.pos < end) {\n            var val = this.readVarint(),\n                tag = val >> 3,\n                startPos = this.pos;\n\n            this.type = val & 0x7;\n            readField(tag, result, this);\n\n            if (this.pos === startPos) this.skip(val);\n        }\n        return result;\n    },\n\n    readMessage: function(readField, result) {\n        return this.readFields(readField, result, this.readVarint() + this.pos);\n    },\n\n    readFixed32: function() {\n        var val = readUInt32(this.buf, this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    readSFixed32: function() {\n        var val = readInt32(this.buf, this.pos);\n        this.pos += 4;\n        return val;\n    },\n\n    // 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)\n\n    readFixed64: function() {\n        var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readSFixed64: function() {\n        var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;\n        this.pos += 8;\n        return val;\n    },\n\n    readFloat: function() {\n        var val = ieee754.read(this.buf, this.pos, true, 23, 4);\n        this.pos += 4;\n        return val;\n    },\n\n    readDouble: function() {\n        var val = ieee754.read(this.buf, this.pos, true, 52, 8);\n        this.pos += 8;\n        return val;\n    },\n\n    readVarint: function(isSigned) {\n        var buf = this.buf,\n            val, b;\n\n        b = buf[this.pos++]; val  =  b & 0x7f;        if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 7;  if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 14; if (b < 0x80) return val;\n        b = buf[this.pos++]; val |= (b & 0x7f) << 21; if (b < 0x80) return val;\n        b = buf[this.pos];   val |= (b & 0x0f) << 28;\n\n        return readVarintRemainder(val, isSigned, this);\n    },\n\n    readVarint64: function() { // for compatibility with v2.0.1\n        return this.readVarint(true);\n    },\n\n    readSVarint: function() {\n        var num = this.readVarint();\n        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding\n    },\n\n    readBoolean: function() {\n        return Boolean(this.readVarint());\n    },\n\n    readString: function() {\n        var end = this.readVarint() + this.pos;\n        var pos = this.pos;\n        this.pos = end;\n\n        if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {\n            // longer strings are fast with the built-in browser TextDecoder API\n            return readUtf8TextDecoder(this.buf, pos, end);\n        }\n        // short strings are fast with our custom implementation\n        return readUtf8(this.buf, pos, end);\n    },\n\n    readBytes: function() {\n        var end = this.readVarint() + this.pos,\n            buffer = this.buf.subarray(this.pos, end);\n        this.pos = end;\n        return buffer;\n    },\n\n    // verbose for performance reasons; doesn't affect gzipped size\n\n    readPackedVarint: function(arr, isSigned) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readVarint(isSigned));\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readVarint(isSigned));\n        return arr;\n    },\n    readPackedSVarint: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSVarint());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSVarint());\n        return arr;\n    },\n    readPackedBoolean: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readBoolean());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readBoolean());\n        return arr;\n    },\n    readPackedFloat: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFloat());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFloat());\n        return arr;\n    },\n    readPackedDouble: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readDouble());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readDouble());\n        return arr;\n    },\n    readPackedFixed32: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed32());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFixed32());\n        return arr;\n    },\n    readPackedSFixed32: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed32());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSFixed32());\n        return arr;\n    },\n    readPackedFixed64: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readFixed64());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readFixed64());\n        return arr;\n    },\n    readPackedSFixed64: function(arr) {\n        if (this.type !== Pbf.Bytes) return arr.push(this.readSFixed64());\n        var end = readPackedEnd(this);\n        arr = arr || [];\n        while (this.pos < end) arr.push(this.readSFixed64());\n        return arr;\n    },\n\n    skip: function(val) {\n        var type = val & 0x7;\n        if (type === Pbf.Varint) while (this.buf[this.pos++] > 0x7f) {}\n        else if (type === Pbf.Bytes) this.pos = this.readVarint() + this.pos;\n        else if (type === Pbf.Fixed32) this.pos += 4;\n        else if (type === Pbf.Fixed64) this.pos += 8;\n        else throw new Error('Unimplemented type: ' + type);\n    },\n\n    // === WRITING =================================================================\n\n    writeTag: function(tag, type) {\n        this.writeVarint((tag << 3) | type);\n    },\n\n    realloc: function(min) {\n        var length = this.length || 16;\n\n        while (length < this.pos + min) length *= 2;\n\n        if (length !== this.length) {\n            var buf = new Uint8Array(length);\n            buf.set(this.buf);\n            this.buf = buf;\n            this.length = length;\n        }\n    },\n\n    finish: function() {\n        this.length = this.pos;\n        this.pos = 0;\n        return this.buf.subarray(0, this.length);\n    },\n\n    writeFixed32: function(val) {\n        this.realloc(4);\n        writeInt32(this.buf, val, this.pos);\n        this.pos += 4;\n    },\n\n    writeSFixed32: function(val) {\n        this.realloc(4);\n        writeInt32(this.buf, val, this.pos);\n        this.pos += 4;\n    },\n\n    writeFixed64: function(val) {\n        this.realloc(8);\n        writeInt32(this.buf, val & -1, this.pos);\n        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeSFixed64: function(val) {\n        this.realloc(8);\n        writeInt32(this.buf, val & -1, this.pos);\n        writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);\n        this.pos += 8;\n    },\n\n    writeVarint: function(val) {\n        val = +val || 0;\n\n        if (val > 0xfffffff || val < 0) {\n            writeBigVarint(val, this);\n            return;\n        }\n\n        this.realloc(4);\n\n        this.buf[this.pos++] =           val & 0x7f  | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] = ((val >>>= 7) & 0x7f) | (val > 0x7f ? 0x80 : 0); if (val <= 0x7f) return;\n        this.buf[this.pos++] =   (val >>> 7) & 0x7f;\n    },\n\n    writeSVarint: function(val) {\n        this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);\n    },\n\n    writeBoolean: function(val) {\n        this.writeVarint(Boolean(val));\n    },\n\n    writeString: function(str) {\n        str = String(str);\n        this.realloc(str.length * 4);\n\n        this.pos++; // reserve 1 byte for short string length\n\n        var startPos = this.pos;\n        // write the string directly to the buffer and see how much was written\n        this.pos = writeUtf8(this.buf, str, this.pos);\n        var len = this.pos - startPos;\n\n        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeFloat: function(val) {\n        this.realloc(4);\n        ieee754.write(this.buf, val, this.pos, true, 23, 4);\n        this.pos += 4;\n    },\n\n    writeDouble: function(val) {\n        this.realloc(8);\n        ieee754.write(this.buf, val, this.pos, true, 52, 8);\n        this.pos += 8;\n    },\n\n    writeBytes: function(buffer) {\n        var len = buffer.length;\n        this.writeVarint(len);\n        this.realloc(len);\n        for (var i = 0; i < len; i++) this.buf[this.pos++] = buffer[i];\n    },\n\n    writeRawMessage: function(fn, obj) {\n        this.pos++; // reserve 1 byte for short message length\n\n        // write the message directly to the buffer and see how much was written\n        var startPos = this.pos;\n        fn(obj, this);\n        var len = this.pos - startPos;\n\n        if (len >= 0x80) makeRoomForExtraLength(startPos, len, this);\n\n        // finally, write the message length in the reserved place and restore the position\n        this.pos = startPos - 1;\n        this.writeVarint(len);\n        this.pos += len;\n    },\n\n    writeMessage: function(tag, fn, obj) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeRawMessage(fn, obj);\n    },\n\n    writePackedVarint:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedVarint, arr);   },\n    writePackedSVarint:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSVarint, arr);  },\n    writePackedBoolean:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedBoolean, arr);  },\n    writePackedFloat:    function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFloat, arr);    },\n    writePackedDouble:   function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedDouble, arr);   },\n    writePackedFixed32:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed32, arr);  },\n    writePackedSFixed32: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed32, arr); },\n    writePackedFixed64:  function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedFixed64, arr);  },\n    writePackedSFixed64: function(tag, arr) { if (arr.length) this.writeMessage(tag, writePackedSFixed64, arr); },\n\n    writeBytesField: function(tag, buffer) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeBytes(buffer);\n    },\n    writeFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFixed32(val);\n    },\n    writeSFixed32Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeSFixed32(val);\n    },\n    writeFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeFixed64(val);\n    },\n    writeSFixed64Field: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeSFixed64(val);\n    },\n    writeVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeVarint(val);\n    },\n    writeSVarintField: function(tag, val) {\n        this.writeTag(tag, Pbf.Varint);\n        this.writeSVarint(val);\n    },\n    writeStringField: function(tag, str) {\n        this.writeTag(tag, Pbf.Bytes);\n        this.writeString(str);\n    },\n    writeFloatField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed32);\n        this.writeFloat(val);\n    },\n    writeDoubleField: function(tag, val) {\n        this.writeTag(tag, Pbf.Fixed64);\n        this.writeDouble(val);\n    },\n    writeBooleanField: function(tag, val) {\n        this.writeVarintField(tag, Boolean(val));\n    }\n};\n\nfunction readVarintRemainder(l, s, p) {\n    var buf = p.buf,\n        h, b;\n\n    b = buf[p.pos++]; h  = (b & 0x70) >> 4;  if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 3;  if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 10; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 17; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x7f) << 24; if (b < 0x80) return toNum(l, h, s);\n    b = buf[p.pos++]; h |= (b & 0x01) << 31; if (b < 0x80) return toNum(l, h, s);\n\n    throw new Error('Expected varint not more than 10 bytes');\n}\n\nfunction readPackedEnd(pbf) {\n    return pbf.type === Pbf.Bytes ?\n        pbf.readVarint() + pbf.pos : pbf.pos + 1;\n}\n\nfunction toNum(low, high, isSigned) {\n    if (isSigned) {\n        return high * 0x100000000 + (low >>> 0);\n    }\n\n    return ((high >>> 0) * 0x100000000) + (low >>> 0);\n}\n\nfunction writeBigVarint(val, pbf) {\n    var low, high;\n\n    if (val >= 0) {\n        low  = (val % 0x100000000) | 0;\n        high = (val / 0x100000000) | 0;\n    } else {\n        low  = ~(-val % 0x100000000);\n        high = ~(-val / 0x100000000);\n\n        if (low ^ 0xffffffff) {\n            low = (low + 1) | 0;\n        } else {\n            low = 0;\n            high = (high + 1) | 0;\n        }\n    }\n\n    if (val >= 0x10000000000000000 || val < -0x10000000000000000) {\n        throw new Error('Given varint doesn\\'t fit into 10 bytes');\n    }\n\n    pbf.realloc(10);\n\n    writeBigVarintLow(low, high, pbf);\n    writeBigVarintHigh(high, pbf);\n}\n\nfunction writeBigVarintLow(low, high, pbf) {\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos++] = low & 0x7f | 0x80; low >>>= 7;\n    pbf.buf[pbf.pos]   = low & 0x7f;\n}\n\nfunction writeBigVarintHigh(high, pbf) {\n    var lsb = (high & 0x07) << 4;\n\n    pbf.buf[pbf.pos++] |= lsb         | ((high >>>= 3) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f | ((high >>>= 7) ? 0x80 : 0); if (!high) return;\n    pbf.buf[pbf.pos++]  = high & 0x7f;\n}\n\nfunction makeRoomForExtraLength(startPos, len, pbf) {\n    var extraLen =\n        len <= 0x3fff ? 1 :\n        len <= 0x1fffff ? 2 :\n        len <= 0xfffffff ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));\n\n    // if 1 byte isn't enough for encoding message length, shift the data to the right\n    pbf.realloc(extraLen);\n    for (var i = pbf.pos - 1; i >= startPos; i--) pbf.buf[i + extraLen] = pbf.buf[i];\n}\n\nfunction writePackedVarint(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeVarint(arr[i]);   }\nfunction writePackedSVarint(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeSVarint(arr[i]);  }\nfunction writePackedFloat(arr, pbf)    { for (var i = 0; i < arr.length; i++) pbf.writeFloat(arr[i]);    }\nfunction writePackedDouble(arr, pbf)   { for (var i = 0; i < arr.length; i++) pbf.writeDouble(arr[i]);   }\nfunction writePackedBoolean(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeBoolean(arr[i]);  }\nfunction writePackedFixed32(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed32(arr[i]);  }\nfunction writePackedSFixed32(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed32(arr[i]); }\nfunction writePackedFixed64(arr, pbf)  { for (var i = 0; i < arr.length; i++) pbf.writeFixed64(arr[i]);  }\nfunction writePackedSFixed64(arr, pbf) { for (var i = 0; i < arr.length; i++) pbf.writeSFixed64(arr[i]); }\n\n// Buffer code below from https://github.com/feross/buffer, MIT-licensed\n\nfunction readUInt32(buf, pos) {\n    return ((buf[pos]) |\n        (buf[pos + 1] << 8) |\n        (buf[pos + 2] << 16)) +\n        (buf[pos + 3] * 0x1000000);\n}\n\nfunction writeInt32(buf, val, pos) {\n    buf[pos] = val;\n    buf[pos + 1] = (val >>> 8);\n    buf[pos + 2] = (val >>> 16);\n    buf[pos + 3] = (val >>> 24);\n}\n\nfunction readInt32(buf, pos) {\n    return ((buf[pos]) |\n        (buf[pos + 1] << 8) |\n        (buf[pos + 2] << 16)) +\n        (buf[pos + 3] << 24);\n}\n\nfunction readUtf8(buf, pos, end) {\n    var str = '';\n    var i = pos;\n\n    while (i < end) {\n        var b0 = buf[i];\n        var c = null; // codepoint\n        var bytesPerSequence =\n            b0 > 0xEF ? 4 :\n            b0 > 0xDF ? 3 :\n            b0 > 0xBF ? 2 : 1;\n\n        if (i + bytesPerSequence > end) break;\n\n        var b1, b2, b3;\n\n        if (bytesPerSequence === 1) {\n            if (b0 < 0x80) {\n                c = b0;\n            }\n        } else if (bytesPerSequence === 2) {\n            b1 = buf[i + 1];\n            if ((b1 & 0xC0) === 0x80) {\n                c = (b0 & 0x1F) << 0x6 | (b1 & 0x3F);\n                if (c <= 0x7F) {\n                    c = null;\n                }\n            }\n        } else if (bytesPerSequence === 3) {\n            b1 = buf[i + 1];\n            b2 = buf[i + 2];\n            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80) {\n                c = (b0 & 0xF) << 0xC | (b1 & 0x3F) << 0x6 | (b2 & 0x3F);\n                if (c <= 0x7FF || (c >= 0xD800 && c <= 0xDFFF)) {\n                    c = null;\n                }\n            }\n        } else if (bytesPerSequence === 4) {\n            b1 = buf[i + 1];\n            b2 = buf[i + 2];\n            b3 = buf[i + 3];\n            if ((b1 & 0xC0) === 0x80 && (b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n                c = (b0 & 0xF) << 0x12 | (b1 & 0x3F) << 0xC | (b2 & 0x3F) << 0x6 | (b3 & 0x3F);\n                if (c <= 0xFFFF || c >= 0x110000) {\n                    c = null;\n                }\n            }\n        }\n\n        if (c === null) {\n            c = 0xFFFD;\n            bytesPerSequence = 1;\n\n        } else if (c > 0xFFFF) {\n            c -= 0x10000;\n            str += String.fromCharCode(c >>> 10 & 0x3FF | 0xD800);\n            c = 0xDC00 | c & 0x3FF;\n        }\n\n        str += String.fromCharCode(c);\n        i += bytesPerSequence;\n    }\n\n    return str;\n}\n\nfunction readUtf8TextDecoder(buf, pos, end) {\n    return utf8TextDecoder.decode(buf.subarray(pos, end));\n}\n\nfunction writeUtf8(buf, str, pos) {\n    for (var i = 0, c, lead; i < str.length; i++) {\n        c = str.charCodeAt(i); // code point\n\n        if (c > 0xD7FF && c < 0xE000) {\n            if (lead) {\n                if (c < 0xDC00) {\n                    buf[pos++] = 0xEF;\n                    buf[pos++] = 0xBF;\n                    buf[pos++] = 0xBD;\n                    lead = c;\n                    continue;\n                } else {\n                    c = lead - 0xD800 << 10 | c - 0xDC00 | 0x10000;\n                    lead = null;\n                }\n            } else {\n                if (c > 0xDBFF || (i + 1 === str.length)) {\n                    buf[pos++] = 0xEF;\n                    buf[pos++] = 0xBF;\n                    buf[pos++] = 0xBD;\n                } else {\n                    lead = c;\n                }\n                continue;\n            }\n        } else if (lead) {\n            buf[pos++] = 0xEF;\n            buf[pos++] = 0xBF;\n            buf[pos++] = 0xBD;\n            lead = null;\n        }\n\n        if (c < 0x80) {\n            buf[pos++] = c;\n        } else {\n            if (c < 0x800) {\n                buf[pos++] = c >> 0x6 | 0xC0;\n            } else {\n                if (c < 0x10000) {\n                    buf[pos++] = c >> 0xC | 0xE0;\n                } else {\n                    buf[pos++] = c >> 0x12 | 0xF0;\n                    buf[pos++] = c >> 0xC & 0x3F | 0x80;\n                }\n                buf[pos++] = c >> 0x6 & 0x3F | 0x80;\n            }\n            buf[pos++] = c & 0x3F | 0x80;\n        }\n    }\n    return pos;\n}\n","module.exports = \"\\nuniform sampler2D u_cmap_sampler;\\nuniform sampler2D u_cmap_nonlin_sampler;\\nuniform highp float u_cmap_min;\\nuniform highp float u_cmap_max;\\nuniform highp vec4 u_underflow_color;\\nuniform highp vec4 u_overflow_color;\\nuniform int u_n_index;\\n\\nlowp vec4 apply_colormap(highp float value) {\\n    lowp float normed_val = (value - u_cmap_min) / (u_cmap_max - u_cmap_min);\\n    \\n    lowp vec4 color;\\n    if (normed_val < 0.0) {\\n        color = u_underflow_color;\\n    }\\n    else if (normed_val > 1.0) {\\n        color = u_overflow_color;\\n    }\\n    else {\\n        lowp float index_buffer = 1. / (2. * float(u_n_index));\\n        normed_val = index_buffer + normed_val * (1. - 2. * index_buffer); // Chop off the half pixels on either end of the texture\\n        highp float nonlin_val = texture(u_cmap_nonlin_sampler, vec2(normed_val, 0.5)).r;\\n        color = texture(u_cmap_sampler, vec2(nonlin_val, 0.5));\\n    }\\n\\n    return color;\\n}\"","\n(function(cb){var geodesic={};geodesic.Constants={};geodesic.Math={};geodesic.Accumulator={};(function(c){\"use strict\";c.WGS84={a:6378137,f:1/298.257223563};c.version={major:2,minor:2,patch:0};c.version_string=\"2.2.0\";})(geodesic.Constants);(function(m){\"use strict\";m.digits=53;m.epsilon=Math.pow(0.5,m.digits-1);m.degree=Math.PI/180;m.sq=function(x){return x*x;};m.hypot=function(x,y){return Math.sqrt(x*x+y*y);};m.cbrt=Math.cbrt||function(x){var y=Math.pow(Math.abs(x),1/3);return x>0?y:(x<0?-y:x);};m.log1p=Math.log1p||function(x){var y=1+x,z=y-1;return z===0?x:x*Math.log(y)/z;};m.atanh=Math.atanh||function(x){var y=Math.abs(x);y=m.log1p(2*y/(1-y))/2;return x>0?y:(x<0?-y:x);};m.copysign=function(x,y){return Math.abs(x)*(y<0||(y===0&&1/y<0)?-1:1);};m.sum=function(u,v){var s=u+v,up=s-v,vpp=s-up,t;up-=u;vpp-=v;t=s?0-(up+vpp):s;return{s:s,t:t};};m.polyval=function(N,p,s,x){var y=N<0?0:p[s++];while(--N>=0)y=y*x+p[s++];return y;};m.AngRound=function(x){var z=1/16,y=Math.abs(x);y=y<z?z-(z-y):y;return m.copysign(y,x);};m.remainder=function(x,y){x%=y;return x<-y/2?x+y:(x<y/2?x:x-y);};m.AngNormalize=function(x){var y=m.remainder(x,360);return Math.abs(y)===180?m.copysign(180,x):y;};m.LatFix=function(x){return Math.abs(x)>90?NaN:x;};m.AngDiff=function(x,y){var r=m.sum(m.remainder(-x,360),m.remainder(y,360)),d,e;r=m.sum(m.remainder(r.s,360),r.t);d=r.s;e=r.t;if(d===0||Math.abs(d)===180)\nd=m.copysign(d,e===0?y-x:-e);return{d:d,e:e};};m.sincosd=function(x){var d,r,q,s,c,sinx,cosx;d=x%360;q=Math.round(d/90);d-=90*q;r=d*this.degree;s=Math.sin(r);c=Math.cos(r);if(Math.abs(d)===45){c=Math.sqrt(0.5);s=m.copysign(c,r);}else if(Math.abs(d)===30){c=Math.sqrt(0.75);s=m.copysign(0.5,r);}\nswitch(q&3){case 0:sinx=s;cosx=c;break;case 1:sinx=c;cosx=-s;break;case 2:sinx=-s;cosx=-c;break;default:sinx=-c;cosx=s;break;}\ncosx+=0;if(sinx===0)sinx=m.copysign(sinx,x);return{s:sinx,c:cosx};};m.sincosde=function(x,t){var d,r,q,s,c,sinx,cosx;d=x%360;q=Math.round(d/90);d=m.AngRound((d-90*q)+t);r=d*this.degree;s=Math.sin(r);c=Math.cos(r);if(Math.abs(d)===45){c=Math.sqrt(0.5);s=m.copysign(c,r);}else if(Math.abs(d)===30){c=Math.sqrt(0.75);s=m.copysign(0.5,r);}\nswitch(q&3){case 0:sinx=s;cosx=c;break;case 1:sinx=c;cosx=-s;break;case 2:sinx=-s;cosx=-c;break;default:sinx=-c;cosx=s;break;}\ncosx+=0;if(sinx===0)sinx=m.copysign(sinx,x+t);return{s:sinx,c:cosx};};m.atan2d=function(y,x){var q=0,ang;if(Math.abs(y)>Math.abs(x)){[y,x]=[x,y];q=2;}\nif(m.copysign(1,x)<0){x=-x;++q;}\nang=Math.atan2(y,x)/this.degree;switch(q){case 1:ang=m.copysign(180,y)-ang;break;case 2:ang=90-ang;break;case 3:ang=-90+ang;break;default:break;}\nreturn ang;};})(geodesic.Math);(function(a,m){\"use strict\";a.Accumulator=function(y){this.Set(y);};a.Accumulator.prototype.Set=function(y){if(!y)y=0;if(y.constructor===a.Accumulator){this._s=y._s;this._t=y._t;}else{this._s=y;this._t=0;}};a.Accumulator.prototype.Add=function(y){var u=m.sum(y,this._t),v=m.sum(u.s,this._s);u=u.t;this._s=v.s;this._t=v.t;if(this._s===0)\nthis._s=u;else\nthis._t+=u;};a.Accumulator.prototype.Sum=function(y){var b;if(!y)\nreturn this._s;else{b=new a.Accumulator(this);b.Add(y);return b._s;}};a.Accumulator.prototype.Negate=function(){this._s*=-1;this._t*=-1;};a.Accumulator.prototype.Remainder=function(y){this._s=m.remainder(this._s,y);this.Add(0);};})(geodesic.Accumulator,geodesic.Math);geodesic.Geodesic={};geodesic.GeodesicLine={};geodesic.PolygonArea={};(function(g,l,p,m,c){\"use strict\";var GEOGRAPHICLIB_GEODESIC_ORDER=6,nA1_=GEOGRAPHICLIB_GEODESIC_ORDER,nA2_=GEOGRAPHICLIB_GEODESIC_ORDER,nA3_=GEOGRAPHICLIB_GEODESIC_ORDER,nA3x_=nA3_,nC3x_,nC4x_,maxit1_=20,maxit2_=maxit1_+m.digits+10,tol0_=m.epsilon,tol1_=200*tol0_,tol2_=Math.sqrt(tol0_),tolb_=tol0_,xthresh_=1000*tol2_,CAP_NONE=0,CAP_ALL=0x1F,OUT_ALL=0x7F80,astroid,A1m1f_coeff,C1f_coeff,C1pf_coeff,A2m1f_coeff,C2f_coeff,A3_coeff,C3_coeff,C4_coeff;g.tiny_=Math.sqrt(Number.MIN_VALUE/Number.EPSILON);g.nC1_=GEOGRAPHICLIB_GEODESIC_ORDER;g.nC1p_=GEOGRAPHICLIB_GEODESIC_ORDER;g.nC2_=GEOGRAPHICLIB_GEODESIC_ORDER;g.nC3_=GEOGRAPHICLIB_GEODESIC_ORDER;g.nC4_=GEOGRAPHICLIB_GEODESIC_ORDER;nC3x_=(g.nC3_*(g.nC3_-1))/2;nC4x_=(g.nC4_*(g.nC4_+1))/2;g.CAP_C1=1<<0;g.CAP_C1p=1<<1;g.CAP_C2=1<<2;g.CAP_C3=1<<3;g.CAP_C4=1<<4;g.NONE=0;g.ARC=1<<6;g.LATITUDE=1<<7|CAP_NONE;g.LONGITUDE=1<<8|g.CAP_C3;g.AZIMUTH=1<<9|CAP_NONE;g.DISTANCE=1<<10|g.CAP_C1;g.STANDARD=g.LATITUDE|g.LONGITUDE|g.AZIMUTH|g.DISTANCE;g.DISTANCE_IN=1<<11|g.CAP_C1|g.CAP_C1p;g.REDUCEDLENGTH=1<<12|g.CAP_C1|g.CAP_C2;g.GEODESICSCALE=1<<13|g.CAP_C1|g.CAP_C2;g.AREA=1<<14|g.CAP_C4;g.ALL=OUT_ALL|CAP_ALL;g.LONG_UNROLL=1<<15;g.OUT_MASK=OUT_ALL|g.LONG_UNROLL;g.SinCosSeries=function(sinp,sinx,cosx,c){var k=c.length,n=k-(sinp?1:0),ar=2*(cosx-sinx)*(cosx+sinx),y0=n&1?c[--k]:0,y1=0;n=Math.floor(n/2);while(n--){y1=ar*y0-y1+c[--k];y0=ar*y1-y0+c[--k];}\nreturn(sinp?2*sinx*cosx*y0:cosx*(y0-y1));};astroid=function(x,y){var k,p=m.sq(x),q=m.sq(y),r=(p+q-1)/6,S,r2,r3,disc,u,T3,T,ang,v,uv,w;if(!(q===0&&r<=0)){S=p*q/4;r2=m.sq(r);r3=r*r2;disc=S*(S+2*r3);u=r;if(disc>=0){T3=S+r3;T3+=T3<0?-Math.sqrt(disc):Math.sqrt(disc);T=m.cbrt(T3);u+=T+(T!==0?r2/T:0);}else{ang=Math.atan2(Math.sqrt(-disc),-(S+r3));u+=2*r*Math.cos(ang/3);}\nv=Math.sqrt(m.sq(u)+q);uv=u<0?q/(v-u):u+v;w=(uv-q)/(2*v);k=uv/(Math.sqrt(uv+m.sq(w))+w);}else{k=0;}\nreturn k;};A1m1f_coeff=[+1,4,64,0,256];g.A1m1f=function(eps){var p=Math.floor(nA1_/2),t=m.polyval(p,A1m1f_coeff,0,m.sq(eps))/A1m1f_coeff[p+1];return(t+eps)/(1-eps);};C1f_coeff=[-1,6,-16,32,-9,64,-128,2048,+9,-16,768,+3,-5,512,-7,1280,-7,2048];g.C1f=function(eps,c){var eps2=m.sq(eps),d=eps,o=0,l,p;for(l=1;l<=g.nC1_;++l){p=Math.floor((g.nC1_-l)/2);c[l]=d*m.polyval(p,C1f_coeff,o,eps2)/C1f_coeff[o+p+1];o+=p+2;d*=eps;}};C1pf_coeff=[+205,-432,768,1536,+4005,-4736,3840,12288,-225,116,384,-7173,2695,7680,+3467,7680,+38081,61440];g.C1pf=function(eps,c){var eps2=m.sq(eps),d=eps,o=0,l,p;for(l=1;l<=g.nC1p_;++l){p=Math.floor((g.nC1p_-l)/2);c[l]=d*m.polyval(p,C1pf_coeff,o,eps2)/C1pf_coeff[o+p+1];o+=p+2;d*=eps;}};A2m1f_coeff=[-11,-28,-192,0,256];g.A2m1f=function(eps){var p=Math.floor(nA2_/2),t=m.polyval(p,A2m1f_coeff,0,m.sq(eps))/A2m1f_coeff[p+1];return(t-eps)/(1+eps);};C2f_coeff=[+1,2,16,32,+35,64,384,2048,+15,80,768,+7,35,512,+63,1280,+77,2048];g.C2f=function(eps,c){var eps2=m.sq(eps),d=eps,o=0,l,p;for(l=1;l<=g.nC2_;++l){p=Math.floor((g.nC2_-l)/2);c[l]=d*m.polyval(p,C2f_coeff,o,eps2)/C2f_coeff[o+p+1];o+=p+2;d*=eps;}};g.Geodesic=function(a,f){this.a=a;this.f=f;this._f1=1-this.f;this._e2=this.f*(2-this.f);this._ep2=this._e2/m.sq(this._f1);this._n=this.f/(2-this.f);this._b=this.a*this._f1;this._c2=(m.sq(this.a)+m.sq(this._b)*(this._e2===0?1:(this._e2>0?m.atanh(Math.sqrt(this._e2)):Math.atan(Math.sqrt(-this._e2)))/Math.sqrt(Math.abs(this._e2))))/2;this._etol2=0.1*tol2_/Math.sqrt(Math.max(0.001,Math.abs(this.f))*Math.min(1,1-this.f/2)/2);if(!(isFinite(this.a)&&this.a>0))\nthrow new Error(\"Equatorial radius is not positive\");if(!(isFinite(this._b)&&this._b>0))\nthrow new Error(\"Polar semi-axis is not positive\");this._A3x=new Array(nA3x_);this._C3x=new Array(nC3x_);this._C4x=new Array(nC4x_);this.A3coeff();this.C3coeff();this.C4coeff();};A3_coeff=[-3,128,-2,-3,64,-1,-3,-1,16,+3,-1,-2,8,+1,-1,2,+1,1];g.Geodesic.prototype.A3coeff=function(){var o=0,k=0,j,p;for(j=nA3_-1;j>=0;--j){p=Math.min(nA3_-j-1,j);this._A3x[k++]=m.polyval(p,A3_coeff,o,this._n)/A3_coeff[o+p+1];o+=p+2;}};C3_coeff=[+3,128,+2,5,128,-1,3,3,64,-1,0,1,8,-1,1,4,+5,256,+1,3,128,-3,-2,3,64,+1,-3,2,32,+7,512,-10,9,384,+5,-9,5,192,+7,512,-14,7,512,+21,2560];g.Geodesic.prototype.C3coeff=function(){var o=0,k=0,l,j,p;for(l=1;l<g.nC3_;++l){for(j=g.nC3_-1;j>=l;--j){p=Math.min(g.nC3_-j-1,j);this._C3x[k++]=m.polyval(p,C3_coeff,o,this._n)/C3_coeff[o+p+1];o+=p+2;}}};C4_coeff=[+97,15015,+1088,156,45045,-224,-4784,1573,45045,-10656,14144,-4576,-858,45045,+64,624,-4576,6864,-3003,15015,+100,208,572,3432,-12012,30030,45045,+1,9009,-2944,468,135135,+5792,1040,-1287,135135,+5952,-11648,9152,-2574,135135,-64,-624,4576,-6864,3003,135135,+8,10725,+1856,-936,225225,-8448,4992,-1144,225225,-1440,4160,-4576,1716,225225,-136,63063,+1024,-208,105105,+3584,-3328,1144,315315,-128,135135,-2560,832,405405,+128,99099];g.Geodesic.prototype.C4coeff=function(){var o=0,k=0,l,j,p;for(l=0;l<g.nC4_;++l){for(j=g.nC4_-1;j>=l;--j){p=g.nC4_-j-1;this._C4x[k++]=m.polyval(p,C4_coeff,o,this._n)/C4_coeff[o+p+1];o+=p+2;}}};g.Geodesic.prototype.A3f=function(eps){return m.polyval(nA3x_-1,this._A3x,0,eps);};g.Geodesic.prototype.C3f=function(eps,c){var mult=1,o=0,l,p;for(l=1;l<g.nC3_;++l){p=g.nC3_-l-1;mult*=eps;c[l]=mult*m.polyval(p,this._C3x,o,eps);o+=p+1;}};g.Geodesic.prototype.C4f=function(eps,c){var mult=1,o=0,l,p;for(l=0;l<g.nC4_;++l){p=g.nC4_-l-1;c[l]=mult*m.polyval(p,this._C4x,o,eps);o+=p+1;mult*=eps;}};g.Geodesic.prototype.Lengths=function(eps,sig12,ssig1,csig1,dn1,ssig2,csig2,dn2,cbet1,cbet2,outmask,C1a,C2a){outmask&=g.OUT_MASK;var vals={},m0x=0,J12=0,A1=0,A2=0,B1,B2,l,csig12,t;if(outmask&(g.DISTANCE|g.REDUCEDLENGTH|g.GEODESICSCALE)){A1=g.A1m1f(eps);g.C1f(eps,C1a);if(outmask&(g.REDUCEDLENGTH|g.GEODESICSCALE)){A2=g.A2m1f(eps);g.C2f(eps,C2a);m0x=A1-A2;A2=1+A2;}\nA1=1+A1;}\nif(outmask&g.DISTANCE){B1=g.SinCosSeries(true,ssig2,csig2,C1a)-\ng.SinCosSeries(true,ssig1,csig1,C1a);vals.s12b=A1*(sig12+B1);if(outmask&(g.REDUCEDLENGTH|g.GEODESICSCALE)){B2=g.SinCosSeries(true,ssig2,csig2,C2a)-\ng.SinCosSeries(true,ssig1,csig1,C2a);J12=m0x*sig12+(A1*B1-A2*B2);}}else if(outmask&(g.REDUCEDLENGTH|g.GEODESICSCALE)){for(l=1;l<=g.nC2_;++l)\nC2a[l]=A1*C1a[l]-A2*C2a[l];J12=m0x*sig12+(g.SinCosSeries(true,ssig2,csig2,C2a)-\ng.SinCosSeries(true,ssig1,csig1,C2a));}\nif(outmask&g.REDUCEDLENGTH){vals.m0=m0x;vals.m12b=dn2*(csig1*ssig2)-dn1*(ssig1*csig2)-\ncsig1*csig2*J12;}else\nvals.m12b=NaN;if(outmask&g.GEODESICSCALE){csig12=csig1*csig2+ssig1*ssig2;t=this._ep2*(cbet1-cbet2)*(cbet1+cbet2)/(dn1+dn2);vals.M12=csig12+(t*ssig2-csig2*J12)*ssig1/dn1;vals.M21=csig12-(t*ssig1-csig1*J12)*ssig2/dn2;}\nreturn vals;};g.Geodesic.prototype.InverseStart=function(sbet1,cbet1,dn1,sbet2,cbet2,dn2,lam12,slam12,clam12,C1a,C2a){var vals={},sbet12=sbet2*cbet1-cbet2*sbet1,cbet12=cbet2*cbet1+sbet2*sbet1,sbet12a,shortline,omg12,sbetm2,somg12,comg12,t,ssig12,csig12,x,y,lamscale,betscale,k2,eps,cbet12a,bet12a,m12b,m0,nvals,k,omg12a,lam12x;vals.sig12=-1;sbet12a=sbet2*cbet1;sbet12a+=cbet2*sbet1;shortline=cbet12>=0&&sbet12<0.5&&cbet2*lam12<0.5;if(shortline){sbetm2=m.sq(sbet1+sbet2);sbetm2/=sbetm2+m.sq(cbet1+cbet2);vals.dnm=Math.sqrt(1+this._ep2*sbetm2);omg12=lam12/(this._f1*vals.dnm);somg12=Math.sin(omg12);comg12=Math.cos(omg12);}else{somg12=slam12;comg12=clam12;}\nvals.salp1=cbet2*somg12;vals.calp1=comg12>=0?sbet12+cbet2*sbet1*m.sq(somg12)/(1+comg12):sbet12a-cbet2*sbet1*m.sq(somg12)/(1-comg12);ssig12=m.hypot(vals.salp1,vals.calp1);csig12=sbet1*sbet2+cbet1*cbet2*comg12;if(shortline&&ssig12<this._etol2){vals.salp2=cbet1*somg12;vals.calp2=sbet12-cbet1*sbet2*(comg12>=0?m.sq(somg12)/(1+comg12):1-comg12);t=m.hypot(vals.salp2,vals.calp2);vals.salp2/=t;vals.calp2/=t;vals.sig12=Math.atan2(ssig12,csig12);}else if(Math.abs(this._n)>0.1||csig12>=0||ssig12>=6*Math.abs(this._n)*Math.PI*m.sq(cbet1)){}else{lam12x=Math.atan2(-slam12,-clam12);if(this.f>=0){k2=m.sq(sbet1)*this._ep2;eps=k2/(2*(1+Math.sqrt(1+k2))+k2);lamscale=this.f*cbet1*this.A3f(eps)*Math.PI;betscale=lamscale*cbet1;x=lam12x/lamscale;y=sbet12a/betscale;}else{cbet12a=cbet2*cbet1-sbet2*sbet1;bet12a=Math.atan2(sbet12a,cbet12a);nvals=this.Lengths(this._n,Math.PI+bet12a,sbet1,-cbet1,dn1,sbet2,cbet2,dn2,cbet1,cbet2,g.REDUCEDLENGTH,C1a,C2a);m12b=nvals.m12b;m0=nvals.m0;x=-1+m12b/(cbet1*cbet2*m0*Math.PI);betscale=x<-0.01?sbet12a/x:-this.f*m.sq(cbet1)*Math.PI;lamscale=betscale/cbet1;y=lam12/lamscale;}\nif(y>-tol1_&&x>-1-xthresh_){if(this.f>=0){vals.salp1=Math.min(1,-x);vals.calp1=-Math.sqrt(1-m.sq(vals.salp1));}else{vals.calp1=Math.max(x>-tol1_?0:-1,x);vals.salp1=Math.sqrt(1-m.sq(vals.calp1));}}else{k=astroid(x,y);omg12a=lamscale*(this.f>=0?-x*k/(1+k):-y*(1+k)/k);somg12=Math.sin(omg12a);comg12=-Math.cos(omg12a);vals.salp1=cbet2*somg12;vals.calp1=sbet12a-\ncbet2*sbet1*m.sq(somg12)/(1-comg12);}}\nif(!(vals.salp1<=0)){t=m.hypot(vals.salp1,vals.calp1);vals.salp1/=t;vals.calp1/=t;}else{vals.salp1=1;vals.calp1=0;}\nreturn vals;};g.Geodesic.prototype.Lambda12=function(sbet1,cbet1,dn1,sbet2,cbet2,dn2,salp1,calp1,slam120,clam120,diffp,C1a,C2a,C3a){var vals={},t,salp0,calp0,somg1,comg1,somg2,comg2,somg12,comg12,B312,eta,k2,nvals;if(sbet1===0&&calp1===0)\ncalp1=-g.tiny_;salp0=salp1*cbet1;calp0=m.hypot(calp1,salp1*sbet1);vals.ssig1=sbet1;somg1=salp0*sbet1;vals.csig1=comg1=calp1*cbet1;t=m.hypot(vals.ssig1,vals.csig1);vals.ssig1/=t;vals.csig1/=t;vals.salp2=cbet2!==cbet1?salp0/cbet2:salp1;vals.calp2=cbet2!==cbet1||Math.abs(sbet2)!==-sbet1?Math.sqrt(m.sq(calp1*cbet1)+(cbet1<-sbet1?(cbet2-cbet1)*(cbet1+cbet2):(sbet1-sbet2)*(sbet1+sbet2)))/cbet2:Math.abs(calp1);vals.ssig2=sbet2;somg2=salp0*sbet2;vals.csig2=comg2=vals.calp2*cbet2;t=m.hypot(vals.ssig2,vals.csig2);vals.ssig2/=t;vals.csig2/=t;vals.sig12=Math.atan2(Math.max(0,vals.csig1*vals.ssig2-\nvals.ssig1*vals.csig2),vals.csig1*vals.csig2+\nvals.ssig1*vals.ssig2);somg12=Math.max(0,comg1*somg2-somg1*comg2);comg12=comg1*comg2+somg1*somg2;eta=Math.atan2(somg12*clam120-comg12*slam120,comg12*clam120+somg12*slam120);k2=m.sq(calp0)*this._ep2;vals.eps=k2/(2*(1+Math.sqrt(1+k2))+k2);this.C3f(vals.eps,C3a);B312=(g.SinCosSeries(true,vals.ssig2,vals.csig2,C3a)-\ng.SinCosSeries(true,vals.ssig1,vals.csig1,C3a));vals.domg12=-this.f*this.A3f(vals.eps)*salp0*(vals.sig12+B312);vals.lam12=eta+vals.domg12;if(diffp){if(vals.calp2===0)\nvals.dlam12=-2*this._f1*dn1/sbet1;else{nvals=this.Lengths(vals.eps,vals.sig12,vals.ssig1,vals.csig1,dn1,vals.ssig2,vals.csig2,dn2,cbet1,cbet2,g.REDUCEDLENGTH,C1a,C2a);vals.dlam12=nvals.m12b;vals.dlam12*=this._f1/(vals.calp2*cbet2);}}\nreturn vals;};g.Geodesic.prototype.Inverse=function(lat1,lon1,lat2,lon2,outmask){var r,vals;if(!outmask)outmask=g.STANDARD;if(outmask===g.LONG_UNROLL)outmask|=g.STANDARD;outmask&=g.OUT_MASK;r=this.InverseInt(lat1,lon1,lat2,lon2,outmask);vals=r.vals;if(outmask&g.AZIMUTH){vals.azi1=m.atan2d(r.salp1,r.calp1);vals.azi2=m.atan2d(r.salp2,r.calp2);}\nreturn vals;};g.Geodesic.prototype.InverseInt=function(lat1,lon1,lat2,lon2,outmask){var vals={},lon12,lon12s,lonsign,t,swapp,latsign,sbet1,cbet1,sbet2,cbet2,s12x,m12x,dn1,dn2,lam12,slam12,clam12,sig12,calp1,salp1,calp2,salp2,C1a,C2a,C3a,meridian,nvals,ssig1,csig1,ssig2,csig2,eps,omg12,dnm,numit,salp1a,calp1a,salp1b,calp1b,tripn,tripb,v,dv,dalp1,sdalp1,cdalp1,nsalp1,lengthmask,salp0,calp0,alp12,k2,A4,C4a,B41,B42,somg12,comg12,domg12,dbet1,dbet2,salp12,calp12,sdomg12,cdomg12;vals.lat1=lat1=m.LatFix(lat1);vals.lat2=lat2=m.LatFix(lat2);lat1=m.AngRound(lat1);lat2=m.AngRound(lat2);lon12=m.AngDiff(lon1,lon2);lon12s=lon12.e;lon12=lon12.d;if(outmask&g.LONG_UNROLL){vals.lon1=lon1;vals.lon2=(lon1+lon12)+lon12s;}else{vals.lon1=m.AngNormalize(lon1);vals.lon2=m.AngNormalize(lon2);}\nlonsign=m.copysign(1,lon12);lon12*=lonsign;lon12s*=lonsign;lam12=lon12*m.degree;t=m.sincosde(lon12,lon12s);slam12=t.s;clam12=t.c;lon12s=(180-lon12)-lon12s;swapp=Math.abs(lat1)<Math.abs(lat2)||isNaN(lat2)?-1:1;if(swapp<0){lonsign*=-1;[lat2,lat1]=[lat1,lat2];}\nlatsign=m.copysign(1,-lat1);lat1*=latsign;lat2*=latsign;t=m.sincosd(lat1);sbet1=this._f1*t.s;cbet1=t.c;t=m.hypot(sbet1,cbet1);sbet1/=t;cbet1/=t;cbet1=Math.max(g.tiny_,cbet1);t=m.sincosd(lat2);sbet2=this._f1*t.s;cbet2=t.c;t=m.hypot(sbet2,cbet2);sbet2/=t;cbet2/=t;cbet2=Math.max(g.tiny_,cbet2);if(cbet1<-sbet1){if(cbet2===cbet1)\nsbet2=m.copysign(sbet1,sbet2);}else{if(Math.abs(sbet2)===-sbet1)\ncbet2=cbet1;}\ndn1=Math.sqrt(1+this._ep2*m.sq(sbet1));dn2=Math.sqrt(1+this._ep2*m.sq(sbet2));C1a=new Array(g.nC1_+1);C2a=new Array(g.nC2_+1);C3a=new Array(g.nC3_);meridian=lat1===-90||slam12===0;if(meridian){calp1=clam12;salp1=slam12;calp2=1;salp2=0;ssig1=sbet1;csig1=calp1*cbet1;ssig2=sbet2;csig2=calp2*cbet2;sig12=Math.atan2(Math.max(0,csig1*ssig2-ssig1*csig2),csig1*csig2+ssig1*ssig2);nvals=this.Lengths(this._n,sig12,ssig1,csig1,dn1,ssig2,csig2,dn2,cbet1,cbet2,outmask|g.DISTANCE|g.REDUCEDLENGTH,C1a,C2a);s12x=nvals.s12b;m12x=nvals.m12b;if(outmask&g.GEODESICSCALE){vals.M12=nvals.M12;vals.M21=nvals.M21;}\nif(sig12<tol2_||m12x>=0){if(sig12<3*g.tiny_||(sig12<tol0_&&(s12x<0||m12x<0)))\nsig12=m12x=s12x=0;m12x*=this._b;s12x*=this._b;vals.a12=sig12/m.degree;}else\nmeridian=false;}\nsomg12=2;if(!meridian&&sbet1===0&&(this.f<=0||lon12s>=this.f*180)){calp1=calp2=0;salp1=salp2=1;s12x=this.a*lam12;sig12=omg12=lam12/this._f1;m12x=this._b*Math.sin(sig12);if(outmask&g.GEODESICSCALE)\nvals.M12=vals.M21=Math.cos(sig12);vals.a12=lon12/this._f1;}else if(!meridian){nvals=this.InverseStart(sbet1,cbet1,dn1,sbet2,cbet2,dn2,lam12,slam12,clam12,C1a,C2a);sig12=nvals.sig12;salp1=nvals.salp1;calp1=nvals.calp1;if(sig12>=0){salp2=nvals.salp2;calp2=nvals.calp2;dnm=nvals.dnm;s12x=sig12*this._b*dnm;m12x=m.sq(dnm)*this._b*Math.sin(sig12/dnm);if(outmask&g.GEODESICSCALE)\nvals.M12=vals.M21=Math.cos(sig12/dnm);vals.a12=sig12/m.degree;omg12=lam12/(this._f1*dnm);}else{numit=0;salp1a=g.tiny_;calp1a=1;salp1b=g.tiny_;calp1b=-1;for(tripn=false,tripb=false;;++numit){nvals=this.Lambda12(sbet1,cbet1,dn1,sbet2,cbet2,dn2,salp1,calp1,slam12,clam12,numit<maxit1_,C1a,C2a,C3a);v=nvals.lam12;salp2=nvals.salp2;calp2=nvals.calp2;sig12=nvals.sig12;ssig1=nvals.ssig1;csig1=nvals.csig1;ssig2=nvals.ssig2;csig2=nvals.csig2;eps=nvals.eps;domg12=nvals.domg12;dv=nvals.dlam12;if(tripb||!(Math.abs(v)>=(tripn?8:1)*tol0_)||numit==maxit2_)\nbreak;if(v>0&&(numit<maxit1_||calp1/salp1>calp1b/salp1b)){salp1b=salp1;calp1b=calp1;}else if(v<0&&(numit<maxit1_||calp1/salp1<calp1a/salp1a)){salp1a=salp1;calp1a=calp1;}\nif(numit<maxit1_&&dv>0){dalp1=-v/dv;if(Math.abs(dalp1)<Math.PI){sdalp1=Math.sin(dalp1);cdalp1=Math.cos(dalp1);nsalp1=salp1*cdalp1+calp1*sdalp1;if(nsalp1>0){calp1=calp1*cdalp1-salp1*sdalp1;salp1=nsalp1;t=m.hypot(salp1,calp1);salp1/=t;calp1/=t;tripn=Math.abs(v)<=16*tol0_;continue;}}}\nsalp1=(salp1a+salp1b)/2;calp1=(calp1a+calp1b)/2;t=m.hypot(salp1,calp1);salp1/=t;calp1/=t;tripn=false;tripb=(Math.abs(salp1a-salp1)+(calp1a-calp1)<tolb_||Math.abs(salp1-salp1b)+(calp1-calp1b)<tolb_);}\nlengthmask=outmask|(outmask&(g.REDUCEDLENGTH|g.GEODESICSCALE)?g.DISTANCE:g.NONE);nvals=this.Lengths(eps,sig12,ssig1,csig1,dn1,ssig2,csig2,dn2,cbet1,cbet2,lengthmask,C1a,C2a);s12x=nvals.s12b;m12x=nvals.m12b;if(outmask&g.GEODESICSCALE){vals.M12=nvals.M12;vals.M21=nvals.M21;}\nm12x*=this._b;s12x*=this._b;vals.a12=sig12/m.degree;if(outmask&g.AREA){sdomg12=Math.sin(domg12);cdomg12=Math.cos(domg12);somg12=slam12*cdomg12-clam12*sdomg12;comg12=clam12*cdomg12+slam12*sdomg12;}}}\nif(outmask&g.DISTANCE)\nvals.s12=0+s12x;if(outmask&g.REDUCEDLENGTH)\nvals.m12=0+m12x;if(outmask&g.AREA){salp0=salp1*cbet1;calp0=m.hypot(calp1,salp1*sbet1);if(calp0!==0&&salp0!==0){ssig1=sbet1;csig1=calp1*cbet1;ssig2=sbet2;csig2=calp2*cbet2;k2=m.sq(calp0)*this._ep2;eps=k2/(2*(1+Math.sqrt(1+k2))+k2);A4=m.sq(this.a)*calp0*salp0*this._e2;t=m.hypot(ssig1,csig1);ssig1/=t;csig1/=t;t=m.hypot(ssig2,csig2);ssig2/=t;csig2/=t;C4a=new Array(g.nC4_);this.C4f(eps,C4a);B41=g.SinCosSeries(false,ssig1,csig1,C4a);B42=g.SinCosSeries(false,ssig2,csig2,C4a);vals.S12=A4*(B42-B41);}else\nvals.S12=0;if(!meridian&&somg12==2){somg12=Math.sin(omg12);comg12=Math.cos(omg12);}\nif(!meridian&&comg12>-0.7071&&sbet2-sbet1<1.75){domg12=1+comg12;dbet1=1+cbet1;dbet2=1+cbet2;alp12=2*Math.atan2(somg12*(sbet1*dbet2+sbet2*dbet1),domg12*(sbet1*sbet2+dbet1*dbet2));}else{salp12=salp2*calp1-calp2*salp1;calp12=calp2*calp1+salp2*salp1;if(salp12===0&&calp12<0){salp12=g.tiny_*calp1;calp12=-1;}\nalp12=Math.atan2(salp12,calp12);}\nvals.S12+=this._c2*alp12;vals.S12*=swapp*lonsign*latsign;vals.S12+=0;}\nif(swapp<0){[salp2,salp1]=[salp1,salp2];[calp2,calp1]=[calp1,calp2];if(outmask&g.GEODESICSCALE){[vals.M21,vals.M12]=[vals.M12,vals.M21];}}\nsalp1*=swapp*lonsign;calp1*=swapp*latsign;salp2*=swapp*lonsign;calp2*=swapp*latsign;return{vals:vals,salp1:salp1,calp1:calp1,salp2:salp2,calp2:calp2};};g.Geodesic.prototype.GenDirect=function(lat1,lon1,azi1,arcmode,s12_a12,outmask){var line;if(!outmask)outmask=g.STANDARD;else if(outmask===g.LONG_UNROLL)outmask|=g.STANDARD;if(!arcmode)outmask|=g.DISTANCE_IN;line=new l.GeodesicLine(this,lat1,lon1,azi1,outmask);return line.GenPosition(arcmode,s12_a12,outmask);};g.Geodesic.prototype.Direct=function(lat1,lon1,azi1,s12,outmask){return this.GenDirect(lat1,lon1,azi1,false,s12,outmask);};g.Geodesic.prototype.ArcDirect=function(lat1,lon1,azi1,a12,outmask){return this.GenDirect(lat1,lon1,azi1,true,a12,outmask);};g.Geodesic.prototype.Line=function(lat1,lon1,azi1,caps){return new l.GeodesicLine(this,lat1,lon1,azi1,caps);};g.Geodesic.prototype.DirectLine=function(lat1,lon1,azi1,s12,caps){return this.GenDirectLine(lat1,lon1,azi1,false,s12,caps);};g.Geodesic.prototype.ArcDirectLine=function(lat1,lon1,azi1,a12,caps){return this.GenDirectLine(lat1,lon1,azi1,true,a12,caps);};g.Geodesic.prototype.GenDirectLine=function(lat1,lon1,azi1,arcmode,s12_a12,caps){var t;if(!caps)caps=g.STANDARD|g.DISTANCE_IN;if(!arcmode)caps|=g.DISTANCE_IN;t=new l.GeodesicLine(this,lat1,lon1,azi1,caps);t.GenSetDistance(arcmode,s12_a12);return t;};g.Geodesic.prototype.InverseLine=function(lat1,lon1,lat2,lon2,caps){var r,t,azi1;if(!caps)caps=g.STANDARD|g.DISTANCE_IN;r=this.InverseInt(lat1,lon1,lat2,lon2,g.ARC);azi1=m.atan2d(r.salp1,r.calp1);if(caps&(g.OUT_MASK&g.DISTANCE_IN))caps|=g.DISTANCE;t=new l.GeodesicLine(this,lat1,lon1,azi1,caps,r.salp1,r.calp1);t.SetArc(r.vals.a12);return t;};g.Geodesic.prototype.Polygon=function(polyline){return new p.PolygonArea(this,polyline);};g.WGS84=new g.Geodesic(c.WGS84.a,c.WGS84.f);})(geodesic.Geodesic,geodesic.GeodesicLine,geodesic.PolygonArea,geodesic.Math,geodesic.Constants);(function(g,l,m){\"use strict\";l.GeodesicLine=function(geod,lat1,lon1,azi1,caps,salp1,calp1){var t,cbet1,sbet1,eps,s,c;if(!caps)caps=g.STANDARD|g.DISTANCE_IN;this.a=geod.a;this.f=geod.f;this._b=geod._b;this._c2=geod._c2;this._f1=geod._f1;this.caps=caps|g.LATITUDE|g.AZIMUTH|g.LONG_UNROLL;this.lat1=m.LatFix(lat1);this.lon1=lon1;if(typeof salp1==='undefined'||typeof calp1==='undefined'){this.azi1=m.AngNormalize(azi1);t=m.sincosd(m.AngRound(this.azi1));this.salp1=t.s;this.calp1=t.c;}else{this.azi1=azi1;this.salp1=salp1;this.calp1=calp1;}\nt=m.sincosd(m.AngRound(this.lat1));sbet1=this._f1*t.s;cbet1=t.c;t=m.hypot(sbet1,cbet1);sbet1/=t;cbet1/=t;cbet1=Math.max(g.tiny_,cbet1);this._dn1=Math.sqrt(1+geod._ep2*m.sq(sbet1));this._salp0=this.salp1*cbet1;this._calp0=m.hypot(this.calp1,this.salp1*sbet1);this._ssig1=sbet1;this._somg1=this._salp0*sbet1;this._csig1=this._comg1=sbet1!==0||this.calp1!==0?cbet1*this.calp1:1;t=m.hypot(this._ssig1,this._csig1);this._ssig1/=t;this._csig1/=t;this._k2=m.sq(this._calp0)*geod._ep2;eps=this._k2/(2*(1+Math.sqrt(1+this._k2))+this._k2);if(this.caps&g.CAP_C1){this._A1m1=g.A1m1f(eps);this._C1a=new Array(g.nC1_+1);g.C1f(eps,this._C1a);this._B11=g.SinCosSeries(true,this._ssig1,this._csig1,this._C1a);s=Math.sin(this._B11);c=Math.cos(this._B11);this._stau1=this._ssig1*c+this._csig1*s;this._ctau1=this._csig1*c-this._ssig1*s;}\nif(this.caps&g.CAP_C1p){this._C1pa=new Array(g.nC1p_+1);g.C1pf(eps,this._C1pa);}\nif(this.caps&g.CAP_C2){this._A2m1=g.A2m1f(eps);this._C2a=new Array(g.nC2_+1);g.C2f(eps,this._C2a);this._B21=g.SinCosSeries(true,this._ssig1,this._csig1,this._C2a);}\nif(this.caps&g.CAP_C3){this._C3a=new Array(g.nC3_);geod.C3f(eps,this._C3a);this._A3c=-this.f*this._salp0*geod.A3f(eps);this._B31=g.SinCosSeries(true,this._ssig1,this._csig1,this._C3a);}\nif(this.caps&g.CAP_C4){this._C4a=new Array(g.nC4_);geod.C4f(eps,this._C4a);this._A4=m.sq(this.a)*this._calp0*this._salp0*geod._e2;this._B41=g.SinCosSeries(false,this._ssig1,this._csig1,this._C4a);}\nthis.a13=this.s13=NaN;};l.GeodesicLine.prototype.GenPosition=function(arcmode,s12_a12,outmask){var vals={},sig12,ssig12,csig12,B12,AB1,ssig2,csig2,tau12,s,c,serr,omg12,lam12,lon12,E,sbet2,cbet2,somg2,comg2,salp2,calp2,dn2,B22,AB2,J12,t,B42,salp12,calp12;if(!outmask)outmask=g.STANDARD;else if(outmask===g.LONG_UNROLL)outmask|=g.STANDARD;outmask&=this.caps&g.OUT_MASK;vals.lat1=this.lat1;vals.azi1=this.azi1;vals.lon1=outmask&g.LONG_UNROLL?this.lon1:m.AngNormalize(this.lon1);if(arcmode)\nvals.a12=s12_a12;else\nvals.s12=s12_a12;if(!(arcmode||(this.caps&g.DISTANCE_IN&g.OUT_MASK))){vals.a12=NaN;return vals;}\nB12=0;AB1=0;if(arcmode){sig12=s12_a12*m.degree;t=m.sincosd(s12_a12);ssig12=t.s;csig12=t.c;}else{tau12=s12_a12/(this._b*(1+this._A1m1));s=Math.sin(tau12);c=Math.cos(tau12);B12=-g.SinCosSeries(true,this._stau1*c+this._ctau1*s,this._ctau1*c-this._stau1*s,this._C1pa);sig12=tau12-(B12-this._B11);ssig12=Math.sin(sig12);csig12=Math.cos(sig12);if(Math.abs(this.f)>0.01){ssig2=this._ssig1*csig12+this._csig1*ssig12;csig2=this._csig1*csig12-this._ssig1*ssig12;B12=g.SinCosSeries(true,ssig2,csig2,this._C1a);serr=(1+this._A1m1)*(sig12+(B12-this._B11))-\ns12_a12/this._b;sig12=sig12-serr/Math.sqrt(1+this._k2*m.sq(ssig2));ssig12=Math.sin(sig12);csig12=Math.cos(sig12);}}\nssig2=this._ssig1*csig12+this._csig1*ssig12;csig2=this._csig1*csig12-this._ssig1*ssig12;dn2=Math.sqrt(1+this._k2*m.sq(ssig2));if(outmask&(g.DISTANCE|g.REDUCEDLENGTH|g.GEODESICSCALE)){if(arcmode||Math.abs(this.f)>0.01)\nB12=g.SinCosSeries(true,ssig2,csig2,this._C1a);AB1=(1+this._A1m1)*(B12-this._B11);}\nsbet2=this._calp0*ssig2;cbet2=m.hypot(this._salp0,this._calp0*csig2);if(cbet2===0)\ncbet2=csig2=g.tiny_;salp2=this._salp0;calp2=this._calp0*csig2;if(arcmode&&(outmask&g.DISTANCE))\nvals.s12=this._b*((1+this._A1m1)*sig12+AB1);if(outmask&g.LONGITUDE){somg2=this._salp0*ssig2;comg2=csig2;E=m.copysign(1,this._salp0);omg12=outmask&g.LONG_UNROLL?E*(sig12-\n(Math.atan2(ssig2,csig2)-\nMath.atan2(this._ssig1,this._csig1))+\n(Math.atan2(E*somg2,comg2)-\nMath.atan2(E*this._somg1,this._comg1))):Math.atan2(somg2*this._comg1-comg2*this._somg1,comg2*this._comg1+somg2*this._somg1);lam12=omg12+this._A3c*(sig12+(g.SinCosSeries(true,ssig2,csig2,this._C3a)-\nthis._B31));lon12=lam12/m.degree;vals.lon2=outmask&g.LONG_UNROLL?this.lon1+lon12:m.AngNormalize(m.AngNormalize(this.lon1)+m.AngNormalize(lon12));}\nif(outmask&g.LATITUDE)\nvals.lat2=m.atan2d(sbet2,this._f1*cbet2);if(outmask&g.AZIMUTH)\nvals.azi2=m.atan2d(salp2,calp2);if(outmask&(g.REDUCEDLENGTH|g.GEODESICSCALE)){B22=g.SinCosSeries(true,ssig2,csig2,this._C2a);AB2=(1+this._A2m1)*(B22-this._B21);J12=(this._A1m1-this._A2m1)*sig12+(AB1-AB2);if(outmask&g.REDUCEDLENGTH)\nvals.m12=this._b*((dn2*(this._csig1*ssig2)-\nthis._dn1*(this._ssig1*csig2))-\nthis._csig1*csig2*J12);if(outmask&g.GEODESICSCALE){t=this._k2*(ssig2-this._ssig1)*(ssig2+this._ssig1)/(this._dn1+dn2);vals.M12=csig12+\n(t*ssig2-csig2*J12)*this._ssig1/this._dn1;vals.M21=csig12-\n(t*this._ssig1-this._csig1*J12)*ssig2/dn2;}}\nif(outmask&g.AREA){B42=g.SinCosSeries(false,ssig2,csig2,this._C4a);if(this._calp0===0||this._salp0===0){salp12=salp2*this.calp1-calp2*this.salp1;calp12=calp2*this.calp1+salp2*this.salp1;}else{salp12=this._calp0*this._salp0*(csig12<=0?this._csig1*(1-csig12)+ssig12*this._ssig1:ssig12*(this._csig1*ssig12/(1+csig12)+this._ssig1));calp12=m.sq(this._salp0)+m.sq(this._calp0)*this._csig1*csig2;}\nvals.S12=this._c2*Math.atan2(salp12,calp12)+\nthis._A4*(B42-this._B41);}\nif(!arcmode)\nvals.a12=sig12/m.degree;return vals;};l.GeodesicLine.prototype.Position=function(s12,outmask){return this.GenPosition(false,s12,outmask);};l.GeodesicLine.prototype.ArcPosition=function(a12,outmask){return this.GenPosition(true,a12,outmask);};l.GeodesicLine.prototype.GenSetDistance=function(arcmode,s13_a13){if(arcmode)\nthis.SetArc(s13_a13);else\nthis.SetDistance(s13_a13);};l.GeodesicLine.prototype.SetDistance=function(s13){var r;this.s13=s13;r=this.GenPosition(false,this.s13,g.ARC);this.a13=0+r.a12;};l.GeodesicLine.prototype.SetArc=function(a13){var r;this.a13=a13;r=this.GenPosition(true,this.a13,g.DISTANCE);this.s13=0+r.s12;};})(geodesic.Geodesic,geodesic.GeodesicLine,geodesic.Math);(function(p,g,m,a){\"use strict\";var transit,transitdirect,AreaReduceA,AreaReduceB;transit=function(lon1,lon2){var lon12=m.AngDiff(lon1,lon2).d;lon1=m.AngNormalize(lon1);lon2=m.AngNormalize(lon2);return lon12>0&&((lon1<0&&lon2>=0)||(lon1>0&&lon2===0))?1:(lon12<0&&lon1>=0&&lon2<0?-1:0);};transitdirect=function(lon1,lon2){lon1=lon1%720;lon2=lon2%720;return((0<=lon2&&lon2<360)||lon2<-360?0:1)-\n((0<=lon1&&lon1<360)||lon1<-360?0:1);};AreaReduceA=function(area,area0,crossings,reverse,sign){area.Remainder(area0);if(crossings&1)\narea.Add((area.Sum()<0?1:-1)*area0/2);if(!reverse)\narea.Negate();if(sign){if(area.Sum()>area0/2)\narea.Add(-area0);else if(area.Sum()<=-area0/2)\narea.Add(+area0);}else{if(area.Sum()>=area0)\narea.Add(-area0);else if(area.Sum()<0)\narea.Add(+area0);}\nreturn 0+area.Sum();};AreaReduceB=function(area,area0,crossings,reverse,sign){area=m.remainder(area,area0);if(crossings&1)\narea+=(area<0?1:-1)*area0/2;if(!reverse)\narea*=-1;if(sign){if(area>area0/2)\narea-=area0;else if(area<=-area0/2)\narea+=area0;}else{if(area>=area0)\narea-=area0;else if(area<0)\narea+=area0;}\nreturn 0+area;};p.PolygonArea=function(geod,polyline){this._geod=geod;this.a=this._geod.a;this.f=this._geod.f;this._area0=4*Math.PI*geod._c2;this.polyline=!polyline?false:polyline;this._mask=g.LATITUDE|g.LONGITUDE|g.DISTANCE|(this.polyline?g.NONE:g.AREA|g.LONG_UNROLL);if(!this.polyline)\nthis._areasum=new a.Accumulator(0);this._perimetersum=new a.Accumulator(0);this.Clear();};p.PolygonArea.prototype.Clear=function(){this.num=0;this._crossings=0;if(!this.polyline)\nthis._areasum.Set(0);this._perimetersum.Set(0);this._lat0=this._lon0=this.lat=this.lon=NaN;};p.PolygonArea.prototype.AddPoint=function(lat,lon){var t;if(this.num===0){this._lat0=this.lat=lat;this._lon0=this.lon=lon;}else{t=this._geod.Inverse(this.lat,this.lon,lat,lon,this._mask);this._perimetersum.Add(t.s12);if(!this.polyline){this._areasum.Add(t.S12);this._crossings+=transit(this.lon,lon);}\nthis.lat=lat;this.lon=lon;}\n++this.num;};p.PolygonArea.prototype.AddEdge=function(azi,s){var t;if(this.num){t=this._geod.Direct(this.lat,this.lon,azi,s,this._mask);this._perimetersum.Add(s);if(!this.polyline){this._areasum.Add(t.S12);this._crossings+=transitdirect(this.lon,t.lon2);}\nthis.lat=t.lat2;this.lon=t.lon2;}\n++this.num;};p.PolygonArea.prototype.Compute=function(reverse,sign){var vals={number:this.num},t,tempsum;if(this.num<2){vals.perimeter=0;if(!this.polyline)\nvals.area=0;return vals;}\nif(this.polyline){vals.perimeter=this._perimetersum.Sum();return vals;}\nt=this._geod.Inverse(this.lat,this.lon,this._lat0,this._lon0,this._mask);vals.perimeter=this._perimetersum.Sum(t.s12);tempsum=new a.Accumulator(this._areasum);tempsum.Add(t.S12);vals.area=AreaReduceA(tempsum,this._area0,this._crossings+transit(this.lon,this._lon0),reverse,sign);return vals;};p.PolygonArea.prototype.TestPoint=function(lat,lon,reverse,sign){var vals={number:this.num+1},t,tempsum,crossings,i;if(this.num===0){vals.perimeter=0;if(!this.polyline)\nvals.area=0;return vals;}\nvals.perimeter=this._perimetersum.Sum();tempsum=this.polyline?0:this._areasum.Sum();crossings=this._crossings;for(i=0;i<(this.polyline?1:2);++i){t=this._geod.Inverse(i===0?this.lat:lat,i===0?this.lon:lon,i!==0?this._lat0:lat,i!==0?this._lon0:lon,this._mask);vals.perimeter+=t.s12;if(!this.polyline){tempsum+=t.S12;crossings+=transit(i===0?this.lon:lon,i!==0?this._lon0:lon);}}\nif(this.polyline)\nreturn vals;vals.area=AreaReduceB(tempsum,this._area0,crossings,reverse,sign);return vals;};p.PolygonArea.prototype.TestEdge=function(azi,s,reverse,sign){var vals={number:this.num?this.num+1:0},t,tempsum,crossings;if(this.num===0)\nreturn vals;vals.perimeter=this._perimetersum.Sum()+s;if(this.polyline)\nreturn vals;tempsum=this._areasum.Sum();crossings=this._crossings;t=this._geod.Direct(this.lat,this.lon,azi,s,this._mask);tempsum+=t.S12;crossings+=transitdirect(this.lon,t.lon2);crossings+=transit(t.lon2,this._lon0);t=this._geod.Inverse(t.lat2,t.lon2,this._lat0,this._lon0,this._mask);vals.perimeter+=t.s12;tempsum+=t.S12;vals.area=AreaReduceB(tempsum,this._area0,crossings,reverse,sign);return vals;};})(geodesic.PolygonArea,geodesic.Geodesic,geodesic.Math,geodesic.Accumulator);cb(geodesic);})(function(geo){if(typeof module==='object'&&module.exports){module.exports=geo;}else if(typeof define==='function'&&define.amd){define('geographiclib-geodesic',[],function(){return geo;});}else{window.geodesic=geo;}});","module.exports = \"#version 300 es\\n\\nin highp vec2 v_tex_coord;\\n\\n#ifdef MASK\\nuniform sampler2D u_mask_sampler;\\n#endif\\n\\nuniform highp float u_opacity;\\n#ifdef MASK\\nuniform int u_mask_val;\\n#endif\\n\\nout highp vec4 fragColor;\\n\\nvoid main() {\\n    highp float fill_val = get_field_value(v_tex_coord);\\n\\n    int draw_mask = 1;\\n\\n#ifdef MASK\\n    highp float mask_val = texture(u_mask_sampler, v_tex_coord).r;\\n    draw_mask = int(mask_val * 255.0) == u_mask_val ? 1 : 0;\\n#endif\\n\\n    if (isnan(fill_val) || draw_mask == 0) {\\n        discard;\\n    }\\n\\n    lowp vec4 color = apply_colormap(fill_val);\\n    color.a = color.a * u_opacity;\\n    fragColor = color;\\n}\"","module.exports = \"#version 300 es\\n\\nuniform int u_offset;\\n\\nin vec2 a_pos;    // Has grid point position\\nin vec2 a_tex_coord; // zoom info is on the x coordinate\\nin lowp float a_geom; // Has corner info\\nuniform lowp float u_bb_size;\\nuniform lowp float u_map_aspect;\\nuniform lowp float u_zoom;\\nuniform lowp float u_bb_width;  // Normalized by texture width\\nuniform lowp float u_bb_height; // Normalized by texture height\\nuniform highp float u_bb_mag_bin_size;\\nuniform highp float u_bb_mag_wrap;\\nuniform int u_rotate_with_map;\\n\\nuniform sampler2D u_rot_sampler;\\n\\nout highp vec2 v_tex_coord;\\n#ifdef COLORMAP\\nout highp float v_mag;\\n#endif\\n\\nmat4 scalingMatrix(float x_scale, float y_scale, float z_scale) {\\n    return mat4(x_scale, 0.0,     0.0,     0.0,\\n                0.0,     y_scale, 0.0,     0.0,\\n                0.0,     0.0,     z_scale, 0.0,\\n                0.0,     0.0,     0.0,     1.0);\\n}\\n\\nmat4 rotationZMatrix(float angle) {\\n    float s = sin(angle);\\n    float c = cos(angle);\\n\\n    return mat4( c,  s,  0., 0.,\\n                -s,  c,  0., 0.,\\n                 0., 0., 1., 0.,\\n                 0., 0., 0., 1.);\\n}\\n\\nmat4 rotationXMatrix(float angle) {\\n    float s = sin(angle);\\n    float c = cos(angle);\\n\\n    return mat4( 1.,  0., 0., 0.,\\n                 0.,  c,  s,  0.,\\n                 0., -s,  c,  0.,\\n                 0.,  0., 0., 1.);\\n}\\n\\nvoid main() {\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    mat4 map_stretch_matrix = scalingMatrix(1.0, 1. / u_map_aspect, 1.0);\\n\\n    vec4 pivot_pos = projectTile(a_pos.xy + globe_offset);\\n    float globe_rotation = 0.0;\\n\\n    if (u_rotate_with_map == 1) {\\n        vec4 pivot_pos_ihat = projectTile(a_pos.xy + globe_offset + vec2(1e-5, 0.));\\n        // Surely there's a more linear-algebra-y way to do this than converting all the rotations to an angle.\\n        vec2 pivot_east = normalize((inverse(map_stretch_matrix) * (pivot_pos_ihat - pivot_pos)).xy);\\n        globe_rotation = atan(pivot_east.x, pivot_east.y) - 3.141592654 / 2.0;\\n    }\\n\\n    highp float min_zoom = floor(a_tex_coord.x);\\n    lowp float corner = a_geom;\\n\\n    vec2 data_texcoord = a_tex_coord;\\n    data_texcoord.x = fract(data_texcoord.x);\\n\\n    highp float u = get_field_value_u(data_texcoord);\\n    highp float v = get_field_value_v(data_texcoord);\\n    highp float rot = texture(u_rot_sampler, data_texcoord).r;\\n\\n    lowp float bb_aspect = u_bb_width / u_bb_height;\\n    lowp float ang = (abs(u) < 1e-6 && abs(v) < 1e-6) ? 0. : atan(v, u) - 3.141592654 / 2.0;\\n    highp float mag = length(vec2(u, v));\\n#ifdef COLORMAP\\n    v_mag = mag;\\n#endif\\n    mag = floor(mag / u_bb_mag_bin_size + 0.5) * u_bb_mag_bin_size;\\n\\n    vec4 offset = vec4(0.0, 0.0, 0.0, 0.0);\\n    vec2 texcoord = vec2(0.0, 0.0);\\n    \\n    if (u_zoom >= min_zoom) {\\n        // Subtracting a small number off of u_bb_mag_wrap fixes (I think) a precision issue on some GPUs\\n        vec2 tex_loc = vec2(mod(mag, u_bb_mag_wrap - 1e-5) / u_bb_mag_bin_size * u_bb_width, floor(mag / (u_bb_mag_wrap - 1e-5)) * u_bb_height);\\n\\n        if (corner < 0.5) {\\n            offset = vec4(-u_bb_size, u_bb_size, 0., 0.);\\n            texcoord = tex_loc;\\n        }\\n        else if (corner < 1.5) {\\n            offset = vec4(u_bb_size, u_bb_size, 0., 0.);\\n            texcoord = tex_loc + vec2(u_bb_width, 0.0);\\n        }\\n        else if (corner < 2.5) {\\n            offset = vec4(-u_bb_size, -u_bb_size * (2. / bb_aspect - 1.), 0., 0.);\\n            texcoord = tex_loc + vec2(0.0, u_bb_height);\\n        }\\n        else if (corner < 3.5) {\\n            offset = vec4(u_bb_size, -u_bb_size * (2. / bb_aspect - 1.), 0., 0.);\\n            texcoord = tex_loc + vec2(u_bb_width, u_bb_height);\\n        }\\n\\n        mat4 barb_rotation = rotationZMatrix(ang - globe_rotation - rot);\\n        offset = map_stretch_matrix * barb_rotation * offset;\\n    }\\n\\n    gl_Position = pivot_pos + offset;\\n    v_tex_coord = texcoord;\\n}\"","module.exports = \"#version 300 es\\n\\nuniform int u_offset;\\n\\nin vec2 a_pos;\\nin vec2 a_tex_coord;\\n\\nout highp vec2 v_tex_coord;\\n\\nvoid main() {\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    gl_Position = projectTile(a_pos.xy + globe_offset);\\n    v_tex_coord = a_tex_coord;\\n}\"","module.exports = \"#version 300 es\\n\\nuniform int u_offset;\\n\\nin vec3 a_pos;\\nin vec2 a_extrusion;\\nin float a_data;\\n\\n#ifdef ZOOM\\nin float a_min_zoom;\\n#endif\\n\\n#ifdef OFFSET\\nin vec2 a_offset;\\n#endif\\n\\nuniform lowp float u_line_width;\\nuniform lowp float u_map_width;\\nuniform lowp float u_map_height;\\n//uniform highp float u_map_bearing;\\n\\n#ifdef ZOOM\\nuniform lowp float u_zoom;\\n#endif\\n\\n#ifdef OFFSET\\nuniform int u_offset_rotates_with_map;\\nuniform lowp float u_offset_scale;\\n#endif\\n\\n#ifdef DATA\\nout highp float v_data;\\n#endif\\n\\nout highp float v_dist;\\nout lowp float v_cross;\\n\\nmat4 scalingMatrix(float x_scale, float y_scale, float z_scale) {\\n    return mat4(x_scale, 0.0,     0.0,     0.0,\\n                0.0,     y_scale, 0.0,     0.0,\\n                0.0,     0.0,     z_scale, 0.0,\\n                0.0,     0.0,     0.0,     1.0);\\n}\\n\\nmat4 rotationZMatrix(float angle) {\\n    float s = sin(angle);\\n    float c = cos(angle);\\n\\n    return mat4( c,  s,  0., 0.,\\n                -s,  c,  0., 0.,\\n                 0., 0., 1., 0.,\\n                 0., 0., 0., 1.);\\n}\\n\\nmat4 rotationXMatrix(float angle) {\\n    float s = sin(angle);\\n    float c = cos(angle);\\n\\n    return mat4( 1.,  0., 0., 0.,\\n                 0.,  c,  s,  0.,\\n                 0., -s,  c,  0.,\\n                 0.,  0., 0., 1.);\\n}\\n\\nvoid main() {\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    v_dist = abs(a_pos.z);\\n    v_cross = sign(a_pos.z);\\n    vec4 center_pos = projectTile(a_pos.xy + globe_offset);\\n    vec4 offset = vec4(0.0, 0.0, 0.0, 0.0);\\n\\n#ifdef ZOOM\\n    if (u_zoom >= a_min_zoom) {\\n#endif\\n\\n        vec2 offset_ext = u_line_width * 2. * a_extrusion;\\n\\n        mat4 map_stretch_matrix = scalingMatrix(u_map_height / u_map_width, 1., 1.);\\n        \\n        vec4 center_pos_ihat = projectTile(a_pos.xy + globe_offset + vec2(1e-5, 0.));\\n        // Surely there's a more linear-algebra-y way to do this than converting all the rotations to an angle.\\n        vec2 center_east = normalize((inverse(map_stretch_matrix) * (center_pos_ihat - center_pos)).xy);\\n        float globe_rotation = atan(center_east.x, center_east.y) - 3.141592654 / 2.0;\\n        mat4 rotation_matrix = rotationZMatrix(-globe_rotation);\\n\\n        offset = map_stretch_matrix * rotation_matrix * vec4(offset_ext, 0., 0.);\\n\\n#ifdef OFFSET\\n        mat4 offset_matrix = scalingMatrix(1., u_map_width / u_map_height, 1.);\\n        if (u_offset_rotates_with_map == 1) {\\n            offset_matrix = offset_matrix * rotation_matrix;\\n        }\\n        else {\\n            offset = map_stretch_matrix * vec4(offset_ext, 0., 0.);\\n        }\\n\\n        vec2 offset_offset = u_offset_scale * a_offset;\\n        offset += offset_matrix * vec4(offset_offset, 0., 0.);\\n#endif\\n\\n#ifdef ZOOM\\n    }\\n#endif\\n\\n    gl_Position = center_pos + offset;\\n\\n#ifdef DATA\\n    v_data = a_data;\\n#endif\\n}\"","module.exports = \"#version 300 es\\n\\nuniform int u_offset;\\nuniform highp float u_map_width;\\nuniform highp float u_map_height;\\nuniform highp float u_map_zoom;\\nuniform highp float u_font_size;\\n\\nin vec3 a_pos;\\nin vec2 a_offset;\\nin vec2 a_tex_coord;\\n\\n#ifdef DATA\\nin highp float a_value;\\n#endif\\n\\nout highp vec2 v_tex_coord;\\n\\n#ifdef DATA\\nout highp float v_value;\\n#endif\\n\\nmat4 scalingMatrix(float x_scale, float y_scale, float z_scale) {\\n    return mat4(x_scale, 0.0,     0.0,     0.0,\\n                0.0,     y_scale, 0.0,     0.0,\\n                0.0,     0.0,     z_scale, 0.0,\\n                0.0,     0.0,     0.0,     1.0);\\n}\\n\\nvoid main() {\\n    float min_zoom = a_pos.z;\\n\\n    vec2 offset = a_offset;\\n    if (u_map_zoom < min_zoom)\\n        offset = vec2(0., 0.);\\n\\n    float globe_width = 1.;\\n    vec2 globe_offset = vec2(globe_width * float(u_offset), 0.);\\n\\n    mat4 map_stretch_matrix = scalingMatrix(u_map_height / u_map_width, 1., 1.);\\n\\n    gl_Position = projectTile(a_pos.xy + globe_offset) + u_font_size / 12. * 1.5 * map_stretch_matrix * vec4(offset, 0., 0.);\\n    v_tex_coord = a_tex_coord;\\n\\n#ifdef DATA\\n    v_value = a_value;\\n#endif\\n}\"","module.exports = \"#version 300 es\\n\\nuniform sampler2D u_dash_sampler;\\n\\n#ifndef DATA\\nuniform lowp vec4 u_color;\\n#endif\\n\\nuniform lowp float u_line_width;\\nuniform lowp float u_zoom;\\nuniform int u_dash_pattern_length;\\n\\n#ifdef DATA\\nin highp float v_data;\\n#endif\\n\\nin highp float v_dist;\\nin lowp float v_cross;\\n\\nout highp vec4 fragColor;\\n\\nvoid main() {\\n    lowp float dash_x = fract(v_dist * 2e2 * pow(2., floor(u_zoom)) / float(u_dash_pattern_length));\\n    lowp float dash = texture(u_dash_sampler, vec2(dash_x, 0.5)).r;\\n\\n    lowp vec4 color;\\n#ifdef DATA\\n    color = apply_colormap(v_data);\\n#else\\n    color = u_color;\\n#endif\\n\\n    lowp float feather = clamp((1. - abs(v_cross)) * u_line_width, 0., 1.);\\n    color.a *= (dash >= 1. ? 1. : 0.) * feather;\\n\\n    fragColor = color;\\n}\"","module.exports = \"#version 300 es\\n\\nin highp vec2 v_tex_coord;\\n\\n#ifdef DATA\\nin highp float v_value;\\n#endif\\n\\nuniform sampler2D u_sdf_sampler;\\nuniform int u_is_halo;\\n\\n#ifndef DATA\\nuniform lowp vec4 u_text_color;\\n#endif\\nuniform lowp vec4 u_halo_color;\\n\\n#define SDF_FILL 0.75\\n#define SDF_HALO 0.45\\n\\nout highp vec4 fragColor;\\n\\nvoid main() {\\n    highp float sdf_val = texture(u_sdf_sampler, v_tex_coord).r;\\n\\n    lowp float step_width = 0.08;\\n    lowp float alpha = smoothstep(SDF_FILL - step_width, SDF_FILL + step_width, sdf_val);\\n\\n#ifdef DATA\\n    lowp vec4 text_color = apply_colormap(v_value);\\n#else\\n    lowp vec4 text_color = u_text_color;\\n#endif\\n\\n    lowp vec4 color = u_is_halo == 1 ? u_halo_color : text_color;\\n\\n    if (u_is_halo == 1) {\\n        alpha = min(smoothstep(SDF_HALO - step_width, SDF_HALO + step_width, sdf_val), 1.0 - alpha);\\n    }\\n\\n    color.a *= alpha;\\n    fragColor = color;\\n}\"","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \".autumnplot-gl.js\";\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/^blob:/, \"\").replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","__webpack_require__.b = document.baseURI || self.location.href;\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t792: 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// no jsonp function","/**\r\n * Copyright 2019 Google Inc. All Rights Reserved.\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *     http://www.apache.org/licenses/LICENSE-2.0\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\nconst proxyMarker = Symbol(\"Comlink.proxy\");\r\nconst createEndpoint = Symbol(\"Comlink.endpoint\");\r\nconst releaseProxy = Symbol(\"Comlink.releaseProxy\");\r\nconst throwMarker = Symbol(\"Comlink.thrown\");\r\nconst isObject = (val) => (typeof val === \"object\" && val !== null) || typeof val === \"function\";\r\n/**\r\n * Internal transfer handle to handle objects marked to proxy.\r\n */\r\nconst proxyTransferHandler = {\r\n    canHandle: (val) => isObject(val) && val[proxyMarker],\r\n    serialize(obj) {\r\n        const { port1, port2 } = new MessageChannel();\r\n        expose(obj, port1);\r\n        return [port2, [port2]];\r\n    },\r\n    deserialize(port) {\r\n        port.start();\r\n        return wrap(port);\r\n    },\r\n};\r\n/**\r\n * Internal transfer handler to handle thrown exceptions.\r\n */\r\nconst throwTransferHandler = {\r\n    canHandle: (value) => isObject(value) && throwMarker in value,\r\n    serialize({ value }) {\r\n        let serialized;\r\n        if (value instanceof Error) {\r\n            serialized = {\r\n                isError: true,\r\n                value: {\r\n                    message: value.message,\r\n                    name: value.name,\r\n                    stack: value.stack,\r\n                },\r\n            };\r\n        }\r\n        else {\r\n            serialized = { isError: false, value };\r\n        }\r\n        return [serialized, []];\r\n    },\r\n    deserialize(serialized) {\r\n        if (serialized.isError) {\r\n            throw Object.assign(new Error(serialized.value.message), serialized.value);\r\n        }\r\n        throw serialized.value;\r\n    },\r\n};\r\n/**\r\n * Allows customizing the serialization of certain values.\r\n */\r\nconst transferHandlers = new Map([\r\n    [\"proxy\", proxyTransferHandler],\r\n    [\"throw\", throwTransferHandler],\r\n]);\r\nfunction expose(obj, ep = self) {\r\n    ep.addEventListener(\"message\", function callback(ev) {\r\n        if (!ev || !ev.data) {\r\n            return;\r\n        }\r\n        const { id, type, path } = Object.assign({ path: [] }, ev.data);\r\n        const argumentList = (ev.data.argumentList || []).map(fromWireValue);\r\n        let returnValue;\r\n        try {\r\n            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);\r\n            const rawValue = path.reduce((obj, prop) => obj[prop], obj);\r\n            switch (type) {\r\n                case \"GET\" /* GET */:\r\n                    {\r\n                        returnValue = rawValue;\r\n                    }\r\n                    break;\r\n                case \"SET\" /* SET */:\r\n                    {\r\n                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);\r\n                        returnValue = true;\r\n                    }\r\n                    break;\r\n                case \"APPLY\" /* APPLY */:\r\n                    {\r\n                        returnValue = rawValue.apply(parent, argumentList);\r\n                    }\r\n                    break;\r\n                case \"CONSTRUCT\" /* CONSTRUCT */:\r\n                    {\r\n                        const value = new rawValue(...argumentList);\r\n                        returnValue = proxy(value);\r\n                    }\r\n                    break;\r\n                case \"ENDPOINT\" /* ENDPOINT */:\r\n                    {\r\n                        const { port1, port2 } = new MessageChannel();\r\n                        expose(obj, port2);\r\n                        returnValue = transfer(port1, [port1]);\r\n                    }\r\n                    break;\r\n                case \"RELEASE\" /* RELEASE */:\r\n                    {\r\n                        returnValue = undefined;\r\n                    }\r\n                    break;\r\n                default:\r\n                    return;\r\n            }\r\n        }\r\n        catch (value) {\r\n            returnValue = { value, [throwMarker]: 0 };\r\n        }\r\n        Promise.resolve(returnValue)\r\n            .catch((value) => {\r\n            return { value, [throwMarker]: 0 };\r\n        })\r\n            .then((returnValue) => {\r\n            const [wireValue, transferables] = toWireValue(returnValue);\r\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\r\n            if (type === \"RELEASE\" /* RELEASE */) {\r\n                // detach and deactive after sending release response above.\r\n                ep.removeEventListener(\"message\", callback);\r\n                closeEndPoint(ep);\r\n            }\r\n        });\r\n    });\r\n    if (ep.start) {\r\n        ep.start();\r\n    }\r\n}\r\nfunction isMessagePort(endpoint) {\r\n    return endpoint.constructor.name === \"MessagePort\";\r\n}\r\nfunction closeEndPoint(endpoint) {\r\n    if (isMessagePort(endpoint))\r\n        endpoint.close();\r\n}\r\nfunction wrap(ep, target) {\r\n    return createProxy(ep, [], target);\r\n}\r\nfunction throwIfProxyReleased(isReleased) {\r\n    if (isReleased) {\r\n        throw new Error(\"Proxy has been released and is not useable\");\r\n    }\r\n}\r\nfunction createProxy(ep, path = [], target = function () { }) {\r\n    let isProxyReleased = false;\r\n    const proxy = new Proxy(target, {\r\n        get(_target, prop) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            if (prop === releaseProxy) {\r\n                return () => {\r\n                    return requestResponseMessage(ep, {\r\n                        type: \"RELEASE\" /* RELEASE */,\r\n                        path: path.map((p) => p.toString()),\r\n                    }).then(() => {\r\n                        closeEndPoint(ep);\r\n                        isProxyReleased = true;\r\n                    });\r\n                };\r\n            }\r\n            if (prop === \"then\") {\r\n                if (path.length === 0) {\r\n                    return { then: () => proxy };\r\n                }\r\n                const r = requestResponseMessage(ep, {\r\n                    type: \"GET\" /* GET */,\r\n                    path: path.map((p) => p.toString()),\r\n                }).then(fromWireValue);\r\n                return r.then.bind(r);\r\n            }\r\n            return createProxy(ep, [...path, prop]);\r\n        },\r\n        set(_target, prop, rawValue) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a\r\n            // boolean. To show good will, we return true asynchronously ¯\\_(ツ)_/¯\r\n            const [value, transferables] = toWireValue(rawValue);\r\n            return requestResponseMessage(ep, {\r\n                type: \"SET\" /* SET */,\r\n                path: [...path, prop].map((p) => p.toString()),\r\n                value,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n        apply(_target, _thisArg, rawArgumentList) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            const last = path[path.length - 1];\r\n            if (last === createEndpoint) {\r\n                return requestResponseMessage(ep, {\r\n                    type: \"ENDPOINT\" /* ENDPOINT */,\r\n                }).then(fromWireValue);\r\n            }\r\n            // We just pretend that `bind()` didn’t happen.\r\n            if (last === \"bind\") {\r\n                return createProxy(ep, path.slice(0, -1));\r\n            }\r\n            const [argumentList, transferables] = processArguments(rawArgumentList);\r\n            return requestResponseMessage(ep, {\r\n                type: \"APPLY\" /* APPLY */,\r\n                path: path.map((p) => p.toString()),\r\n                argumentList,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n        construct(_target, rawArgumentList) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            const [argumentList, transferables] = processArguments(rawArgumentList);\r\n            return requestResponseMessage(ep, {\r\n                type: \"CONSTRUCT\" /* CONSTRUCT */,\r\n                path: path.map((p) => p.toString()),\r\n                argumentList,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n    });\r\n    return proxy;\r\n}\r\nfunction myFlat(arr) {\r\n    return Array.prototype.concat.apply([], arr);\r\n}\r\nfunction processArguments(argumentList) {\r\n    const processed = argumentList.map(toWireValue);\r\n    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];\r\n}\r\nconst transferCache = new WeakMap();\r\nfunction transfer(obj, transfers) {\r\n    transferCache.set(obj, transfers);\r\n    return obj;\r\n}\r\nfunction proxy(obj) {\r\n    return Object.assign(obj, { [proxyMarker]: true });\r\n}\r\nfunction windowEndpoint(w, context = self, targetOrigin = \"*\") {\r\n    return {\r\n        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),\r\n        addEventListener: context.addEventListener.bind(context),\r\n        removeEventListener: context.removeEventListener.bind(context),\r\n    };\r\n}\r\nfunction toWireValue(value) {\r\n    for (const [name, handler] of transferHandlers) {\r\n        if (handler.canHandle(value)) {\r\n            const [serializedValue, transferables] = handler.serialize(value);\r\n            return [\r\n                {\r\n                    type: \"HANDLER\" /* HANDLER */,\r\n                    name,\r\n                    value: serializedValue,\r\n                },\r\n                transferables,\r\n            ];\r\n        }\r\n    }\r\n    return [\r\n        {\r\n            type: \"RAW\" /* RAW */,\r\n            value,\r\n        },\r\n        transferCache.get(value) || [],\r\n    ];\r\n}\r\nfunction fromWireValue(value) {\r\n    switch (value.type) {\r\n        case \"HANDLER\" /* HANDLER */:\r\n            return transferHandlers.get(value.name).deserialize(value.value);\r\n        case \"RAW\" /* RAW */:\r\n            return value.value;\r\n    }\r\n}\r\nfunction requestResponseMessage(ep, msg, transfers) {\r\n    return new Promise((resolve) => {\r\n        const id = generateUUID();\r\n        ep.addEventListener(\"message\", function l(ev) {\r\n            if (!ev.data || !ev.data.id || ev.data.id !== id) {\r\n                return;\r\n            }\r\n            ep.removeEventListener(\"message\", l);\r\n            resolve(ev.data);\r\n        });\r\n        if (ep.start) {\r\n            ep.start();\r\n        }\r\n        ep.postMessage(Object.assign({ id }, msg), transfers);\r\n    });\r\n}\r\nfunction generateUUID() {\r\n    return new Array(4)\r\n        .fill(0)\r\n        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))\r\n        .join(\"-\");\r\n}\n\nexport { createEndpoint, expose, proxy, proxyMarker, releaseProxy, transfer, transferHandlers, windowEndpoint, wrap };\n//# sourceMappingURL=comlink.mjs.map\n","import { TypedArray, TypedArrayStr } from \"./AutumnTypes\";\n\nfunction getMinZoom(jlat: number, ilon: number, thin_fac_base: number) {\n    const zoom_base = 1;\n\n    let zoom = zoom_base;\n    let thin_fac = thin_fac_base;\n\n    while (((jlat % thin_fac) != 0) || ((ilon % thin_fac) != 0)) {\n        zoom += 1;\n        thin_fac /= 2;\n    }\n\n    return zoom;\n}\n\nfunction* zip(...args: any[]) {\n\tconst iterators = args.map(x => x[Symbol.iterator]());\n\twhile (true) {\n\t\tconst current = iterators.map(x => x.next());\n\t\tif (current.some(x => x.done)) {\n\t\t\tbreak;\n\t\t}\n\t\tyield current.map(x => x.value);\n\t}\n}\n\nfunction getOS() {\n    const userAgent = window.navigator.userAgent,\n        platform = window.navigator.platform,\n        macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'],\n        windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'],\n        iosPlatforms = ['iPhone', 'iPad', 'iPod'];\n    let os = null;\n\n    if (macosPlatforms.indexOf(platform) !== -1 && navigator.maxTouchPoints <= 1) {\n        os = 'Mac OS';\n    } \n    else if (iosPlatforms.indexOf(platform) !== -1 || (macosPlatforms.indexOf(platform) !== -1 && navigator.maxTouchPoints > 1)) { \n        os = 'iOS';\n    } \n    else if (windowsPlatforms.indexOf(platform) !== -1) {\n        os = 'Windows';\n    } \n    else if (/Android/.test(userAgent)) {\n        os = 'Android';\n    } \n    else if (/Linux/.test(platform)) {\n        os = 'Linux';\n    }\n\n    return os;\n}\n\nclass Cache<A extends unknown[], R> {\n    private cached_values: Record<string, R>;\n    private readonly compute_value: (...args: A) => R;\n    private readonly make_key: (...args: A) => string;\n\n    constructor(compute_value: (...args: A) => R, make_key?: (...args: A) => string) {\n        this.cached_values = {};\n        this.compute_value = compute_value;\n        this.make_key = make_key === undefined ? (...args: A) => JSON.stringify(args) : make_key;\n    }\n\n    public getValue(...args: A) {\n        const key = this.make_key(...args);\n\n        if (!(key in this.cached_values)) {\n            this.cached_values[key] = this.compute_value(...args);\n        }\n\n        return this.cached_values[key];\n    }\n}\n\n\nfunction normalizeOptions<Type extends Record<string, any>>(opts: Type | undefined, defaults: Required<Type>) {\n    const ret = {...defaults} as Required<Type>;\n\n    if (opts !== undefined) {\n        Object.entries(opts).forEach(([k, v]: [keyof Type, any]) => {\n            ret[k] = v;\n        });\n    }\n\n    return ret;\n}\n\nfunction getArrayConstructor<ArrayType extends TypedArray>(ary: ArrayType) : new(...args: any[]) => ArrayType {\n    return ary.constructor as new(...args: any[]) => ArrayType;\n}\n\nfunction mergeShaderCode(snippet: string, main: string) {\n    const ES3_SHADER_MAGIC = '#version 300 es\\n';\n    const is_es3_shader = main.startsWith(ES3_SHADER_MAGIC);\n\n    if (is_es3_shader) {\n        return ES3_SHADER_MAGIC + snippet + \"\\n\" + main.slice(ES3_SHADER_MAGIC.length);\n    }\n    \n    return snippet + \"\\n\" + main;\n}\n\nfunction applySamplerCodeScalar(src: string, sampler_names: string[], sampler_expression: string, dtypes: TypedArrayStr[]) {\n    // TAS: find a better place for this to live.\n    const SAMPLER_DTYPES = {\n        'float16': 'sampler2D', 'float32': 'sampler2D', \n        'uint8': 'lowp usampler2D', 'uint16': 'mediump usampler2D', 'uint32': 'highp usampler2D',\n        'int16': 'mediump isampler2D', 'int32': 'highp isampler2D',\n    };\n\n    const SHADER_DTYPES = {\n        'float16': 'highp float', 'float32': 'highp float',\n        'uint8': 'uint', 'uint16': 'uint', 'uint32': 'uint',\n        'int16': 'int', 'int32': 'int',\n    }\n\n    const samplers = sampler_names.map((v, i) => `uniform ${SAMPLER_DTYPES[dtypes[i]]} ${v};`).join(\"\\n\");\n    const sampler_get = sampler_names.map((v, i) => `    ${SHADER_DTYPES[dtypes[i]]} ${v}_val = texture(${v}, tex_coord).r;`).join(\"\\n\");\n\n    sampler_names.forEach(v => sampler_expression = sampler_expression.replaceAll(v, `${v}_val`));\n\n    // TAS: This assumes that the return type of the expression is the same as the type of the inputs. May need to revisit this later.\n    const sampler_code = `\n${samplers}\n\n${SHADER_DTYPES[dtypes[0]]} get_field_value(lowp vec2 tex_coord) {\n${sampler_get}\n    return ${sampler_expression};\n}`;\n\n    return mergeShaderCode(sampler_code, src);\n}\n\nfunction applySamplerCodeVector(src: string, sampler_names: {u: string[], v: string[]}, sampler_expressions: {u: string, v: string}) {\n    const samplers = sampler_names.u.map(v => `uniform sampler2D ${v};`).join(\"\\n\") + \"\\n\" +\n                     sampler_names.v.map(v => `uniform sampler2D ${v};`).join(\"\\n\");\n    const sampler_u_get = sampler_names.u.map(v => `    highp float ${v}_val = texture(${v}, tex_coord).r;`).join(\"\\n\");\n    const sampler_v_get = sampler_names.v.map(v => `    highp float ${v}_val = texture(${v}, tex_coord).r;`).join(\"\\n\");\n\n    let sampler_expression_u = sampler_expressions.u;\n    sampler_names.u.forEach(v => sampler_expression_u = sampler_expression_u.replaceAll(v, `${v}_val`));\n    let sampler_expression_v = sampler_expressions.v;\n    sampler_names.v.forEach(v => sampler_expression_v = sampler_expression_v.replaceAll(v, `${v}_val`));\n\n    const sampler_code = `\n${samplers}\n\nhighp float get_field_value_u(lowp vec2 tex_coord) {\n${sampler_u_get}\n    return ${sampler_expression_u};\n}\n\nhighp float get_field_value_v(lowp vec2 tex_coord) {\n${sampler_v_get}\n    return ${sampler_expression_v};\n}`;\n\n    return mergeShaderCode(sampler_code, src);\n}\n\nfunction argMin<T>(ary: T[] | TypedArray) {\n    if (ary.length === 0) {\n        return -1;\n    }\n\n    let min = ary[0];\n    let minIndex = 0;\n\n    for (let i = 1; i < ary.length; i++) {\n        if (ary[i] < min) {\n            minIndex = i;\n            min = ary[i];\n        }\n    }\n\n    return minIndex;\n}\n\nexport {zip, getMinZoom, getOS, Cache, normalizeOptions, getArrayConstructor, mergeShaderCode, applySamplerCodeScalar, applySamplerCodeVector, argMin};\n","\nimport { Float16Array } from \"@petamoriken/float16\";\n\n/** A wind profile with a storm-motion for plotting storm-relative hodographs */\ninterface StormRelativeWindProfile {\n    /** The grid index in the j direction (ignored for unstructured grids) */\n    jlat: number;\n\n    /** The grid index in the i direction */\n    ilon: number;\n\n    /** u component of storm motion in kts */\n    smu: number;\n\n    /** v component of storm motion in kts */\n    smv: number;\n\n    /** Ground-relative u winds in kts (will be converted to storm-relative during plotting) */\n    u: Float32Array;\n\n    /** Ground-relative v winds in kts (will be converted to storm-relative during plotting) */\n    v: Float32Array;\n\n    /** Height of each data point in km */\n    z: Float32Array\n}\n\n/** A wind profile without a storm motion for plotting ground-relative hodographs */\ninterface GroundRelativeWindProfile {\n    /** The grid index in the j direction (ignored for unstructured grids) */\n    jlat: number;\n\n    /** The grid index in the i direction */\n    ilon: number;\n\n    /** Ground-relative u winds in kts */\n    u: Float32Array;\n\n    /** Ground-relative v winds in kts */\n    v: Float32Array;\n\n    /** Height of each data point in km */\n    z: Float32Array\n}\n\n/** Different types of wind profiles for {@link Hodographs} components */\ntype WindProfile = StormRelativeWindProfile | GroundRelativeWindProfile;\n\nfunction isStormRelativeWindProfile(obj: any) : obj is StormRelativeWindProfile {\n    return 'smu' in obj && 'smv' in obj;\n}\n\ninterface BillboardSpec {\n    BB_WIDTH: number;\n    BB_HEIGHT: number;\n    BB_TEX_WIDTH: number;\n    BB_TEX_HEIGHT: number;\n    BB_MAG_BIN_SIZE: number;\n    BB_MAG_WRAP: number;\n    BB_MAG_MAX: number;\n}\n\ntype LineData = {\n    vertices: [number, number][];\n    offsets?: [number, number][];\n    data?: number[];\n    zoom?: number;\n}\n\ntype Polyline = {\n    extrusion: Float32Array;\n    vertices: Float32Array;\n    offsets?: Float32Array;\n    data?: Float32Array;\n    zoom?: Float32Array;\n};\n\n/** WebGL rendering contexts (either WebGL1 or WebGL2) */\ntype WebGLAnyRenderingContext = WebGLRenderingContext | WebGL2RenderingContext;\n\nfunction isWebGL2Ctx(gl: WebGLAnyRenderingContext) : gl is WebGL2RenderingContext {\n    return gl.getParameter(gl.VERSION).includes('WebGL 2.0');\n}\n\n/** Javascript typed arrays for use in raw fields */\ntype TypedArray = Float16Array | Float32Array | Uint8Array | Uint16Array | Uint32Array | Int16Array | Int32Array;\ntype TypedArrayStr = 'float16' | 'float32' | 'uint8' | 'uint16' | 'uint32' | 'int16' | 'int32';\ntype ContourableTypedArray = Float16Array | Float32Array;\n\nfunction isContourable(ary: any) : ary is ContourableTypedArray {\n    return ary instanceof Uint16Array || ary instanceof Float32Array;\n}\n\n/** \n * The result of contouring a field\n *\n * Each property is a different contour level giving an array of contours, and each contour is an array of [longitude, latitude].\n */\ntype ContourData = Record<number, [number, number][][]>;\n\ntype mat4 = number[] | Float32Array | Float64Array;\ntype RenderShaderData = {vertexShaderPrelude: string, define: string, variantName: string};\n\ntype MapLibreRendererDataProjection = {\n    clippingPlane: [number, number, number, number];\n    fallbackMatrix: mat4;\n    mainMatrix: mat4;\n    projectionTransition: number;\n    tileMercatorCoords: [number, number, number, number];\n};\ntype MapLibreRendererDataShader = RenderShaderData;\n\ntype MapLibreRendererData = {\n    defaultProjectionData: MapLibreRendererDataProjection;\n    farZ: number\n    fov: number\n    modelViewProjectionMatrix: mat4;\n    nearZ: number\n    projectionMatrix: mat4;\n    shaderData: MapLibreRendererDataShader;\n};\n\ntype RenderMethodArg = mat4 | MapLibreRendererData;\n\nfunction isMapLibreRenderArg(obj: any) : obj is MapLibreRendererData {\n    return 'modelViewProjectionMatrix' in obj && 'defaultProjectionData' in obj && 'mainMatrix' in obj.defaultProjectionData;\n}\n\ntype RendererDataProjection = {\n    clippingPlane: number[];\n    fallbackMatrix: number[];\n    mainMatrix: number[];\n    projectionTransition: number;\n    tileMercatorCoords: number[];\n};\ntype RendererDataShader = RenderShaderData;\n\ntype RendererDataMapLibre = {\n    type: 'maplibre';\n    defaultProjectionData: RendererDataProjection;\n    farZ: number\n    fov: number\n    modelViewProjectionMatrix: number[];\n    nearZ: number\n    projectionMatrix: number[];\n    shaderData: RendererDataShader;\n};\n\ntype RendererDataAutumn = {\n    type: 'autumn';\n    mainMatrix: number[];\n    shaderData: null;\n}\n\ntype RendererData = RendererDataMapLibre | RendererDataAutumn;\n\nfunction getRendererData(arg: RenderMethodArg) : RendererData{\n    if (isMapLibreRenderArg(arg)) {\n        return {\n            type: 'maplibre',\n            defaultProjectionData: {\n                clippingPlane: [...arg.defaultProjectionData.clippingPlane],\n                fallbackMatrix: [...arg.defaultProjectionData.fallbackMatrix],\n                mainMatrix: [...arg.defaultProjectionData.mainMatrix],\n                projectionTransition: arg.defaultProjectionData.projectionTransition,\n                tileMercatorCoords: [...arg.defaultProjectionData.tileMercatorCoords]\n            },\n            farZ: arg.farZ,\n            fov: arg.fov,\n            modelViewProjectionMatrix: [...arg.modelViewProjectionMatrix],\n            nearZ: arg.nearZ,\n            projectionMatrix: [...arg.projectionMatrix],\n            shaderData: arg.shaderData\n        };\n    }\n\n    return {type: 'autumn', mainMatrix: [...arg], shaderData: null};\n}\n\nexport {isWebGL2Ctx, isContourable, getRendererData, isStormRelativeWindProfile};\nexport type {WindProfile, StormRelativeWindProfile, GroundRelativeWindProfile, BillboardSpec, Polyline, LineData, WebGLAnyRenderingContext, \n             TypedArray, TypedArrayStr, ContourableTypedArray, ContourData, RenderMethodArg, RendererData, RenderShaderData};","\nimport * as Comlink from 'comlink';\n\ninterface WorkerData<T> {\n    worker: Comlink.Remote<T>;\n    is_busy: boolean;\n}\n\ninterface WorkerQueueData {\n    args: any[];\n    callback: (...args: any[]) => any;\n}\n\nclass WorkerPool_<T> {\n    private readonly workers: WorkerData<T>[];\n\n    private queue: Map<string, WorkerQueueData[]>;\n\n    constructor(workers: Worker[], init?: (wkr: Comlink.Remote<T>) => void) {\n        this.workers = workers.map(wkr => ({worker: Comlink.wrap<T>(wkr), is_busy: false}));\n\n        if (init) {\n            this.workers.forEach(wkr => init(wkr.worker));\n        }\n\n        this.queue = new Map();\n    }\n\n    call(path: (string | number | symbol)[], args: any[], callback: (...args: any) => any) {\n        const worker_idx = this.workers.map(((w, iw) => [w, iw] as [WorkerData<T>, number])).filter(([w, iw]) => !w.is_busy)[0];\n\n        if (worker_idx === undefined) {\n            this.enqueue(path, args, callback);\n        }\n        else {\n            const [worker, iw] = worker_idx;\n            const dequeueAndStart = () => {\n                if (this.queueSize(path) > 0) {\n                    const queue_data = this.dequeue(path);\n                    if (queue_data === undefined) return;\n\n                    this.startRun(worker, path, queue_data.args).then(queue_data.callback).then(dequeueAndStart);\n                }\n            }\n\n            this.startRun(worker, path, args).then(callback).then(dequeueAndStart);\n        }\n    }\n\n    private enqueue(path: (string | number | symbol)[], args: any[], callback: (...args: any) => any) {\n        const path_str = path.join(\".\");\n        const old_queue = this.queue.get(path_str);\n        const new_queue = old_queue ? old_queue : [];\n        new_queue.push({args: args, callback: callback});\n        this.queue.set(path_str, new_queue);\n    }\n\n    private dequeue(path: (string | number | symbol)[]) {\n        const path_str = path.join(\".\");\n        const queue = this.queue.get(path_str);\n        if (!queue) {\n            return undefined;\n        }\n\n        const elem = queue.shift();\n\n        this.queue.set(path_str, queue);\n        return elem;\n    }\n\n    private queueSize(path: (string | number | symbol)[]) {\n        const path_str = path.join(\".\");\n        const queue = this.queue.get(path_str);\n\n        if (!queue) {\n            return 0;\n        }\n\n        return queue.length;\n    }\n\n    private async startRun(worker: WorkerData<T>, path: (string | number | symbol)[], args: any[]) {\n        let rem = worker.worker as any;\n        path.forEach(p => rem = rem[p]);\n\n        worker.is_busy = true;\n        const ret = await rem(...args);\n        worker.is_busy = false;\n        return ret;\n    }\n}\n\nfunction createProxy<T>(pool: WorkerPool_<T>, path: (string | number | symbol)[], target: object) : any {\n    const proxy = new Proxy(target, {\n        get(tgt, prop: string | number | symbol) {\n            return createProxy(pool, [...path, prop], () => {});\n        },\n        apply(tgt, this_arg, func_args) {\n            return new Promise((resolve, reject) => pool.call(path, func_args, resolve));\n        }\n    });\n\n    return proxy;\n}\n\ntype Promisify<T> = (T extends (...args: infer TArguments) => infer TReturn\n      ? (...args: TArguments) => Promise<TReturn>\n      : unknown);\n\ntype WorkerPool<T> = {[K in keyof T]: Promisify<T[K]>};\n\nfunction createWorkerPool<T>(workers: Worker[], init?: (wkr: Comlink.Remote<T>) => void) : WorkerPool<T> {\n    const pool = new WorkerPool_<T>(workers, init);\n\n    return createProxy(pool, [], () => {}) as WorkerPool<T>;\n}\n\nexport {createWorkerPool};\nexport type {WorkerPool};","\nimport * as Comlink from 'comlink';\n\nimport { getOS } from \"./utils\";\nimport { PlotLayerWorker } from './PlotLayer.worker';\nimport { ContourCreatorWorker } from './ContourCreator.worker';\nimport { MapLikeType } from './Map';\nimport { RenderMethodArg, TypedArrayStr, WebGLAnyRenderingContext, isWebGL2Ctx } from './AutumnTypes';\nimport { WorkerPool, createWorkerPool } from './WorkerPool';\n\nconst worker = new Worker(new URL('./PlotLayer.worker', import.meta.url));\nconst layer_worker = Comlink.wrap<PlotLayerWorker>(worker);\n\nlet c_worker_pool: WorkerPool<ContourCreatorWorker> | null = null;\nfunction getContourWorkerPool(wasm_base_url: string | undefined, n_workers: number) {\n    if (c_worker_pool !== null) {\n        return c_worker_pool;\n    }\n\n    const c_workers = [];\n    for (let iw = 0; iw < n_workers; iw++) {\n        c_workers.push(new Worker(new URL('./ContourCreator.worker', import.meta.url)));\n    }\n\n    const pool = createWorkerPool<ContourCreatorWorker>(c_workers, wkr => wkr.init(wasm_base_url));\n    c_worker_pool = pool;\n    return pool;\n}\n\n/** Base class for all plot components */\nabstract class PlotComponent<MapType extends MapLikeType> {\n    public abstract onAdd(map: MapType, gl: WebGLAnyRenderingContext) : Promise<void>;\n    public abstract render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg) : void;\n}\n\nfunction getGLFormatTypeAlignment(gl: WebGLAnyRenderingContext, array_dtype: TypedArrayStr) {\n    let format, type, row_alignment;\n    const is_webgl2 = isWebGL2Ctx(gl);\n\n    if (array_dtype == 'float16') {\n        const ext = gl.getExtension('OES_texture_half_float');\n        const ext_lin = gl.getExtension('OES_texture_half_float_linear');\n\n        if (is_webgl2) {\n            format = gl.R16F;\n            type = gl.HALF_FLOAT;\n        }\n        else {\n            if (ext === null || ext_lin === null)\n                throw \"Float16 data are not supported on this hardware. Try Float32 data instead.\";\n\n            format = gl.LUMINANCE;\n            type = ext.HALF_FLOAT_OES;\n        }\n\n        row_alignment = 2;\n    }\n    else if (array_dtype == 'float32') {\n        const ext = gl.getExtension('OES_texture_float');\n        const ext_lin = gl.getExtension('OES_texture_float_linear');\n\n\t\t// As of 11/3/2023, Safari/WebKit on iOS reports as supporting float textures,\n\t\t// but really doesn't. It just silently fails. In WebGL 1, Safari/Webkit returns\n\t\t// null for ext_lin here, but in WebGL2, both ext vars are null because they were \n\t\t// merged into the standard. This means that to properly fail for iOS devices using\n\t\t// WebGL2, we have to hard code an OS check... this OS check also works when uers\n\t\t// request desktop-mode websites.\n\t\tif ((!is_webgl2 && ext === null) || (!is_webgl2 && ext_lin === null) || (getOS() === 'iOS')) {\t\n            throw \"Float32 data are not supported on this hardware. Try Float16 data instead.\";\n        }\n\n        format = is_webgl2 ? gl.R32F : gl.LUMINANCE;\n        type = gl.FLOAT;\n        row_alignment = 4;\n    }\n    else if (array_dtype == 'uint16') {\n        format = is_webgl2 ? gl.R16UI : gl.LUMINANCE;\n        type = gl.UNSIGNED_SHORT;\n        row_alignment = 2;\n    }\n    else if (array_dtype == 'uint32') {\n        format = is_webgl2 ? gl.R32UI : gl.LUMINANCE;\n        type = gl.UNSIGNED_INT;\n        row_alignment = 4;\n    }\n    else if (array_dtype == 'int16') {\n        format = is_webgl2 ? gl.R16I : gl.LUMINANCE;\n        type = gl.SHORT;\n        row_alignment = 2;\n    }\n    else if (array_dtype == 'int32') {\n        format = is_webgl2 ? gl.R32I : gl.LUMINANCE;\n        type = gl.INT;\n        row_alignment = 4;\n    }\n    else {\n        format = is_webgl2 ? gl.R8 : gl.LUMINANCE;\n        type = gl.UNSIGNED_BYTE;\n\n        row_alignment = 1;\n    }\n\n    return {format: format, type: type, row_alignment: row_alignment};\n}\n\nexport { PlotComponent, layer_worker, getContourWorkerPool, getGLFormatTypeAlignment };\n","\n\n// Stub in required method and property types for the mapping library. God help me if these start to diverge between Mapbox and MapLibre.\ntype StyleSpecification = {\n    glyphs?: string;\n}\n\n/** Type with the required methods for mapping libraries */\ntype MapLikeType = {\n    triggerRepaint: () => void;\n    getCanvas: () => HTMLCanvasElement;\n    getStyle: () => StyleSpecification;\n\n    getZoom: () => number;\n    getMaxZoom: () => number;\n    getBearing: () => number;\n    getPitch: () => number;\n};\n\ninterface LambertConformalConicParameters {\n    lon_0: number,\n    lat_0: number,\n    lat_std: [number, number] | number;\n    a: number;\n    b: number;\n}\n\nfunction lambertConformalConic(params: LambertConformalConicParameters) {\n    // Formulas from https://pubs.usgs.gov/pp/1395/report.pdf\n\n    const compute_t = (lat: number) => {\n        const sin_lat = Math.sin(lat);\n        return Math.tan(Math.PI / 4 - lat / 2) * Math.pow((1 + eccen * sin_lat) / (1 - eccen * sin_lat), eccen / 2);\n    };\n    const compute_m = (lat: number) => {\n        const sin_lat = Math.sin(lat);\n        return Math.cos(lat) / Math.sqrt(1 - eccen * eccen * sin_lat * sin_lat);\n    }\n\n    // WGS 84 spheroid\n    const semimajor = params.a;\n    const semiminor = params.b;\n    const eccen = Math.sqrt(1 - (semiminor * semiminor) / (semimajor * semimajor));\n    const radians = Math.PI / 180;\n\n    let {lon_0, lat_0, lat_std} = params;\n    lat_std = Array.isArray(lat_std) && lat_std[0] == lat_std[1] ? lat_std[0] : lat_std;\n\n    lon_0 *= radians;\n    lat_0 *= radians;\n\n    let F: number, n: number;\n    const t_0 = compute_t(lat_0);\n\n    if (Array.isArray(lat_std)) {\n        let [lat_1, lat_2] = lat_std;\n        lat_1 *= radians;\n        lat_2 *= radians;\n\n        const t_1 = compute_t(lat_1);\n        const t_2 = compute_t(lat_2);\n        const m_1 = compute_m(lat_1);\n        const m_2 = compute_m(lat_2);\n\n        n = Math.log(m_1 / m_2) / Math.log(t_1 / t_2);\n        F = m_1 / (n * Math.pow(t_1, n));\n    }\n    else {\n        let lat_1 = lat_std;\n        lat_1 *= radians;\n\n        const t_1 = compute_t(lat_1);\n        const m_1 = compute_m(lat_1);\n        n = Math.sin(lat_1);\n        F = m_1 / (n * Math.pow(t_1, n));\n    }\n\n    const rho_0 = semimajor * F * Math.pow(t_0, n);\n\n    const compute_lcc = (lon: number, lat: number) : [number, number] => {\n        lon *= radians;\n        lat *= radians;\n\n        const t = compute_t(lat);\n        const rho = semimajor * F * Math.pow(t, n);\n        const theta = n * (lon - lon_0);\n        const x = rho * Math.sin(theta);\n        const y = rho_0 - rho * Math.cos(theta);\n\n        return [x, y];\n    }\n\n    const eccen2 = eccen * eccen;\n    const eccen4 = eccen2 * eccen2;\n    const eccen6 = eccen4 * eccen2;\n    const eccen8 = eccen6 * eccen2;\n\n/*\n    const A = eccen2 / 2 + 5 * eccen4 / 24 + eccen6 / 12 + 13 * eccen8 / 360;\n    const B = 7 * eccen4 / 48 + 29 * eccen6 / 240 + 811 * eccen8 / 11520;\n    const C = 7 * eccen6 / 120 + 81 * eccen8 / 1120;\n    const D = 4279 * eccen8 / 161280;\n    const Ap = A - C;\n    const Bp = 2 * B - 4 * D;\n    const Cp = 4 * C;\n    const Dp = 8 * D;\n*/\n\n    const Ap = eccen2 / 2 + 5 * eccen4 / 24 + 3 * eccen6 / 120 - 73 * eccen8 / 2016;\n    const Bp = 7 * eccen4 / 24 + 29 * eccen6 / 120 + 233 * eccen8 / 6720;\n    const Cp = 7 * eccen6 / 30 + 81 * eccen8 / 280;\n    const Dp = 4729 * eccen8 / 20160;\n\n    const compute_lcc_inverse = (x: number, y: number) : [number, number] => {\n        const theta = Math.atan2(x, rho_0 - y); // These arguments are backwards from what I'd expect ...\n        const lon = theta / n + lon_0;\n        const rho = Math.hypot(x, rho_0 - y) * Math.sign(n);\n        const t = Math.pow(rho / (semimajor * F), 1 / n);\n\n        const chi = Math.PI / 2 - 2 * Math.atan(t);\n        const sin_2chi = Math.sin(2 * chi);\n        const cos_2chi = Math.cos(2 * chi);\n\n        const lat = chi + sin_2chi * (Ap + cos_2chi * (Bp + cos_2chi * (Cp + Dp * cos_2chi)));\n\n        return [lon / radians, lat / radians];\n    }\n\n    return (a: number, b: number, opts?: {inverse: boolean}) : [number, number] => {\n        opts = opts === undefined ? {inverse: false} : opts;\n        return opts.inverse ? compute_lcc_inverse(a, b) : compute_lcc(a, b);\n    }\n}\n\ninterface RotateSphereParams {\n    np_lon: number,\n    np_lat: number,\n    lon_shift: number,\n}\n\nfunction rotateSphere(params: RotateSphereParams) {\n    const radians = Math.PI / 180;\n    const np_lat = params.np_lat * radians;\n    const np_lon = params.np_lon * radians;\n    const lon_shift = params.lon_shift * radians;\n\n    const sin_np_lat = Math.sin(np_lat);\n    const cos_np_lat = Math.cos(np_lat);\n\n    const compute_rotation = (lon: number, lat: number) : [number, number] => {\n        lon *= radians;\n        lat *= radians;\n\n        const sin_lat = Math.sin(lat);\n        const cos_lat = Math.cos(lat);\n        const sin_lon_diff = Math.sin(lon - lon_shift);\n        const cos_lon_diff = Math.cos(lon - lon_shift);\n\n        const lat_p = Math.asin(sin_np_lat * sin_lat - cos_np_lat * cos_lat * cos_lon_diff);\n        let lon_p = np_lon + Math.atan2((cos_lat * sin_lon_diff), (sin_np_lat * cos_lat * cos_lon_diff + cos_np_lat * sin_lat));\n\n        if (lon_p > Math.PI) lon_p -= 2 * Math.PI;\n\n        return [lon_p / radians, lat_p / radians];\n    }\n\n    const compute_rotation_inverse = (lon_p: number, lat_p: number) : [number, number] => {\n        lon_p *= radians;\n        lat_p *= radians;\n\n        const sin_lat_p = Math.sin(lat_p);\n        const cos_lat_p = Math.cos(lat_p);\n        const sin_lon_p_diff = Math.sin(lon_p - np_lon);\n        const cos_lon_p_diff = Math.cos(lon_p - np_lon);\n\n        const lat = Math.asin(sin_np_lat * sin_lat_p + cos_np_lat * cos_lat_p * cos_lon_p_diff);\n        let lon = lon_shift + Math.atan2((cos_lat_p * sin_lon_p_diff), (sin_np_lat * cos_lat_p * cos_lon_p_diff - cos_np_lat * sin_lat_p));\n\n        if (lon_p > Math.PI) lon_p -= 2 * Math.PI;\n\n        return [lon / radians, lat / radians];\n    }\n\n    return (a: number, b: number, opts?: {inverse: boolean}) => {\n        opts = opts === undefined ? {inverse: false} : opts;\n        return opts.inverse ? compute_rotation_inverse(a, b) : compute_rotation(a, b);\n    }\n}\n\n// interface VerticalPerspectiveParams {\n//     lat_0: number,\n//     lon_0: number,\n//     alt: number,\n//     a: number,\n//     b: number,\n// }\n\n// function verticalPerspective(params: VerticalPerspectiveParams) {\n//     // WGS 84 spheroid\n//     const semimajor = params.a;\n//     const semiminor = params.b;\n//     const eccen = Math.sqrt(1 - (semiminor * semiminor) / (semimajor * semimajor));\n//     const radians = Math.PI / 180;\n\n//     let {lat_0, lon_0, alt} = params;\n//     const alt_0 = 0;\n//     const alt_00 = 0;\n//     const eccen2 = eccen * eccen;\n\n//     lat_0 *= radians;\n//     lon_0 *= radians;\n\n//     const sin_lat_0 = Math.sin(lat_0);\n//     const cos_lat_0 = Math.cos(lat_0);\n\n//     const N1 = semimajor / Math.sqrt(1 - (eccen * sin_lat_0) ** 2);\n//     let lat_g = lat_0, P = 0;\n\n//     for (let i = 0; i < 3; i++) {\n//         P = Math.cos(lat_0) / Math.cos(lat_g) * (alt + N1 + alt_00) / semimajor;\n//         lat_g = lat_0 - Math.asin(N1 * eccen * eccen * sin_lat_0 * cos_lat_0 / (P * semimajor));\n//     }\n\n//     const compute_perspective = (lon: number, lat: number) : [number, number] => {\n//         lon *= radians;\n//         lat *= radians;\n\n//         const sin_lat = Math.sin(lat);\n//         const cos_lat = Math.cos(lat);\n\n//         const N = semimajor / Math.sqrt(1 - (eccen * sin_lat) ** 2);\n//         const C = (N + alt_0) / semimajor * cos_lat;\n//         const S = ((N * (1 - eccen * eccen) + alt_0) / semimajor) * sin_lat;\n//         const K = alt / (P * Math.cos(lat_0 - lat_g) - S * sin_lat_0 - C * cos_lat_0 * Math.cos(lon - lon_0));\n//         const x = K * C * Math.sin(lon - lon_0);\n//         const y = K * (P * Math.sin(lat_0 - lat_g) + S * cos_lat_0 - C * sin_lat_0 * Math.cos(lon - lon_0));\n\n//         return [x, y];\n//     }\n\n//     const B = P * Math.cos(lat_0 - lat_g);\n//     const D = P * Math.sin(lat_0 - lat_g);\n//     const L = 1 - eccen2 * cos_lat_0 * cos_lat_0;\n//     const G = 1 - eccen2 * sin_lat_0 * sin_lat_0;\n//     const J = 2 * eccen2 * sin_lat_0 * cos_lat_0;\n//     const E = 1; // If alt_0 = 0, set E = 1\n//     const t = P * P * (1 - (eccen * Math.cos(lat_g)) ** 2) - E * (1 - eccen2);\n\n//     const compute_perspective_inverse = (x: number, y: number) : [number, number] => {\n//         const u = -2 * B * L * alt - 2 * D * G * y + B * J * y + D * J * alt;\n//         const v = L * alt * alt + G * y * y - alt * J * y + (1 - eccen2) * x * x;\n//         const K_prime = (-u + Math.sqrt(u * u - 4 * t * v)) / (2 * t);\n//         const X = semimajor * ((B - alt / K_prime) * cos_lat_0 - (y / K_prime - D) * sin_lat_0);\n//         const Y = semimajor * x / K_prime;\n//         const S = (y / K_prime - D) * cos_lat_0 + (B - alt / K_prime) * sin_lat_0;\n//         const lon = lon_0 + Math.atan2(Y, X);\n//         const lat = Math.atan2(S, Math.sqrt((1 - eccen2) * (1 - eccen2 - S * S)));\n\n//         return [lon / radians, lat / radians];\n//     }\n\n//     return (a: number, b: number, opts?: {inverse: boolean}) => {\n//         opts = opts === undefined ? {inverse: false} : opts;\n//         return opts.inverse ? compute_perspective_inverse(a, b) : compute_perspective(a, b);\n//     }\n// }\n\ninterface GeostationaryProjectionParams {\n    lon_0: number,\n    alt: number,\n    a: number,\n    b: number,\n}\n\n// Changes to the geostationaryProjection to make sure the coastlines and satellite line up\nfunction geostationaryProjection(params: GeostationaryProjectionParams) {\n\n    const radians = Math.PI / 180;\n\n    const { lon_0, alt, a, b } = params;\n    const lambda_0 = lon_0 * radians;\n\n    const a2 = a * a;\n    const b2 = b * b;\n\n    const forward = (lon: number, lat: number): [number, number] => {\n        lon *= radians;\n        lat *= radians;\n\n        const cos_lat = Math.cos(lat);\n        const sin_lat = Math.sin(lat);\n        const cos_lon = Math.cos(lon - lambda_0);\n        const sin_lon = Math.sin(lon - lambda_0);\n\n        const rc = b / Math.sqrt(1 - (1 - (b2 / a2)) * cos_lat * cos_lat);\n\n        const sx = rc * cos_lat * cos_lon;\n        const sy = rc * cos_lat * sin_lon;\n        const sz = rc * sin_lat;\n\n        const x = Math.atan(-sy / (alt - sx));\n        const y = Math.atan(sz / Math.sqrt((alt - sx) * (alt - sx) + sy * sy));\n\n        return [x, y];\n    };\n\n    const inverse = (x: number, y: number): [number, number] => {\n        // x = E-W scan angle (radians), y = N-S scan angle (radians)\n        // GOES-R PUG-L1B-vol3 Section 4.2 / Table 4.2.8-1\n        const sin_x = Math.sin(x);\n        const cos_x = Math.cos(x);\n        const sin_y = Math.sin(y);\n        const cos_y = Math.cos(y);\n\n        const a_var = sin_x * sin_x + cos_x * cos_x * (cos_y * cos_y + (a2 / b2) * sin_y * sin_y);\n        const b_var = -2 * alt * cos_x * cos_y;\n        const c_var = alt * alt - a2;\n\n        const disc = b_var * b_var - 4 * a_var * c_var;\n        if (disc < 0) return [NaN, NaN];   // off-Earth scan angle\n\n        const rs = (-b_var - Math.sqrt(disc)) / (2 * a_var);\n\n        const sx = rs * cos_x * cos_y;\n        const sy = -rs * sin_x;              // no cos_y factor\n        const sz =  rs * cos_x * sin_y;     // needs cos_x factor\n\n        const lon = lambda_0 - Math.atan(sy / (alt - sx));\n        const lat = Math.atan((a2 / b2) * (sz / Math.sqrt((alt - sx) * (alt - sx) + sy * sy)));\n\n        return [lon / radians, lat / radians];\n    };\n\n    return (a: number, b: number, opts?: {inverse: boolean}) => {\n        return opts?.inverse ? inverse(a, b) : forward(a, b);\n    };\n}\n\nfunction mercatorXfromLng(lng: number) {\n    return (180 + lng) / 360;\n}\n\nfunction lngFromMercatorX(x: number) {\n    return 360 * x - 180;\n}\n\nfunction mercatorYfromLat(lat: number) {\n    const sin_lat = Math.sin(lat * Math.PI / 180);\n    const y = (180 - (90 / Math.PI * Math.log((1 + sin_lat) / (1 - sin_lat)))) / 360;\n    return Math.min(1.5, Math.max(-0.5, y));\n}\n\nfunction latFromMercatorY(y: number) {\n    return Math.atan(Math.sinh((180 - y * 360) * Math.PI / 180)) * 180 / Math.PI;\n}\n\n/**\n * A `LngLat` object represents a given longitude and latitude coordinate, measured in degrees.\n * These coordinates are based on the [WGS84 (EPSG:4326) standard](https://en.wikipedia.org/wiki/World_Geodetic_System#WGS84).\n *\n * MapLibre GL uses longitude, latitude coordinate order (as opposed to latitude, longitude) to match the\n * [GeoJSON specification](https://tools.ietf.org/html/rfc7946).\n *\n * @param {number} lng Longitude, measured in degrees.\n * @param {number} lat Latitude, measured in degrees.\n * @example\n * var ll = new LngLat(-123.9749, 40.7736);\n * ll.lng; // = -123.9749\n */\n class LngLat {\n    public lng: number;\n    public lat: number;\n\n    constructor(lng: number, lat: number) {\n        if (isNaN(lng) || isNaN(lat)) {\n            this.lng = NaN;\n            this.lat = NaN;\n        }\n        else {\n            this.lng = +lng;\n            this.lat = +lat;\n            if (this.lat > 90 || this.lat < -90) {\n                throw new Error('Invalid LngLat latitude value: must be between -90 and 90');\n            }\n        }\n    }\n\n    public toMercatorCoord() {\n        if (isNaN(this.lng) || isNaN(this.lng)) return {x: NaN, y: NaN};\n\n        return {x: mercatorXfromLng(this.lng), y: mercatorYfromLat(this.lat)};\n    }\n\n    public static fromMercatorCoord(x: number, y: number) {\n        if (isNaN(x) || isNaN(y)) return new LngLat(NaN, NaN);\n\n        return new LngLat(lngFromMercatorX(x), latFromMercatorY(y));\n    }\n}\n\nexport {LngLat, lambertConformalConic, rotateSphere, geostationaryProjection};\nexport type {MapLikeType};","function isWebGL2Ctx(gl) {\n    return gl.getParameter(gl.VERSION).includes('WebGL 2.0');\n}\nexport { isWebGL2Ctx };\n","/**\n * @module wgl/WebGLBuffer\n * Module containing a helper class for WebGL data buffers\n */\nconst getGLDtype = (gl, ary) => {\n    const DTYPES = {\n        'Float32Array': gl.FLOAT,\n        'Uint8Array': gl.UNSIGNED_BYTE,\n        'Uint16Array': gl.UNSIGNED_SHORT,\n        'Uint32Array': gl.UNSIGNED_INT,\n    };\n    return DTYPES[ary.constructor.name];\n};\nimport { isWebGL2Ctx } from \"./utils\";\nclass WGLBufferBase {\n    constructor(gl, verts, n_coords_per_vert, draw_mode, bind_target, usage) {\n        this.gl = gl;\n        this.n_coords_per_vert = n_coords_per_vert;\n        this.dtype = getGLDtype(gl, verts);\n        this.n_verts = verts.length / n_coords_per_vert;\n        this.draw_mode = draw_mode;\n        const buffer = gl.createBuffer();\n        if (buffer === null) {\n            throw \"Could not create WebGL buffer\";\n        }\n        this.buffer = buffer;\n        gl.bindBuffer(bind_target, this.buffer);\n        gl.bufferData(bind_target, verts, usage);\n    }\n    getDataSync() {\n        const gl = this.gl;\n        if (!isWebGL2Ctx(gl))\n            throw 'getDataSync() needs webgl2';\n        const view = new Float32Array(this.n_verts * this.n_coords_per_vert);\n        gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer);\n        gl.getBufferSubData(gl.ARRAY_BUFFER, 0, view);\n        return view;\n    }\n}\n/** A class representing a WebGL data buffer */\nclass WGLBuffer extends WGLBufferBase {\n    /**\n     * Create a WebGL buffer and put some data in it\n     * @param gl                 - The WebGL rendering context\n     * @param verts              - The vertex data to use for this buffer\n     * @param n_coords_per_vert  - The number of coordinates for each vertex in the data buffer\n     * @param draw_mode          - The draw mode to use for this buffer. Should be one of gl.TRIANGLE_STRIP, etc.\n     */\n    constructor(gl, verts, n_coords_per_vert, draw_mode, opts) {\n        opts = opts === undefined ? {} : opts;\n        const usage = opts.usage === undefined ? gl.STATIC_DRAW : opts.usage;\n        super(gl, verts, n_coords_per_vert, draw_mode, gl.ARRAY_BUFFER, usage);\n        this.is_per_instance = opts.per_instance === undefined ? false : opts.per_instance;\n        // Cache which version of the function to use, avoiding running gl.getParameter in the render loop\n        if (isWebGL2Ctx(this.gl)) {\n            this.vadFunc = this.gl.vertexAttribDivisor.bind(this.gl);\n        }\n        else {\n            const ext = this.gl.getExtension(\"ANGLE_instanced_arrays\");\n            this.vadFunc = ext.vertexAttribDivisorANGLE.bind(ext);\n        }\n    }\n    setPerInstance(per_instance) {\n        this.is_per_instance = per_instance;\n    }\n    /**\n     * Bind this buffer to a location in a shader program\n     * @internal\n     * @param prog_attr_location - The location of the variable in the shader program (returned from gl.getAttribLocation())\n     */\n    bindToProgram(prog_attr_location) {\n        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.buffer);\n        this.gl.enableVertexAttribArray(prog_attr_location);\n        this.gl.vertexAttribPointer(prog_attr_location, this.n_coords_per_vert, this.dtype, false, 0, 0);\n        const instance_skip = this.is_per_instance ? 1 : 0;\n        this.vadFunc(prog_attr_location, instance_skip);\n    }\n    bindToTransformFeedback(feedback) {\n        // Need to do this check at initialization time\n        if (isWebGL2Ctx(this.gl)) {\n            this.gl.bindTransformFeedback(this.gl.TRANSFORM_FEEDBACK, feedback === undefined ? null : feedback);\n            this.gl.bindBufferBase(this.gl.TRANSFORM_FEEDBACK_BUFFER, 0, this.buffer);\n        }\n        else {\n            throw `Transform feedbacks are a webgl2-only function`;\n        }\n    }\n}\n/** A class representing a WebGL data buffer for array indices */\nclass WGLIndexBuffer extends WGLBufferBase {\n    /**\n     *\n     * @param gl         - The WebGL rendering context\n     * @param indices    - The index data\n     * @param draw_mode  - The draw mode to use for this buffer. Should be one of gl.TRIANGLE_STRIP, etc.\n     */\n    constructor(gl, indices, draw_mode) {\n        super(gl, indices, 1, draw_mode, gl.ELEMENT_ARRAY_BUFFER, gl.STATIC_DRAW);\n    }\n    /**\n     * Bind this buffer to the ELEMENT_ARRAY_BUFFER target\n     * @internal\n     */\n    bind() {\n        this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, this.buffer);\n    }\n}\nexport { WGLBuffer, WGLIndexBuffer };\n","/**\n * @module wgl/WebGLTexture\n * A module containing a helper class for WebGL textures\n */\nimport { isWebGL2Ctx } from \"./utils\";\nfunction isRawImageTextureSpec(obj) {\n    return 'width' in obj && 'height' in obj;\n}\nfunction getWebGL2Format(gl, internal_format, data_type) {\n    switch (data_type) {\n        case (gl.UNSIGNED_BYTE):\n            switch (internal_format) {\n                case (gl.RGBA8): return gl.RGBA;\n                case (gl.RGB5_A1): return gl.RGBA;\n                case (gl.RGBA4): return gl.RGBA;\n                case (gl.SRGB8_ALPHA8): return gl.RGBA;\n                case (gl.RGBA8UI): return gl.RGBA_INTEGER;\n                case (gl.RGB8): return gl.RGB;\n                case (gl.RGB565): return gl.RGB;\n                case (gl.SRGB8): return gl.RGB;\n                case (gl.RGB8UI): return gl.RGB_INTEGER;\n                case (gl.RG8): return gl.RG;\n                case (gl.RG8UI): return gl.RG_INTEGER;\n                case (gl.R8): return gl.RED;\n                case (gl.R8UI): return gl.RED_INTEGER;\n                case (gl.RGBA): return gl.RGBA;\n                case (gl.RGB): return gl.RGB;\n                case (gl.LUMINANCE_ALPHA): return gl.LUMINANCE_ALPHA;\n                case (gl.LUMINANCE): return gl.LUMINANCE;\n                case (gl.ALPHA): return gl.ALPHA;\n            }\n            break;\n        case (gl.BYTE):\n            switch (internal_format) {\n                case (gl.RGBA8_SNORM): return gl.RGBA;\n                case (gl.RGBA8I): return gl.RGBA_INTEGER;\n                case (gl.RGB8_SNORM): return gl.RGB;\n                case (gl.RGB8I): return gl.RGB_INTEGER;\n                case (gl.RG8_SNORM): return gl.RG;\n                case (gl.RG8I): return gl.RG_INTEGER;\n                case (gl.R8_SNORM): return gl.RED;\n                case (gl.R8I): return gl.RED_INTEGER;\n            }\n            break;\n        case (gl.UNSIGNED_SHORT_4_4_4_4):\n            switch (internal_format) {\n                case (gl.RGBA4): return gl.RGBA;\n                case (gl.RGBA): return gl.RGBA;\n            }\n            break;\n        case (gl.UNSIGNED_SHORT_5_5_5_1):\n            switch (internal_format) {\n                case (gl.RGB5_A1): return gl.RGBA;\n                case (gl.RGBA): return gl.RGBA;\n            }\n            break;\n        case (gl.UNSIGNED_INT_2_10_10_10_REV):\n            switch (internal_format) {\n                case (gl.RGB10_A2): return gl.RGBA;\n                case (gl.RGB5_A1): return gl.RGBA;\n                case (gl.RGB10_A2UI): return gl.RGBA_INTEGER;\n            }\n            break;\n        case (gl.HALF_FLOAT):\n            switch (internal_format) {\n                case (gl.RGBA16F): return gl.RGBA;\n                case (gl.RGB16F): return gl.RGB;\n                case (gl.R11F_G11F_B10F): return gl.RGB;\n                case (gl.RGB9_E5): return gl.RGB;\n                case (gl.RG16F): return gl.RG;\n                case (gl.R16F): return gl.RED;\n            }\n            break;\n        case (gl.FLOAT):\n            switch (internal_format) {\n                case (gl.RGBA32F): return gl.RGBA;\n                case (gl.RGBA16F): return gl.RGBA;\n                case (gl.RGB32F): return gl.RGB;\n                case (gl.RGB16F): return gl.RGB;\n                case (gl.R11F_G11F_B10F): return gl.RGB;\n                case (gl.RGB9_E5): return gl.RGB;\n                case (gl.RG32F): return gl.RG;\n                case (gl.RG16F): return gl.RG;\n                case (gl.R32F): return gl.RED;\n                case (gl.R16F): return gl.RED;\n                case (gl.DEPTH_COMPONENT32F): return gl.DEPTH_COMPONENT;\n            }\n            break;\n        case (gl.UNSIGNED_SHORT):\n            switch (internal_format) {\n                case (gl.RGBA16UI): return gl.RGBA_INTEGER;\n                case (gl.RGB16UI): return gl.RGB_INTEGER;\n                case (gl.RG16UI): return gl.RG_INTEGER;\n                case (gl.R16UI): return gl.RED_INTEGER;\n                case (gl.DEPTH_COMPONENT16): return gl.DEPTH_COMPONENT;\n            }\n            break;\n        case (gl.SHORT):\n            switch (internal_format) {\n                case (gl.RGBA16I): return gl.RGBA_INTEGER;\n                case (gl.RGB16I): return gl.RGB_INTEGER;\n                case (gl.RG16I): return gl.RG_INTEGER;\n                case (gl.R16I): return gl.RED_INTEGER;\n            }\n            break;\n        case (gl.UNSIGNED_INT):\n            switch (internal_format) {\n                case (gl.RGBA32UI): return gl.RGBA_INTEGER;\n                case (gl.RGB32UI): return gl.RGB_INTEGER;\n                case (gl.RG32UI): return gl.RG_INTEGER;\n                case (gl.R32UI): return gl.RED_INTEGER;\n                case (gl.DEPTH_COMPONENT24): return gl.DEPTH_COMPONENT;\n                case (gl.DEPTH_COMPONENT16): return gl.DEPTH_COMPONENT;\n            }\n            break;\n        case (gl.INT):\n            switch (internal_format) {\n                case (gl.RGBA32I): return gl.RGBA_INTEGER;\n                case (gl.RGB32I): return gl.RGB_INTEGER;\n                case (gl.RG32I): return gl.RG_INTEGER;\n                case (gl.R32I): return gl.RED_INTEGER;\n            }\n            break;\n        case (gl.UNSIGNED_SHORT_5_6_5):\n            switch (internal_format) {\n                case (gl.RGB565): return gl.RGB;\n                case (gl.RGB): return gl.RGB;\n            }\n            break;\n        case (gl.UNSIGNED_INT_10F_11F_11F_REV):\n            switch (internal_format) {\n                case (gl.R11F_G11F_B10F): return gl.RGB;\n            }\n            break;\n        case (gl.UNSIGNED_INT_5_9_9_9_REV):\n            switch (internal_format) {\n                case (gl.RGB9_E5): return gl.RGB;\n            }\n            break;\n        case (gl.UNSIGNED_INT_24_8):\n            switch (internal_format) {\n                case (gl.DEPTH24_STENCIL8): return gl.DEPTH_STENCIL;\n            }\n            break;\n        case (gl.FLOAT_32_UNSIGNED_INT_24_8_REV):\n            switch (internal_format) {\n                case (gl.DEPTH32F_STENCIL8): return gl.DEPTH_STENCIL;\n            }\n            break;\n        default:\n            throw `Unknown format in getWebGL2InternalFormat`;\n    }\n    throw `Invalid combination of internal format and data type`;\n}\n/** Class representing a WebGL texture */\nclass WGLTexture {\n    /**\n     *\n     * @param gl               - The WebGL rendering context\n     * @param image            - The specification for the image\n     * @param image.format     - The format for the image (e.g., which color channels are present?). Should be one of gl.RGBA, gl.RGB, etc.\n     * @param image.type       - The data type for the image. Should be one of gl.FLOAT, gl.UNSIGNED_BYTE, etc.\n     * @param image.width      - The width of the texture\n     * @param image.height     - The height of the texture\n     * @param image.mag_filter - The magnification filter to use for the texture. Should be one of gl.LINEAR, gl.NEAREST, etc.\n     * @param image.image      - The image to use for the texture. Can be null to allocate space without filling it.\n     */\n    constructor(gl, image) {\n        this.gl = gl;\n        const texture = gl.createTexture();\n        if (texture === null) {\n            throw \"Could not create WebGL texture\";\n        }\n        this.texture = texture;\n        this.tex_num = null;\n        this.setImageData(image);\n        const mag_filter = image['mag_filter'] === undefined ? gl.LINEAR : image['mag_filter'];\n        const min_filter = image['min_filter'] === undefined ? gl.LINEAR : image['min_filter'];\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, min_filter);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, mag_filter);\n    }\n    /**\n     * Set image data in this texture\n     * @param image        - The specification for the image\n     * @param image.format - The format for the image (e.g., which color channels are present?). Should be one of gl.RGBA, gl.RGB, etc.\n     * @param image.type   - The data type for the image. Should be one of gl.FLOAT, gl.UNSIGNED_BYTE, etc.\n     * @param image.width  - The width of the texture\n     * @param image.height - The height of the texture\n     * @param image.image  - The image to use for the texture. Can be null to allocate space without filling it.\n     */\n    setImageData(image) {\n        const gl = this.gl;\n        this.spec = image;\n        gl.bindTexture(gl.TEXTURE_2D, this.texture);\n        const format = isWebGL2Ctx(gl) ? getWebGL2Format(gl, image['format'], image['type']) : image['format'];\n        const row_alignment = image['row_alignment'] === undefined ? 4 : image['row_alignment'];\n        gl.pixelStorei(gl.UNPACK_ALIGNMENT, row_alignment);\n        if (isRawImageTextureSpec(image)) {\n            gl.texImage2D(gl.TEXTURE_2D, 0, image['format'], image['width'], image['height'], 0, format, image['type'], image['image']);\n        }\n        else {\n            gl.texImage2D(gl.TEXTURE_2D, 0, image['format'], format, image['type'], image['image']);\n        }\n    }\n    /**\n     * Bind this texture to a location in a shader program\n     * @internal\n     * @param prog_uni_location - The location of the sampler uniform value (returned from gl.getUniform()) in the shader program.\n     * @param gl_tex_num        - The texture number to bind this texture to.\n     */\n    bindToProgram(prog_uni_location, gl_tex_num) {\n        this.activate(gl_tex_num);\n        this.gl.uniform1i(prog_uni_location, gl_tex_num);\n    }\n    /**\n     * Bind this texture to a given texture number\n     * @param gl_tex_num - The texture number to bind this texture to.\n     */\n    activate(gl_tex_num) {\n        this.tex_num = gl_tex_num;\n        this.gl.activeTexture(this.gl.TEXTURE0 + this.tex_num);\n        this.gl.bindTexture(this.gl.TEXTURE_2D, this.texture);\n    }\n    /**\n     * Unbind this texture from the texture number it was most recently bound to.\n     */\n    deactivate() {\n        if (this.tex_num === null) {\n            return;\n        }\n        this.gl.activeTexture(this.gl.TEXTURE0 + this.tex_num);\n        this.gl.bindTexture(this.gl.TEXTURE_2D, null);\n        this.tex_num = null;\n    }\n    /**\n     * Delete this texture.\n     */\n    delete() {\n        this.gl.deleteTexture(this.texture);\n        this.tex_num = null;\n    }\n}\nexport { WGLTexture };\n","import { isWebGL2Ctx } from \"./utils\";\n/**\n * @module wgl/WebGLProgram\n * Module containing a helper class for WebGL programs\n */\nfunction preprocessShader(shader_src, opts) {\n    opts = opts === undefined ? {} : opts;\n    const defines = opts.define === undefined ? [] : [...opts.define];\n    const current_defines = [];\n    const define_truth = {};\n    const processed_shader_src = shader_src.split(\"\\n\").map(line => {\n        const match_define = line.match(/#define\\s+([\\w\\d_]+)/i);\n        if (match_define !== null) {\n            defines.push(match_define[1]);\n        }\n        const match_ifdef = line.match(/#ifdef\\s+([\\w\\d_]+)/i);\n        if (match_ifdef !== null) {\n            current_defines.push(match_ifdef[1]);\n            define_truth[match_ifdef[1]] = true;\n            return \"\";\n        }\n        const match_ifndef = line.match(/#ifndef\\s+([\\w\\d_]+)/i);\n        if (match_ifndef !== null) {\n            current_defines.push(match_ifndef[1]);\n            define_truth[match_ifndef[1]] = false;\n            return \"\";\n        }\n        const match_else = line.match(/#else/i);\n        if (match_else !== null) {\n            const def = current_defines[current_defines.length - 1];\n            define_truth[def] = !define_truth[def];\n            return \"\";\n        }\n        const match_endif = line.match(/#endif/i);\n        if (match_endif !== null) {\n            const def = current_defines.pop();\n            define_truth[def] = undefined;\n            return \"\";\n        }\n        const keep_line = current_defines.map(def => defines.includes(def) == define_truth[def]).reduce((a, b) => a && b, true);\n        return keep_line ? line : \"\";\n    }).join(\"\\n\");\n    if (current_defines.length > 0) {\n        throw `Unterminated #ifdef/#ifndef block in shader`;\n    }\n    return processed_shader_src;\n}\n/**\n * Compile and link a shader program\n * @param gl                - The WebGL rendering context\n * @param vertex_shader_src - The source code for the vertex shader\n * @param frag_shader_src   - The source code for the fragment shader\n * @returns                   A compiled and linked WebGL program\n */\nconst compileAndLinkShaders = (gl, vertex_shader_src, frag_shader_src, tf_varyings) => {\n    // create a vertex shader\n    const vertexShader = gl.createShader(gl.VERTEX_SHADER);\n    if (vertexShader === null) {\n        throw \"Could not create vertex shader\";\n    }\n    gl.shaderSource(vertexShader, vertex_shader_src);\n    gl.compileShader(vertexShader);\n    const vertexCompiled = gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS);\n    if (!vertexCompiled) {\n        const compilationLog = gl.getShaderInfoLog(vertexShader);\n        console.log('Vertex shader compiler log: ' + compilationLog);\n    }\n    // create a fragment shader\n    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);\n    if (fragmentShader === null) {\n        throw \"Could not create fragment shader\";\n    }\n    gl.shaderSource(fragmentShader, frag_shader_src);\n    gl.compileShader(fragmentShader);\n    const fragmentCompiled = gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS);\n    if (!fragmentCompiled) {\n        const compilationLog = gl.getShaderInfoLog(fragmentShader);\n        console.log('Fragment shader compiler log: ' + compilationLog);\n    }\n    // link the two shaders into a WebGL program\n    const program = gl.createProgram();\n    if (program === null) {\n        throw \"Could not create shader program\";\n    }\n    gl.attachShader(program, vertexShader);\n    gl.attachShader(program, fragmentShader);\n    if (tf_varyings !== null) {\n        if (isWebGL2Ctx(gl)) {\n            gl.transformFeedbackVaryings(program, tf_varyings, gl.INTERLEAVED_ATTRIBS);\n        }\n        else {\n            throw `Transform feedback only supported in WebGL2`;\n        }\n    }\n    gl.linkProgram(program);\n    const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n    if (!linked) {\n        const linkLog = gl.getProgramInfoLog(program);\n        console.log('Linker log: ' + linkLog);\n    }\n    return program;\n};\n/** Class representing a WebGL shader program */\nclass WGLProgram {\n    /**\n     * Create and compile a shader program from source\n     * @param gl                  - The WebGL rendering context\n     * @param vertex_shader_src   - The vertex shader source code\n     * @param fragment_shader_src - The fragment shader source code\n     * @param opts.define         - Preprocessor macros to define (like -D when running gcc)\n     */\n    constructor(gl, vertex_shader_src, fragment_shader_src, opts) {\n        opts = opts === undefined ? {} : opts;\n        const defines = opts.define === undefined ? [] : opts.define;\n        const tf_varyings = opts.tf_varyings === undefined ? null : opts.tf_varyings;\n        vertex_shader_src = preprocessShader(vertex_shader_src, { define: defines });\n        fragment_shader_src = preprocessShader(fragment_shader_src, { define: defines });\n        this.gl = gl;\n        this.prog = compileAndLinkShaders(gl, vertex_shader_src, fragment_shader_src, tf_varyings);\n        this.attributes = {};\n        this.uniforms = {};\n        this.n_verts = null;\n        this.draw_mode = null;\n        this.index_buffer = null;\n        this.sampler_names = [];\n        this.instance_count = 0;\n        const remove_comments = (line) => {\n            const comment_idx = line.indexOf('//');\n            if (comment_idx >= 0) {\n                line = line.slice(0, comment_idx);\n            }\n            return line;\n        };\n        vertex_shader_src = vertex_shader_src.split('\\n').map(remove_comments).join('\\n');\n        fragment_shader_src = fragment_shader_src.split('\\n').map(remove_comments).join('\\n');\n        // safety check the vertex shader source\n        const is_webgl2 = isWebGL2Ctx(this.gl);\n        if (!is_webgl2 &&\n            (vertex_shader_src.includes('#version 300 es') || fragment_shader_src.includes('#version 300 es'))) {\n            throw `WebGL2 context required for shader source containing '#version 300 es'`;\n        }\n        // in WebGL2 shaders (gl 300 es), attribute just become the keyword 'in'\n        let vtx_shader_match = is_webgl2 ?\n            /\\b(?:in|attribute)+([\\w ]+?) +([\\w_]+);[\\s]*/mg : /attribute +([\\w ]+?) +([\\w_]+);[\\s]*/mg;\n        for (const match of vertex_shader_src.matchAll(vtx_shader_match)) {\n            const [full_match, type, a_name] = match;\n            this.attributes[a_name] = { 'type': type, 'location': gl.getAttribLocation(this.prog, a_name) };\n        }\n        for (const match of vertex_shader_src.matchAll(/uniform +([\\w ]+?) +([\\w_]+)(?:[\\s]*\\[.*\\])?;[\\s]*/mg)) {\n            const [full_match, type, u_name] = match;\n            const type_parts = type.split(' ');\n            const uniform_loc = gl.getUniformLocation(this.prog, u_name);\n            if (uniform_loc === null) {\n                throw `Could not get vertex shader uniform location for '${u_name}'`;\n            }\n            this.uniforms[u_name] = { 'type': type_parts[type_parts.length - 1], 'location': uniform_loc };\n        }\n        for (const match of fragment_shader_src.matchAll(/uniform +([\\w ]+?) +([\\w_]+)(?:[\\s]*\\[.*\\])?;[\\s]*/mg)) {\n            const [full_match, type, u_name] = match;\n            const type_parts = type.split(' ');\n            const uniform_loc = gl.getUniformLocation(this.prog, u_name);\n            if (uniform_loc === null) {\n                throw `Could not get fragment shader uniform location for '${u_name}'`;\n            }\n            this.uniforms[u_name] = { 'type': type_parts[type_parts.length - 1], 'location': uniform_loc };\n        }\n        Object.entries(this.uniforms).forEach(([u_name, uniform]) => {\n            if (uniform.type.toLowerCase().endsWith('sampler2d')) {\n                this.sampler_names.push(u_name);\n            }\n        });\n        // Cache which version of the functions to use, avoiding running gl.getParameter in the render loop\n        if (isWebGL2Ctx(this.gl)) {\n            this.daiFunc = this.gl.drawArraysInstanced.bind(this.gl);\n            this.deiFunc = this.gl.drawElementsInstanced.bind(this.gl);\n        }\n        else {\n            const ext = this.gl.getExtension(\"ANGLE_instanced_arrays\");\n            this.daiFunc = ext.drawArraysInstancedANGLE.bind(ext);\n            this.deiFunc = ext.drawElementsInstancedANGLE.bind(ext);\n        }\n    }\n    /**\n     * Enable this program for rendering and optionally bind attribute, uniform, and texture values. This function should be called before calling\n     * {@link WGLProgram.bindAttributes}, {@link WGLProgram.setUniforms}, or {@link WGLProgram.bindTextures} on a given rendering pass.\n     * @param attribute_buffers - An object with the keys being the attribute variable names and the values being the buffers to associate with each variable\n     * @param uniform_values    - An object with the keys being the uniform variable names and the values being the uniform values\n     * @param textures          - An object with the keys being the sampler names in the source code and the values being the textures to associate with each sampler\n     * @param index_buffer      - A WGLIndexBuffer specifying which indices to draw in which order\n     */\n    use(attribute_buffers, uniform_values, textures, index_buffer) {\n        this.gl.useProgram(this.prog);\n        if (index_buffer !== undefined) {\n            index_buffer.bind();\n            this.index_buffer = index_buffer;\n        }\n        else {\n            this.index_buffer = null;\n        }\n        this.draw_mode = null;\n        this.n_verts = null;\n        this.instance_count = 0;\n        if (attribute_buffers !== undefined) {\n            this.bindAttributes(attribute_buffers);\n        }\n        if (uniform_values !== undefined) {\n            this.setUniforms(uniform_values);\n        }\n        if (textures !== undefined) {\n            this.bindTextures(textures);\n        }\n    }\n    /**\n     * Bind attribute buffers to variables in this shader program. When rendring, call {@link WGLProgram.use} before calling this function.\n     * @param attribute_buffers - An object with the keys being the attribute variable names and the values being the buffers to associate with each variable\n     */\n    bindAttributes(attribute_buffers) {\n        Object.entries(attribute_buffers).forEach(([a_name, buffer]) => {\n            if (this.attributes[a_name] === undefined) {\n                console.warn(`Skipping attribute buffer provided for '${a_name}' because the attribute was not found in the program.`);\n                return;\n            }\n            this.draw_mode = this.draw_mode === null ? buffer.draw_mode : this.draw_mode;\n            if (buffer.is_per_instance) {\n                if (this.instance_count == 0) {\n                    this.instance_count = buffer.n_verts;\n                }\n                else if (this.instance_count != buffer.n_verts) {\n                    throw `Unexpected number of instances for attribute buffer ${a_name} (expected ${this.instance_count}, got ${buffer.n_verts})`;\n                }\n            }\n            else {\n                this.n_verts = this.n_verts === null ? buffer.n_verts : this.n_verts;\n                if (this.n_verts != buffer.n_verts) {\n                    throw `Unexpected number of vertices for attribute buffer ${a_name} (expected ${this.n_verts}, got ${buffer.n_verts}).`;\n                }\n                if (this.draw_mode != buffer.draw_mode) {\n                    throw `Unexpected draw mode for attribute buffer ${a_name} (expected ${this.draw_mode}, got ${buffer.draw_mode}).`;\n                }\n            }\n            const { type, location } = this.attributes[a_name];\n            buffer.bindToProgram(location);\n        });\n    }\n    /**\n     * Set uniform values in this shader program. When rendering, call {@link WGLProgram.use} before calling this function.\n     * @param uniform_values - An object with the keys being the uniform variable names and the values being the uniform values\n     */\n    setUniforms(uniform_values) {\n        Object.entries(uniform_values).forEach(([u_name, value]) => {\n            if (this.uniforms[u_name] === undefined) {\n                console.warn(`Skipping uniform value provided for '${u_name}' because the uniform was not found in the program.`);\n                return;\n            }\n            const { type, location } = this.uniforms[u_name];\n            if (type === 'int' && typeof value == 'number') {\n                this.gl.uniform1i(location, value);\n            }\n            else if (type === 'float' && typeof value == 'number') {\n                this.gl.uniform1f(location, value);\n            }\n            else if (type === 'float' && value instanceof Array) {\n                this.gl.uniform1fv(location, value);\n            }\n            else if (type === 'vec2' && value instanceof Array) {\n                this.gl.uniform2fv(location, value);\n            }\n            else if (type === 'vec3' && value instanceof Array) {\n                this.gl.uniform3fv(location, value);\n            }\n            else if (type === 'vec4' && value instanceof Array) {\n                this.gl.uniform4fv(location, value);\n            }\n            else if (type === 'mat4' && value instanceof Array) {\n                this.gl.uniformMatrix4fv(location, false, value);\n            }\n            else {\n                throw `Could not figure out uniform function for type '${type}' and value '${String(value)}'`;\n            }\n        });\n    }\n    /**\n     * Bind textures to samplers in this shader program. When rendring, call {@link WGLProgram.use} before calling this function.\n     * @param textures - An object with the keys being the sampler names in the source code and the values being the textures to associate with each sampler\n     */\n    bindTextures(textures) {\n        Object.entries(textures).forEach(([sampler_name, texture]) => {\n            if (this.uniforms[sampler_name] === undefined) {\n                console.warn(`Skipping texture provided for sampler '${sampler_name}' because the sampler was not found in the program.`);\n                return;\n            }\n            const gl_tex_num = this.sampler_names.indexOf(sampler_name);\n            const { type, location } = this.uniforms[sampler_name];\n            texture.bindToProgram(location, gl_tex_num);\n        });\n    }\n    /**\n     * Run this shader program.\n     */\n    draw() {\n        if (this.draw_mode === null || this.n_verts === null) {\n            throw \"Cannot draw without binding attribute buffers\";\n        }\n        if (this.index_buffer === null) {\n            if (this.instance_count == 0) {\n                this.gl.drawArrays(this.draw_mode, 0, this.n_verts);\n            }\n            else {\n                this.daiFunc(this.draw_mode, 0, this.n_verts, this.instance_count);\n            }\n        }\n        else {\n            if (this.instance_count == 0) {\n                this.gl.drawElements(this.draw_mode, this.index_buffer.n_verts, this.index_buffer.dtype, 0);\n            }\n            else {\n                this.deiFunc(this.draw_mode, this.index_buffer.n_verts, this.index_buffer.dtype, 0, this.instance_count);\n            }\n        }\n    }\n}\nexport { WGLProgram };\n","/**\n * @module wgl/WebGLFramebuffer\n * Module containing helper classes for WebGL Framebuffers\n */\n/**\n * Base class for WebGL framebuffers\n */\nclass WGLFramebufferBase {\n    constructor(gl, framebuffer) {\n        this.gl = gl;\n        this.framebuffer = framebuffer;\n    }\n    /**\n     * Clear the framebuffer to a particular color\n     * @param color - The color to use when clearing the framebuffer as a float RGBA tuple\n     */\n    clear(color) {\n        const gl = this.gl;\n        if (gl === null) {\n            throw \"Register WebGL drawing context using registerGLContext() first\";\n        }\n        gl.clearColor(...color);\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n        gl.clear(gl.COLOR_BUFFER_BIT);\n    }\n    /**\n     * Render to a portion of this framebuffer\n     * @param x      - The x coordinate of the starting point for the viewport\n     * @param y      - The y coordinate of the starting point for the viewport\n     * @param width  - The width of the viewport\n     * @param height - The height of the viewport\n     */\n    renderTo(x, y, width, height) {\n        const gl = this.gl;\n        if (gl === null) {\n            throw \"Register WebGL drawing context using registerGLContext() first\";\n        }\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n        gl.viewport(x, y, width, height);\n    }\n    /**\n     * Copy the contents of this framebuffer to another texture\n     * @param texture - The destination texture for the copy\n     * @param x       - The x coordinate of the start of the source rectangle\n     * @param y       - The y coordinate of the start of the source rectangle\n     * @param width   - The width of the source rectangle\n     * @param height  - The height of the source rectangle\n     */\n    copyToTexture(texture, x, y, width, height) {\n        const gl = this.gl;\n        if (gl === null) {\n            throw \"Register WebGL drawing context using registerGLContext() first\";\n        }\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n        texture.activate(0);\n        gl.copyTexImage2D(gl.TEXTURE_2D, 0, texture.spec.format, x, y, width, height, 0);\n    }\n}\n/**\n * Class representing the screen buffer\n * @extends WGLFramebufferBase\n */\nclass WGLScreenbuffer extends WGLFramebufferBase {\n    /**\n     * Create the screen buffer. Use the {@link WGLFramebuffer.screen} static variable of {@link WGLFramebuffer} instead of creating your own screenbuffer.\n     */\n    constructor() {\n        super(null, null);\n    }\n    /**\n     * Register the WebGL rendering context for later use\n     * @param gl - The WebGL rendering context\n     */\n    registerGLContext(gl) {\n        this.gl = gl;\n    }\n}\nconst SCREEN = new WGLScreenbuffer();\n/**\n * Class representing a WebGL framebuffer\n * @extends WGLFramebufferBase\n */\nclass WGLFramebuffer extends WGLFramebufferBase {\n    /**\n     * Create a framebuffer associated with a texture\n     * @param gl      - The WebGL rendering context\n     * @param texture - The texture object to associate with this framebuffer\n     */\n    constructor(gl, texture) {\n        const framebuffer = gl.createFramebuffer();\n        if (framebuffer === null) {\n            throw \"Could not create WebGL Framebuffer\";\n        }\n        super(gl, framebuffer);\n        this.texture = texture;\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture['texture'], 0);\n    }\n    /**\n     * Get a screen buffer object for interacting with the screen\n     * @static\n     * @param gl - The WebGL rendering context to use\n     */\n    static screen(gl) {\n        SCREEN.registerGLContext(gl);\n        return SCREEN;\n    }\n}\n/**\n * Perform several rendering passes, flip-flopping between two framebuffers\n * @param n_passes  - The number of rendering passes to do\n * @param source_fb - The framebuffer containing the initial data for the rendering\n * @param aux_fb    - The auxilary rendering framebuffers (should be 2 of them)\n * @param do_render - A method that does the actual rendering pass\n */\nconst flipFlopBuffers = (n_passes, source_fb, aux_fb, do_render) => {\n    // fb1 is the source and fb2 is the target for each pass\n    let fb1 = source_fb, fb2 = aux_fb[0];\n    for (let ipass = 0; ipass < n_passes; ipass++) {\n        // Clear and unbind destination texture\n        fb2.clear([0., 0., 0., 1.]);\n        fb2.texture.deactivate();\n        // Do whatever rendering task we want to do\n        do_render(fb1, fb2, ipass);\n        if (ipass > 0) {\n            // Flip the framebuffers so the destination on this pass becomes the source on the next pass and vice-versa\n            aux_fb.reverse();\n        }\n        [fb1, fb2] = aux_fb;\n    }\n    // The most recent target is fb2, but the two framebuffers got flipped at the end of the loop, so the data we want are in fb1.\n    return fb1;\n};\nexport { WGLFramebuffer, flipFlopBuffers };\n","export const THIS_IS_NOT_AN_OBJECT = \"This is not an object\";\nexport const THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = \"This is not a Float16Array object\";\nexport const THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY =\n  \"This constructor is not a subclass of Float16Array\";\nexport const THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT =\n  \"The constructor property value is not an object\";\nexport const SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT =\n  \"Species constructor didn't return TypedArray object\";\nexport const DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH =\n  \"Derived constructor created TypedArray object which was too small length\";\nexport const ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER =\n  \"Attempting to access detached ArrayBuffer\";\nexport const CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT =\n  \"Cannot convert undefined or null to object\";\nexport const CANNOT_MIX_BIGINT_AND_OTHER_TYPES =\n  \"Cannot mix BigInt and other types, use explicit conversions\";\nexport const ITERATOR_PROPERTY_IS_NOT_CALLABLE = \"@@iterator property is not callable\";\nexport const REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE =\n  \"Reduce of empty array with no initial value\";\nexport const THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED =\n  \"The comparison function must be either a function or undefined\";\nexport const OFFSET_IS_OUT_OF_BOUNDS = \"Offset is out of bounds\";\n","/* eslint-disable no-restricted-globals, no-restricted-syntax */\n/* global SharedArrayBuffer */\n\nimport { CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT } from \"./messages.mjs\";\n\n/** @type {<T extends (...args: any) => any>(target: T) => (thisArg: ThisType<T>, ...args: any[]) => any} */\nfunction uncurryThis(target) {\n  return (thisArg, ...args) => {\n    return ReflectApply(target, thisArg, args);\n  };\n}\n\n/** @type {(target: any, key: string | symbol) => (thisArg: any, ...args: any[]) => any} */\nfunction uncurryThisGetter(target, key) {\n  return uncurryThis(\n    ReflectGetOwnPropertyDescriptor(\n      target,\n      key\n    ).get\n  );\n}\n\n// Reflect\nexport const {\n  apply: ReflectApply,\n  construct: ReflectConstruct,\n  defineProperty: ReflectDefineProperty,\n  get: ReflectGet,\n  getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,\n  getPrototypeOf: ReflectGetPrototypeOf,\n  has: ReflectHas,\n  ownKeys: ReflectOwnKeys,\n  set: ReflectSet,\n  setPrototypeOf: ReflectSetPrototypeOf,\n} = Reflect;\n\n// Proxy\nexport const NativeProxy = Proxy;\n\n// Number\nexport const {\n  EPSILON,\n  MAX_SAFE_INTEGER,\n  isFinite: NumberIsFinite,\n  isNaN: NumberIsNaN,\n} = Number;\n\n// Symbol\nexport const {\n  iterator: SymbolIterator,\n  species: SymbolSpecies,\n  toStringTag: SymbolToStringTag,\n  for: SymbolFor,\n} = Symbol;\n\n// Object\nexport const NativeObject = Object;\nexport const {\n  create: ObjectCreate,\n  defineProperty: ObjectDefineProperty,\n  freeze: ObjectFreeze,\n  is: ObjectIs,\n} = NativeObject;\nconst ObjectPrototype = NativeObject.prototype;\n/** @type {(object: object, key: PropertyKey) => Function | undefined} */\nexport const ObjectPrototype__lookupGetter__ = /** @type {any} */ (ObjectPrototype).__lookupGetter__\n  ? uncurryThis(/** @type {any} */ (ObjectPrototype).__lookupGetter__)\n  : (object, key) => {\n    if (object == null) {\n      throw NativeTypeError(\n        CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n      );\n    }\n\n    let target = NativeObject(object);\n    do {\n      const descriptor = ReflectGetOwnPropertyDescriptor(target, key);\n      if (descriptor !== undefined) {\n        if (ObjectHasOwn(descriptor, \"get\")) {\n          return descriptor.get;\n        }\n\n        return;\n      }\n    } while ((target = ReflectGetPrototypeOf(target)) !== null);\n  };\n/** @type {(object: object, key: PropertyKey) => boolean} */\nexport const ObjectHasOwn = /** @type {any} */ (NativeObject).hasOwn ||\n  uncurryThis(ObjectPrototype.hasOwnProperty);\n\n// Array\nconst NativeArray = Array;\nexport const ArrayIsArray = NativeArray.isArray;\nconst ArrayPrototype = NativeArray.prototype;\n/** @type {(array: ArrayLike<unknown>, separator?: string) => string} */\nexport const ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join);\n/** @type {<T>(array: T[], ...items: T[]) => number} */\nexport const ArrayPrototypePush = uncurryThis(ArrayPrototype.push);\n/** @type {(array: ArrayLike<unknown>, ...opts: any[]) => string} */\nexport const ArrayPrototypeToLocaleString = uncurryThis(\n  ArrayPrototype.toLocaleString\n);\nexport const NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator];\n/** @type {<T>(array: T[]) => IterableIterator<T>} */\nexport const ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator);\n\n// Math\nexport const {\n  abs: MathAbs,\n  trunc: MathTrunc,\n} = Math;\n\n// ArrayBuffer\nexport const NativeArrayBuffer = ArrayBuffer;\nexport const ArrayBufferIsView = NativeArrayBuffer.isView;\nconst ArrayBufferPrototype = NativeArrayBuffer.prototype;\n/** @type {(buffer: ArrayBuffer, begin?: number, end?: number) => number} */\nexport const ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice);\n/** @type {(buffer: ArrayBuffer) => ArrayBuffer} */\nexport const ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, \"byteLength\");\n\n// SharedArrayBuffer\nexport const NativeSharedArrayBuffer = typeof SharedArrayBuffer !== \"undefined\" ? SharedArrayBuffer : null;\n/** @type {(buffer: SharedArrayBuffer) => SharedArrayBuffer} */\nexport const SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer\n  && uncurryThisGetter(NativeSharedArrayBuffer.prototype, \"byteLength\");\n\n// TypedArray\n/** @typedef {Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array|BigUint64Array|BigInt64Array} TypedArray */\n/** @type {any} */\nexport const TypedArray = ReflectGetPrototypeOf(Uint8Array);\nconst TypedArrayFrom = TypedArray.from;\nexport const TypedArrayPrototype = TypedArray.prototype;\nexport const NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator];\n/** @type {(typedArray: TypedArray) => IterableIterator<number>} */\nexport const TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys);\n/** @type {(typedArray: TypedArray) => IterableIterator<number>} */\nexport const TypedArrayPrototypeValues = uncurryThis(\n  TypedArrayPrototype.values\n);\n/** @type {(typedArray: TypedArray) => IterableIterator<[number, number]>} */\nexport const TypedArrayPrototypeEntries = uncurryThis(\n  TypedArrayPrototype.entries\n);\n/** @type {(typedArray: TypedArray, array: ArrayLike<number>, offset?: number) => void} */\nexport const TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set);\n/** @type {<T extends TypedArray>(typedArray: T) => T} */\nexport const TypedArrayPrototypeReverse = uncurryThis(\n  TypedArrayPrototype.reverse\n);\n/** @type {<T extends TypedArray>(typedArray: T, value: number, start?: number, end?: number) => T} */\nexport const TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill);\n/** @type {<T extends TypedArray>(typedArray: T, target: number, start: number, end?: number) => T} */\nexport const TypedArrayPrototypeCopyWithin = uncurryThis(\n  TypedArrayPrototype.copyWithin\n);\n/** @type {<T extends TypedArray>(typedArray: T, compareFn?: (a: number, b: number) => number) => T} */\nexport const TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort);\n/** @type {<T extends TypedArray>(typedArray: T, start?: number, end?: number) => T} */\nexport const TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice);\n/** @type {<T extends TypedArray>(typedArray: T, start?: number, end?: number) => T} */\nexport const TypedArrayPrototypeSubarray = uncurryThis(\n  TypedArrayPrototype.subarray\n);\n/** @type {((typedArray: TypedArray) => ArrayBuffer)} */\nexport const TypedArrayPrototypeGetBuffer = uncurryThisGetter(\n  TypedArrayPrototype,\n  \"buffer\"\n);\n/** @type {((typedArray: TypedArray) => number)} */\nexport const TypedArrayPrototypeGetByteOffset = uncurryThisGetter(\n  TypedArrayPrototype,\n  \"byteOffset\"\n);\n/** @type {((typedArray: TypedArray) => number)} */\nexport const TypedArrayPrototypeGetLength = uncurryThisGetter(\n  TypedArrayPrototype,\n  \"length\"\n);\n/** @type {(target: unknown) => string} */\nexport const TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter(\n  TypedArrayPrototype,\n  SymbolToStringTag\n);\n\n// Uint8Array\nexport const NativeUint8Array = Uint8Array;\n\n// Uint16Array\nexport const NativeUint16Array = Uint16Array;\n/** @type {Uint16ArrayConstructor[\"from\"]} */\nexport const Uint16ArrayFrom = (...args) => {\n  return ReflectApply(TypedArrayFrom, NativeUint16Array, args);\n};\n\n// Uint32Array\nexport const NativeUint32Array = Uint32Array;\n\n// Float32Array\nexport const NativeFloat32Array = Float32Array;\n\n// ArrayIterator\n/** @type {any} */\nexport const ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]());\n/** @type {<T>(arrayIterator: IterableIterator<T>) => IteratorResult<T>} */\nexport const ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next);\n\n// Generator\n/** @type {<T = unknown, TReturn = any, TNext = unknown>(generator: Generator<T, TReturn, TNext>, value?: TNext) => T} */\nexport const GeneratorPrototypeNext = uncurryThis((function* () {})().next);\n\n// Iterator\nexport const IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype);\n\n// DataView\nconst DataViewPrototype = DataView.prototype;\n/** @type {(dataView: DataView, byteOffset: number, littleEndian?: boolean) => number} */\nexport const DataViewPrototypeGetUint16 = uncurryThis(\n  DataViewPrototype.getUint16\n);\n/** @type {(dataView: DataView, byteOffset: number, value: number, littleEndian?: boolean) => void} */\nexport const DataViewPrototypeSetUint16 = uncurryThis(\n  DataViewPrototype.setUint16\n);\n\n// Error\nexport const NativeTypeError = TypeError;\nexport const NativeRangeError = RangeError;\n\n// WeakSet\n/**\n * Do not construct with arguments to avoid calling the \"add\" method\n * @type {{new <T extends {}>(): WeakSet<T>}}\n */\nexport const NativeWeakSet = WeakSet;\nconst WeakSetPrototype = NativeWeakSet.prototype;\n/** @type {<T extends {}>(set: WeakSet<T>, value: T) => Set<T>} */\nexport const WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add);\n/** @type {<T extends {}>(set: WeakSet<T>, value: T) => boolean} */\nexport const WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has);\n\n// WeakMap\n/**\n * Do not construct with arguments to avoid calling the \"set\" method\n * @type {{new <K extends {}, V>(): WeakMap<K, V>}}\n */\nexport const NativeWeakMap = WeakMap;\nconst WeakMapPrototype = NativeWeakMap.prototype;\n/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K) => V} */\nexport const WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get);\n/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K) => boolean} */\nexport const WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has);\n/** @type {<K extends {}, V>(weakMap: WeakMap<K, V>, key: K, value: V) => WeakMap} */\nexport const WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set);\n","import {\n  ArrayIteratorPrototype,\n  ArrayIteratorPrototypeNext,\n  ArrayPrototypeSymbolIterator,\n  GeneratorPrototypeNext,\n  IteratorPrototype,\n  NativeArrayPrototypeSymbolIterator,\n  NativeWeakMap,\n  ObjectCreate,\n  ObjectDefineProperty,\n  ReflectGetOwnPropertyDescriptor,\n  ReflectOwnKeys,\n  SymbolIterator,\n  WeakMapPrototypeGet,\n  WeakMapPrototypeSet,\n} from \"./primordials.mjs\";\n\n/** @type {WeakMap<{}, IterableIterator<any>>} */\nconst arrayIterators = new NativeWeakMap();\n\nconst SafeIteratorPrototype = ObjectCreate(null, {\n  next: {\n    value: function next() {\n      const arrayIterator = WeakMapPrototypeGet(arrayIterators, this);\n      return ArrayIteratorPrototypeNext(arrayIterator);\n    },\n  },\n\n  [SymbolIterator]: {\n    value: function values() {\n      return this;\n    },\n  },\n});\n\n/**\n * Wrap the Array around the SafeIterator If Array.prototype [@@iterator] has been modified\n * @type {<T>(array: T[]) => Iterable<T>}\n */\nexport function safeIfNeeded(array) {\n  if (\n    array[SymbolIterator] === NativeArrayPrototypeSymbolIterator &&\n    ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext\n  ) {\n    return array;\n  }\n\n  const safe = ObjectCreate(SafeIteratorPrototype);\n  WeakMapPrototypeSet(arrayIterators, safe, ArrayPrototypeSymbolIterator(array));\n  return safe;\n}\n\n/** @type {WeakMap<{}, Generator<any>>} */\nconst generators = new NativeWeakMap();\n\n/** @see https://tc39.es/ecma262/#sec-%arrayiteratorprototype%-object */\nconst DummyArrayIteratorPrototype = ObjectCreate(IteratorPrototype, {\n  next: {\n    value: function next() {\n      const generator = WeakMapPrototypeGet(generators, this);\n      return GeneratorPrototypeNext(generator);\n    },\n    writable: true,\n    configurable: true,\n  },\n});\n\nfor (const key of ReflectOwnKeys(ArrayIteratorPrototype)) {\n  // next method has already defined\n  if (key === \"next\") {\n    continue;\n  }\n\n  // Copy ArrayIteratorPrototype descriptors to DummyArrayIteratorPrototype\n  ObjectDefineProperty(DummyArrayIteratorPrototype, key, ReflectGetOwnPropertyDescriptor(ArrayIteratorPrototype, key));\n}\n\n/**\n * Wrap the Generator around the dummy ArrayIterator\n * @type {<T>(generator: Generator<T>) => IterableIterator<T>}\n */\nexport function wrap(generator) {\n  const dummy = ObjectCreate(DummyArrayIteratorPrototype);\n  WeakMapPrototypeSet(generators, dummy, generator);\n  return dummy;\n}\n","import {\n  ArrayBufferPrototypeGetByteLength,\n  ArrayIsArray,\n  ArrayIteratorPrototype,\n  ArrayIteratorPrototypeNext,\n  MathTrunc,\n  NativeArrayPrototypeSymbolIterator,\n  NativeSharedArrayBuffer,\n  NativeTypedArrayPrototypeSymbolIterator,\n  NumberIsFinite,\n  SharedArrayBufferPrototypeGetByteLength,\n  SymbolIterator,\n  TypedArrayPrototypeGetSymbolToStringTag,\n} from \"./primordials.mjs\";\n\n/**\n * @param {unknown} value\n * @returns {value is {}}\n */\nexport function isObject(value) {\n  return (\n    (value !== null && typeof value === \"object\") ||\n    typeof value === \"function\"\n  );\n}\n\n/**\n * @param {unknown} value\n * @returns {value is {}}\n */\nexport function isObjectLike(value) {\n  return value !== null && typeof value === \"object\";\n}\n\n// Inspired by util.types implementation of Node.js\n/** @typedef {Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array|BigUint64Array|BigInt64Array} TypedArray */\n\n/**\n * @param {unknown} value\n * @returns {value is TypedArray}\n */\nexport function isNativeTypedArray(value) {\n  return TypedArrayPrototypeGetSymbolToStringTag(value) !== undefined;\n}\n\n/**\n * @param {unknown} value\n * @returns {value is BigInt64Array|BigUint64Array}\n */\nexport function isNativeBigIntTypedArray(value) {\n  const typedArrayName = TypedArrayPrototypeGetSymbolToStringTag(value);\n  return (\n    typedArrayName === \"BigInt64Array\" ||\n    typedArrayName === \"BigUint64Array\"\n  );\n}\n\n/**\n * @param {unknown} value\n * @returns {value is ArrayBuffer}\n */\nfunction isArrayBuffer(value) {\n  try {\n    ArrayBufferPrototypeGetByteLength(/** @type {any} */ (value));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * @param {unknown} value\n * @returns {value is SharedArrayBuffer}\n */\nexport function isSharedArrayBuffer(value) {\n  if (NativeSharedArrayBuffer === null) {\n    return false;\n  }\n\n  try {\n    SharedArrayBufferPrototypeGetByteLength(/** @type {any} */ (value));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * @param {unknown} value\n * @returns {value is ArrayBuffer|SharedArrayBuffer}\n */\nexport function isAnyArrayBuffer(value) {\n  return isArrayBuffer(value) || isSharedArrayBuffer(value);\n}\n\n/**\n * @param {unknown} value\n * @returns {value is unknown[]}\n */\nexport function isOrdinaryArray(value) {\n  if (!ArrayIsArray(value)) {\n    return false;\n  }\n\n  // Verify that there are no changes in ArrayIterator\n  return (\n    value[SymbolIterator] === NativeArrayPrototypeSymbolIterator &&\n    ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext\n  );\n}\n\n/**\n * @param {unknown} value\n * @returns {value is TypedArray}\n */\nexport function isOrdinaryNativeTypedArray(value) {\n  if (!isNativeTypedArray(value)) {\n    return false;\n  }\n\n  // Verify that there are no changes in ArrayIterator\n  return (\n    value[SymbolIterator] === NativeTypedArrayPrototypeSymbolIterator &&\n    ArrayIteratorPrototype.next === ArrayIteratorPrototypeNext\n  );\n}\n\n/**\n * @param {unknown} value\n * @returns {value is string}\n */\nexport function isCanonicalIntegerIndexString(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n\n  const number = +value;\n  if (value !== number + \"\") {\n    return false;\n  }\n\n  if (!NumberIsFinite(number)) {\n    return false;\n  }\n\n  return number === MathTrunc(number);\n}\n","import { isObject, isObjectLike } from \"./is.mjs\";\nimport { THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT } from \"./messages.mjs\";\nimport { NativeTypeError, ReflectGetPrototypeOf, ReflectHas, SymbolFor } from \"./primordials.mjs\";\n\nexport const brand = SymbolFor(\"__Float16Array__\");\n\n/**\n * @param {unknown} target\n * @throws {TypeError}\n * @returns {boolean}\n */\nexport function hasFloat16ArrayBrand(target) {\n  if (!isObjectLike(target)) {\n    return false;\n  }\n\n  const prototype = ReflectGetPrototypeOf(target);\n  if (!isObjectLike(prototype)) {\n    return false;\n  }\n\n  const constructor = prototype.constructor;\n  if (constructor === undefined) {\n    return false;\n  }\n  if (!isObject(constructor)) {\n    throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);\n  }\n\n  return ReflectHas(constructor, brand);\n}\n","import {\n  EPSILON,\n  MathAbs,\n  NativeArrayBuffer,\n  NativeFloat32Array,\n  NativeUint16Array,\n  NativeUint32Array,\n  NativeUint8Array,\n  NumberIsFinite,\n  NumberIsNaN,\n} from \"./primordials.mjs\";\n\nconst INVERSE_OF_EPSILON = 1 / EPSILON;\n\n/**\n * rounds to the nearest value;\n * if the number falls midway, it is rounded to the nearest value with an even least significant digit\n * @param {number} num\n * @returns {number}\n */\nfunction roundTiesToEven(num) {\n  return (num + INVERSE_OF_EPSILON) - INVERSE_OF_EPSILON;\n}\n\nconst FLOAT16_MIN_VALUE = 6.103515625e-05;\nconst FLOAT16_MAX_VALUE = 65504;\nconst FLOAT16_EPSILON = 0.0009765625;\n\nconst FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE = FLOAT16_EPSILON * FLOAT16_MIN_VALUE;\nconst FLOAT16_EPSILON_DEVIDED_BY_EPSILON = FLOAT16_EPSILON * INVERSE_OF_EPSILON;\n\n/**\n * round a number to a half float number\n * @param {unknown} num - double float\n * @returns {number} half float number bits\n */\nexport function roundToFloat16(num) {\n  const number = +num;\n\n  // NaN, Infinity, -Infinity, 0, -0\n  if (!NumberIsFinite(number) || number === 0) {\n    return number;\n  }\n\n  // finite except 0, -0\n  const sign = number > 0 ? 1 : -1;\n  const absolute = MathAbs(number);\n\n  // small number\n  if (absolute < FLOAT16_MIN_VALUE) {\n    return sign * roundTiesToEven(absolute / FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE) * FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE;\n  }\n\n  const temp = (1 + FLOAT16_EPSILON_DEVIDED_BY_EPSILON) * absolute;\n  const result = temp - (temp - absolute);\n\n  // large number\n  if (result > FLOAT16_MAX_VALUE || NumberIsNaN(result)) {\n    return sign * Infinity;\n  }\n\n  return sign * result;\n}\n\n// base algorithm: http://fox-toolkit.org/ftp/fasthalffloatconversion.pdf\n\nconst buffer = new NativeArrayBuffer(4);\nconst floatView = new NativeFloat32Array(buffer);\nconst uint32View = new NativeUint32Array(buffer);\n\nconst baseTable = new NativeUint16Array(512);\nconst shiftTable = new NativeUint8Array(512);\n\nfor (let i = 0; i < 256; ++i) {\n  const e = i - 127;\n\n  // very small number (0, -0)\n  if (e < -27) {\n    baseTable[i]         = 0x0000;\n    baseTable[i | 0x100] = 0x8000;\n    shiftTable[i]         = 24;\n    shiftTable[i | 0x100] = 24;\n\n  // small number (denorm)\n  } else if (e < -14) {\n    baseTable[i]         =  0x0400 >> (-e - 14);\n    baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;\n    shiftTable[i]         = -e - 1;\n    shiftTable[i | 0x100] = -e - 1;\n\n  // normal number\n  } else if (e <= 15) {\n    baseTable[i]         =  (e + 15) << 10;\n    baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;\n    shiftTable[i]         = 13;\n    shiftTable[i | 0x100] = 13;\n\n  // large number (Infinity, -Infinity)\n  } else if (e < 128) {\n    baseTable[i]         = 0x7c00;\n    baseTable[i | 0x100] = 0xfc00;\n    shiftTable[i]         = 24;\n    shiftTable[i | 0x100] = 24;\n\n  // stay (NaN, Infinity, -Infinity)\n  } else {\n    baseTable[i]         = 0x7c00;\n    baseTable[i | 0x100] = 0xfc00;\n    shiftTable[i]         = 13;\n    shiftTable[i | 0x100] = 13;\n  }\n}\n\n/**\n * round a number to a half float number bits\n * @param {unknown} num - double float\n * @returns {number} half float number bits\n */\nexport function roundToFloat16Bits(num) {\n  floatView[0] = roundToFloat16(num);\n  const f = uint32View[0];\n  const e = (f >> 23) & 0x1ff;\n  return baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);\n}\n\nconst mantissaTable = new NativeUint32Array(2048);\nfor (let i = 1; i < 1024; ++i) {\n  let m = i << 13; // zero pad mantissa bits\n  let e = 0; // zero exponent\n\n  // normalized\n  while ((m & 0x00800000) === 0) {\n    m <<= 1;\n    e -= 0x00800000; // decrement exponent\n  }\n\n  m &= ~0x00800000; // clear leading 1 bit\n  e += 0x38800000; // adjust bias\n\n  mantissaTable[i] = m | e;\n}\nfor (let i = 1024; i < 2048; ++i) {\n  mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);\n}\n\nconst exponentTable = new NativeUint32Array(64);\nfor (let i = 1; i < 31; ++i) {\n  exponentTable[i] = i << 23;\n}\nexponentTable[31] = 0x47800000;\nexponentTable[32] = 0x80000000;\nfor (let i = 33; i < 63; ++i) {\n  exponentTable[i] = 0x80000000 + ((i - 32) << 23);\n}\nexponentTable[63] = 0xc7800000;\n\nconst offsetTable = new NativeUint16Array(64);\nfor (let i = 1; i < 64; ++i) {\n  if (i !== 32) {\n    offsetTable[i] = 1024;\n  }\n}\n\n/**\n * convert a half float number bits to a number\n * @param {number} float16bits - half float number bits\n * @returns {number} double float\n */\nexport function convertToNumber(float16bits) {\n  const i = float16bits >> 10;\n  uint32View[0] = mantissaTable[offsetTable[i] + (float16bits & 0x3ff)] + exponentTable[i];\n  return floatView[0];\n}\n","import { isObject, isSharedArrayBuffer } from \"./is.mjs\";\nimport {\n  THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT,\n  THIS_IS_NOT_AN_OBJECT,\n} from \"./messages.mjs\";\nimport {\n  ArrayBufferPrototypeSlice,\n  MAX_SAFE_INTEGER,\n  MathTrunc,\n  NativeTypeError,\n  NumberIsNaN,\n  ObjectIs,\n  SymbolSpecies,\n} from \"./primordials.mjs\";\n\n/**\n * @see https://tc39.es/ecma262/#sec-tointegerorinfinity\n * @param {unknown} target\n * @returns {number}\n */\nexport function ToIntegerOrInfinity(target) {\n  const number = +target;\n\n  if (NumberIsNaN(number) || number === 0) {\n    return 0;\n  }\n\n  return MathTrunc(number);\n}\n\n/**\n * @see https://tc39.es/ecma262/#sec-tolength\n * @param {unknown} target\n * @returns {number}\n */\nexport function ToLength(target) {\n  const length = ToIntegerOrInfinity(target);\n  if (length < 0) {\n    return 0;\n  }\n\n  return length < MAX_SAFE_INTEGER\n    ? length\n    : MAX_SAFE_INTEGER;\n}\n\n/**\n * @see https://tc39.es/ecma262/#sec-speciesconstructor\n * @param {object} target\n * @param {{ new(...args: any[]): any; }} defaultConstructor\n * @returns {{ new(...args: any[]): any; }}\n */\nexport function SpeciesConstructor(target, defaultConstructor) {\n  if (!isObject(target)) {\n    throw NativeTypeError(THIS_IS_NOT_AN_OBJECT);\n  }\n\n  const constructor = target.constructor;\n  if (constructor === undefined) {\n    return defaultConstructor;\n  }\n  if (!isObject(constructor)) {\n    throw NativeTypeError(THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);\n  }\n\n  const species = constructor[SymbolSpecies];\n  if (species == null) {\n    return defaultConstructor;\n  }\n\n  return species;\n}\n\n/**\n * @see https://tc39.es/ecma262/#sec-isdetachedbuffer\n * @param {ArrayBufferLike} buffer\n * @returns {boolean}\n */\nexport function IsDetachedBuffer(buffer) {\n  if (isSharedArrayBuffer(buffer)) {\n    return false;\n  }\n\n  try {\n    ArrayBufferPrototypeSlice(buffer, 0, 0);\n    return false;\n  } catch (e) {/* empty */}\n\n  return true;\n}\n\n/**\n * bigint comparisons are not supported\n * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort\n * @param {number} x\n * @param {number} y\n * @returns {-1 | 0 | 1}\n */\nexport function defaultCompare(x, y) {\n  const isXNaN = NumberIsNaN(x);\n  const isYNaN = NumberIsNaN(y);\n\n  if (isXNaN && isYNaN) {\n    return 0;\n  }\n\n  if (isXNaN) {\n    return 1;\n  }\n\n  if (isYNaN) {\n    return -1;\n  }\n\n  if (x < y) {\n    return -1;\n  }\n\n  if (x > y) {\n    return 1;\n  }\n\n  if (x === 0 && y === 0) {\n    const isXPlusZero = ObjectIs(x, 0);\n    const isYPlusZero = ObjectIs(y, 0);\n\n    if (!isXPlusZero && isYPlusZero) {\n      return -1;\n    }\n\n    if (isXPlusZero && !isYPlusZero) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n","import { safeIfNeeded, wrap } from \"./_util/arrayIterator.mjs\";\nimport { brand, hasFloat16ArrayBrand } from \"./_util/brand.mjs\";\nimport { convertToNumber, roundToFloat16Bits } from \"./_util/converter.mjs\";\nimport {\n  isAnyArrayBuffer,\n  isCanonicalIntegerIndexString,\n  isNativeBigIntTypedArray,\n  isNativeTypedArray,\n  isObject,\n  isOrdinaryArray,\n  isOrdinaryNativeTypedArray,\n} from \"./_util/is.mjs\";\nimport {\n  ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER,\n  CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT,\n  CANNOT_MIX_BIGINT_AND_OTHER_TYPES,\n  DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH,\n  ITERATOR_PROPERTY_IS_NOT_CALLABLE,\n  OFFSET_IS_OUT_OF_BOUNDS,\n  REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE,\n  SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT,\n  THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED,\n  THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY,\n  THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT,\n} from \"./_util/messages.mjs\";\nimport {\n  ArrayBufferIsView,\n  ArrayPrototypeJoin,\n  ArrayPrototypePush,\n  ArrayPrototypeToLocaleString,\n  NativeArrayBuffer,\n  NativeObject,\n  NativeProxy,\n  NativeRangeError,\n  NativeTypeError,\n  NativeUint16Array,\n  NativeWeakMap,\n  NativeWeakSet,\n  NumberIsNaN,\n  ObjectDefineProperty,\n  ObjectFreeze,\n  ObjectHasOwn,\n  ObjectPrototype__lookupGetter__,\n  ReflectApply,\n  ReflectConstruct,\n  ReflectDefineProperty,\n  ReflectGet,\n  ReflectGetOwnPropertyDescriptor,\n  ReflectHas,\n  ReflectOwnKeys,\n  ReflectSet,\n  ReflectSetPrototypeOf,\n  SymbolIterator,\n  SymbolToStringTag,\n  TypedArray,\n  TypedArrayPrototype,\n  TypedArrayPrototypeCopyWithin,\n  TypedArrayPrototypeEntries,\n  TypedArrayPrototypeFill,\n  TypedArrayPrototypeGetBuffer,\n  TypedArrayPrototypeGetByteOffset,\n  TypedArrayPrototypeGetLength,\n  TypedArrayPrototypeKeys,\n  TypedArrayPrototypeReverse,\n  TypedArrayPrototypeSet,\n  TypedArrayPrototypeSlice,\n  TypedArrayPrototypeSort,\n  TypedArrayPrototypeSubarray,\n  TypedArrayPrototypeValues,\n  Uint16ArrayFrom,\n  WeakMapPrototypeGet,\n  WeakMapPrototypeHas,\n  WeakMapPrototypeSet,\n  WeakSetPrototypeAdd,\n  WeakSetPrototypeHas,\n} from \"./_util/primordials.mjs\";\nimport {\n  IsDetachedBuffer,\n  SpeciesConstructor,\n  ToIntegerOrInfinity,\n  ToLength,\n  defaultCompare,\n} from \"./_util/spec.mjs\";\n\nconst BYTES_PER_ELEMENT = 2;\n\n/** @typedef {Uint16Array & { __float16bits: never }} Float16BitsArray */\n\n/** @type {WeakMap<Float16Array, Float16BitsArray>} */\nconst float16bitsArrays = new NativeWeakMap();\n\n/**\n * @param {unknown} target\n * @returns {target is Float16Array}\n */\nexport function isFloat16Array(target) {\n  return WeakMapPrototypeHas(float16bitsArrays, target) ||\n    (!ArrayBufferIsView(target) && hasFloat16ArrayBrand(target));\n}\n\n/**\n * @param {unknown} target\n * @throws {TypeError}\n * @returns {asserts target is Float16Array}\n */\nfunction assertFloat16Array(target) {\n  if (!isFloat16Array(target)) {\n    throw NativeTypeError(THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT);\n  }\n}\n\n/**\n * @param {unknown} target\n * @param {number=} count\n * @throws {TypeError}\n * @returns {asserts target is Uint8Array|Uint8ClampedArray|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float16Array|Float32Array|Float64Array}\n */\nfunction assertSpeciesTypedArray(target, count) {\n  const isTargetFloat16Array = isFloat16Array(target);\n  const isTargetTypedArray = isNativeTypedArray(target);\n\n  if (!isTargetFloat16Array && !isTargetTypedArray) {\n    throw NativeTypeError(SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT);\n  }\n\n  if (typeof count === \"number\") {\n    let length;\n    if (isTargetFloat16Array) {\n      const float16bitsArray = getFloat16BitsArray(target);\n      length = TypedArrayPrototypeGetLength(float16bitsArray);\n    } else {\n      length = TypedArrayPrototypeGetLength(target);\n    }\n\n    if (length < count) {\n      throw NativeTypeError(\n        DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH\n      );\n    }\n  }\n\n  if (isNativeBigIntTypedArray(target)) {\n    throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);\n  }\n}\n\n/**\n * @param {Float16Array} float16\n * @throws {TypeError}\n * @returns {Float16BitsArray}\n */\nfunction getFloat16BitsArray(float16) {\n  const float16bitsArray = WeakMapPrototypeGet(float16bitsArrays, float16);\n  if (float16bitsArray !== undefined) {\n    const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray);\n\n    if (IsDetachedBuffer(buffer)) {\n      throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n    }\n\n    return float16bitsArray;\n  }\n\n  // from another Float16Array instance (a different version?)\n  const buffer = /** @type {any} */ (float16).buffer;\n\n  if (IsDetachedBuffer(buffer)) {\n    throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n  }\n\n  const cloned = ReflectConstruct(Float16Array, [\n    buffer,\n    /** @type {any} */ (float16).byteOffset,\n    /** @type {any} */ (float16).length,\n  ], float16.constructor);\n  return WeakMapPrototypeGet(float16bitsArrays, cloned);\n}\n\n/**\n * @param {Float16BitsArray} float16bitsArray\n * @returns {number[]}\n */\nfunction copyToArray(float16bitsArray) {\n  const length = TypedArrayPrototypeGetLength(float16bitsArray);\n\n  const array = [];\n  for (let i = 0; i < length; ++i) {\n    array[i] = convertToNumber(float16bitsArray[i]);\n  }\n\n  return array;\n}\n\n/** @type {WeakSet<Function>} */\nconst TypedArrayPrototypeGetters = new NativeWeakSet();\nfor (const key of ReflectOwnKeys(TypedArrayPrototype)) {\n  // @@toStringTag getter property is defined in Float16Array.prototype\n  if (key === SymbolToStringTag) {\n    continue;\n  }\n\n  const descriptor = ReflectGetOwnPropertyDescriptor(TypedArrayPrototype, key);\n  if (ObjectHasOwn(descriptor, \"get\") && typeof descriptor.get === \"function\") {\n    WeakSetPrototypeAdd(TypedArrayPrototypeGetters, descriptor.get);\n  }\n}\n\nconst handler = ObjectFreeze(/** @type {ProxyHandler<Float16BitsArray>} */ ({\n  get(target, key, receiver) {\n    if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n      return convertToNumber(ReflectGet(target, key));\n    }\n\n    // %TypedArray%.prototype getter properties cannot called by Proxy receiver\n    if (WeakSetPrototypeHas(TypedArrayPrototypeGetters, ObjectPrototype__lookupGetter__(target, key))) {\n      return ReflectGet(target, key);\n    }\n\n    return ReflectGet(target, key, receiver);\n  },\n\n  set(target, key, value, receiver) {\n    if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n      return ReflectSet(target, key, roundToFloat16Bits(value));\n    }\n\n    return ReflectSet(target, key, value, receiver);\n  },\n\n  getOwnPropertyDescriptor(target, key) {\n    if (isCanonicalIntegerIndexString(key) && ObjectHasOwn(target, key)) {\n      const descriptor = ReflectGetOwnPropertyDescriptor(target, key);\n      descriptor.value = convertToNumber(descriptor.value);\n      return descriptor;\n    }\n\n    return ReflectGetOwnPropertyDescriptor(target, key);\n  },\n\n  defineProperty(target, key, descriptor) {\n    if (\n      isCanonicalIntegerIndexString(key) &&\n      ObjectHasOwn(target, key) &&\n      ObjectHasOwn(descriptor, \"value\")\n    ) {\n      descriptor.value = roundToFloat16Bits(descriptor.value);\n      return ReflectDefineProperty(target, key, descriptor);\n    }\n\n    return ReflectDefineProperty(target, key, descriptor);\n  },\n}));\n\nexport class Float16Array {\n  /** @see https://tc39.es/ecma262/#sec-typedarray */\n  constructor(input, _byteOffset, _length) {\n    /** @type {Float16BitsArray} */\n    let float16bitsArray;\n\n    if (isFloat16Array(input)) {\n      float16bitsArray = ReflectConstruct(NativeUint16Array, [getFloat16BitsArray(input)], new.target);\n    } else if (isObject(input) && !isAnyArrayBuffer(input)) { // object without ArrayBuffer, SharedArrayBuffer\n      /** @type {ArrayLike<unknown>} */\n      let list;\n      /** @type {number} */\n      let length;\n\n      if (isNativeTypedArray(input)) { // TypedArray\n        list = input;\n        length = TypedArrayPrototypeGetLength(input);\n\n        const buffer = TypedArrayPrototypeGetBuffer(input);\n\n        if (IsDetachedBuffer(buffer)) {\n          throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n        }\n\n        if (isNativeBigIntTypedArray(input)) {\n          throw NativeTypeError(CANNOT_MIX_BIGINT_AND_OTHER_TYPES);\n        }\n\n        const data = new NativeArrayBuffer(\n          length * BYTES_PER_ELEMENT\n        );\n        float16bitsArray = ReflectConstruct(NativeUint16Array, [data], new.target);\n      } else {\n        const iterator = input[SymbolIterator];\n        if (iterator != null && typeof iterator !== \"function\") {\n          throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE);\n        }\n\n        if (iterator != null) { // Iterable (Array)\n          // for optimization\n          if (isOrdinaryArray(input)) {\n            list = input;\n            length = input.length;\n          } else {\n            // eslint-disable-next-line no-restricted-syntax\n            list = [... /** @type {Iterable<unknown>} */ (input)];\n            length = list.length;\n          }\n        } else { // ArrayLike\n          list = /** @type {ArrayLike<unknown>} */ (input);\n          length = ToLength(list.length);\n        }\n        float16bitsArray = ReflectConstruct(NativeUint16Array, [length], new.target);\n      }\n\n      // set values\n      for (let i = 0; i < length; ++i) {\n        float16bitsArray[i] = roundToFloat16Bits(list[i]);\n      }\n    } else { // primitive, ArrayBuffer, SharedArrayBuffer\n      float16bitsArray = ReflectConstruct(NativeUint16Array, arguments, new.target);\n    }\n\n    /** @type {Float16Array} */\n    const proxy = /** @type {any} */ (new NativeProxy(float16bitsArray, handler));\n\n    // proxy private storage\n    WeakMapPrototypeSet(float16bitsArrays, proxy, float16bitsArray);\n\n    return proxy;\n  }\n\n  /**\n   * limitation: `Object.getOwnPropertyNames(Float16Array)` or `Reflect.ownKeys(Float16Array)` include this key\n   * @see https://tc39.es/ecma262/#sec-%typedarray%.from\n   */\n  static from(src, ...opts) {\n    const Constructor = this;\n\n    if (!ReflectHas(Constructor, brand)) {\n      throw NativeTypeError(\n        THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY\n      );\n    }\n\n    // for optimization\n    if (Constructor === Float16Array) {\n      if (isFloat16Array(src) && opts.length === 0) {\n        const float16bitsArray = getFloat16BitsArray(src);\n        const uint16 = new NativeUint16Array(\n          TypedArrayPrototypeGetBuffer(float16bitsArray),\n          TypedArrayPrototypeGetByteOffset(float16bitsArray),\n          TypedArrayPrototypeGetLength(float16bitsArray)\n        );\n        return new Float16Array(\n          TypedArrayPrototypeGetBuffer(TypedArrayPrototypeSlice(uint16))\n        );\n      }\n\n      if (opts.length === 0) {\n        return new Float16Array(\n          TypedArrayPrototypeGetBuffer(\n            Uint16ArrayFrom(src, roundToFloat16Bits)\n          )\n        );\n      }\n\n      const mapFunc = opts[0];\n      const thisArg = opts[1];\n\n      return new Float16Array(\n        TypedArrayPrototypeGetBuffer(\n          Uint16ArrayFrom(src, function (val, ...args) {\n            return roundToFloat16Bits(\n              ReflectApply(mapFunc, this, [val, ...safeIfNeeded(args)])\n            );\n          }, thisArg)\n        )\n      );\n    }\n\n    /** @type {ArrayLike<unknown>} */\n    let list;\n    /** @type {number} */\n    let length;\n\n    const iterator = src[SymbolIterator];\n    if (iterator != null && typeof iterator !== \"function\") {\n      throw NativeTypeError(ITERATOR_PROPERTY_IS_NOT_CALLABLE);\n    }\n\n    if (iterator != null) { // Iterable (TypedArray, Array)\n      // for optimization\n      if (isOrdinaryArray(src)) {\n        list = src;\n        length = src.length;\n      } else if (isOrdinaryNativeTypedArray(src)) {\n        list = src;\n        length = TypedArrayPrototypeGetLength(src);\n      } else {\n        // eslint-disable-next-line no-restricted-syntax\n        list = [...src];\n        length = list.length;\n      }\n    } else { // ArrayLike\n      if (src == null) {\n        throw NativeTypeError(\n          CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n        );\n      }\n      list = NativeObject(src);\n      length = ToLength(list.length);\n    }\n\n    const array = new Constructor(length);\n\n    if (opts.length === 0) {\n      for (let i = 0; i < length; ++i) {\n        array[i] = /** @type {number} */ (list[i]);\n      }\n    } else {\n      const mapFunc = opts[0];\n      const thisArg = opts[1];\n      for (let i = 0; i < length; ++i) {\n        array[i] = ReflectApply(mapFunc, thisArg, [list[i], i]);\n      }\n    }\n\n    return array;\n  }\n\n  /**\n   * limitation: `Object.getOwnPropertyNames(Float16Array)` or `Reflect.ownKeys(Float16Array)` include this key\n   * @see https://tc39.es/ecma262/#sec-%typedarray%.of\n   */\n  static of(...items) {\n    const Constructor = this;\n\n    if (!ReflectHas(Constructor, brand)) {\n      throw NativeTypeError(\n        THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY\n      );\n    }\n\n    const length = items.length;\n\n    // for optimization\n    if (Constructor === Float16Array) {\n      const proxy = new Float16Array(length);\n      const float16bitsArray = getFloat16BitsArray(proxy);\n\n      for (let i = 0; i < length; ++i) {\n        float16bitsArray[i] = roundToFloat16Bits(items[i]);\n      }\n\n      return proxy;\n    }\n\n    const array = new Constructor(length);\n\n    for (let i = 0; i < length; ++i) {\n      array[i] = items[i];\n    }\n\n    return array;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.keys */\n  keys() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    return TypedArrayPrototypeKeys(float16bitsArray);\n  }\n\n  /**\n   * limitation: returns a object whose prototype is not `%ArrayIteratorPrototype%`\n   * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.values\n   */\n  values() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    return wrap((function* () {\n      // eslint-disable-next-line no-restricted-syntax\n      for (const val of TypedArrayPrototypeValues(float16bitsArray)) {\n        yield convertToNumber(val);\n      }\n    })());\n  }\n\n  /**\n   * limitation: returns a object whose prototype is not `%ArrayIteratorPrototype%`\n   * @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.entries\n   */\n  entries() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    return wrap((function* () {\n      // eslint-disable-next-line no-restricted-syntax\n      for (const [i, val] of TypedArrayPrototypeEntries(float16bitsArray)) {\n        yield /** @type {[number, number]} */ ([i, convertToNumber(val)]);\n      }\n    })());\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.at */\n  at(index) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const relativeIndex = ToIntegerOrInfinity(index);\n    const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;\n\n    if (k < 0 || k >= length) {\n      return;\n    }\n\n    return convertToNumber(float16bitsArray[k]);\n  }\n\n  /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.with */\n  with(index, value) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const relativeIndex = ToIntegerOrInfinity(index);\n    const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;\n\n    const number = +value;\n\n    if (k < 0 || k >= length) {\n      throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);\n    }\n\n    // don't use SpeciesConstructor\n    const uint16 = new NativeUint16Array(\n      TypedArrayPrototypeGetBuffer(float16bitsArray),\n      TypedArrayPrototypeGetByteOffset(float16bitsArray),\n      TypedArrayPrototypeGetLength(float16bitsArray)\n    );\n    const cloned = new Float16Array(\n      TypedArrayPrototypeGetBuffer(\n        TypedArrayPrototypeSlice(uint16)\n      )\n    );\n    const array = getFloat16BitsArray(cloned);\n\n    array[k] = roundToFloat16Bits(number);\n\n    return cloned;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.map */\n  map(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n\n    // for optimization\n    if (Constructor === Float16Array) {\n      const proxy = new Float16Array(length);\n      const array = getFloat16BitsArray(proxy);\n\n      for (let i = 0; i < length; ++i) {\n        const val = convertToNumber(float16bitsArray[i]);\n        array[i] = roundToFloat16Bits(\n          ReflectApply(callback, thisArg, [val, i, this])\n        );\n      }\n\n      return proxy;\n    }\n\n    const array = new Constructor(length);\n    assertSpeciesTypedArray(array, length);\n\n    for (let i = 0; i < length; ++i) {\n      const val = convertToNumber(float16bitsArray[i]);\n      array[i] = ReflectApply(callback, thisArg, [val, i, this]);\n    }\n\n    return /** @type {any} */ (array);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.filter */\n  filter(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    const kept = [];\n    for (let i = 0; i < length; ++i) {\n      const val = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [val, i, this])) {\n        ArrayPrototypePush(kept, val);\n      }\n    }\n\n    const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n    const array = new Constructor(kept);\n    assertSpeciesTypedArray(array);\n\n    return /** @type {any} */ (array);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduce */\n  reduce(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    if (length === 0 && opts.length === 0) {\n      throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);\n    }\n\n    let accumulator, start;\n    if (opts.length === 0) {\n      accumulator = convertToNumber(float16bitsArray[0]);\n      start = 1;\n    } else {\n      accumulator = opts[0];\n      start = 0;\n    }\n\n    for (let i = start; i < length; ++i) {\n      accumulator = callback(\n        accumulator,\n        convertToNumber(float16bitsArray[i]),\n        i,\n        this\n      );\n    }\n\n    return accumulator;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduceright */\n  reduceRight(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    if (length === 0 && opts.length === 0) {\n      throw NativeTypeError(REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);\n    }\n\n    let accumulator, start;\n    if (opts.length === 0) {\n      accumulator = convertToNumber(float16bitsArray[length - 1]);\n      start = length - 2;\n    } else {\n      accumulator = opts[0];\n      start = length - 1;\n    }\n\n    for (let i = start; i >= 0; --i) {\n      accumulator = callback(\n        accumulator,\n        convertToNumber(float16bitsArray[i]),\n        i,\n        this\n      );\n    }\n\n    return accumulator;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.foreach */\n  forEach(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      ReflectApply(callback, thisArg, [\n        convertToNumber(float16bitsArray[i]),\n        i,\n        this,\n      ]);\n    }\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.find */\n  find(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      const value = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [value, i, this])) {\n        return value;\n      }\n    }\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.findindex */\n  findIndex(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      const value = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [value, i, this])) {\n        return i;\n      }\n    }\n\n    return -1;\n  }\n\n  /** @see https://tc39.es/proposal-array-find-from-last/index.html#sec-%typedarray%.prototype.findlast */\n  findLast(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = length - 1; i >= 0; --i) {\n      const value = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [value, i, this])) {\n        return value;\n      }\n    }\n  }\n\n  /** @see https://tc39.es/proposal-array-find-from-last/index.html#sec-%typedarray%.prototype.findlastindex */\n  findLastIndex(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = length - 1; i >= 0; --i) {\n      const value = convertToNumber(float16bitsArray[i]);\n      if (ReflectApply(callback, thisArg, [value, i, this])) {\n        return i;\n      }\n    }\n\n    return -1;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.every */\n  every(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      if (\n        !ReflectApply(callback, thisArg, [\n          convertToNumber(float16bitsArray[i]),\n          i,\n          this,\n        ])\n      ) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.some */\n  some(callback, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const thisArg = opts[0];\n\n    for (let i = 0; i < length; ++i) {\n      if (\n        ReflectApply(callback, thisArg, [\n          convertToNumber(float16bitsArray[i]),\n          i,\n          this,\n        ])\n      ) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.set */\n  set(input, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const targetOffset = ToIntegerOrInfinity(opts[0]);\n    if (targetOffset < 0) {\n      throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);\n    }\n\n    if (input == null) {\n      throw NativeTypeError(\n        CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT\n      );\n    }\n\n    if (isNativeBigIntTypedArray(input)) {\n      throw NativeTypeError(\n        CANNOT_MIX_BIGINT_AND_OTHER_TYPES\n      );\n    }\n\n    // for optimization\n    if (isFloat16Array(input)) {\n      // peel off Proxy\n      return TypedArrayPrototypeSet(\n        getFloat16BitsArray(this),\n        getFloat16BitsArray(input),\n        targetOffset\n      );\n    }\n\n    if (isNativeTypedArray(input)) {\n      const buffer = TypedArrayPrototypeGetBuffer(input);\n      if (IsDetachedBuffer(buffer)) {\n        throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n      }\n    }\n\n    const targetLength = TypedArrayPrototypeGetLength(float16bitsArray);\n\n    const src = NativeObject(input);\n    const srcLength = ToLength(src.length);\n\n    if (targetOffset === Infinity || srcLength + targetOffset > targetLength) {\n      throw NativeRangeError(OFFSET_IS_OUT_OF_BOUNDS);\n    }\n\n    for (let i = 0; i < srcLength; ++i) {\n      float16bitsArray[i + targetOffset] = roundToFloat16Bits(src[i]);\n    }\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.reverse */\n  reverse() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    TypedArrayPrototypeReverse(float16bitsArray);\n\n    return this;\n  }\n\n  /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toReversed */\n  toReversed() {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    // don't use SpeciesConstructor\n    const uint16 = new NativeUint16Array(\n      TypedArrayPrototypeGetBuffer(float16bitsArray),\n      TypedArrayPrototypeGetByteOffset(float16bitsArray),\n      TypedArrayPrototypeGetLength(float16bitsArray)\n    );\n    const cloned = new Float16Array(\n      TypedArrayPrototypeGetBuffer(\n        TypedArrayPrototypeSlice(uint16)\n      )\n    );\n\n    const clonedFloat16bitsArray = getFloat16BitsArray(cloned);\n    TypedArrayPrototypeReverse(clonedFloat16bitsArray);\n\n    return cloned;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill */\n  fill(value, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    TypedArrayPrototypeFill(\n      float16bitsArray,\n      roundToFloat16Bits(value),\n      ...safeIfNeeded(opts)\n    );\n\n    return this;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.copywithin */\n  copyWithin(target, start, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    TypedArrayPrototypeCopyWithin(float16bitsArray, target, start, ...safeIfNeeded(opts));\n\n    return this;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort */\n  sort(compareFn) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const sortCompare = compareFn !== undefined ? compareFn : defaultCompare;\n    TypedArrayPrototypeSort(float16bitsArray, (x, y) => {\n      return sortCompare(convertToNumber(x), convertToNumber(y));\n    });\n\n    return this;\n  }\n\n  /** @see https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toSorted */\n  toSorted(compareFn) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    if (compareFn !== undefined && typeof compareFn !== \"function\") {\n      throw new NativeTypeError(THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED);\n    }\n    const sortCompare = compareFn !== undefined ? compareFn : defaultCompare;\n\n    // don't use SpeciesConstructor\n    const uint16 = new NativeUint16Array(\n      TypedArrayPrototypeGetBuffer(float16bitsArray),\n      TypedArrayPrototypeGetByteOffset(float16bitsArray),\n      TypedArrayPrototypeGetLength(float16bitsArray)\n    );\n    const cloned = new Float16Array(\n      TypedArrayPrototypeGetBuffer(\n        TypedArrayPrototypeSlice(uint16)\n      )\n    );\n\n    const clonedFloat16bitsArray = getFloat16BitsArray(cloned);\n    TypedArrayPrototypeSort(clonedFloat16bitsArray, (x, y) => {\n      return sortCompare(convertToNumber(x), convertToNumber(y));\n    });\n\n    return cloned;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.slice */\n  slice(start, end) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n\n    // for optimization\n    if (Constructor === Float16Array) {\n      const uint16 = new NativeUint16Array(\n        TypedArrayPrototypeGetBuffer(float16bitsArray),\n        TypedArrayPrototypeGetByteOffset(float16bitsArray),\n        TypedArrayPrototypeGetLength(float16bitsArray)\n      );\n      return new Float16Array(\n        TypedArrayPrototypeGetBuffer(\n          TypedArrayPrototypeSlice(uint16, start, end)\n        )\n      );\n    }\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n    const relativeStart = ToIntegerOrInfinity(start);\n    const relativeEnd = end === undefined ? length : ToIntegerOrInfinity(end);\n\n    let k;\n    if (relativeStart === -Infinity) {\n      k = 0;\n    } else if (relativeStart < 0) {\n      k = length + relativeStart > 0 ? length + relativeStart : 0;\n    } else {\n      k = length < relativeStart ? length : relativeStart;\n    }\n\n    let final;\n    if (relativeEnd === -Infinity) {\n      final = 0;\n    } else if (relativeEnd < 0) {\n      final = length + relativeEnd > 0 ? length + relativeEnd : 0;\n    } else {\n      final = length < relativeEnd ? length : relativeEnd;\n    }\n\n    const count = final - k > 0 ? final - k : 0;\n    const array = new Constructor(count);\n    assertSpeciesTypedArray(array, count);\n\n    if (count === 0) {\n      return array;\n    }\n\n    const buffer = TypedArrayPrototypeGetBuffer(float16bitsArray);\n    if (IsDetachedBuffer(buffer)) {\n      throw NativeTypeError(ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);\n    }\n\n    let n = 0;\n    while (k < final) {\n      array[n] = convertToNumber(float16bitsArray[k]);\n      ++k;\n      ++n;\n    }\n\n    return /** @type {any} */ (array);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.subarray */\n  subarray(begin, end) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const Constructor = SpeciesConstructor(float16bitsArray, Float16Array);\n\n    const uint16 = new NativeUint16Array(\n      TypedArrayPrototypeGetBuffer(float16bitsArray),\n      TypedArrayPrototypeGetByteOffset(float16bitsArray),\n      TypedArrayPrototypeGetLength(float16bitsArray)\n    );\n    const uint16Subarray = TypedArrayPrototypeSubarray(uint16, begin, end);\n\n    const array = new Constructor(\n      TypedArrayPrototypeGetBuffer(uint16Subarray),\n      TypedArrayPrototypeGetByteOffset(uint16Subarray),\n      TypedArrayPrototypeGetLength(uint16Subarray)\n    );\n    assertSpeciesTypedArray(array);\n\n    return /** @type {any} */ (array);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.indexof */\n  indexOf(element, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n\n    let from = ToIntegerOrInfinity(opts[0]);\n    if (from === Infinity) {\n      return -1;\n    }\n\n    if (from < 0) {\n      from += length;\n      if (from < 0) {\n        from = 0;\n      }\n    }\n\n    for (let i = from; i < length; ++i) {\n      if (\n        ObjectHasOwn(float16bitsArray, i) &&\n        convertToNumber(float16bitsArray[i]) === element\n      ) {\n        return i;\n      }\n    }\n\n    return -1;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.lastindexof */\n  lastIndexOf(element, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n\n    let from = opts.length >= 1 ? ToIntegerOrInfinity(opts[0]) : length - 1;\n    if (from === -Infinity) {\n      return -1;\n    }\n\n    if (from >= 0) {\n      from = from < length - 1 ? from : length - 1;\n    } else {\n      from += length;\n    }\n\n    for (let i = from; i >= 0; --i) {\n      if (\n        ObjectHasOwn(float16bitsArray, i) &&\n        convertToNumber(float16bitsArray[i]) === element\n      ) {\n        return i;\n      }\n    }\n\n    return -1;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.includes */\n  includes(element, ...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const length = TypedArrayPrototypeGetLength(float16bitsArray);\n\n    let from = ToIntegerOrInfinity(opts[0]);\n    if (from === Infinity) {\n      return false;\n    }\n\n    if (from < 0) {\n      from += length;\n      if (from < 0) {\n        from = 0;\n      }\n    }\n\n    const isNaN = NumberIsNaN(element);\n    for (let i = from; i < length; ++i) {\n      const value = convertToNumber(float16bitsArray[i]);\n\n      if (isNaN && NumberIsNaN(value)) {\n        return true;\n      }\n\n      if (value === element) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.join */\n  join(separator) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const array = copyToArray(float16bitsArray);\n\n    return ArrayPrototypeJoin(array, separator);\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype.tolocalestring */\n  toLocaleString(...opts) {\n    assertFloat16Array(this);\n    const float16bitsArray = getFloat16BitsArray(this);\n\n    const array = copyToArray(float16bitsArray);\n\n    return ArrayPrototypeToLocaleString(array, ...safeIfNeeded(opts));\n  }\n\n  /** @see https://tc39.es/ecma262/#sec-get-%typedarray%.prototype-@@tostringtag */\n  get [SymbolToStringTag]() {\n    if (isFloat16Array(this)) {\n      return /** @type {any} */ (\"Float16Array\");\n    }\n  }\n}\n\n/** @see https://tc39.es/ecma262/#sec-typedarray.bytes_per_element */\nObjectDefineProperty(Float16Array, \"BYTES_PER_ELEMENT\", {\n  value: BYTES_PER_ELEMENT,\n});\n\n// limitation: It is peaked by `Object.getOwnPropertySymbols(Float16Array)` and `Reflect.ownKeys(Float16Array)`\nObjectDefineProperty(Float16Array, brand, {});\n\n/** @see https://tc39.es/ecma262/#sec-properties-of-the-typedarray-constructors */\nReflectSetPrototypeOf(Float16Array, TypedArray);\n\nconst Float16ArrayPrototype = Float16Array.prototype;\n\n/** @see https://tc39.es/ecma262/#sec-typedarray.prototype.bytes_per_element */\nObjectDefineProperty(Float16ArrayPrototype, \"BYTES_PER_ELEMENT\", {\n  value: BYTES_PER_ELEMENT,\n});\n\n/** @see https://tc39.es/ecma262/#sec-%typedarray%.prototype-@@iterator */\nObjectDefineProperty(Float16ArrayPrototype, SymbolIterator, {\n  value: Float16ArrayPrototype.values,\n  writable: true,\n  configurable: true,\n});\n\nReflectSetPrototypeOf(Float16ArrayPrototype, TypedArrayPrototype);\n","\nconst hex2rgba = (hexstr: string, out_type?: string) : [number, number, number, number] => {\n    out_type = out_type === undefined ? 'float' : out_type;\n\n    const match = hexstr.match(/#([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})?/i);\n    if (match === null) {\n        throw `Got '${hexstr}' in hex2rgba, which does not look like a hex color`;\n    }\n\n    let rgba = match.slice(1).filter(c => c !== undefined).map(c => parseInt(c, 16));\n\n    if (out_type == 'float') {\n        rgba = rgba.map(c => c / 255);\n    }\n\n    return rgba[3] === undefined ? [rgba[0], rgba[1], rgba[2], 1] : [rgba[0], rgba[1], rgba[2], rgba[3]];\n}\n\nconst rgba2hex = (rgba: [number, number, number, number], in_type?: string) : string => {\n    in_type = in_type === undefined ? 'float' : in_type;\n\n    let rgba_ = rgba as number[];\n    if (in_type == 'float') {\n        rgba_ = rgba_.map(c => Math.round(c * 255));\n    }\n\n    return '#' + rgba_.map(c => c.toString(16).padStart(2, '0').toUpperCase()).join('');\n}\n\nconst rgb2hsv = (rgb: [number, number, number]) : [number, number, number] => {\n    const [r, g, b] = rgb;\n\n    const Cmax = Math.max(r, g, b);\n    const Cmin = Math.min(r, g, b);\n    const Delta = Cmax - Cmin;\n    \n    let H: number;\n    if (Delta == 0) {\n        H = 0;\n    }\n    else if (Cmax == r) {\n        H = 60 * ((g - b) / Delta) % 6;\n    }\n    else if (Cmax == g) {\n        H = 60 * ((b - r) / Delta + 2);\n    }\n    else if (Cmax == b) {\n        H = 60 * ((r - g) / Delta + 4);\n    }\n    else {\n        throw \"You've messed something up in rgb2hsv()\";\n    }\n\n    let S = Cmax == 0 ? 0 : Delta / Cmax;\n    let V = Cmax;\n\n    return [H, S, V];\n}\n\nconst hsv2rgb = (hsv: [number, number, number]) : [number, number, number] => {\n    const [H, S, V] = hsv;\n\n    const C = V * S;\n    const X = C * (1 - Math.abs(H / 60 % 2 - 1));\n    const m = V - C;\n\n    let r_prime, g_prime, b_prime;\n    if (0 <= H && H < 60) {\n        r_prime = C; g_prime = X, b_prime = 0;\n    }\n    else if (60 <= H && H < 120) {\n        r_prime = X; g_prime = C, b_prime = 0;\n    }\n    else if (120 <= H && H < 180) {\n        r_prime = 0; g_prime = C, b_prime = X;\n    }\n    else if (180 <= H && H < 240) {\n        r_prime = 0; g_prime = X, b_prime = C;\n    }\n    else if (240 <= H && H < 300) {\n        r_prime = X; g_prime = 0, b_prime = C;\n    }\n    else if (300 <= H && H < 360) {\n        r_prime = C; g_prime = 0, b_prime = X;\n    }\n    else {\n        throw \"H is out of bounds in hsv2rgb\";\n    }\n\n    return [r_prime + m, g_prime + m, b_prime + m];\n}\n\n/** A class for handling colors and translations between different color spaces */\nclass Color {\n    private rgba: [number, number, number, number];\n\n    /**\n     * Create a new color object\n     * @param rgba - An RGBA tuple of floats between 0 and 1\n     */\n    constructor(rgba: [number, number, number, number]) {\n        this.rgba = rgba;\n    }\n\n    /**\n     * The red component of the color as a float value between 0 and 1\n     */\n    get r() {\n        return this.rgba[0];\n    }\n\n    /**\n     * The green component of the color as a float value between 0 and 1\n     */\n    get g() {\n        return this.rgba[1];\n    }\n\n    /**\n     * The blue component of the color as a float value between 0 and 1\n     */\n    get b() {\n        return this.rgba[2];\n    }\n\n    /**\n     * The alpha component (opacity) of the color as a float value between 0 and 1\n     */\n    get a() {\n        return this.rgba[3];\n    }\n\n    /**\n     * @param opacity - The new alpha component (opacity)\n     * @returns A new color with the alpha component set to opacity.\n     */\n    withOpacity(opacity: number) {\n        return new Color([this.r, this.g, this.b, opacity]);\n    }\n\n    /**\n     * @returns The color as an RGB hex string (e.g., '#dedbef')\n     */\n    toRGBHex() {\n        return this.toRGBAHex().slice(0, -2);\n    }\n\n    /**\n     * @returns The color as an RGBA hex string (e.g., '#dedbefff')\n     */\n    toRGBAHex() {\n        return rgba2hex(this.rgba);\n    }\n\n    /**\n     * @returns The color as an RGBA float tuple\n     */\n    toRGBATuple() {\n        return this.rgba;\n    }\n\n    /**\n     * @returns The color as a tuple of HSV values\n     */\n    toHSVTuple() {\n        return rgb2hsv([this.r, this.g, this.b]);\n    }\n\n    /**\n     * @param hex - An RGB or RGBA hex string to parse\n     * @returns a new Color object\n     */\n    static fromHex(hex: string) {\n        return new Color(hex2rgba(hex));\n    }\n\n    /**\n     * @param hsv - A tuple of HSV values\n     * @returns a new Color object\n     */\n    static fromHSVTuple(hsv: [number, number, number]) {\n        const rgb = hsv2rgb(hsv);\n        return new Color([rgb[0], rgb[1], rgb[2], 1]);\n    }\n\n    static normalizeColor(color: Color | string) {\n        return color instanceof Color ? color : Color.fromHex(color);\n    }\n}\n\nexport {Color};","\nimport spd500_colormap_data from \"./json/pw500speed_colormap.json\";\nimport spd850_colormap_data from \"./json/pw850speed_colormap.json\";\nimport cape_colormap_data from \"./json/pwcape_colormap.json\";\nimport t2m_colormap_data from \"./json/pwt2m_colormap.json\";\nimport td2m_colormap_data from \"./json/pwtd2m_colormap.json\";\nimport nws_storm_clear_refl_colormap_data from \"./json/nws_storm_clear_refl_colormap.json\";\nimport wv_cimss_data from \"./json/wv_cimss.json\";\nimport { Float16Array } from \"@petamoriken/float16\";\nimport { WGLProgram, WGLTexture } from \"autumn-wgl\";\nimport { WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { getGLFormatTypeAlignment } from \"./PlotComponent\";\nimport { Color } from \"./Color\";\nimport { mergeShaderCode } from \"./utils\";\n\nconst colormap_shader_src = require('./glsl/colormap.glsl');\n\n/** Options for {@link ColorMap}s */\ninterface ColorMapOptions {\n    /** The color to use for areas where the value is above the highest value in the color map */\n    overflow_color?: Color | string;\n\n    /** The color to use for areas where the value is below the lowest value in the color map */\n    underflow_color?: Color | string;\n}\n\n/** A mapping from values to colors */\nclass ColorMap {\n    public readonly levels: number[];\n    public readonly colors: Color[];\n    public readonly overflow_color: Color | null;\n    public readonly underflow_color: Color | null;\n\n    /**\n     * Create a color map\n     * @param levels - The list of levels. The number of levels should always be one more than the number of colors.\n     * @param colors - A list of colors\n     * @param opts   - Options for the color map\n     */\n    constructor(levels: number[], colors: Color[] | string[], opts?: ColorMapOptions) {\n        if (levels.length != colors.length + 1) {\n            throw `Mismatch between number of levels (${levels.length}) and number of colors (${colors.length}; expected ${levels.length - 1})`;\n        }\n\n        this.levels = levels;\n        this.colors = colors.map(c => Color.normalizeColor(c));\n\n        opts = opts === undefined ? {} : opts;\n        this.overflow_color = opts.overflow_color === undefined ? null : Color.normalizeColor(opts.overflow_color);\n        this.underflow_color = opts.underflow_color === undefined ? null : Color.normalizeColor(opts.underflow_color);\n    }\n\n    /**\n     * @returns an array of hex color strings\n     */\n    public getColors() : string[] {\n        return this.colors.map(s => s.toRGBHex());\n    }\n\n    /**\n     * @returns an array of opacities, one for each color in the color map\n     */\n    public getOpacities() : number[] {\n        return this.colors.map(s => s.a);\n    }\n\n    /**\n     * Sample from the color map\n     * @param val - The value to sample from the color map\n     * @returns A color as an RGBA hex string\n     */\n    public getColor(val: number) : string {\n        if (val < this.levels[0]) {\n            return this.underflow_color === null ? '#00000000' : this.underflow_color.toRGBAHex();\n        }\n\n        if (val > this.levels[this.levels.length - 1]) {\n            return this.overflow_color === null ? '#00000000' : this.overflow_color.toRGBAHex();\n        }\n\n        let ilev = -1;\n        for (ilev = 0; ilev < this.levels.length - 1; ilev++) {\n            if (this.levels[ilev] <= val && val < this.levels[ilev + 1]) break;\n        }\n\n        return this.colors[Math.min(ilev, this.levels.length - 2)].toRGBAHex();\n    }\n\n    /**\n     * Make a new color map with different opacities. The opacities are set by func.\n     * @param func - A function which takes the two levels associated with a color (an upper and lower bound) and returns an opacity in the range from 0 to 1.\n     * @returns A new color map\n     */\n    public withOpacity(func: (level_lower: number, level_upper: number) => number) {\n        const new_colors: Color[] = [];\n        const new_levels: number[] = [];\n        const opts: ColorMapOptions = {};\n\n        for (let ic = 0 ; ic < this.colors.length ; ic++) {\n            const color = this.colors[ic];\n            const level_lower = this.levels[ic];\n            const level_upper = this.levels[ic + 1];\n\n            const new_opacity = func(level_lower, level_upper)\n            const new_color = color.withOpacity(new_opacity);\n            if (new_opacity > 0) {\n                if (new_levels[new_levels.length - 1] != level_lower)\n                    new_levels.push(level_lower)\n                new_levels.push(level_upper);\n                new_colors.push(new_color);\n            }\n        }\n\n        if (this.underflow_color !== null) {\n            const underflow_opacity = func(this.levels[0], this.levels[0]);\n            if (underflow_opacity > 0) {\n                opts.underflow_color = this.underflow_color.withOpacity(underflow_opacity);\n            }\n        }\n\n        if (this.overflow_color !== null) {\n            const overflow_opacity = func(this.levels[this.levels.length - 1], this.levels[this.levels.length - 1]);\n            if (overflow_opacity > 0) {\n                opts.overflow_color = this.overflow_color.withOpacity(overflow_opacity);\n            }\n        }\n        \n        return new ColorMap(new_levels, new_colors, opts);\n    }\n\n    /**\n     * Create a diverging color map using two input colors\n     * @param color1    - The color corresponding to the lowest value in the color map\n     * @param color2    - The color corresponding to the highest value in the color map\n     * @param level_min - The lowest value in the color map\n     * @param level_max - The highest value in the color map\n     * @param n_colors  - The number of colors to use\n     * @returns a Colormap object\n     */\n    public static diverging(color1: string, color2: string, level_min: number, level_max: number, n_colors: number) {\n        const stops: Color[] = [];\n        const levels: number[] = [];\n\n        const level_step = (level_max - level_min) / (n_colors - 1);\n        const crossover = (level_max + level_min) / 2;\n        const crossover_hsv: [number, number, number] = [0, 0, 0.9];\n\n        const color1_hsv = Color.fromHex(color1).toHSVTuple();\n        const color2_hsv = Color.fromHex(color2).toHSVTuple();\n        const interp_fac_power = 1.5;\n\n        for (let istop = 0; istop < n_colors; istop++) {\n            const level = level_min + istop * level_step;\n            let h, s, v;\n            let interp_fac;\n            if (level < crossover) {\n                interp_fac = Math.pow((crossover - level) / (crossover - level_min), interp_fac_power);\n\n                [h, s, v] = [\n                    color1_hsv[0], \n                    crossover_hsv[1] + (color1_hsv[1] - crossover_hsv[1]) * interp_fac,\n                    crossover_hsv[2] + (color1_hsv[2] - crossover_hsv[2]) * interp_fac]\n            }\n            else {\n                interp_fac = Math.pow((level - crossover) / (level_max - crossover), interp_fac_power);\n                \n                [h, s, v] = [\n                    color2_hsv[0], \n                    crossover_hsv[1] + (color2_hsv[1] - crossover_hsv[1]) * interp_fac,\n                    crossover_hsv[2] + (color2_hsv[2] - crossover_hsv[2]) * interp_fac]\n            }\n\n            stops.push(Color.fromHSVTuple([h, s, v]).withOpacity(Math.min(2 * interp_fac, 1)));\n        }\n\n        for (let ilev = 0; ilev <= n_colors; ilev++) {\n            const level_step = (level_max - level_min) / n_colors;\n            levels.push(level_min + ilev * level_step);\n        }\n\n        return new ColorMap(levels, stops);\n    }\n}\n\nfunction buildColormap(cm_data: {levels: number[], colors: string[]}, overflow: 'under' | 'over' | 'both' | 'neither') {\n    const n_colors = cm_data.colors.length;\n    const opts: ColorMapOptions = {};\n\n    if (overflow == 'over' || overflow == 'both') {\n        opts.overflow_color = cm_data.colors[n_colors - 1];\n    }\n    if (overflow == 'under' || overflow == 'both') {\n        opts.underflow_color = cm_data.colors[0];\n    }\n\n    return new ColorMap(cm_data.levels, cm_data.colors, opts);\n}\n\n// This was dumb. Fix this later.\nwv_cimss_data.colors = wv_cimss_data.colors.reverse();\n\n// Some built-in colormaps\nconst pw_speed500mb = buildColormap(spd500_colormap_data, 'over').withOpacity((levl, levu) => Math.min((levu - 20) / 10, 1.));\nconst pw_speed850mb = buildColormap(spd850_colormap_data, 'over').withOpacity((levl, levu) => Math.min((levu - 20) / 10, 1.));\nconst pw_cape = buildColormap(cape_colormap_data, 'over').withOpacity((levl, levu) => Math.min(levu / 1000., 1.));\nconst pw_t2m = buildColormap(t2m_colormap_data, 'both');\nconst pw_td2m = buildColormap(td2m_colormap_data, 'both');\nconst nws_storm_clear_refl = buildColormap(nws_storm_clear_refl_colormap_data, 'over');\nconst wv_cimss = buildColormap(wv_cimss_data, 'neither');\n\n/**\n * Create a diverging red/blue colormap, where red corresponds to the lowest value and blue corresponds to the highest value\n * @param level_min - The lowest value in the color map\n * @param level_max - The highest value in the color map\n * @param n_colors  - The number of colors\n * @returns a Colormap object\n */\nconst redblue = (level_min: number, level_max: number, n_colors: number) => {\n    return ColorMap.diverging('#ff0000', '#0000ff', level_min, level_max, n_colors);\n}\n\n/**\n * Create a diverging blue/red colormap, where blue corresponds to the lowest value and red corresponds to the highest value\n * @param level_min - The lowest value in the color map\n * @param level_max - The highest value in the color map\n * @param n_colors  - The number of colors\n * @returns a Colormap object\n */\nconst bluered = (level_min: number, level_max: number, n_colors: number) => {\n    return ColorMap.diverging('#0000ff', '#ff0000', level_min, level_max, n_colors);\n}\n\n\ninterface ColorMapGLElems {\n    cmap_texture: WGLTexture;\n    cmap_nonlin_texture: WGLTexture;\n}\n\nconst N_INDEX_MAP = 101;\n\nclass ColorMapGPUInterface {\n    public readonly colormap: ColorMap;\n    public gl_elems: ColorMapGLElems | null;\n\n    constructor(colormap: ColorMap) {\n        this.colormap = colormap;\n        this.gl_elems = null;\n    }\n\n    public static applyShader(shader_src: string) {        \n        return mergeShaderCode(colormap_shader_src, shader_src);\n    }\n\n    public setupShaderVariables(gl: WebGLAnyRenderingContext, mag_filter: number) {\n        const index_map = makeIndexMap(this.colormap);\n        const cmap_image = makeTextureImage(this.colormap);\n\n        const {format: format_nonlin, type: type_nonlin, row_alignment: row_alignment_nonlin} = getGLFormatTypeAlignment(gl, 'float16');\n\n        const cmap_image_spec = {'format': gl.RGBA, 'type': gl.UNSIGNED_BYTE, 'image': cmap_image, 'mag_filter': mag_filter};\n        const cmap_texture = new WGLTexture(gl, cmap_image_spec);\n\n        const cmap_nonlin_image = {'format': format_nonlin, 'type': type_nonlin, \n            'width': index_map.length, 'height': 1,\n            'image': new Uint16Array(index_map.buffer), \n            'mag_filter': gl.LINEAR, 'row_alignment': row_alignment_nonlin,\n        };\n\n        const cmap_nonlin_texture = new WGLTexture(gl, cmap_nonlin_image);\n        this.gl_elems = {cmap_texture: cmap_texture, cmap_nonlin_texture: cmap_nonlin_texture};\n    }\n\n    public bindShaderVariables(program: WGLProgram) {\n        if (this.gl_elems === null) return;\n\n        const cmap = this.colormap;\n        const underflow_color = cmap.underflow_color === null ? [0, 0, 0, 0] : cmap.underflow_color.toRGBATuple();\n        const overflow_color = cmap.overflow_color === null ? [0, 0, 0, 0] : cmap.overflow_color.toRGBATuple();\n\n        program.setUniforms({'u_cmap_min': cmap.levels[0], 'u_cmap_max': cmap.levels[cmap.levels.length - 1],\n                             'u_n_index': N_INDEX_MAP, 'u_underflow_color': underflow_color, 'u_overflow_color': overflow_color});\n        program.bindTextures({'u_cmap_sampler': this.gl_elems.cmap_texture, 'u_cmap_nonlin_sampler': this.gl_elems.cmap_nonlin_texture});\n    }\n}\n\n/**\n * Make a canvas image corresponding to a color map\n * @param colormap - The color map to use\n * @returns A canvas element containing each color of the color map\n */\nfunction makeTextureImage(colormap: ColorMap) {\n    const cmap_image = document.createElement('canvas');\n    cmap_image.width = colormap.colors.length;\n    cmap_image.height = 1;\n\n    let ctx = cmap_image.getContext('2d');\n\n    colormap.colors.forEach((stop, istop) => {\n        if (ctx === null) {\n            throw \"Could not get rendering context for colormap image canvas\";\n        }\n\n        ctx.fillStyle = stop.toRGBAHex();\n        ctx.fillRect(istop, 0, 1, 1);\n    });\n\n    return cmap_image;\n}\n\nfunction makeIndexMap(colormap: ColorMap) {\n    // Build a texture to account for nonlinear colormaps (basically inverts the relationship between\n    //  the normalized index and the normalized level)\n    const n_nonlin = N_INDEX_MAP;\n    const map_norm = [];\n    for (let i = 0; i < n_nonlin; i++) {\n        map_norm.push(i / (n_nonlin - 1));\n    }\n\n    const levels = colormap.levels;\n    const n_lev = levels.length - 1;\n\n    const input_norm = levels.map((lev, ilev) => ilev / n_lev);\n    const cmap_norm = levels.map(lev => (lev - levels[0]) / (levels[n_lev] - levels[0]));\n    const inv_cmap_norm = map_norm.map(lev => {\n        let jlev;\n        for (jlev = 0; !(cmap_norm[jlev] <= lev && lev <= cmap_norm[jlev + 1]); jlev++) {}\n\n        const alpha = (lev - cmap_norm[jlev]) / (cmap_norm[jlev + 1] - cmap_norm[jlev]);\n        return input_norm[jlev] * (1 - alpha) + input_norm[jlev + 1] * alpha;\n    });\n\n    return new Float16Array(inv_cmap_norm);\n}\n\nexport {ColorMap, ColorMapGPUInterface, bluered, redblue, pw_speed500mb, pw_speed850mb, pw_cape, pw_t2m, pw_td2m, nws_storm_clear_refl, wv_cimss}\nexport type {ColorMapOptions};","import { WGLProgram } from \"autumn-wgl\";\nimport { RenderShaderData, RendererData, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { mergeShaderCode } from \"./utils\";\n\nclass ShaderProgramManager {\n    public readonly vertex_shader_src: string;\n    public readonly fragment_shader_src: string;\n    public readonly shader_defines: string[];\n    private readonly program_map:  Map<string, WGLProgram>;\n\n    constructor(vertex_shader_src: string, fragment_shader_src: string, shader_defines: string[]) {\n        this.vertex_shader_src = vertex_shader_src;\n        this.fragment_shader_src = fragment_shader_src;\n        this.shader_defines = shader_defines;\n\n        this.program_map = new Map();\n    }\n\n    public getShaderProgram(gl: WebGLAnyRenderingContext, shader_data: RenderShaderData | null) {\n        const shader_key = shader_data === null ? 'default' : shader_data.variantName;\n\n        const cached_program = this.program_map.get(shader_key);\n        if (cached_program !== undefined) {\n            return cached_program;\n        }\n\n        let vertex_src = this.vertex_shader_src;\n        if (shader_data !== null) {\n            vertex_src = mergeShaderCode(shader_data.vertexShaderPrelude + '\\n' + shader_data.define, vertex_src);\n        }\n        else {\n            const prelude = `\n            uniform mat4 u_projection_matrix;\n\n            vec4 projectTile(vec2 p) {\n                vec4 result = u_projection_matrix * vec4(p, 0.0, 1.0);\n                return result;\n            }`;\n\n            vertex_src = mergeShaderCode(prelude, vertex_src);\n        }\n\n        const program = new WGLProgram(gl, vertex_src, this.fragment_shader_src, {define: this.shader_defines});\n        this.program_map.set(shader_key, program);\n\n        return program;\n    }\n\n    public getShaderUniforms(render_data: RendererData) : Record<string, number | number[]> {\n        if (render_data.type == 'maplibre') {\n            if (render_data.shaderData.define.includes('GLOBE')) {\n                return {\n                    'u_projection_matrix': render_data.defaultProjectionData.mainMatrix,\n                    'u_projection_fallback_matrix': render_data.defaultProjectionData.fallbackMatrix,\n                    'u_projection_tile_mercator_coords': render_data.defaultProjectionData.tileMercatorCoords,\n                    'u_projection_clipping_plane': render_data.defaultProjectionData.clippingPlane,\n                    'u_projection_transition': render_data.defaultProjectionData.projectionTransition\n                };\n            }\n            else {\n                return {\n                    'u_projection_matrix': render_data.defaultProjectionData.mainMatrix,\n                };\n            }\n        }\n        else {\n            return {\n                'u_projection_matrix': render_data.mainMatrix,\n            }\n        }\n    }\n}\n\nexport {ShaderProgramManager};","\nimport { WGLBuffer, WGLTexture } from \"autumn-wgl\";\nimport { Polyline, LineData, WebGLAnyRenderingContext, isWebGL2Ctx, RenderMethodArg, getRendererData } from \"./AutumnTypes\";\nimport { ColorMap, ColorMapGPUInterface } from \"./Colormap\";\nimport { Color } from \"./Color\";\nimport { layer_worker } from \"./PlotComponent\";\nimport { ShaderProgramManager } from \"./ShaderManager\";\n\nconst polyline_vertex_src = require('./glsl/polyline_vertex.glsl');\nconst polyline_fragment_src = require('./glsl/polyline_fragment.glsl');\n\n/**\n * A style to use to draw lines. The possible options are '-' for a solid line, '--' for a dashed line, ':' for a\n *  dotted line, '-.' for a dash-dot line, or you could pass a list of numbers (e.g., [1, 1, 1, 0, 1, 0]) to\n *  specify a custom dash scheme.\n */\ntype LineStyle = \"-\" | \"--\" | \":\" | \"-.\" | number[];\n\nconst dash_arrays: Record<Exclude<LineStyle, number[]>, number[]> = {\n    \"-\": [1],\n    \"--\": [1, 1, 1, 1, 0, 0],\n    \":\": [1, 0],\n    \"-.\": [1, 1, 1, 0, 1, 0],\n}\n\nfunction isLineStyle(obj: any) : obj is LineStyle {\n    return obj in dash_arrays || Array.isArray(obj) && obj.length > 0 && obj.map(e => typeof e === 'number').reduce((a, b) => a && b, true);\n}\n\ninterface PolylineCollectionOpts {\n    offset_scale?: number;\n    offset_rotates_with_map?: boolean;\n    color?: string;\n    cmap?: ColorMap;\n    line_width?: number;\n    line_style?: LineStyle | number[];\n}\n\nfunction makeDashTexture(gl: WebGLAnyRenderingContext, line_style: LineStyle) {\n\n    const dash_array = Array.isArray(line_style) ? line_style : dash_arrays[line_style];\n\n    const is_webgl2 = isWebGL2Ctx(gl);\n    const format = is_webgl2 ? gl.R8 : gl.LUMINANCE;\n    const type = gl.UNSIGNED_BYTE;\n    const row_alignment = 1;\n\n    const fill_image = {'format': format, 'type': type,\n        'width': dash_array.length, 'height': 1, 'image': new Uint8Array(dash_array.map(d => d > 0 ? 255 : 0)),\n        'mag_filter': gl.NEAREST, 'row_alignment': row_alignment,\n    };\n\n    return [dash_array.length, new WGLTexture(gl, fill_image)] as [number, WGLTexture];\n}\n\nclass PolylineCollection {\n    public readonly width: number;\n    public readonly scale: number | null;\n\n    private readonly shader_manager: ShaderProgramManager;\n\n    private readonly vertices: WGLBuffer;\n    private readonly extrusion: WGLBuffer;\n\n    private readonly offset: WGLBuffer | null;\n    private readonly min_zoom: WGLBuffer | null;\n    private readonly line_data: WGLBuffer | null;\n    private readonly color: Color;\n    private readonly cmap_gpu: ColorMapGPUInterface | null;\n    private readonly offset_rotates_with_map: boolean;\n    private readonly dash_texture: WGLTexture;\n    private readonly n_dash: number;\n\n    private constructor(gl: WebGLAnyRenderingContext, polyline: Polyline, opts?: PolylineCollectionOpts) {\n        opts = opts === undefined ? {} : opts;\n        const color_hex = opts.color === undefined ? '#000000' : opts.color;\n        this.color = Color.fromHex(color_hex);\n\n        const line_width = opts.line_width === undefined ? 1 : opts.line_width;\n        const line_style = opts.line_style === undefined ? '-' : opts.line_style;\n        this.offset_rotates_with_map = opts.offset_rotates_with_map === undefined ? true : opts.offset_rotates_with_map;\n\n        this.width = line_width;\n\n        const shader_defines = [];\n\n        this.vertices = new WGLBuffer(gl, polyline['vertices'], 3, gl.TRIANGLE_STRIP);\n        this.extrusion = new WGLBuffer(gl, polyline['extrusion'], 2, gl.TRIANGLE_STRIP);\n\n        if (polyline.offsets !== undefined) {\n            this.offset = new WGLBuffer(gl, polyline.offsets, 2, gl.TRIANGLE_STRIP);\n            this.scale = opts.offset_scale === undefined ? 1 : opts.offset_scale;\n            shader_defines.push('OFFSET');\n        }\n        else {\n            this.offset = null;\n            this.scale = null;\n        }\n\n        if (polyline.zoom !== undefined) {\n            this.min_zoom = new WGLBuffer(gl, polyline.zoom, 1, gl.TRIANGLE_STRIP);\n            shader_defines.push('ZOOM');\n        }\n        else {\n            this.min_zoom = null;\n        }\n\n        let fragment_src = polyline_fragment_src;\n        if (polyline.data !== undefined) {\n            shader_defines.push('DATA');\n\n            this.line_data = new WGLBuffer(gl, polyline.data, 1, gl.TRIANGLE_STRIP);\n\n            const cmap = opts.cmap === undefined ? new ColorMap([0, 1], [color_hex], {overflow_color: color_hex, underflow_color: color_hex}) : opts.cmap;\n            this.cmap_gpu = new ColorMapGPUInterface(cmap);\n            this.cmap_gpu.setupShaderVariables(gl, gl.NEAREST);\n\n            fragment_src = ColorMapGPUInterface.applyShader(fragment_src);\n        }\n        else {\n            this.line_data = null;\n            this.cmap_gpu = null;\n        }\n\n        [this.n_dash, this.dash_texture] = makeDashTexture(gl, line_style);\n        this.shader_manager = new ShaderProgramManager(polyline_vertex_src, fragment_src, shader_defines);\n    }\n\n    static async make(gl: WebGLAnyRenderingContext, lines: LineData[], opts?: PolylineCollectionOpts) {\n        const polylines = await layer_worker.makePolyLines(lines);\n        return new PolylineCollection(gl, polylines, opts);\n    }\n\n    public render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg, [map_width, map_height]: [number, number], map_zoom: number, map_bearing: number, map_pitch: number) {\n        const render_data = getRendererData(arg);\n        const program = this.shader_manager.getShaderProgram(gl, render_data.shaderData);\n\n        const attributes: Record<string, WGLBuffer> = {'a_pos': this.vertices, 'a_extrusion': this.extrusion};\n        const uniforms: Record<string, number | number[]> = {\n            'u_line_width': this.width, 'u_map_width': map_width, 'u_map_height': map_height, 'u_offset': 0, 'u_zoom': map_zoom,\n            'u_dash_pattern_length': this.n_dash, ...this.shader_manager.getShaderUniforms(render_data)\n        };\n        const textures: Record<string, WGLTexture> = {'u_dash_sampler': this.dash_texture};\n\n        if (this.offset !== null && this.scale !== null) {\n            attributes['a_offset'] = this.offset;\n            uniforms['u_offset_scale'] = this.scale * (map_height / map_width);\n            uniforms['u_offset_rotates_with_map'] = this.offset_rotates_with_map ? 1 : 0;\n        }\n\n        if (this.min_zoom !== null) {\n            attributes['a_min_zoom'] = this.min_zoom;\n        }\n\n        if (this.line_data !== null) {\n            attributes['a_data'] = this.line_data;\n        }\n        else {\n            uniforms['u_color'] = this.color.toRGBATuple();\n        }\n\n        program.use(attributes, uniforms, textures);\n\n        if (this.cmap_gpu !== null) {\n            this.cmap_gpu.bindShaderVariables(program);\n        }\n\n        gl.enable(gl.BLEND);\n        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n        program.draw();\n\n        if (render_data.type != 'maplibre' || !render_data.shaderData.define.includes('GLOBE')) {\n            program.setUniforms({'u_offset': -2});\n            program.draw();\n\n            program.setUniforms({'u_offset': -1});\n            program.draw();\n\n            program.setUniforms({'u_offset': 1});\n            program.draw();\n        }\n    }\n}\n\nexport {PolylineCollection, isLineStyle};\nexport type {PolylineCollectionOpts, LineStyle};","import { getRendererData, isWebGL2Ctx, RenderMethodArg, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { Color } from \"./Color\";\nimport { ColorMap, ColorMapGPUInterface } from \"./Colormap\";\nimport { LngLat } from \"./Map\";\nimport { ShaderProgramManager } from \"./ShaderManager\";\nimport { Cache, normalizeOptions } from \"./utils\";\n\nimport { WGLBuffer, WGLTexture } from \"autumn-wgl\";\n\nimport Protobuf from 'pbf';\nimport potpack, {PotpackBox} from \"potpack\";\n\nconst text_vertex_shader_src = require('./glsl/text_vertex.glsl');\nconst text_fragment_shader_src = require('./glsl/text_fragment.glsl');\n\nconst PADDING = 3\n\ninterface PBFGlyph {\n    id: number;\n    data: Uint8Array;\n    width: number;\n    height: number;\n    left: number;\n    top: number;\n    advance: number;\n}\n\ninterface Glyph {\n    id: number;\n    width: number;\n    height: number;\n    left: number;\n    top: number;\n    atlas_i: number;\n    atlas_j: number;\n    advance: number;\n}\n\nfunction parseFontPBF(data: Uint8Array) {\n    const readGlyph = (tag: number, glyph: any, pbf?: Protobuf) => {\n        if (pbf === undefined)\n            return;\n\n        switch (tag) {\n            case 1:\n                glyph.id = pbf.readVarint();\n                break;\n            case 2:\n                glyph.data = pbf.readBytes();\n                break;\n            case 3:\n                glyph.width = pbf.readVarint() + 2 * PADDING;\n                break;\n            case 4:\n                glyph.height = pbf.readVarint() + 2 * PADDING;\n                break;\n            case 5:\n                glyph.left = pbf.readSVarint();\n                break;\n            case 6:\n                glyph.top = pbf.readSVarint();\n                break;\n            case 7:\n                glyph.advance = pbf.readVarint();\n                break;\n        }\n    }\n\n    const readFontStack = (tag: number, glyphs?: PBFGlyph[], pbf?: Protobuf) => {\n        if (glyphs === undefined || pbf === undefined)\n            return;\n        \n        if (tag == 3) {\n            const glyph = pbf.readMessage(readGlyph, {} as PBFGlyph);\n            glyphs.push(glyph);\n        }\n    }\n\n    const readFontStacks = (tag: number, glyphs?: PBFGlyph[], pbf?: Protobuf) => {\n        if (pbf === undefined) \n            return;\n\n        if (tag == 1) {\n            pbf.readMessage(readFontStack, glyphs);\n        }\n    }\n\n    return new Protobuf(data).readFields(readFontStacks, []);\n}\n\ninterface FontAtlas {\n    atlas: Uint8Array;\n    atlas_width: number;\n    atlas_height: number;\n    baseline: number;\n    top: number;\n    glyph_info: Record<number, Glyph>;\n}\n\nfunction createAtlas(pbf_glyphs: PBFGlyph[]): FontAtlas {\n    const pbf_glyphs_filtered = pbf_glyphs.filter(glyph => glyph.data !== undefined);\n\n    const glyph_bins: {glyph: PBFGlyph, bin: PotpackBox}[] = [];\n\n    const bins = pbf_glyphs_filtered.map(glyph => {\n        const bin = {x: 0, y: 0, w: glyph.width, h: glyph.height} as PotpackBox;\n        glyph_bins.push({glyph: glyph, bin: bin});\n\n        return bin;\n    });\n\n    const {w: img_width, h: img_height} = potpack(bins);\n\n    const atlas_data = new Uint8Array(img_width * img_height);\n    const glyphs: Record<number, Glyph> = {}\n    let max_glyph_height = 0;\n\n    glyph_bins.forEach(glyph_bin => {\n        const {bin, glyph} = glyph_bin;\n\n        if (bin.x === undefined || bin.y === undefined)\n            throw `Potpack couldn't pack this pot, I guess?`;\n\n        glyphs[glyph.id] = {\n            id: glyph.id, width: glyph.width, height: glyph.height, left: glyph.left, top: glyph.top,\n            atlas_i: bin.x, atlas_j: bin.y, advance: glyph.advance\n        };\n\n        max_glyph_height = Math.max(max_glyph_height, glyph.height);\n\n        for (let i = 0; i < glyph.width; i++) {\n            for (let j = 0; j < glyph.height; j++) {\n                const glyph_idx = i + glyph.width * j;\n                const atlas_idx = (i + bin.x) + img_width * (j + bin.y);\n                atlas_data[atlas_idx] = glyph.data[glyph_idx];\n            }\n        }\n    });\n\n    const glyph_M = glyphs['M'.charCodeAt(0)];\n    const baseline = glyph_M === undefined ? max_glyph_height : glyph_M.height - glyph_M.top;\n    const top = glyph_M === undefined ? 0 : -glyph_M.top;\n\n    return {atlas: atlas_data, atlas_width: img_width, atlas_height: img_height, baseline: baseline, top: top, glyph_info: glyphs};\n}\n\nconst FONT_ATLAS_CACHE = new Cache(async (urls: string[]) => {\n    const promises = urls.map(async url => {\n        const resp = await fetch(url);\n        \n        if (resp.status != 200) {\n            throw `Error ${resp.status} retrieving font pbf from '${url}'`;\n        }\n\n        const blob = await resp.blob();\n        const data_buffer = await blob.arrayBuffer();\n    \n        // Parse the PBF and get the glyph data\n        return parseFontPBF(new Uint8Array(data_buffer));\n    });\n\n    const glyphs = (await Promise.all(promises)).flat();\n\n    // Create an atlas for the glyphs\n    return createAtlas(glyphs);\n});\n\ninterface TextSpec {\n    lat: number;\n    lon: number;\n    text: string;\n    min_zoom?: number;\n    data_value?: number;\n}\n\ntype HorizontalAlign = 'left' | 'center' | 'right';\ntype VerticalAlign = 'baseline' | 'middle' | 'top';\n\ninterface TextCollectionOptions {\n    horizontal_align?: HorizontalAlign;\n    vertical_align?: VerticalAlign;\n    font_size?: number;\n    text_color?: Color;\n    cmap?: ColorMap | null;\n    halo_color?: Color;\n    halo?: boolean;\n    offset_x?: number;\n    offset_y?: number;\n}\n\nconst text_collection_opt_defaults: Required<TextCollectionOptions> = {\n    horizontal_align: 'left',\n    vertical_align: 'baseline',\n    font_size: 12,\n    text_color: new Color([0, 0, 0, 1]),\n    cmap: null,\n    halo_color: new Color([0, 0, 0, 1]),\n    halo: false,\n    offset_x: 0,\n    offset_y: 0\n}\n\nclass TextCollection {\n    readonly shader_manager: ShaderProgramManager;\n    readonly anchors: WGLBuffer;\n    readonly offsets: WGLBuffer;\n    readonly texcoords: WGLBuffer;\n    readonly data: WGLBuffer | null;\n    readonly texture: WGLTexture;\n\n    readonly cmap_gpu: ColorMapGPUInterface | null;\n\n    readonly opts: Required<TextCollectionOptions>;\n\n    private constructor(gl: WebGLAnyRenderingContext, text_locs: TextSpec[], font_atlas: FontAtlas, opts?: TextCollectionOptions) {\n        this.opts = normalizeOptions(opts, text_collection_opt_defaults);\n\n        const text_color_hex = this.opts.text_color === undefined ? new Color([0, 0, 0, 1]) : this.opts.text_color;\n        \n        const is_webgl2 = isWebGL2Ctx(gl);\n        const format = is_webgl2 ? gl.R8 : gl.LUMINANCE;\n        const type = gl.UNSIGNED_BYTE;\n        const row_alignment = 1;\n\n        const empty_atlas = font_atlas.atlas_width == 0 || font_atlas.atlas_height == 0 || font_atlas.atlas.length == 0;\n        const atlas_width = empty_atlas ? 1 : font_atlas.atlas_width;\n        const atlas_height = empty_atlas ? 1 : font_atlas.atlas_height\n        const atlas_data = empty_atlas ? new Uint8Array([0, 0, 0, 0]) : font_atlas.atlas;\n\n        const image = {\n            'format': format, 'type': type, 'width': atlas_width, 'height': atlas_height, \n            'image': atlas_data, 'row_alignment': row_alignment, 'mag_filter': gl.LINEAR\n        };\n\n        this.texture = new WGLTexture(gl, image);\n\n        const n_verts = text_locs.map(tl => tl.text.length).reduce((a, b) => a + b, 0) * 6;\n\n        const anchor_data = new Float32Array(n_verts * 3);\n        const offset_data = new Float32Array(n_verts * 2);\n        const tc_data = new Float32Array(n_verts * 2);\n        const value_data = new Float32Array(n_verts);\n\n        let i_anch = 0, i_off = 0, i_tc = 0, i_dat = 0;\n        let has_data = false;\n\n        text_locs.forEach(loc => {\n            const {lat, lon, text} = loc;\n            const min_zoom = loc.min_zoom === undefined ? 0 : loc.min_zoom;\n            const data_value = loc.data_value === undefined ? NaN : loc.data_value;\n            const {x: anchor_x, y: anchor_y} = new LngLat(lon, lat).toMercatorCoord();\n\n            has_data = has_data || loc.data_value !== undefined;\n            \n            let x_offset = this.opts.offset_x;\n            let y_offset = this.opts.offset_y;\n            const init_i_off = i_off;\n\n            for (let i = 0; i < text.length; i++) {\n                const glyph_code = text.charCodeAt(i);\n                const glyph_info = font_atlas.glyph_info[glyph_code];\n\n                if (glyph_info === undefined) {\n                    x_offset += 7;\n                    continue;\n                }\n\n                x_offset += glyph_info.left;\n\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                anchor_data[i_anch++] = anchor_x; anchor_data[i_anch++] = anchor_y; anchor_data[i_anch++] = min_zoom;\n                \n                offset_data[i_off++] = x_offset;                    offset_data[i_off++] = y_offset + font_atlas.baseline + glyph_info.top - glyph_info.height;\n                offset_data[i_off++] = x_offset;                    offset_data[i_off++] = y_offset + font_atlas.baseline + glyph_info.top - glyph_info.height;\n                offset_data[i_off++] = x_offset + glyph_info.width; offset_data[i_off++] = y_offset + font_atlas.baseline + glyph_info.top - glyph_info.height;\n                offset_data[i_off++] = x_offset;                    offset_data[i_off++] = y_offset + font_atlas.baseline + glyph_info.top;\n                offset_data[i_off++] = x_offset + glyph_info.width; offset_data[i_off++] = y_offset + font_atlas.baseline + glyph_info.top;\n                offset_data[i_off++] = x_offset + glyph_info.width; offset_data[i_off++] = y_offset + font_atlas.baseline + glyph_info.top;\n                \n                tc_data[i_tc++] = glyph_info.atlas_i / font_atlas.atlas_width;                      tc_data[i_tc++] = (glyph_info.atlas_j + glyph_info.height) / font_atlas.atlas_height;\n                tc_data[i_tc++] = glyph_info.atlas_i / font_atlas.atlas_width;                      tc_data[i_tc++] = (glyph_info.atlas_j + glyph_info.height) / font_atlas.atlas_height;\n                tc_data[i_tc++] = (glyph_info.atlas_i + glyph_info.width) / font_atlas.atlas_width; tc_data[i_tc++] = (glyph_info.atlas_j + glyph_info.height) / font_atlas.atlas_height;\n                tc_data[i_tc++] = glyph_info.atlas_i / font_atlas.atlas_width;                      tc_data[i_tc++] = glyph_info.atlas_j / font_atlas.atlas_height;\n                tc_data[i_tc++] = (glyph_info.atlas_i + glyph_info.width) / font_atlas.atlas_width; tc_data[i_tc++] = glyph_info.atlas_j / font_atlas.atlas_height;\n                tc_data[i_tc++] = (glyph_info.atlas_i + glyph_info.width) / font_atlas.atlas_width; tc_data[i_tc++] = glyph_info.atlas_j / font_atlas.atlas_height;\n\n                value_data[i_dat++] = data_value;\n                value_data[i_dat++] = data_value;\n                value_data[i_dat++] = data_value;\n                value_data[i_dat++] = data_value;\n                value_data[i_dat++] = data_value;\n                value_data[i_dat++] = data_value;\n\n                x_offset += glyph_info.advance - glyph_info.left;\n            }\n\n            if (this.opts.horizontal_align == 'center') {\n                for (let i = init_i_off; i < init_i_off + text.length * 12; i += 2) {\n                    offset_data[i] -= (x_offset - this.opts.offset_x) / 2;\n                }\n            }\n            else if (this.opts.horizontal_align == 'right') {\n                for (let i = init_i_off; i < init_i_off + text.length * 12; i += 2) {\n                    offset_data[i] -= (x_offset - this.opts.offset_x);\n                }\n            }\n\n            if (this.opts.vertical_align == 'top') {\n                for (let i = init_i_off + 1; i < init_i_off + text.length * 12; i += 2) {\n                    offset_data[i] -= (font_atlas.baseline - font_atlas.top);\n                }\n            }\n            else if (this.opts.vertical_align == 'middle') {\n                for (let i = init_i_off + 1; i < init_i_off + text.length * 12; i += 2) {\n                    offset_data[i] -= (font_atlas.baseline - font_atlas.top) / 2;\n                }\n            }\n        });\n\n        const shader_defines: string[] = [];\n        let fragment_src = text_fragment_shader_src;\n\n        if (has_data) {\n            shader_defines.push('DATA');\n\n            this.data = new WGLBuffer(gl, value_data, 1, gl.TRIANGLE_STRIP);\n\n            const cmap = this.opts.cmap === null ? new ColorMap([0, 1], [text_color_hex], {overflow_color: text_color_hex, underflow_color: text_color_hex}) : this.opts.cmap;\n            this.cmap_gpu = new ColorMapGPUInterface(cmap);\n            this.cmap_gpu.setupShaderVariables(gl, gl.NEAREST);\n\n            fragment_src = ColorMapGPUInterface.applyShader(fragment_src);\n        }\n        else {\n            this.data = null;\n            this.cmap_gpu = null;\n        }\n\n        this.shader_manager = new ShaderProgramManager(text_vertex_shader_src, fragment_src, shader_defines);\n\n        this.anchors = new WGLBuffer(gl, anchor_data, 3, gl.TRIANGLE_STRIP);\n        this.offsets = new WGLBuffer(gl, offset_data, 2, gl.TRIANGLE_STRIP);\n        this.texcoords = new WGLBuffer(gl, tc_data, 2, gl.TRIANGLE_STRIP);\n        this.data = has_data ? new WGLBuffer(gl, value_data, 1, gl.TRIANGLE_STRIP) : null;\n    }\n\n    static async make(gl: WebGLAnyRenderingContext, text_locs: TextSpec[], fontstack_url_template: string, opts?: TextCollectionOptions) {\n        const FONT_GROUP_SIZE = 256;\n        const characters = text_locs.map(tl => [...tl.text]).flat().map(c => c.charCodeAt(0)).filter((c, i, ary) => ary.indexOf(c) == i);\n\n        let stack_start: number, stack_end: number;\n\n        if (characters.length > 0) {\n            const char_code_min = Math.min(...characters);\n            const char_code_max = Math.max(...characters);\n\n            stack_start = Math.floor(char_code_min / FONT_GROUP_SIZE) * FONT_GROUP_SIZE;\n            stack_end = Math.floor(char_code_max / FONT_GROUP_SIZE) * FONT_GROUP_SIZE;\n        }\n        else {\n            stack_start = 0;\n            stack_end = 0;\n        }\n\n        const fontstack_urls = [];\n        for (let istack = stack_start; istack <= stack_end; istack += FONT_GROUP_SIZE) {\n            fontstack_urls.push(fontstack_url_template.replace('{range}', `${istack}-${istack + FONT_GROUP_SIZE - 1}`));\n        }\n\n        const atlas = await FONT_ATLAS_CACHE.getValue(fontstack_urls);\n        if (atlas.atlas_height == 0 || atlas.atlas_width == 0 || atlas.atlas.length == 0) console.warn(`No font data from '${fontstack_url_template}'`);\n\n        return new TextCollection(gl, text_locs, atlas, opts);\n    }\n\n    render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg, [map_width, map_height]: [number, number], map_zoom: number) {\n        const render_data = getRendererData(arg);\n        const program = this.shader_manager.getShaderProgram(gl, render_data.shaderData);\n\n        const attributes: Record<string, any> = {'a_pos': this.anchors, 'a_offset': this.offsets, 'a_tex_coord': this.texcoords};\n\n        const uniforms: Record<string, any> = {\n            'u_map_width': map_width, 'u_map_height': map_height, 'u_map_zoom': map_zoom, 'u_font_size': this.opts.font_size,\n            'u_halo_color': this.opts.halo_color.toRGBATuple(), 'u_offset': 0,\n            ...this.shader_manager.getShaderUniforms(render_data)\n        }\n\n        if (this.data !== null) {\n            attributes['a_value'] = this.data;\n        }\n        else {\n            uniforms['u_text_color'] = this.opts.text_color.toRGBATuple();\n        }\n\n        uniforms['u_is_halo'] = this.opts.halo ? 1 : 0;\n\n        program.use(\n            attributes,\n            uniforms,\n            {'u_sdf_sampler': this.texture}\n        );\n\n        if (this.cmap_gpu !== null) {\n            this.cmap_gpu.bindShaderVariables(program);\n        }\n\n        gl.enable(gl.BLEND);\n        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n        program.draw();\n\n        if (this.opts.halo) {\n            program.setUniforms({'u_is_halo': 0});\n            program.draw();\n        }\n\n        if (render_data.type != 'maplibre' || !render_data.shaderData.define.includes('GLOBE')) {\n            program.setUniforms({'u_offset': -2, 'u_is_halo': this.opts.halo ? 1 : 0});\n            program.draw();\n    \n            if (this.opts.halo) {\n                program.setUniforms({'u_is_halo': 0});\n                program.draw();\n            }\n    \n            program.setUniforms({'u_offset': -1, 'u_is_halo': this.opts.halo ? 1 : 0});\n            program.draw();\n    \n            if (this.opts.halo) {\n                program.setUniforms({'u_is_halo': 0});\n                program.draw();\n            }\n    \n            program.setUniforms({'u_offset': 1, 'u_is_halo': this.opts.halo ? 1 : 0});\n            program.draw();\n    \n            if (this.opts.halo) {\n                program.setUniforms({'u_is_halo': 0});\n                program.draw();\n            }\n        }\n    }\n}\n\nexport {TextCollection};\nexport type {TextSpec, TextCollectionOptions, HorizontalAlign, VerticalAlign};","\nexport default function potpack(boxes) {\n\n    // calculate total box area and maximum box width\n    let area = 0;\n    let maxWidth = 0;\n\n    for (const box of boxes) {\n        area += box.w * box.h;\n        maxWidth = Math.max(maxWidth, box.w);\n    }\n\n    // sort the boxes for insertion by height, descending\n    boxes.sort((a, b) => b.h - a.h);\n\n    // aim for a squarish resulting container,\n    // slightly adjusted for sub-100% space utilization\n    const startWidth = Math.max(Math.ceil(Math.sqrt(area / 0.95)), maxWidth);\n\n    // start with a single empty space, unbounded at the bottom\n    const spaces = [{x: 0, y: 0, w: startWidth, h: Infinity}];\n\n    let width = 0;\n    let height = 0;\n\n    for (const box of boxes) {\n        // look through spaces backwards so that we check smaller spaces first\n        for (let i = spaces.length - 1; i >= 0; i--) {\n            const space = spaces[i];\n\n            // look for empty spaces that can accommodate the current box\n            if (box.w > space.w || box.h > space.h) continue;\n\n            // found the space; add the box to its top-left corner\n            // |-------|-------|\n            // |  box  |       |\n            // |_______|       |\n            // |         space |\n            // |_______________|\n            box.x = space.x;\n            box.y = space.y;\n\n            height = Math.max(height, box.y + box.h);\n            width = Math.max(width, box.x + box.w);\n\n            if (box.w === space.w && box.h === space.h) {\n                // space matches the box exactly; remove it\n                const last = spaces.pop();\n                if (i < spaces.length) spaces[i] = last;\n\n            } else if (box.h === space.h) {\n                // space matches the box height; update it accordingly\n                // |-------|---------------|\n                // |  box  | updated space |\n                // |_______|_______________|\n                space.x += box.w;\n                space.w -= box.w;\n\n            } else if (box.w === space.w) {\n                // space matches the box width; update it accordingly\n                // |---------------|\n                // |      box      |\n                // |_______________|\n                // | updated space |\n                // |_______________|\n                space.y += box.h;\n                space.h -= box.h;\n\n            } else {\n                // otherwise the box splits the space into two spaces\n                // |-------|-----------|\n                // |  box  | new space |\n                // |_______|___________|\n                // | updated space     |\n                // |___________________|\n                spaces.push({\n                    x: space.x + box.w,\n                    y: space.y,\n                    w: space.w - box.w,\n                    h: box.h\n                });\n                space.y += box.h;\n                space.h -= box.h;\n            }\n            break;\n        }\n    }\n\n    return {\n        w: width, // container width\n        h: height, // container height\n        fill: (area / (width * height)) || 0 // space utilization\n    };\n}\n","import { WGLBuffer, WGLTexture, WGLTextureSpec } from \"autumn-wgl\";\nimport { TypedArray, WebGLAnyRenderingContext } from \"../AutumnTypes\";\nimport { Cache } from \"../utils\";\nimport { AbstractConstructor, Grid } from \"./Grid\";\nimport { getGLFormatTypeAlignment, layer_worker } from \"../PlotComponent\";\nimport { Float16Array } from \"@petamoriken/float16\";\n\nasync function makeWGLBillboardBuffers(gl: WebGLAnyRenderingContext, grid: AutoZoomGrid, thin_fac: number, map_max_zoom: number) {\n    const {lats: field_lats, lons: field_lons} = grid.getEarthCoords();\n    const min_zoom = grid.getMinVisibleZoom(thin_fac);\n    const bb_elements = await layer_worker.makeBBElements(field_lats, field_lons, min_zoom, grid.ni, grid.nj, map_max_zoom);\n\n    const vertices = new WGLBuffer(gl, bb_elements['pts'], 2, gl.POINTS, {per_instance: true});\n    const texcoords = new WGLBuffer(gl, bb_elements['tex_coords'], 2, gl.POINTS, {per_instance: true});\n\n    return {'vertices': vertices, 'texcoords': texcoords};\n}\n\nfunction makeVectorRotationTexture(gl: WebGLAnyRenderingContext, grid: AutoZoomGrid, data_are_earth_relative: boolean) {\n    const coords = grid.getEarthCoords();\n\n    const rot_vals = new Float16Array(grid.ni * grid.nj).fill(parseFloat('nan'));\n\n    if (data_are_earth_relative) {\n        rot_vals.fill(0);\n    }\n    else {\n        if (!grid.is_conformal) {\n            // If the grid is non-conformal, we need a fully general change of basis from grid coordinates to earth coordinates. This is not supported for now, so warn about it.\n            console.warn('Vector rotations for non-conformal projections are not supported. The output may look incorrect.')\n        }\n\n        for (let icd = 0; icd < coords.lats.length; icd++) {\n            const lon = coords.lons[icd];\n            const lat = coords.lats[icd];\n    \n            rot_vals[icd] = grid.getVectorRotationAtPoint(lon, lat);\n        }\n    }\n\n    const {format, type, row_alignment} = getGLFormatTypeAlignment(gl, 'float16');\n\n    const rot_img: WGLTextureSpec = {\n        format: format, type: type, row_alignment: row_alignment, image: new Uint16Array(rot_vals.buffer),\n        width: grid.ni, height: grid.nj, mag_filter: gl.LINEAR\n    };\n\n    const rot_tex = new WGLTexture(gl, rot_img);\n    return {'rotation': rot_tex};\n}\n\ninterface AutoZoomGridIntf {\n    getWGLBillboardBuffers(gl: WebGLAnyRenderingContext, thin_fac: number, max_zoom: number) : Promise<{'vertices': WGLBuffer, 'texcoords': WGLBuffer}>;\n    getVectorRotationTexture(gl: WebGLAnyRenderingContext, data_are_earth_relative: boolean) : {'rotation': WGLTexture};\n    getVectorRotationAtPoint(lon: number, lat: number) : number;\n    getMinVisibleZoom(thin_fac: number): Uint8Array;\n}\n\nfunction autoZoomGridMixin<G extends AbstractConstructor<Grid>>(base: G) : AbstractConstructor<AutoZoomGridIntf> & G {\n    abstract class AutoZoomGrid extends base {\n        private readonly billboard_buffer_cache: Cache<[WebGLAnyRenderingContext, number, number], Promise<{'vertices': WGLBuffer, 'texcoords': WGLBuffer}>>;\n        private readonly vector_rotation_cache: Cache<[WebGLAnyRenderingContext, boolean], {'rotation': WGLTexture}>\n\n        constructor(...args: any[]) {\n            super(...args);\n\n            this.billboard_buffer_cache = new Cache((gl: WebGLAnyRenderingContext, thin_fac: number, max_zoom: number) => {\n                return makeWGLBillboardBuffers(gl, this, thin_fac, max_zoom);\n            });\n\n            this.vector_rotation_cache = new Cache((gl: WebGLAnyRenderingContext, data_are_earth_relative: boolean) => {\n                return makeVectorRotationTexture(gl, this, data_are_earth_relative);\n            });\n        }\n\n        public async getWGLBillboardBuffers(gl: WebGLAnyRenderingContext, thin_fac: number, max_zoom: number) {\n            return await this.billboard_buffer_cache.getValue(gl, thin_fac, max_zoom);\n        }\n\n        public getVectorRotationTexture(gl: WebGLAnyRenderingContext, data_are_earth_relative: boolean) {\n            return this.vector_rotation_cache.getValue(gl, data_are_earth_relative);\n        }\n\n        public getVectorRotationAtPoint(lon: number, lat: number) {    \n            const [x, y] = this.transform(lon, lat);\n            const [x_pertlon, y_pertlon] = this.transform(lon + 0.01, lat);\n            return Math.atan2(y_pertlon - y, x_pertlon - x);\n        }\n\n        public abstract getMinVisibleZoom(thin_fac: number): Uint8Array;\n    }\n\n    return AutoZoomGrid;\n}\n\n/**\n * Grids of this type can be used with wind barbs, observations, and anything that needs automatic thinning.\n */\ntype AutoZoomGrid<T extends Grid = Grid> = InstanceType<ReturnType<typeof autoZoomGridMixin<AbstractConstructor<T>>>>;\n\nexport {autoZoomGridMixin};\nexport type {AutoZoomGrid, AutoZoomGridIntf};","import { TypedArray } from \"../AutumnTypes\";\n\ninterface EarthCoords {\n    lons: Float32Array;\n    lats: Float32Array;\n}\n\ninterface GridCoords {\n    x: Float32Array;\n    y: Float32Array;\n}\n\ntype GridType = 'latlon' | 'latlonrot' | 'lcc' | 'unstructured' | 'radar' | 'geostationary';\n\nconst WGS84_SEMIMAJOR = 6378137.0;\nconst WGS84_SEMIMINOR = 6356752.314245;\n\n/** The base class for grid types */\nabstract class Grid {\n    public readonly type: GridType;\n    public readonly ni: number;\n    public readonly nj: number;\n    public readonly is_conformal: boolean;\n\n    constructor(type: GridType, is_conformal: boolean, ni: number, nj: number) {\n        this.type = type;\n        this.is_conformal = is_conformal;\n        this.ni = ni;\n        this.nj = nj;\n    }\n\n    public abstract getEarthCoords(): EarthCoords;\n    public abstract getGridCoords(): GridCoords;\n    public abstract transform(x: number, y: number, opts?: {inverse?: boolean}): [number, number];\n    public abstract sampleNearestGridPoint(lon: number, lat: number, ary: TypedArray): {sample: number, sample_lon: number, sample_lat: number};\n\n    public abstract getThinnedGrid(thin_fac: number, map_max_zoom: number): this;\n    public abstract thinDataArray<ArrayType extends TypedArray>(original_grid: Grid, ary: ArrayType): ArrayType;\n\n    public abstract copy(): Grid;\n}\n\ntype AbstractConstructor<T> = abstract new(...args: any[]) => T;\n\nexport {Grid, WGS84_SEMIMAJOR, WGS84_SEMIMINOR};\nexport type {AbstractConstructor, EarthCoords, GridCoords, GridType};","import { kdTree } from \"kd-tree-javascript\";\nimport { Cache, argMin, getArrayConstructor } from \"../utils\";\nimport { autoZoomGridMixin } from \"./AutoZoom\";\nimport { Grid, GridCoords } from \"./Grid\";\nimport { LngLat } from \"../Map\";\nimport { TypedArray } from \"../AutumnTypes\";\n\n/**\n * An unstructured grid defined by a list of latitudes and longitudes \n *\n * ## Plot Component Compatibility\n * - :x:                `Fill`\n * - :x:                `Raster`\n * - :x:                `Contour`\n * - :x:                `Paintball`\n * - :white_check_mark: `Barbs`\n * - :white_check_mark: `Hodographs`\n * - :white_check_mark: `StationPlot`\n */\nclass UnstructuredGrid extends autoZoomGridMixin(Grid) {\n    public readonly coords: {lon: number, lat: number}[];\n    private readonly zoom_cache: Cache<[number], Uint8Array>\n    private readonly zoom_arg: Uint8Array | null;\n\n    /**\n     * Create an unstructured grid\n     * @param coords - The lat/lon coordinates of the grid points\n     */\n    constructor(coords: {lon: number, lat: number}[], zoom?: Uint8Array) {\n        const MAX_DIM = 4096;\n\n        super('unstructured', true, Math.min(coords.length, MAX_DIM), Math.floor(coords.length / MAX_DIM) + 1);\n        this.coords = coords;\n        this.zoom_arg = zoom === undefined ? null : zoom;\n\n        this.zoom_cache = new Cache((thin_fac: number) => {\n            interface kdNode {\n                x: number;\n                y: number;\n                min_zoom: number;\n            }\n    \n            const MAP_MAX_ZOOM = 24;\n            const offset = Math.log2(thin_fac);\n            const kd_nodes = this.coords.map(c => ({...new LngLat(c.lon, c.lat).toMercatorCoord(), min_zoom: MAP_MAX_ZOOM} as kdNode));\n            const tree = new kdTree([...kd_nodes], (a, b) => Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)), ['x', 'y']);\n    \n            const recursiveThin = (x: number, y: number, depth: number) => {\n                const size = Math.pow(0.5, depth + 1);\n                const nodes = tree.nearest({x: x, y: y, min_zoom: 0}, 2, size);\n\n                if (nodes.length > 0) {\n                    const [node, dist] = nodes.sort((a, b) => a[1] - b[1])[0];\n                    if (node.min_zoom == MAP_MAX_ZOOM) {\n                        node.min_zoom = Math.max(depth - offset, 0);\n                    }\n                }\n\n                if (nodes.length > 1 && depth < MAP_MAX_ZOOM + offset) {\n                    recursiveThin(x - size / 2, y - size / 2, depth + 1);\n                    recursiveThin(x + size / 2, y - size / 2, depth + 1);\n                    recursiveThin(x - size / 2, y + size / 2, depth + 1);\n                    recursiveThin(x + size / 2, y + size / 2, depth + 1);\n                }\n            }\n\n            // Start at -1 zoom depth, which should handle longitudes > 180 degrees.\n            recursiveThin(0.5, 0.5, -1);\n\n            return new Uint8Array(kd_nodes.map(n => n.min_zoom));\n        });\n    }\n\n    /** @internal */\n    public copy() {\n        return new UnstructuredGrid(this.coords);\n    }\n\n    /** @internal */\n    public getEarthCoords() {\n        return {lons: new Float32Array(this.coords.map(c => c.lon)), lats: new Float32Array(this.coords.map(c => c.lat))};\n    }\n\n    /** @internal */\n    public getGridCoords() {\n        const {lons, lats} = this.getEarthCoords();\n        return {x: lons, y: lats} as GridCoords;\n    }\n\n    /** @internal */\n    public transform(x: number, y: number, opts?: {inverse?: boolean}) {\n        return [x, y] as [number, number];\n    }\n\n    /** @internal */\n    public getMinVisibleZoom(thin_fac: number) {\n        if (this.zoom_arg !== null) \n            return this.zoom_arg;\n        return this.zoom_cache.getValue(thin_fac);\n    }\n\n    /** @internal */\n    public getThinnedGrid(thin_fac: number, map_max_zoom: number) {\n        const min_zoom = this.getMinVisibleZoom(thin_fac);\n        return new UnstructuredGrid(this.coords.filter((ll, ill) => min_zoom[ill] <= map_max_zoom), min_zoom.filter(ll => ll <= map_max_zoom)) as this;\n    }\n\n    /** @internal */\n    public thinDataArray<ArrayType extends TypedArray>(original_grid: UnstructuredGrid, ary: ArrayType) {\n        let i_new = 0;\n        \n        const arrayType = getArrayConstructor(ary);\n        const new_data = new arrayType(this.ni * this.nj);\n\n        for (let i = 0; i < original_grid.coords.length; i++) {\n            if (this.coords[i_new].lat == original_grid.coords[i].lat && this.coords[i_new].lon == original_grid.coords[i].lon) {\n                new_data[i_new++] = ary[i];\n\n                if (i_new >= this.coords.length) break;\n            }\n        }\n\n        return new_data;\n    }\n\n    public sampleNearestGridPoint(lon: number, lat: number, ary: TypedArray): {sample: number, sample_lon: number, sample_lat: number} {\n        // TAS: This is gonna be slow. Need to think about using the kdTree here.\n        const idx = argMin(this.coords.map(c => (c.lon - lon) * (c.lon - lon) + (c.lat - lat) * (c.lat - lat)));\n        return {sample: ary[idx], sample_lon: this.coords[idx].lon, sample_lat: this.coords[idx].lat};\n    }\n}\n\nexport {UnstructuredGrid};","\nimport { LineData, RenderMethodArg, TypedArray, WebGLAnyRenderingContext } from './AutumnTypes';\nimport { LngLat, MapLikeType } from './Map';\nimport { PlotComponent } from './PlotComponent';\nimport { RawScalarField } from './RawField';\nimport { LineStyle, PolylineCollection, PolylineCollectionOpts, isLineStyle } from './PolylineCollection';\nimport { TextCollection, TextCollectionOptions, TextSpec } from './TextCollection';\nimport { Color } from './Color';\n\nimport { normalizeOptions } from './utils';\nimport { ColorMap } from './Colormap';\nimport { StructuredGrid} from './grids/StructuredGrid';\nimport { UnstructuredGrid } from './grids/UnstructuredGrid';\n\n/** Options for {@link Contour} components */\ninterface ContourOptions {\n    /** \n     * The color of the contours as a hex color string \n     * @default '#000000'\n     */\n    color?: string;\n\n    /**\n     * A color map to use to color the contours. Specifying a colormap overrides the color option.\n     * @default null\n     */\n    cmap?: ColorMap | null;\n\n    /** \n     * The contour interval for drawing contours at regular intervals\n     * @default 1\n     */\n    interval?: number;\n\n    /**\n     * A list of arbitrary levels to contour. This overrides the `interval` option.\n     * @default null\n     */\n    levels?: number[] | null;\n\n    /**\n     * The width of the line in pixels. This could be either a number or a function that takes a contour level as a number and returns a line width. This\n     *  can be used to vary the width of the contours by value.\n     * @example level => level >= 100 ? 3 : 1.5\n     * @default 2\n     */\n    line_width?: number | ((level: number) => number);\n\n    /**\n     * The style to use for the line. This can be either a LineStyle or a function that takes a contour level as a number and returns a LineStyle. This \n     *  can be used to vary the contours by value.\n     * @example level => level < 0 ? '--' : '-'\n     * @default '-'\n     */\n    line_style?: LineStyle | ((level: number) => LineStyle);\n\n\n    /**\n     * \n     */\n    quad_as_tri?: boolean;\n}\n\nconst contour_opt_defaults: Required<ContourOptions> = {\n    color: '#000000',\n    cmap: null,\n    interval: 1,\n    levels: null,\n    line_width: 2,\n    line_style: '-',\n    quad_as_tri: false\n}\n\ninterface ContourGLElems<MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n}\n\n/** \n * A field of contoured data.\n * \n *  ## Grid Compatibility\n * - :white_check_mark: `PlateCarreeGrid`\n * - :white_check_mark: `PlateCarreeRotatedGrid`\n * - :white_check_mark: `LambertGrid`\n * - :x:                `UnstructuredGrid`\n * - :white_check_mark: `RadarSweepGrid`\n * - :white_check_mark: `Geostationary`\n * \n * @example\n * // Create a contoured height field, with black contours every 30 m (assuming the height field is in \n * // meters).\n * const contours = new Contour(height_field, {color: '#000000', interval: 30});\n */\nclass Contour<ArrayType extends TypedArray, GridType extends StructuredGrid, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private field: RawScalarField<ArrayType, GridType>;\n    public readonly opts: Required<ContourOptions>;\n\n    private gl_elems: ContourGLElems<MapType> | null;\n    private contours: PolylineCollection[] | null;\n\n    /**\n     * Create a contoured field\n     * @param field - The field to contour\n     * @param opts  - Options for creating the contours\n     */\n    constructor(field: RawScalarField<ArrayType, GridType>, opts: ContourOptions) {\n        super();\n\n        this.field = field;\n        this.opts = normalizeOptions(opts, contour_opt_defaults);\n\n        this.gl_elems = null;\n        this.contours = null;\n    }\n\n    /**\n     * Update the data displayed as contours\n     * @param field - The new field to contour\n     */\n    public async updateField(field: RawScalarField<ArrayType, GridType>) {\n        this.field = field;\n        if (this.gl_elems === null) return;\n\n        const gl = this.gl_elems.gl;\n\n        const contour_data = await this.getContours();\n\n        type LineDataStyleWidth = {data: LineData[], line_width: number, line_style: LineStyle};\n        const line_data: LineDataStyleWidth[] = [];\n\n        // Make contour data and sort them by line width and line style\n        Object.entries(contour_data).forEach(([cv, cd]) => {\n            const cv_ = parseFloat(cv);\n            const contour_style = isLineStyle(this.opts.line_style) ? this.opts.line_style : this.opts.line_style(cv_);\n            const contour_width = typeof this.opts.line_width === 'number' ? this.opts.line_width : this.opts.line_width(cv_);\n\n            const polyline_data = cd.map(c => {\n                const ld: LineData = {vertices: c};\n                if (this.opts.cmap !== null){\n                    ld.data = c.map(() => cv_)\n                }\n                return ld;\n            });\n\n            const line_data_filtered = line_data.filter(ld => ld.line_style == contour_style && ld.line_width == contour_width);\n            let contour_line_data: LineDataStyleWidth;\n            if (line_data_filtered.length == 0) {\n                contour_line_data = {data: [], line_width: contour_width, line_style: contour_style};\n                line_data.push(contour_line_data);\n            }\n            else {\n                contour_line_data = line_data_filtered[0];\n            }\n\n            contour_line_data.data = contour_line_data.data.concat(polyline_data);\n        });\n\n        // Make one PolylineCollection for each combination of line width and line style\n        const promises = line_data.map(async ld => {\n            const plc_opts: PolylineCollectionOpts = {line_width: ld.line_width, line_style: ld.line_style};\n            if (this.opts.cmap !== null) {\n                plc_opts.cmap = this.opts.cmap;\n            }\n            else {\n                plc_opts.color = this.opts.color;\n            }\n\n            return await PolylineCollection.make(gl, ld.data, plc_opts);\n        });\n\n        Promise.all(promises).then(values => {\n            if (this.gl_elems === null) return;\n\n            this.contours = values;\n            this.gl_elems.map.triggerRepaint();\n        });\n    }\n\n    public async getContours() {\n        const levels = this.opts.levels === null ? undefined : this.opts.levels;\n        return await this.field.getContours({interval: this.opts.interval, levels: levels, quad_as_tri: this.opts.quad_as_tri});\n    }\n\n    /**\n     * @internal\n     * Add the contours to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n\n        this.gl_elems = {\n            gl: gl, map: map\n        };\n\n        await this.updateField(this.field);\n    }\n\n    /**\n     * @internal\n     * Render the contours\n     */\n    public render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg) {\n        if (this.gl_elems === null || this.contours === null) return;\n        const gl_elems = this.gl_elems;\n\n        const zoom = gl_elems.map.getZoom();\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const bearing = gl_elems.map.getBearing();\n        const pitch = gl_elems.map.getPitch();\n\n        // XXX: This will compile another shader each time updateField() is called. Is there a way to not do that?\n        this.contours.forEach(cnt => cnt.render(gl, arg, [map_width, map_height], zoom, bearing, pitch));\n    }\n}\n\ninterface ContourLabelGLElems<MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n}\n\n/** Options for {@link ContourLabels} */\ninterface ContourLabelOptions {\n    /**\n     * Number of decimal places to use in the contour labels\n     * @default 0\n     */\n    n_decimal_places?: number;\n\n    /**\n     * Font face to use for the contour labels\n     * @default 'Trebuchet MS'\n     */\n    font_face?: string;\n\n    /**\n     * Font size in points to use for the contour labels\n     * @default 12\n     */\n    font_size?: number;\n\n    /**\n     * URL template to use in retrieving the font data for the labels. The default is to use the template from the map style.\n     */\n    font_url_template?: string;\n\n    /**\n     * Function to format the labels from numbers to a string\n     * @example val => Math.round(val).toString() // Round a number before to the nearest integer before converting to a string\n     * @default val => val.toString()\n     */\n    label_formatter?: (val: number) => string;\n\n    /**\n     * Text color for the contour labels\n     * @default '#000000'\n     */\n    text_color?: string;\n\n    /**\n     * Halo (outline) color for the contour labels\n     * @default '#000000'\n     */\n    halo_color?: string;\n\n    /**\n     * Whether to draw the halo (outline) on the contour labels\n     * @default false\n     */\n    halo?: boolean;\n\n    /**\n     * Label density. 2 makes the labels twice as dense, 0.5 makes them half as dense.\n     * @default 1\n     */\n    density?: number;\n}\n\nconst contour_label_opt_defaults: Required<ContourLabelOptions> = {\n    n_decimal_places: 0,\n    font_face: 'Trebuchet MS',\n    font_size: 12,\n    font_url_template: '',\n    label_formatter: (val: number) => val.toString(),\n    text_color: '#000000',\n    halo_color: '#000000',\n    halo: false,\n    density: 1\n}\n\n/** \n * Label the contours on a plot \n * @example \n * // Contour some data\n * const contours = new Contour(height_field, {color: '#000000', interval: 30});\n * // Label the contours\n * const labels = new ContourLabels(contours, {text_color: '#ffffff', halo: true});\n */\nclass ContourLabels<ArrayType extends TypedArray, GridType extends StructuredGrid, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private readonly contours: Contour<ArrayType, GridType, MapType>;\n    private gl_elems: ContourLabelGLElems<MapType> | null;\n    private text_collection: TextCollection | null;\n    private readonly opts: Required<ContourLabelOptions>;\n\n    constructor(contours: Contour<ArrayType, GridType, MapType>, opts?: ContourLabelOptions) {\n        super();\n\n        this.opts = normalizeOptions(opts, contour_label_opt_defaults);\n\n        this.contours = contours;\n        this.text_collection = null;\n        this.gl_elems = null;\n    }\n\n    /**\n     * Update contour labels when the field for the associated Contour object has been changed.\n     */\n    public async updateField() {\n        if (this.gl_elems === null) return;\n\n        const map = this.gl_elems.map;\n        const gl = this.gl_elems.gl;\n\n        const map_style = map.getStyle();\n\n        const font_url_template = this.opts.font_url_template == '' ? map_style.glyphs : this.opts.font_url_template;\n        if (font_url_template === undefined)\n            throw \"The map style doesn't have any glyph information. Please pass the font_url_template option to ContourLabels\";\n\n        const font_url = font_url_template.replace('{fontstack}', this.opts.font_face);\n\n        interface ContourLabelPlacement {\n            coord: {lon: number, lat: number};\n            text: string;\n        }\n        const label_pos: ContourLabelPlacement[] = [];\n\n        const contour_data = await this.contours.getContours();\n        const contour_levels = Object.keys(contour_data).map(parseFloat);\n        contour_levels.sort((a, b) => a - b);\n\n        const map_max_zoom = map.getMaxZoom();\n        const contour_label_spacing = 0.006 / this.opts.density * Math.pow(2, 7 - map_max_zoom);\n\n        Object.entries(contour_data).forEach(([level, contours]) => {\n            const icntr = (parseFloat(level) - contour_levels[0]);\n            const level_str = this.opts.label_formatter(level as unknown as keyof typeof contour_data);\n\n            contours.forEach(contour => {\n                const c_map = contour.map(v => {\n                    const v_ll = new LngLat(...v).toMercatorCoord();\n                    return [v_ll.x, v_ll.y] as [number, number];\n                });\n        \n                const dist: number[] = [];\n                c_map.forEach((v, i) => {\n                    if (i == 0) {\n                        dist.push(0);\n                    }\n                    else {\n                        const v_last = c_map[i - 1];\n                        const this_dist = Math.hypot(v_last[0] - v[0], v_last[1] - v[1]);\n                        dist.push(dist[i - 1] + this_dist);\n                    }\n                });\n\n                let n_labels_placed = 0;\n                for (let idist = 1; idist < dist.length; idist++) {\n                    const target_dist = contour_label_spacing * (n_labels_placed + (icntr / 2) % 1);\n                    // This works fine when contour_label_spacing > the spacing between points along a contour, but when you allow the map to zoom in\n                    //  (and therefore contour_label_spacing gets small), dist[idist] outruns target_dist, so it doesn't put any more labels after the first.\n                    if (dist[idist - 1] <= target_dist && target_dist < dist[idist]) {\n                        const pt1 = contour[idist - 1];\n                        const pt2 = contour[idist];\n\n                        const alpha = (target_dist - dist[idist - 1]) / (dist[idist] - dist[idist - 1]);\n                        const pt_lon = (1 - alpha) * pt1[0] + alpha * pt2[0];\n                        const pt_lat = (1 - alpha) * pt1[1] + alpha * pt2[1];\n\n                        label_pos.push({coord: {lon: pt_lon, lat: pt_lat}, text: level_str});\n                        n_labels_placed++;\n                    }\n                }\n            });\n        });\n\n        const label_grid = new UnstructuredGrid(label_pos.map(lp => lp.coord));\n        const min_zoom = label_grid.getMinVisibleZoom(4);\n        const text_specs: TextSpec[] = label_pos.map((lp, ilp) => ({...lp.coord, min_zoom: min_zoom[ilp], text: lp.text}));\n\n        const tc_opts: TextCollectionOptions = {\n            horizontal_align: 'center', vertical_align: 'middle', font_size: this.opts.font_size,\n            halo: this.opts.halo, \n            text_color: Color.fromHex(this.opts.text_color), halo_color: Color.fromHex(this.opts.halo_color),\n        };\n\n        this.text_collection = await TextCollection.make(gl, text_specs, font_url, tc_opts);\n        map.triggerRepaint();\n    }\n\n    /** \n     * @internal \n     * Add the contour labels to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.gl_elems = {\n            gl: gl, map: map,\n        }\n\n        this.updateField();\n    }\n\n    /** \n     * @internal \n     * Render the contour labels\n     */\n    public render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg) {\n        if (this.gl_elems === null || this.text_collection === null) return;\n        const gl_elems = this.gl_elems;\n\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const map_zoom = gl_elems.map.getZoom();\n\n        // XXX: This will compile another shader each time updateField() is called. Is there a way to not do that?\n        this.text_collection.render(gl, arg, [map_width, map_height], map_zoom);\n    }\n}\n\nexport default Contour;\nexport {ContourLabels};\nexport type {ContourOptions, ContourLabelOptions};","\nimport { PlotComponent, getGLFormatTypeAlignment } from './PlotComponent';\nimport { ColorMap, ColorMapGPUInterface} from './Colormap';\nimport { WGLBuffer, WGLTexture } from 'autumn-wgl';\nimport { ExpressionScalarField } from './RawField';\nimport { MapLikeType } from './Map';\nimport { RenderMethodArg, TypedArray, WebGLAnyRenderingContext, getRendererData } from './AutumnTypes';\nimport { applySamplerCodeScalar, normalizeOptions } from './utils';\nimport { ShaderProgramManager } from './ShaderManager';\nimport { DomainBufferGrid } from './grids/DomainBuffer';\n\nconst contourfill_vertex_shader_src = require('./glsl/contourfill_vertex.glsl');\nconst contourfill_fragment_shader_src = require('./glsl/contourfill_fragment.glsl');\n\n/** Options for {@link ContourFill} components */\ninterface ContourFillOptions {\n    /** The color maps to use when creating the fills */\n    cmap: ColorMap | ColorMap[];\n\n    /** \n     * A mask specifying where to use each color map. This should be on the same grid as the RawScalarField passed. \n     * A 1 in the mask means to use the first colormap, a 2 means to use the second colormap, etc.\n     */\n    cmap_mask?: Uint8Array | null;\n\n    /** \n     * The opacity for the filled contours \n     * @default 1\n     */\n    opacity?: number;\n}\n\nconst default_cmap = new ColorMap([0, 1], ['#000000'], {overflow_color: '#000000', underflow_color: '#000000'})\n\nconst contour_fill_opt_defaults: Required<ContourFillOptions> = {\n    cmap: [default_cmap],\n    cmap_mask: null,\n    opacity: 1,\n}\n\n/** Options for {@link Raster} components */\ninterface RasterOptions {\n    /** The color map to use when creating the raster plot */\n    cmap: ColorMap | ColorMap[];\n\n    /** \n     * A mask specifying where to use each color map. This should be on the same grid as the RawScalarField passed. \n     * A 1 in the mask means to use the first colormap, a 2 means to use the second colormap, etc.\n     */\n    cmap_mask?: Uint8Array | null;\n\n    /** \n     * The opacity for the raster plot\n     * @default 1\n     */\n    opacity?: number;\n}\n\nconst raster_opt_defaults: Required<RasterOptions> = {\n    cmap: [default_cmap],\n    cmap_mask: null,\n    opacity: 1,\n}\n\ninterface PlotComponentFillGLElems<MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n    shader_manager: ShaderProgramManager;\n    vertices: WGLBuffer;\n\n    texcoords: WGLBuffer;\n}\n\nclass PlotComponentFill<ArrayType extends TypedArray, GridType extends DomainBufferGrid, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private field: ExpressionScalarField<ArrayType, GridType>;\n    public readonly opts: Required<ContourFillOptions>;\n\n    private readonly cmap_gpu: ColorMapGPUInterface[];\n\n    private gl_elems: PlotComponentFillGLElems<MapType> | null;\n    private fill_texture: Map<string, WGLTexture> | null;\n    private mask_texture: WGLTexture | null;\n    protected image_mag_filter: number | null;\n    protected cmap_mag_filter: number | null;\n\n    constructor(field: ExpressionScalarField<ArrayType, GridType>, opts: ContourFillOptions) {\n        super();\n\n        this.field = field;\n        this.opts = normalizeOptions(opts, contour_fill_opt_defaults);\n        this.opts.cmap = Array.isArray(this.opts.cmap) ? this.opts.cmap : [this.opts.cmap];\n\n        this.cmap_gpu = this.opts.cmap.map(cm => new ColorMapGPUInterface(cm));\n\n        this.gl_elems = null;\n        this.fill_texture = null;\n        this.mask_texture = null;\n        this.image_mag_filter = null;\n        this.cmap_mag_filter = null;\n    }\n\n    public async updateField(field: ExpressionScalarField<ArrayType, GridType>, mask?: Uint8Array) {\n        this.field = field;\n\n        if (this.image_mag_filter === null || this.cmap_mag_filter === null) {\n            throw `Implement magnification filters in a subclass`;\n        }\n\n        if (this.gl_elems === null) return;\n\n        const gl = this.gl_elems.gl;\n        const map = this.gl_elems.map;\n    \n        this.fill_texture = this.field.updateTexImageData(gl, this.image_mag_filter, this.fill_texture);\n\n        if (mask !== undefined) {\n            if (this.opts.cmap_mask === null) {\n                console.warn(\"A mask was passed to updateField on a Fill component that didn't have a mask. The updated mask will be ignored.\");\n                return;\n            }\n\n            const {format, type, row_alignment} = getGLFormatTypeAlignment(gl, 'uint8');\n            const mask_image = {'format': format, 'type': type,\n                'width': this.field.grid.ni, 'height': this.field.grid.nj, 'image': mask,\n                'mag_filter': gl.NEAREST, 'row_alignment': row_alignment,\n            };\n            \n            if (this.mask_texture === null) {\n                this.mask_texture = new WGLTexture(gl, mask_image);\n            }\n            else {\n                this.mask_texture.setImageData(mask_image);\n            }\n        }\n\n        map.triggerRepaint();\n    }\n\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        // Basic procedure for the filled contours inspired by https://blog.mbq.me/webgl-weather-globe/\n\n        const {vertices: vertices, texcoords: texcoords} = await this.field.grid.getDomainBuffers(gl);\n\n        this.cmap_gpu.forEach(cmg => {\n            if (this.image_mag_filter === null || this.cmap_mag_filter === null) {\n                throw `Implement magnification filters in a subclass`;\n            }\n\n            cmg.setupShaderVariables(gl, this.cmap_mag_filter);\n        });\n\n        const shader_defines = [];\n\n        if (this.opts.cmap_mask !== null) {\n            shader_defines.push('MASK');\n        }\n\n        if (this.image_mag_filter === null || this.cmap_mag_filter === null) {\n            throw `Implement magnification filters in a subclass`;\n        }\n\n        const sampler_keys = this.field.getSamplerIds();\n        const sampler_expression = this.field.getExpression();\n        const data_types = this.field.dtypes;\n\n        const frag_shader_src = applySamplerCodeScalar(ColorMapGPUInterface.applyShader(contourfill_fragment_shader_src), sampler_keys, sampler_expression, data_types);\n\n        const shader_manger = new ShaderProgramManager(contourfill_vertex_shader_src, frag_shader_src, shader_defines);\n\n        this.gl_elems = {\n            gl: gl, shader_manager: shader_manger, map: map, vertices: vertices, texcoords: texcoords,\n        };\n\n        this.updateField(this.field, this.opts.cmap_mask === null ? undefined : this.opts.cmap_mask);\n    }\n\n    public render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg) {\n        if (this.gl_elems === null || this.fill_texture === null) return;\n        const gl_elems = this.gl_elems;\n\n        const render_data = getRendererData(arg);\n        const program = this.gl_elems.shader_manager.getShaderProgram(gl, render_data.shaderData);\n\n        const samplers = Object.fromEntries([...this.fill_texture.entries()])\n\n        program.use(\n            {'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords},\n            {'u_opacity': this.opts.opacity, ...this.gl_elems.shader_manager.getShaderUniforms(render_data)},\n            samplers\n        );\n\n        this.cmap_gpu.forEach((cmg, icmg) => {\n            program.setUniforms({'u_offset': 0});\n\n            if (this.opts.cmap_mask !== null && this.mask_texture !== null) {\n                program.setUniforms({'u_mask_val': icmg + 1});\n                program.bindTextures({'u_mask_sampler': this.mask_texture});\n            }\n\n            cmg.bindShaderVariables(program);\n\n            gl.enable(gl.BLEND);\n            gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n    \n            program.draw();\n    \n            if (render_data.type != 'maplibre' || !render_data.shaderData.define.includes('GLOBE')) {\n                program.setUniforms({'u_offset': -2});\n                program.draw();\n    \n                program.setUniforms({'u_offset': -1});\n                program.draw();\n    \n                program.setUniforms({'u_offset': 1});\n                program.draw();\n            }\n        });\n    }\n}\n\n/** \n * A raster (i.e. pixel) plot \n * \n * ## Grid Compatibility\n * - :white_check_mark: `PlateCarreeGrid`\n * - :white_check_mark: `PlateCarreeRotatedGrid`\n * - :white_check_mark: `LambertGrid`\n * - :x:                `UnstructuredGrid`\n * - :white_check_mark: `RadarSweepGrid`\n * - :white_check_mark: `Geostationary`\n * \n * @example\n * // Create a raster plot with the provided color map\n * const raster = new Raster(wind_speed_field, {cmap: color_map});\n */\nclass Raster<ArrayType extends TypedArray, GridType extends DomainBufferGrid, MapType extends MapLikeType> extends PlotComponentFill<ArrayType, GridType, MapType> {\n\n    /**\n     * Create a raster plot\n     * @param field - The field to create the raster plot from\n     * @param opts  - Options for creating the raster plot\n     */\n    constructor(field: ExpressionScalarField<ArrayType, GridType>, opts: RasterOptions) {\n        super(field, opts);\n    }\n\n    /**\n     * Update the data displayed as a raster plot\n     * @param field - The new field to display as a raster plot\n     */\n    public async updateField(field: ExpressionScalarField<ArrayType, GridType>, mask?: Uint8Array) {\n        await super.updateField(field, mask);\n    }\n\n    /**\n     * @internal\n     * Add the raster plot to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.image_mag_filter = gl.NEAREST;\n        this.cmap_mag_filter = gl.LINEAR;\n        await super.onAdd(map, gl);\n    }\n\n    /**\n     * @internal\n     * Render the raster plot\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        super.render(gl, matrix);\n    }\n}\n\n/** \n * A filled contoured field \n * \n * ## Grid Compatibility\n * - :white_check_mark: `PlateCarreeGrid`\n * - :white_check_mark: `PlateCarreeRotatedGrid`\n * - :white_check_mark: `LambertGrid`\n * - :x:                `UnstructuredGrid`\n * - :white_check_mark: `RadarSweepGrid`\n * - :white_check_mark: `Geostationary`\n * \n * @example\n * // Create a field of filled contours with the provided color map\n * const fill = new ContourFill(wind_speed_field, {cmap: color_map});\n */\nclass ContourFill<ArrayType extends TypedArray, GridType extends DomainBufferGrid, MapType extends MapLikeType> extends PlotComponentFill<ArrayType, GridType, MapType> {\n\n    /**\n     * Create a filled contoured field\n     * @param field - The field to create filled contours from\n     * @param opts  - Options for creating the filled contours\n     */\n    constructor(field: ExpressionScalarField<ArrayType, GridType>, opts: ContourFillOptions) {\n        super(field, opts);\n    }\n\n    /**\n     * Update the data displayed as filled contours\n     * @param field - The new field to display as filled contours\n     */\n    public async updateField(field: ExpressionScalarField<ArrayType, GridType>, mask?: Uint8Array) {\n        await super.updateField(field, mask);\n    }\n\n    /**\n     * @internal\n     * Add the filled contours to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.image_mag_filter = gl.LINEAR;\n        this.cmap_mag_filter = gl.NEAREST;\n        await super.onAdd(map, gl);\n    }\n\n    /**\n     * @internal\n     * Render the filled contours\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) {\n        super.render(gl, matrix);\n    }\n}\n\nexport {ContourFill, Raster};\nexport type {ContourFillOptions, RasterOptions};","\nimport { BillboardSpec, RenderMethodArg, TypedArray, WebGLAnyRenderingContext, getRendererData } from \"./AutumnTypes\";\nimport { Color } from \"./Color\";\nimport { ColorMap, ColorMapGPUInterface } from \"./Colormap\";\nimport { AutoZoomGrid } from \"./grids/AutoZoom\";\nimport { RawVectorField } from \"./RawField\";\nimport { WGLBuffer, WGLTexture, WGLTextureSpec } from \"autumn-wgl\";\nimport { ShaderProgramManager } from \"./ShaderManager\";\nimport { applySamplerCodeVector } from \"./utils\";\n\nconst billboard_vertex_shader_src = require('./glsl/billboard_vertex.glsl');\nconst billboard_fragment_shader_src = require('./glsl/billboard_fragment.glsl');\n\ninterface BillboardCollectionOpts {\n    color?: Color;\n    cmap?: ColorMap;\n    rotate_with_map?: boolean;\n}\n\ninterface BillboardCollectionGLElems {\n    gl: WebGLAnyRenderingContext;\n    shader_manager: ShaderProgramManager;\n    geom_vertices: WGLBuffer;\n    vertices: WGLBuffer;\n    texcoords: WGLBuffer;\n    texture: WGLTexture;\n    proj_rot_texture: WGLTexture;\n    cmap_gpu: ColorMapGPUInterface | null;\n}\n\nclass BillboardCollection<ArrayType extends TypedArray, GridType extends AutoZoomGrid> {\n    private field: RawVectorField<ArrayType, GridType>;\n    public readonly spec: BillboardSpec;\n    public readonly color: Color;\n    public readonly cmap: ColorMap | null;\n    public readonly rotate_with_map: boolean;\n    public readonly size_multiplier: number;\n    public readonly thin_fac: number;\n    public readonly max_zoom: number;\n    public readonly billboard_image: WGLTextureSpec;\n\n    private gl_elems: BillboardCollectionGLElems | null;\n    private wind_textures: {u: Map<string, WGLTexture>, v: Map<string, WGLTexture>} | null;\n\n    constructor(field: RawVectorField<ArrayType, GridType>, thin_fac: number, max_zoom: number, \n                billboard_image: WGLTextureSpec, billboard_spec: BillboardSpec, billboard_size_mult: number, opts?: BillboardCollectionOpts) {\n\n        opts = opts === undefined ? {} : opts;\n        this.color = opts.color === undefined ? new Color([0, 0, 0, 1]) : opts.color;\n        this.cmap = opts.cmap === undefined ? null : opts.cmap;\n        this.rotate_with_map = opts.rotate_with_map === undefined ? true : opts.rotate_with_map;\n\n        this.field = field;\n        this.spec = billboard_spec;\n        this.size_multiplier = billboard_size_mult;\n        this.thin_fac = thin_fac;\n        this.max_zoom = max_zoom;\n        this.billboard_image = billboard_image;\n        this.gl_elems = null;\n        this.wind_textures = null;\n    }\n\n    public updateField(field: RawVectorField<ArrayType, GridType>) {\n        this.field = field;\n\n        if (this.gl_elems === null) return;\n\n        const gl = this.gl_elems.gl;\n        const data = this.field.getThinnedField(this.thin_fac, this.max_zoom);\n\n        this.wind_textures = data.updateTexImageData(gl, gl.NEAREST, this.wind_textures);\n    }\n\n    public async setup(gl: WebGLAnyRenderingContext) {\n        const thinned_grid = this.field.grid.getThinnedGrid(this.thin_fac, this.max_zoom);\n\n        const geom_verts = new Float32Array([0., 1., 2., 3.]);\n        const geom_buffer = new WGLBuffer(gl, geom_verts, 1, gl.TRIANGLE_STRIP);\n\n        const {vertices, texcoords} = await thinned_grid.getWGLBillboardBuffers(gl, this.thin_fac, this.max_zoom);\n        const {rotation: proj_rotation_tex} = thinned_grid.getVectorRotationTexture(gl, this.field.relative_to == 'earth');\n\n        const texture = new WGLTexture(gl, this.billboard_image);\n\n        const shader_defines: string[] = [];\n        let fragment_src = billboard_fragment_shader_src;\n        let cmap_gpu = null;\n        if (this.cmap !== null) {\n            fragment_src = ColorMapGPUInterface.applyShader(fragment_src);\n\n            cmap_gpu = new ColorMapGPUInterface(this.cmap);\n            cmap_gpu.setupShaderVariables(gl, gl.NEAREST);\n\n            shader_defines.push('COLORMAP');\n        }\n\n        const sampler_keys = this.field.getSamplerIds();\n        const sampler_expressions = this.field.getExpressions();\n\n        const vertex_shader_src = applySamplerCodeVector(billboard_vertex_shader_src, sampler_keys, sampler_expressions);\n        const shader_manager = new ShaderProgramManager(vertex_shader_src, fragment_src, shader_defines);\n\n        this.gl_elems = {gl: gl, shader_manager: shader_manager, geom_vertices: geom_buffer, vertices: vertices, texcoords: texcoords, texture: texture, \n                         proj_rot_texture: proj_rotation_tex, cmap_gpu: cmap_gpu};\n    }\n\n    public render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg, [map_width, map_height]: [number, number], map_zoom: number, map_bearing: number, map_pitch: number) {\n        if (this.gl_elems === null || this.wind_textures === null) return;\n\n        const render_data = getRendererData(arg);\n        const program = this.gl_elems.shader_manager.getShaderProgram(gl, render_data.shaderData);\n\n        const gl_elems = this.gl_elems;\n\n        const bb_size = this.spec.BB_HEIGHT * (map_height / map_width) * this.size_multiplier;\n        const bb_width = this.spec.BB_WIDTH / this.spec.BB_TEX_WIDTH;\n        const bb_height = this.spec.BB_HEIGHT / this.spec.BB_TEX_HEIGHT;\n\n        const samplers = {\n            'u_sampler': gl_elems.texture, 'u_rot_sampler': gl_elems.proj_rot_texture, \n            ...Object.fromEntries([...this.wind_textures.u.entries()]),\n            ...Object.fromEntries([...this.wind_textures.v.entries()])\n        };\n\n        program.use(\n            {'a_geom': gl_elems.geom_vertices, 'a_pos': gl_elems.vertices, 'a_tex_coord': gl_elems.texcoords},\n            {'u_bb_size': bb_size, 'u_bb_width': bb_width, 'u_bb_height': bb_height,\n             'u_bb_mag_bin_size': this.spec.BB_MAG_BIN_SIZE, 'u_bb_mag_wrap': this.spec.BB_MAG_WRAP, 'u_offset': 0,\n             'u_map_aspect': map_height / map_width, 'u_zoom': map_zoom, 'u_rotate_with_map': this.rotate_with_map ? 1 : 0,\n              ...this.gl_elems.shader_manager.getShaderUniforms(render_data)},\n            samplers\n        );\n\n        if (gl_elems.cmap_gpu !== null) {\n            gl_elems.cmap_gpu.bindShaderVariables(program);\n        }\n        else {\n            program.setUniforms({'u_bb_color': this.color.toRGBATuple()});\n        }\n\n        gl.enable(gl.BLEND);\n        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n        program.draw();\n\n        if (render_data.type != 'maplibre' || !render_data.shaderData.define.includes('GLOBE')) {\n            program.setUniforms({'u_offset': -2});\n            program.draw();\n\n            program.setUniforms({'u_offset': -1});\n            program.draw();\n\n            program.setUniforms({'u_offset': 1});\n            program.draw();\n        }\n    }\n}\n\nexport {BillboardCollection};","\nimport { PlotComponent } from \"./PlotComponent\";\nimport { BillboardCollection } from './BillboardCollection';\nimport { normalizeOptions } from './utils';\nimport { RawVectorField } from \"./RawField\";\nimport { MapLikeType } from \"./Map\";\nimport { BillboardSpec, RenderMethodArg, TypedArray, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { Color } from \"./Color\";\nimport { ColorMap } from \"./Colormap\";\nimport { AutoZoomGrid } from \"./grids/AutoZoom\";\n\nconst BASE_BARB_DIMS: BillboardSpec = {\n    BB_WIDTH: 85,\n    BB_HEIGHT: 256,\n    BB_TEX_WIDTH: 1024,\n    BB_TEX_HEIGHT: 1024,\n    BB_MAG_MAX: 235,\n    BB_MAG_WRAP: 60,\n    BB_MAG_BIN_SIZE: 5,\n}\n\nconst LINE_WIDTH_MULTIPLIER = 4;\n\nfunction createBarbTexture(dimensions: BillboardSpec, line_width: number) : HTMLCanvasElement {\n    let canvas = document.createElement('canvas');\n\n    canvas.width = dimensions.BB_TEX_WIDTH;\n    canvas.height = dimensions.BB_TEX_HEIGHT;\n    \n    function drawWindBarb(ctx: CanvasRenderingContext2D, tipx: number, tipy: number, mag: number) : void {\n        const elem_full_size = dimensions.BB_WIDTH / 2 - 4;\n        const elem_spacing = elem_full_size / 2;\n        \n        if (mag < 2.5) {\n            ctx.beginPath();\n            ctx.arc(tipx, tipy, elem_full_size / 2, 0, 2 * Math.PI);\n            ctx.stroke();\n        }\n        else {\n            let elem_pos = 0;\n            let mag_countdown = mag;\n\n            let staff_length = 0;\n            const n_flags = Math.floor((mag_countdown + 2.5) / 50)\n            staff_length += n_flags * elem_full_size / 2 + elem_spacing \n                                   + (n_flags - 1) * elem_spacing / 2;\n            mag_countdown -= n_flags * 50;\n            const n_full_barbs = Math.floor((mag_countdown + 2.5) / 10)\n            staff_length += n_full_barbs * elem_spacing;\n            mag_countdown -= n_full_barbs * 10;\n            const n_half_barbs = Math.floor((mag_countdown + 2.5) / 5);\n            staff_length += n_half_barbs * elem_spacing;\n            \n            if (mag < 7.5) {\n                staff_length += elem_spacing;\n            }\n            \n            staff_length = Math.max(120, staff_length);\n            \n            // staff\n            ctx.beginPath();\n            ctx.moveTo(tipx, tipy);\n            ctx.lineTo(tipx, tipy + staff_length);\n\n            mag_countdown = mag;\n\n            elem_pos = tipy + staff_length;\n            let last_was_flag = false;\n            let first_elem = true;\n        \n            while (mag_countdown > 47.5) {\n                if (last_was_flag) elem_pos += elem_spacing / 2;\n                // flag\n                if (!first_elem) {\n                    ctx.moveTo(tipx, elem_pos);\n                }\n                ctx.lineTo(tipx - elem_full_size, elem_pos);\n                ctx.lineTo(tipx, elem_pos - elem_full_size / 2)\n\n                elem_pos -= elem_full_size / 2 + elem_spacing;\n                mag_countdown -= 50;\n                last_was_flag = true;\n                first_elem = false;\n            }\n        \n            while (mag_countdown > 7.5) {\n                // full barb\n                if (!first_elem) {\n                    ctx.moveTo(tipx, elem_pos);\n                }\n                ctx.lineTo(tipx - elem_full_size, elem_pos + elem_full_size / 2);\n            \n                elem_pos -= elem_spacing;\n                mag_countdown -= 10;\n                first_elem = false;\n            }\n            \n            if (mag < 7.5) {\n                elem_pos -= elem_spacing;\n            }\n        \n            while (mag_countdown > 2.5) {\n                // half barb\n                ctx.moveTo(tipx, elem_pos);\n                ctx.lineTo(tipx - elem_full_size / 2, elem_pos + elem_full_size / 4);\n                mag_countdown -= 5;\n            }\n\n            ctx.stroke();\n        }\n    }\n    \n    let ctx = canvas.getContext('2d');\n    if (ctx === null) {\n        throw \"Could not get rendering context for the wind barb canvas\";\n    }\n\n    ctx.lineWidth = line_width;\n    ctx.miterLimit = 4;\n    \n    for (let ibarb = 0; ibarb <= dimensions.BB_MAG_MAX; ibarb += dimensions.BB_MAG_BIN_SIZE) {\n        const x_pos = (ibarb % dimensions.BB_MAG_WRAP) / dimensions.BB_MAG_BIN_SIZE * dimensions.BB_WIDTH + dimensions.BB_WIDTH / 2;\n        const y_pos = Math.floor(ibarb / dimensions.BB_MAG_WRAP) * dimensions.BB_HEIGHT + dimensions.BB_WIDTH / 2;\n        drawWindBarb(ctx, x_pos, y_pos, ibarb);\n    }\n\n    return canvas;\n}\n\n/** Options for {@link Barbs} components */\ninterface BarbsOptions {\n    /** \n     * The color to use for the barbs as a hex color string;.\n     * @default '#000000'\n     */\n    color?: string;\n\n    /**\n     * A color map to use to color the barbs by magnitude. Specifying cmap overrides the color argument.\n     */\n    cmap?: ColorMap | null;\n\n    /**\n     * The width of the lines to use for the barbs\n     * @default 2\n     */\n    line_width?: number;\n\n    /**\n     * A multiplier for the barb size\n     * @default 1\n     */\n    barb_size_multiplier?: number;\n\n    /** \n     * How much to thin the barbs at zoom level 1 on the map. This effectively means to plot every `n`th barb in the i and j directions, where `n` = \n     * `thin_fac`. `thin_fac` should be a power of 2. \n     * @default 1\n     */\n    thin_fac?: number;\n}\n\nconst barb_opt_defaults: Required<BarbsOptions> = {\n    color: '#000000',\n    cmap: null,\n    line_width: 2,\n    barb_size_multiplier: 1, \n    thin_fac: 1\n}\n\ninterface BarbsGLElems<ArrayType extends TypedArray, GridType extends AutoZoomGrid, MapType extends MapLikeType> {\n    map: MapType;\n    barb_billboards: BillboardCollection<ArrayType, GridType>;\n}\n\n/** \n * A class representing a field of wind barbs. The barbs are automatically thinned based on the zoom level on the map; the user only has to provide a\n * thinning factor at zoom level 1.\n * \n * ## Grid Compatibility\n * - :white_check_mark: `PlateCarreeGrid`\n * - :white_check_mark: `PlateCarreeRotatedGrid`\n * - :white_check_mark: `LambertGrid`\n * - :white_check_mark: `UnstructuredGrid`\n * - :x:                `RadarSweepGrid`\n * - :x:                `Geostationary`\n * \n * @example\n * // Create a barb field with black barbs and plotting every 16th wind barb in both i and j at zoom level 1\n * const vector_field = new RawVectorField(grid, u_data, v_data);\n * const barbs = new Barbs(vector_field, {color: '#000000', thin_fac: 16});\n */\nclass Barbs<ArrayType extends TypedArray, GridType extends AutoZoomGrid, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    /** The vector field */\n    private fields: RawVectorField<ArrayType, GridType>;\n    public readonly opts: Required<BarbsOptions>;\n    private readonly color: Color;\n\n    private gl_elems: BarbsGLElems<ArrayType, GridType, MapType> | null;\n    private barb_texture: HTMLCanvasElement;\n\n    /**\n     * Create a field of wind barbs\n     * @param fields - The vector field to plot as barbs\n     * @param opts   - Options for creating the wind barbs\n     */\n    constructor(fields: RawVectorField<ArrayType, GridType>, opts: BarbsOptions) {\n        super();\n\n        this.fields = fields;\n\n        this.opts = normalizeOptions(opts, barb_opt_defaults);\n        this.color = Color.fromHex(this.opts.color);\n        this.barb_texture = createBarbTexture(BASE_BARB_DIMS, this.opts.line_width / this.opts.barb_size_multiplier * LINE_WIDTH_MULTIPLIER);\n\n        this.gl_elems = null;\n    }\n\n    /**\n     * Update the field displayed as barbs\n     * @param fields - The new field to display as barbs\n     */\n    public async updateField(fields: RawVectorField<ArrayType, GridType>) {\n        this.fields = fields;\n        if (this.gl_elems === null) return;\n        this.gl_elems.barb_billboards.updateField(fields);\n        this.gl_elems.map.triggerRepaint();\n    }\n\n    /**\n     * @internal \n     * Add the barb field to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        gl.getExtension('OES_texture_float');\n        gl.getExtension('OES_texture_float_linear');\n        \n        const map_max_zoom = map.getMaxZoom();\n\n        const barb_image = {format: gl.RGBA, type: gl.UNSIGNED_BYTE, image: this.barb_texture, mag_filter: gl.NEAREST};\n\n        const cmap = this.opts.cmap === null ? undefined : this.opts.cmap;\n        const barb_billboards = new BillboardCollection(this.fields, this.opts.thin_fac, map_max_zoom, barb_image, \n            BASE_BARB_DIMS, 0.1 * this.opts.barb_size_multiplier, {color: this.color, cmap: cmap});\n        await barb_billboards.setup(gl);\n\n        this.gl_elems = {\n            map: map, barb_billboards: barb_billboards\n        }\n\n        this.updateField(this.fields);\n    }\n\n    /**\n     * @internal \n     * Render the barb field\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: RenderMethodArg) {\n        if (this.gl_elems === null) return;\n        const gl_elems = this.gl_elems\n\n        const zoom = gl_elems.map.getZoom();\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const bearing = gl_elems.map.getBearing();\n        const pitch = gl_elems.map.getPitch();\n\n        gl_elems.barb_billboards.render(gl, matrix, [map_width, map_height], zoom, bearing, pitch);\n    }\n}\n\nexport default Barbs;\nexport type {BarbsOptions};","\nimport { RenderMethodArg, TypedArray, WebGLAnyRenderingContext, getRendererData } from \"./AutumnTypes\";\nimport { Color } from \"./Color\";\nimport { DomainBufferGrid } from \"./grids/DomainBuffer\";\nimport { MapLikeType } from \"./Map\";\nimport { PlotComponent, getGLFormatTypeAlignment } from \"./PlotComponent\";\nimport { ExpressionScalarField } from \"./RawField\";\nimport { ShaderProgramManager } from \"./ShaderManager\";\nimport { applySamplerCodeScalar, normalizeOptions } from \"./utils\";\nimport { WGLBuffer, WGLFramebuffer, WGLProgram, WGLTexture } from \"autumn-wgl\";\n\nconst paintball_step1_vertex_shader_src = require('./glsl/paintball_step1_vertex.glsl');\nconst paintball_step2_vertex_shader_src = require('./glsl/paintball_step2_vertex.glsl');\nconst paintball_step1_fragment_shader_src = require('./glsl/paintball_step1_fragment.glsl');\nconst paintball_step2_fragment_shader_src = require('./glsl/paintball_step2_fragment.glsl');\n\n/** Options for {@link Paintball} components */\ninterface PaintballOptions {\n    /**\n     * The list of colors (as hex strings) to use for each member in the paintball plot. The first color corresponds to member 1, the second to member 2, etc.\n     */\n    colors?: string[];\n\n    /**\n     * The opacity of the paintball plot\n     * @default 1\n     */\n    opacity?: number;\n}\n\nconst paintball_opt_defaults: Required<PaintballOptions> = {\n    colors: ['#000000'],\n    opacity: 1\n}\n\ninterface PaintballGLElems<MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n    shader_program_1: WGLProgram;\n    shader_manager_2: ShaderProgramManager;\n    vertices_step1: WGLBuffer;\n    vertices_step2: WGLBuffer;\n    texcoords_step2: WGLBuffer;\n    framebuffer: WGLFramebuffer;\n}\n\n/** \n * A class representing a paintball plot, which is a plot of objects in every member of an ensemble. Objects are usually defined by a single threshold on\n * a field (such as simulated reflectivity greater than 40 dBZ), but could in theory be defined by any arbitrarily complicated method. In autumnplot-gl,\n * the data for the paintball plot is given as a single field with the objects from each member encoded as \"bits\" in the field. Because the field is made up\n * of single-precision floats, this works for up to 24 members. (Technically speaking, I don't need the quotes around \"bits\", as they're bits of the \n * significand of an IEEE 754 float.)\n * \n * ## Grid Compatibility\n * - :white_check_mark: `PlateCarreeGrid`\n * - :white_check_mark: `PlateCarreeRotatedGrid`\n * - :white_check_mark: `LambertGrid`\n * - :x:                `UnstructuredGrid`\n * - :white_check_mark: `RadarSweepGrid`\n * - :white_check_mark: `Geostationary`\n */\nclass Paintball<ArrayType extends TypedArray, GridType extends DomainBufferGrid, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private field: ExpressionScalarField<ArrayType, GridType>;\n    public readonly opts: Required<PaintballOptions>;\n    private readonly color_components: [number, number, number, number][];\n\n    private gl_elems: PaintballGLElems<MapType> | null;\n    private fill_texture: Map<string, WGLTexture> | null;\n\n    /**\n     * Create a paintball plot\n     * @param field - A scalar field containing the member objects encoded as \"bits.\" The numerical value of each grid point can be constructed like \n     *               `1.0 * M1 + 2.0 * M2 + 4.0 * M3 + 8.0 * M4 ...`, where `M1` is 1 if that grid point is in an object in member 1 and 0 otherwise,\n     *               `M2` is the same thing for member 2, and `M3` and `M4` and up to `Mn` are the same thing for the rest of the members.\n     * @param opts  - Options for creating the paintball plot\n     */\n    constructor(field: ExpressionScalarField<ArrayType, GridType>, opts?: PaintballOptions) {\n        super();\n\n        this.field = field;\n\n        this.opts = normalizeOptions(opts, paintball_opt_defaults);\n        this.color_components = this.opts.colors.map(color => Color.fromHex(color).toRGBATuple());\n        \n        this.gl_elems = null;\n        this.fill_texture = null;\n    }\n\n    /**\n     * Update the field displayed as a paintball plot\n     * @param field - The new field to display as a paintball plot\n     */\n    public async updateField(field: ExpressionScalarField<ArrayType, GridType>) {\n        this.field = field;\n\n        if (this.gl_elems === null) return;\n        const gl = this.gl_elems.gl;\n\n        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 2);\n\n        this.fill_texture = this.field.updateTexImageData(gl, gl.NEAREST, this.fill_texture);\n    }\n\n    /**\n     * @internal\n     * Add the paintball plot to a map.\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        gl.getExtension('OES_texture_float');\n\n        const vertices_step1 = new WGLBuffer(gl, new Float32Array([-1., -1., 1., -1., -1., 1., 1., 1.]), 2, gl.TRIANGLE_STRIP);\n        const {vertices: vertices_step2, texcoords: texcoords_step2} = await this.field.grid.getDomainBuffers(gl);\n\n        const sampler_keys = this.field.getSamplerIds();\n        const sampler_expression = this.field.getExpression();\n        const dtypes = this.field.dtypes;\n\n        const step1_frag_shader_src = applySamplerCodeScalar(paintball_step1_fragment_shader_src, sampler_keys, sampler_expression, dtypes);\n\n        const shader_program_step1 = new WGLProgram(gl, paintball_step1_vertex_shader_src, step1_frag_shader_src);\n        const shader_manager_step2 = new ShaderProgramManager(paintball_step2_vertex_shader_src, paintball_step2_fragment_shader_src, []);\n\n        const {format, type, row_alignment} = getGLFormatTypeAlignment(gl, 'float16');\n\n        const fb_texture = new WGLTexture(gl, {format: format, type: type,\n            width: this.field.grid.ni, height: this.field.grid.nj, image: null,\n            mag_filter: gl.LINEAR, row_alignment: row_alignment});\n\n        const fb = new WGLFramebuffer(gl, fb_texture);\n\n        this.gl_elems = {\n            gl: gl, map: map, shader_program_1: shader_program_step1, shader_manager_2: shader_manager_step2, \n            vertices_step1: vertices_step1, vertices_step2: vertices_step2, texcoords_step2: texcoords_step2,\n            framebuffer: fb\n        };\n\n        this.updateField(this.field);\n    }\n\n    /**\n     * @internal\n     * Render the paintball plot\n     */\n    public render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg) {\n        if (this.gl_elems === null || this.fill_texture === null) return;\n        const gl_elems = this.gl_elems;\n        const fill_texture = this.fill_texture;\n\n        const map = gl_elems.map;\n        const viewport_width = map.getCanvas().width;\n        const viewport_height = map.getCanvas().height;\n\n        const render_data = getRendererData(arg);\n        const program_step1 = this.gl_elems.shader_program_1;\n        const program_step2 = this.gl_elems.shader_manager_2.getShaderProgram(gl, render_data.shaderData);\n\n        const samplers = Object.fromEntries([...this.fill_texture.entries()])\n\n        this.color_components.forEach((color, icolor) => {\n            // Render to framebuffer to pull out an individual member from the packed field\n            program_step1.use(\n                {'a_pos': gl_elems.vertices_step1},\n                {'u_imem': icolor},\n                samplers\n            );\n\n            gl_elems.framebuffer.clear([0, 0, 0, 1]);\n            gl_elems.framebuffer.renderTo(0, 0, this.field.grid.ni, this.field.grid.nj);\n\n            gl.enable(gl.BLEND);\n            gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n            program_step1.draw();\n\n            // Now render the framebuffer as a filled contour\n            program_step2.use(\n                {'a_pos': gl_elems.vertices_step2, 'a_tex_coord': gl_elems.texcoords_step2},\n                {'u_opacity': this.opts.opacity, 'u_color': color, 'u_offset': 0,\n                ...gl_elems.shader_manager_2.getShaderUniforms(render_data)},\n                {'u_fill_sampler': gl_elems.framebuffer.texture}\n            );\n\n            WGLFramebuffer.screen(gl).renderTo(0, 0, viewport_width, viewport_height);\n\n            gl.enable(gl.BLEND);\n            gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n\n            program_step2.draw();\n\n            if (render_data.type != 'maplibre' || !render_data.shaderData.define.includes('GLOBE')) {\n                program_step2.setUniforms({'u_offset': -2});\n                program_step2.draw();\n        \n                program_step2.setUniforms({'u_offset': -1});\n                program_step2.draw();\n        \n                program_step2.setUniforms({'u_offset': 1});\n                program_step2.draw();\n            }\n        });\n    }\n}\n\nexport default Paintball;\nexport type {PaintballOptions};","\nimport { PlotComponent } from \"./PlotComponent\";\nimport { PolylineCollection } from \"./PolylineCollection\";\nimport { BillboardCollection } from \"./BillboardCollection\";\nimport { normalizeOptions } from './utils';\nimport { MapLikeType } from \"./Map\";\nimport { RawProfileField } from \"./RawField\";\nimport { LineData, RenderMethodArg, TypedArray, WebGLAnyRenderingContext, WindProfile, isStormRelativeWindProfile } from \"./AutumnTypes\";\nimport { Float16Array } from \"@petamoriken/float16\";\nimport { ColorMap } from \"./Colormap\";\nimport { Color } from \"./Color\";\nimport { Grid } from \"./grids/Grid\";\nimport { AutoZoomGrid } from \"./grids/AutoZoom\";\n\nconst LINE_WIDTH_MULTIPLIER = 2.5;\n\nconst HODO_BG_DIMS = {\n    BB_WIDTH: 256,\n    BB_HEIGHT: 256,\n    BB_TEX_WIDTH: 256,\n    BB_TEX_HEIGHT: 256,\n    BB_MAG_MAX: 1000,\n    BB_MAG_WRAP: 1000,\n    BB_MAG_BIN_SIZE: 1000,\n}\n\nfunction _createHodoBackgroundTexture(line_width: number, arrow_head: boolean) {\n    let canvas = document.createElement('canvas');\n\n    canvas.width = HODO_BG_DIMS.BB_TEX_WIDTH;\n    canvas.height = HODO_BG_DIMS.BB_TEX_HEIGHT;\n\n    let ctx = canvas.getContext('2d');\n\n    if (ctx === null) {\n        throw \"Could not get rendering context for the hodograph background canvas\";\n    }\n\n    ctx.lineWidth = line_width;\n\n    for (let irng = HODO_BG_DIMS.BB_TEX_WIDTH / 4; irng <= HODO_BG_DIMS.BB_TEX_WIDTH / 2; irng += HODO_BG_DIMS.BB_TEX_WIDTH / 4) {\n        ctx.beginPath();\n        ctx.arc(HODO_BG_DIMS.BB_TEX_WIDTH / 2, HODO_BG_DIMS.BB_TEX_WIDTH / 2, irng - line_width / 2, 0, 2 * Math.PI);\n        ctx.stroke();\n    }\n\n    if (arrow_head) {\n        const ctr_x = HODO_BG_DIMS.BB_TEX_WIDTH / 2, ctr_y = HODO_BG_DIMS.BB_TEX_WIDTH / 2;\n        const arrow_size = 20\n        ctx.beginPath()\n        ctx.moveTo(ctr_x, ctr_y);\n        ctx.lineTo(ctr_x + arrow_size / 2, ctr_y + arrow_size);\n        ctx.lineTo(ctr_x - arrow_size / 2, ctr_y + arrow_size);\n        ctx.lineTo(ctr_x, ctr_y);\n        ctx.fill();\n    }\n    else {\n        ctx.beginPath();\n        ctx.arc(HODO_BG_DIMS.BB_TEX_WIDTH / 2, HODO_BG_DIMS.BB_TEX_WIDTH / 2, line_width, 0, 2 * Math.PI);\n        ctx.fill();\n    }\n\n    return canvas;\n};\n\nconst HODO_CMAP = new ColorMap([0, 1, 3, 6, 9], ['#ffffcc', '#a1dab4', '#41b6c4', '#225ea8']);\n\n/** Options for {@link Hodographs} components */\ninterface HodographOptions {\n    /** \n     * The color of the hodograph plot background as a hex string\n     * @default '#000000'\n     */\n    bgcolor?: string;\n\n    /** \n     * How much to thin the hodographs at zoom level 1 on the map. This effectively means to plot every `n`th hodograph in the i and j directions, where `n` = \n     * `thin_fac`. `thin_fac` should be a power of 2. \n     * @default 1\n     */\n    thin_fac?: number;\n\n    /**\n     * The width of the hodograph line in pixels\n     * @default 2.5\n     */\n    hodo_line_width?: number;\n\n    /**\n     * The width of the lines on the background in pixels\n     * @default 1.5\n     */\n    background_line_width?: number;\n\n    /**\n     * The colormap to use for the heights on the hodograph. Default is a yellow-blue colormap.\n     */\n    height_cmap?: ColorMap;\n\n    /**\n     * The wind speed (in kts) of the largest ring on the hodograph background\n     * @default 80\n     */\n    max_wind_speed_ring?: number;\n}\n\nconst hodograph_opt_defaults: Required<HodographOptions> = {\n    bgcolor: '#000000',\n    thin_fac: 1,\n    hodo_line_width: 2.5,\n    background_line_width: 1.5,\n    height_cmap: HODO_CMAP,\n    max_wind_speed_ring: 80\n}\n\ninterface HodographGLElems<ArrayType extends TypedArray, GridType extends AutoZoomGrid, MapType extends MapLikeType> {\n    gl: WebGLAnyRenderingContext;\n    map: MapType;\n    bg_billboard: BillboardCollection<ArrayType, GridType>;\n}\n\n/** \n * A class representing a field of hodograph plots \n * \n * ## Grid Compatibility\n * - :white_check_mark: `PlateCarreeGrid`\n * - :white_check_mark: `PlateCarreeRotatedGrid`\n * - :white_check_mark: `LambertGrid`\n * - :white_check_mark: `UnstructuredGrid`\n * - :x:                `RadarSweepGrid`\n * - :x:                `Geostationary`\n */\nclass Hodographs<GridType extends AutoZoomGrid, MapType extends MapLikeType> extends PlotComponent<MapType> {\n    private profile_field: RawProfileField<GridType>;\n    public readonly opts: Required<HodographOptions>;\n\n    private gl_elems: HodographGLElems<Float16Array, GridType, MapType> | null;\n    private line_elems: {hodo_line: PolylineCollection, sm_line: PolylineCollection} | null;\n    private hodo_bg_texture: HTMLCanvasElement;\n    private readonly hodo_scale;\n    private readonly bg_size;\n\n    /**\n     * Create a field of hodographs\n     * @param profile_field - The grid of profiles to plot\n     * @param opts          - Various options to use when creating the hodographs \n     */\n    constructor(profile_field: RawProfileField<GridType>, opts?: HodographOptions) {\n        super();\n        \n        this.profile_field = profile_field;\n        this.opts = normalizeOptions(opts, hodograph_opt_defaults);\n\n        this.hodo_bg_texture = _createHodoBackgroundTexture(this.opts.background_line_width * LINE_WIDTH_MULTIPLIER, isStormRelativeWindProfile(profile_field.profiles[0]));\n        this.hodo_scale = (HODO_BG_DIMS.BB_TEX_WIDTH - this.opts.background_line_width / 2) / (HODO_BG_DIMS.BB_TEX_WIDTH * this.opts.max_wind_speed_ring);\n        this.bg_size = 140;\n\n        this.gl_elems = null;\n        this.line_elems = null;\n    }\n\n    /**\n     * Update the profiles displayed\n     * @param field - The new profiles to display as hodographs\n     */\n    public async updateField(field: RawProfileField<GridType>) {\n        this.profile_field = field;\n\n        if (this.gl_elems === null) return;\n        // XXX: This might leak VRAM\n        const gl = this.gl_elems.gl;\n\n        this.gl_elems.bg_billboard.updateField(field.getStormMotionGrid());\n\n        const profiles = this.profile_field.profiles;\n        const {lats, lons} = this.profile_field.getProfileCoords();\n        const min_visible_zoom = this.profile_field.grid.getMinVisibleZoom(this.opts.thin_fac);\n        \n        const hodo_polyline = profiles.map((prof, iprof) => {\n            return {\n                'offsets': [...prof['u']].map((u, ipt) => {\n                    if (isStormRelativeWindProfile(prof)) {\n                        return [u - prof['smu'], prof['v'][ipt] - prof['smv']]\n                    }\n                    return [u, prof['v'][ipt]];\n                }),\n                'vertices': [...prof['u']].map(u => [lons[iprof], lats[iprof]]),\n                'zoom': min_visible_zoom[iprof],\n                'data': [...prof['z']],\n            } as LineData;\n        });\n\n        const hodo_line = await PolylineCollection.make(gl, hodo_polyline, {line_width: this.opts.hodo_line_width, cmap: this.opts.height_cmap, \n                                                                            offset_scale: this.hodo_scale * this.bg_size, offset_rotates_with_map: false});\n\n        const sm_polyline = profiles.map((prof, iprof) => {\n            if (!isStormRelativeWindProfile(prof)) {\n                return {vertices: []} as LineData;\n            }\n\n            const sm_mag = Math.hypot(prof['smu'], prof['smv']);\n            const sm_ang = Math.PI / 2 - Math.atan2(-prof['smv'], -prof['smu']);\n            const buffer = 2\n\n            return {\n                'offsets': [[buffer * Math.sin(sm_ang), buffer * Math.cos(sm_ang)], \n                              [sm_mag * Math.sin(sm_ang), sm_mag * Math.cos(sm_ang)]],\n                'vertices': [[lons[iprof], lats[iprof]], [lons[iprof], lats[iprof]]],\n                'zoom': min_visible_zoom[iprof]\n            } as LineData;\n        });\n\n        const sm_line = await PolylineCollection.make(gl, sm_polyline, {line_width: this.opts.background_line_width, color: this.opts.bgcolor, \n                                                                        offset_scale: this.hodo_scale * this.bg_size, offset_rotates_with_map: false});\n\n        this.line_elems = {\n            hodo_line: hodo_line, sm_line: sm_line\n        }\n    }\n\n    /**\n     * @internal\n     * Add the hodographs to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        const bg_image = {'format': gl.RGBA, 'type': gl.UNSIGNED_BYTE, 'image': this.hodo_bg_texture, 'mag_filter': gl.NEAREST};\n        const max_zoom = map.getMaxZoom();\n\n        const bg_billboard = new BillboardCollection(this.profile_field.getStormMotionGrid(), this.opts.thin_fac, max_zoom, bg_image, HODO_BG_DIMS, this.bg_size * 0.004,\n                                                     {color: Color.fromHex(this.opts.bgcolor), rotate_with_map: false});\n        await bg_billboard.setup(gl);\n\n        this.gl_elems = {\n            gl: gl, map: map, bg_billboard: bg_billboard\n        };\n\n        this.updateField(this.profile_field);\n    }\n\n    /**\n     * @internal\n     * Render the hodographs\n     */\n    public render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg) {\n        if (this.gl_elems === null || this.line_elems === null) return;\n        const gl_elems = this.gl_elems;\n        const line_elems = this.line_elems;\n\n        const zoom = gl_elems.map.getZoom();\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const bearing = gl_elems.map.getBearing();\n        const pitch = gl_elems.map.getPitch();\n\n        line_elems.hodo_line.render(gl, arg, [map_width, map_height], zoom, bearing, pitch);\n        line_elems.sm_line.render(gl, arg, [map_width, map_height], zoom, bearing, bearing);\n        gl_elems.bg_billboard.render(gl, arg, [map_width, map_height], zoom, bearing, pitch);\n    }\n}\n\nexport default Hodographs;\nexport type {HodographOptions};","\nimport { RenderMethodArg, WebGLAnyRenderingContext } from \"./AutumnTypes\";\nimport { MapLikeType } from \"./Map\";\nimport { PlotComponent } from \"./PlotComponent\";\nimport { normalizeOptions } from \"./utils\";\nimport { Grid } from \"./grids/Grid\";\nimport { AutoZoomGrid } from \"./grids/AutoZoom\";\nimport { RawObsField } from \"./RawField\";\nimport { HorizontalAlign, TextCollection, TextCollectionOptions, TextSpec, VerticalAlign } from \"./TextCollection\";\nimport { Float16Array } from \"@petamoriken/float16\";\nimport { Color } from \"./Color\";\nimport { ColorMap } from \"./Colormap\";\nimport Barbs from \"./Barbs\";\n\n/**\n * Positions around the station plot at which to draw the various elements\n * \n *  | Value   | Position     |\n *  | --------|--------------|\n *  | `'cl'`  | center-left  |\n *  | `'ll'`  | lower-left   |\n *  | `'lc'`  | lower-center |\n *  | `'lr'`  | lower-right  |\n *  | `'cr'`  | center-right |\n *  | `'ur'`  | upper-right  |\n *  | `'uc'`  | upper-center |\n *  | `'ul'`  | upper-left   |\n *  | `'c'`   | center       |\n */\ntype SPPosition = 'cl' | 'll' | 'lc' | 'lr' | 'cr' | 'ur' | 'uc' | 'ul' | 'c';\n\n/** Configuration for numerical values on station plots */\ninterface SPNumberConfig {\n    type: 'number';\n\n    /**\n     * The position on the station plot at which to place the number\n     */\n    pos: SPPosition;\n\n    /**\n     * The color to use to draw the number\n     * @default '#000000'\n     */\n    color?: string;\n\n    /**\n     * A colormap to use for coloring numeric values\n     * @default null\n     */\n    cmap?: ColorMap | null;\n\n    /**\n     * Whether to draw a halo (outline) around the number\n     * @default true;\n     */\n    halo?: boolean;\n\n    /**\n     * The color to use for the halo (outline)\n     * @default '#ffffff'\n     */\n    halo_color?: string;\n\n    /**\n     * A function that properly formats the number for display\n     * @example (val) => val === null ? '' : val.toFixed(0)\n     * @param val - The number to format\n     * @returns A string containing the formatted nubmer\n     */\n    formatter?: (val: number | null) => string;\n}\n\n/** Configuration for strings on station plots */\ninterface SPStringConfig {\n    type: 'string';\n\n    /**\n     * The position on the station plot at which to place the string\n     */\n    pos: SPPosition;\n\n    /**\n     * The color to use to draw the string\n     * @default '#000000'\n     */\n    color?: string;\n\n    /**\n     * Whether to draw a halo (outline) around the string\n     * @default true;\n     */\n    halo?: boolean;\n\n    /**\n     * The color to use for the halo (outline)\n     * @default '#ffffff'\n     */\n    halo_color?: string;\n}\n\n/** Configuration for wind barbs on station plots */\ninterface SPBarbConfig {\n    type: 'barb';\n\n    /**\n     * The color to use to draw the barb\n     * @default '#000000'\n     */\n    color?: string;\n\n    /**\n     * A multiplier for the barb size\n     * @default 1\n     */\n    barb_size_multipler?: number;\n}\n\n/**\n * Accepted symbol codes for sky cover and present weather symbols\n */\ntype SPSymbol = ('0/8' | '1/8' | '2/8' | '3/8' | '4/8' | '5/8' | '6/8' | '7/8' | '8/8' | \n               'clr' | 'few' | 'sct' | 'bkn' | 'ovc' | 'obsc' |\n               'va' | 'fu' | 'hz' | 'du' | 'bldu' | 'sa' | 'blsa' | 'vcblsa' | 'vcbldu' | 'blpy' | 'po' | 'vcpo' | 'vcds' | 'vcss' | \n               'br' | 'bcbr' | 'bc' | 'mifg' | 'vcts' | 'virga' | 'vcsh' | 'ts' | 'thdr' | 'vctshz' | 'tsfzfg' | 'tsbr' | 'tsdz' | 'vctsup' | '-tsup' | 'tsup' | '+tsup' | \n               'sq' | 'fc' | '+fc' | 'ds' | 'ss' | 'drsa' | 'drdu' | '+ds' | '+ss' | 'drsn' | '+drsn' | '-blsn' | 'blsn' | '+blsn' | 'vcblsn' | \n               'vcfg' | 'bcfg' | 'prfg' | 'fg' | 'fzfg' | \n               '-vctsdz' | '-dz' | '-dzbr' | 'vctsdz' | 'dz' | '+vctsdz' | '+dz' | '-fzdz' | '-fzdzsn' | 'fzdz' | '+fzdz' | 'fzdzsn' | '-dzra' | 'dzra' | '+dzra' | \n               '-ra' | '-rabr' | 'ra' | 'rabr' | 'rafg' | 'vcra' | '+ra' | \n               '-fzra' | '-fzrasn' | '-fzrabr' | '-fzrapl' | '-fzrasnpl' | 'tsfzrapl' | '-tsfzra' | 'fzra' | '+fzra' | 'fzrasn' | 'tsfzra' | \n               '-dzsn' | '-rasn' | '-snra' | '-sndz' | 'rasn' | '+rasn' | 'snra' | 'dzsn' | 'sndz' | '+dzsn' | '+sndz' | '-sn' | '-snbr' | 'sn' | '+sn' |  '-snsg' | 'sg' | '-sg' | 'ic' | \n               '-fzdzpl' | '-fzdzplsn' | 'fzdzpl' | '-fzraplsn' | 'fzrapl' | '+fzrapl' | '-rapl' | '-rasnpl' | '-raplsn' | '+rapl' | 'rapl' | '-snpl' | 'snpl' | \n               '-pl' | 'pl' | '-plsn' | '-plra' | 'plra' | '-pldz' | '+pl' | 'plsn' | 'plup' | '+plsn' | \n               '-sh' | '-shra' | 'sh' | 'shra' | '+sh' | '+shra' | '-shrasn' | '-shsnra' | '+shrabr' | 'shrasn' | '+shrasn' | 'shsnra' | '+shsnra' | '-shsn' | 'shsn' | '+shsn' | \n               '-gs' | '-shgs' | 'fzraplgs' | '-sngs' | 'gsplsn' | 'gspl' | 'plgssn' | 'gs' | 'shgs' | '+gs' | '+shgs' | '-gr' | '-shgr' | '-sngr' | 'gr' | 'shgr' | '+gr' | '+shgr' | \n               '-tsrasn' | 'tsrasn' | '-tssnra' | 'tssnra' | '-vctsra' | '-tsra' | 'tsra' | \n               '-tsdz' | 'vctsra' | 'tspl' | '-tssn' | '-tspl' | 'tssn' | '-vctssn' | 'vctssn' | 'tsplsn' | 'tssnpl' | \n               '-tssnpl' | '-tsragr' | 'tsrags' | 'tsragr' | 'tsgs' | 'tsgr' | \n               '+tsfzrapl' | '+vctsra' | '+tsra' | '+tsfzra' | '+tssn' | '+tspl' | '+tsplsn' | '+vctssn' | 'tssa' | 'tsds' | 'tsdu' | '+tsgs' | '+tsgr' | '+tsrags' | '+tsragr' | \n               'in' | '-up' | 'up' | '+up' | '-fzup' | 'fzup' | '+fzup');\n\nconst SYMBOLS: Record<SPSymbol, number> = {\n    // Sky cover symbols\n    '0/8': 59658, '1/8': 59659, '2/8': 59660, '3/8': 59661, '4/8': 59662, '5/8': 59663, '6/8': 59664, '7/8': 59665, '8/8': 59666,\n    'clr': 59658, 'few': 59660, 'sct': 59662, 'bkn': 59664, 'ovc': 59666, 'obsc': 59667,\n\n    // Present weather symbols\n    'va': 59810, 'fu': 59810, 'hz': 59811, 'du': 59812, 'bldu': 59814, 'sa': 59814, 'blsa': 59814, 'vcblsa': 59814, 'vcbldu': 59814, 'blpy': 59814,\n    'po': 59816, 'vcpo': 59816, 'vcds': 59817, 'vcss': 59817,\n    'br': 59818, 'bcbr': 59818, 'bc': 59819, 'mifg': 59820,\n    'vcts': 59821, 'virga': 59822, 'vcsh': 59824, 'ts': 59825, 'thdr': 59825, 'vctshz': 59825,\n    'tsfzfg': 59825, 'tsbr': 59825, 'tsdz': 59825, 'vctsup': 59825,\n    '-tsup': 59825, 'tsup': 59825, '+tsup': 59825,\n    'sq': 59826, 'fc': 59827, '+fc': 59827,\n    'ds': 59839,'ss': 59839, 'drsa': 59839, 'drdu': 59839, '+ds': 59842, '+ss': 59842,\n    'drsn': 59844, '+drsn': 59845, '-blsn': 59846, 'blsn': 59846, '+blsn': 59847, 'vcblsn': 59846,\n    'vcfg': 59848, 'bcfg': 59849, 'prfg': 59852, 'fg': 59853, 'fzfg': 59857,\n    '-vctsdz': 59859, '-dz': 59859, '-dzbr': 59859, 'vctsdz': 59861, 'dz': 59861, '+vctsdz': 59863, '+dz': 59863,\n    '-fzdz': 59864, '-fzdzsn': 59864, 'fzdz': 59865, '+fzdz': 59865, 'fzdzsn': 59865,\n    '-dzra': 59866, 'dzra': 59867, '+dzra': 59867, '-ra': 59869, '-rabr': 59869, 'ra': 59871, 'rabr': 59871, 'rafg': 59871, 'vcra': 59871, '+ra': 59873,\n    '-fzra': 59874, '-fzrasn': 59874, '-fzrabr': 59874, '-fzrapl': 59874, '-fzrasnpl': 59874, 'tsfzrapl': 59875, '-tsfzra': 59875,\n    'fzra': 59875, '+fzra': 59875, 'fzrasn': 59875, 'tsfzra': 59875,\n    '-dzsn': 59876, '-rasn': 59876, '-snra': 59876, '-sndz': 59876, 'rasn': 59877, '+rasn': 59877, 'snra': 59877, 'dzsn': 59877, 'sndz': 59877, '+dzsn': 59877, '+sndz': 59877,\n    '-sn': 59879, '-snbr': 59879, 'sn': 59881, '+sn': 59883, '-snsg': 59885, 'sg': 59885, '-sg': 59885, 'ic': 59886,\n    '-fzdzpl': 59887, '-fzdzplsn': 59887, 'fzdzpl': 59887, '-fzraplsn': 59887, 'fzrapl': 59887, '+fzrapl': 59887,\n    '-rapl': 59887, '-rasnpl': 59887, '-raplsn': 59887, '+rapl': 59887, 'rapl': 59887, '-snpl': 59887, 'snpl': 59887,\n    '-pl': 59887, 'pl': 59887, '-plsn': 59887, '-plra': 59887, 'plra': 59887, '-pldz': 59887, '+pl': 59887, 'plsn': 59887, 'plup': 59887, '+plsn': 59887,\n    '-sh': 59888, '-shra': 59888, 'sh': 59889, 'shra': 59889, '+sh': 59889, '+shra': 59889, '-shrasn': 59891, '-shsnra': 59891, '+shrabr': 59892,\n    'shrasn': 59892, '+shrasn': 59892, 'shsnra': 59892, '+shsnra': 59892, '-shsn': 59893, 'shsn': 59894, '+shsn': 59894,\n    '-gs': 59895, '-shgs': 59895, 'fzraplgs': 59896, '-sngs': 59896, 'gsplsn': 59896, 'gspl': 59896, 'plgssn': 59896, 'gs': 59896, 'shgs': 59896, '+gs': 59896, '+shgs': 59896,\n    '-gr': 59897, '-shgr': 59897, '-sngr': 59898, 'gr': 59898, 'shgr': 59898, '+gr': 59898, '+shgr': 59898,\n    '-tsrasn': 59907, 'tsrasn': 59907, '-tssnra': 59907, 'tssnra': 59907, '-vctsra': 59908, '-tsra': 59908, 'tsra': 59908, '-tsdz': 59908, 'vctsra': 59908,\n    'tspl': 59909, '-tssn': 59909, '-tspl': 59909, 'tssn': 59909, '-vctssn': 59909, 'vctssn': 59909, 'tsplsn': 59909, 'tssnpl': 59909, '-tssnpl': 59909, '-tsragr': 59910,\n    'tsrags': 59910, 'tsragr': 59910, 'tsgs': 59910, 'tsgr': 59910,\n    '+tsfzrapl': 59911, '+vctsra': 59912, '+tsra': 59912, '+tsfzra': 59912, '+tssn': 59913, '+tspl': 59913, '+tsplsn': 59913, '+vctssn': 59913,\n    'tssa': 59914, 'tsds': 59914, 'tsdu': 59914, '+tsgs': 59915, '+tsgr': 59915, '+tsrags': 59915, '+tsragr': 59915, 'in': 59750,\n    '-up': 59750, 'up': 59750, '+up': 59751, '-fzup': 59756, 'fzup': 59756, '+fzup': 59757,\n}\n\n/** Configuration for symbols on station plots */\ninterface SPSymbolConfig {\n    type: 'symbol';\n\n    /**\n     * The position on the station plot at which to place the symbol\n     */\n    pos: SPPosition;\n\n    /**\n     * The color to use to draw the symbol\n     * @default '#000000'\n     */\n    color?: string | ((symbol: SPSymbol | null, category: SPSymbolCategory) => string);\n\n    /**\n     * Whether to draw a halo (outline) around the string\n     * @default true;\n     */\n    halo?: boolean;\n\n    /**\n     * The color to use for the halo (outline)\n     * @default '#ffffff'\n     */\n    halo_color?: string;\n}\n\n/** Configuration for station plot sub-elements */\ntype SPConfig = SPNumberConfig | SPStringConfig | SPBarbConfig | SPSymbolConfig;\n\n/**\n * Configuration for station data plots\n * @example\n * spconfig : SPDataConfig<'id' | 'tmpf' | 'wind' | 'skyc'> = {\n *      // Add a string to the station plot (like the station ID)\n *      id:   {type: 'string', pos: 'lr'},\n * \n *      // Add a number to the station plot (like the temperature)\n *      tmpf: {type: 'number', pos: 'ul', color: '#cc0000', formatter: val => val === null ? '' : val.toFixed(0)},\n * \n *      // Add a barb to the station plot\n *      wind: {type: 'barb', pos: 'c'},\n * \n *      // Add a symbol to the station plot\n *      skyc: {type: 'symbol', pos: 'c'},\n * }\n */\ntype SPDataConfig<ObsFieldName extends string> = Record<ObsFieldName, SPConfig>;\n\n/** Options for {@link StationPlot} components */\ninterface StationPlotOptions<ObsFieldName extends string> {\n    config: SPDataConfig<ObsFieldName>, \n    /**\n     * Thin factor at zoom level 1 for the station plots. Should be a power of 2.\n     * @default 1\n     */\n    thin_fac?: number;\n\n    /**\n     * Font face to use for plotting text\n     * @default 'Trebuchet MS'\n     */\n    font_face?: string;\n    \n    /**\n     * Size of the font to use for the text\n     * @default 12\n     */\n    font_size?: number;\n\n    /**\n     * URL template to use in retrieving the font data for the text. The default is to use the template from the map style.\n     */\n    font_url_template?: string;\n}\n\nconst station_plot_opts_defaults: Required<StationPlotOptions<never>> = {\n    config: {},\n    thin_fac: 1,\n    font_face: 'Trebuchet MS',\n    font_size: 12,\n    font_url_template: '',\n};\n\ninterface StationPlotGLElems<GridType extends AutoZoomGrid, MapType extends MapLikeType> {\n    map: MapType;\n    gl: WebGLAnyRenderingContext;\n    barb_components: Barbs<Float16Array, GridType, MapType>[];\n}\n\nfunction positionToAlignmentAndOffset(pos: SPPosition, off_size?: number) {\n    off_size = off_size === undefined ? 10 : off_size;\n\n    let ha: HorizontalAlign, va: VerticalAlign;\n    let xoff: number, yoff: number;\n\n    if(pos == 'll' || pos == 'cl' || pos == 'ul')      { ha = 'right'; xoff = -off_size; }\n    else if (pos == 'lc' || pos == 'c' || pos == 'uc') { ha = 'center'; xoff = 0; }\n    else                                               { ha = 'left'; xoff = off_size;}\n\n    if (pos == 'll' || pos == 'lc' || pos == 'lr')     { va = 'top'; yoff = -off_size; }\n    else if (pos == 'cl' || pos == 'c' || pos == 'cr') { va = 'middle'; yoff = 0; }\n    else                                               { va = 'baseline'; yoff = off_size; }\n\n    return {horizontal_align: ha, vertical_align: va, offset_x: xoff, offset_y: yoff};\n}\n\ntype SPSymbolCategory = 'freezing_rain' | 'sleet' | 'snow' | 'rain' | 'blowing_dust' | 'thunder' | 'fog' | 'none';\n\nfunction symbolCategory(symbol: SPSymbol) : SPSymbolCategory {\n    const sym = symbol.toLowerCase();\n\n    if (sym.includes('fzra') || (sym.includes('fz') && sym.includes('ra'))) return 'freezing_rain';\n    if (sym.includes('pl')) return 'sleet';\n    if (sym.includes('sn') || sym.includes('sg') || sym.includes('gs')) return 'snow';\n    if (sym.includes('ra') || sym.includes('dz')) return 'rain';\n    if (sym.includes('du') || sym.includes('ds') || sym.includes('ss') || sym.includes('blsa') || sym.includes('bldu') || sym.includes('blpy')) return 'blowing_dust';\n    if (sym.includes('ts') || sym.includes('thdr')) return 'thunder';\n    if (sym.includes('fg')) return 'fog';\n\n    return 'none';\n}\n\n/** \n * Station model plots for observed data\n * \n * ## Grid Compatibility\n * - :white_check_mark: `PlateCarreeGrid`\n * - :white_check_mark: `PlateCarreeRotatedGrid`\n * - :white_check_mark: `LambertGrid`\n * - :white_check_mark: `UnstructuredGrid`\n * - :x:                `RadarSweepGrid`\n * - :x:                `Geostationary`\n * \n * @example\n * // Specify how to set up the station plot\n * const station_plot_locs = {\n *     tmpf: {type: 'number', pos: 'ul', color: '#cc0000', formatter: val => val === null ? '' : val.toFixed(0)},\n *     dwpf: {type: 'number', pos: 'll', color: '#00aa00', formatter: val => val === null ? '' : val.toFixed(0)}, \n *     wind: {type: 'barb', pos: 'c'},\n *     preswx: {type: 'symbol', pos: 'cl', color: '#ff00ff'},\n *     skyc: {type: 'symbol', pos: 'c'},\n * };\n * \n * // Create the station plot\n * const station_plot = new StationPlot(obs_field, {config: station_plot_locs, thin_fac: 8, font_size: 14});\n */\nclass StationPlot<GridType extends AutoZoomGrid, MapType extends MapLikeType, ObsFieldName extends string> extends PlotComponent<MapType> {\n    private field: RawObsField<GridType, ObsFieldName>;\n    public readonly opts: Required<StationPlotOptions<ObsFieldName>>;\n    private gl_elems: StationPlotGLElems<GridType, MapType> | null;\n    private text_components: TextCollection[][] | null;\n\n    /**\n     * Create station plots\n     * @param field - A field containing the observed data\n     * @param opts  - Various options for the station plots\n     */\n    constructor(field: RawObsField<GridType, ObsFieldName>, opts: StationPlotOptions<ObsFieldName>) {\n        super();\n\n        this.field = field;\n        this.opts = normalizeOptions(opts, station_plot_opts_defaults as Required<StationPlotOptions<ObsFieldName>>); // Is there a way to do this without invoking `as`?\n        this.gl_elems = null;\n        this.text_components = null;\n    }\n\n    /**\n     * Update the data displayed as station plots\n     * @param field - The new field to display as station plots\n     */\n    public async updateField(field: RawObsField<GridType, ObsFieldName>) {\n        this.field = field;\n\n        if (this.gl_elems === null) return;\n\n        const map = this.gl_elems.map;\n        const gl = this.gl_elems.gl;\n        const barb_components = this.gl_elems.barb_components;\n\n        const map_style = map.getStyle();\n\n        const font_url_template = this.opts.font_url_template == '' ? map_style.glyphs : this.opts.font_url_template;\n        if (font_url_template === undefined)\n            throw \"The map style doesn't have any glyph information. Please pass the font_url_template option to StationPlot\";\n\n        const font_url = font_url_template.replace('{fontstack}', this.opts.font_face);\n\n        const coords = this.field.grid.getEarthCoords();\n        const zoom = this.field.grid.getMinVisibleZoom(this.opts.thin_fac);\n\n        let ibarb = 0;\n\n        let sub_component_promises: Promise<TextCollection>[][] = [];\n\n        Object.entries<SPConfig>(this.opts.config).forEach(async ([k_, config]) => {\n            const k = k_ as ObsFieldName;\n\n            if (config.type == 'number' || config.type == 'string') {\n                const pos = config.pos;\n                const color = config.color === undefined ? Color.fromHex('#000000') : Color.normalizeColor(config.color);\n                const halo_color = config.halo_color === undefined ? Color.fromHex('#ffffff') : Color.normalizeColor(config.halo_color);\n                const halo = config.halo === undefined ? true : config.halo;\n                let cmap: ColorMap | null = null;\n\n                let text_specs: TextSpec[];\n                if (config.type == 'number') {\n                    cmap = config.cmap === undefined ? null : config.cmap;\n                    const comp = this.field.getScalar(k);\n                    const formatter = config.formatter === undefined ? (val: number | null) => val === null ? 'null' : val.toString() : config.formatter;\n\n                    text_specs = comp.map((v, i) => {\n                        const spec: TextSpec = {\n                            text: formatter(v),\n                            lat: coords.lats[i],\n                            lon: coords.lons[i],\n                            min_zoom: zoom[i],\n                        };\n\n                        if (v !== null) \n                            spec.data_value = v;\n\n                        return spec;\n                    });\n                }\n                else {\n                    const comp = this.field.getStrings(k);\n                    text_specs = comp.map((v, i) => ({\n                        text: v === null ? '' : v,\n                        lat: coords.lats[i],\n                        lon: coords.lons[i],\n                        min_zoom: zoom[i],\n                    }));\n                }\n\n                const tc_opts: TextCollectionOptions = {\n                    ...positionToAlignmentAndOffset(pos),\n                    font_size: this.opts.font_size, halo: halo, \n                    text_color: color, halo_color: halo_color,\n                    cmap: cmap\n                };\n\n                sub_component_promises.push([TextCollection.make(gl, text_specs, font_url, tc_opts)]);\n            }\n            else if (config.type == 'barb') {\n                const comp = this.field.getVector(k);\n                const barb_comp = barb_components[ibarb++];\n                barb_comp.updateField(comp);\n            }\n            else if (config.type == 'symbol') {\n                const pos = config.pos;\n                const color = config.color === undefined ? '#000000' : config.color;\n                const halo_color = config.halo_color === undefined ? Color.fromHex('#ffffff') : Color.normalizeColor(config.halo_color);\n                const halo = config.halo === undefined ? true : config.halo;\n\n                const comp = this.field.getStrings(k) as (SPSymbol | null)[];\n                const wxsym_font_url = font_url_template.replace('{fontstack}', 'wx_symbols');\n                \n                type TextSpecDataColor = {specs: TextSpec[], color: string};\n                const text_spec_data: TextSpecDataColor[] = [];\n\n                comp.forEach((v, i) => {\n                    const v_cat: SPSymbolCategory = v === null ? 'none' : symbolCategory(v);\n                    const text_color = typeof color === 'string' ? color : color(v, v_cat);\n                    const text_spec_data_filtered = text_spec_data.filter(tsd => tsd.color == text_color)\n\n                    let text_spec_color : TextSpecDataColor;\n                    if (text_spec_data_filtered.length == 0) {\n                        text_spec_color = {specs: [], color: text_color};\n                        text_spec_data.push(text_spec_color);\n                    }\n                    else {\n                        text_spec_color = text_spec_data_filtered[0];\n                    }\n\n                    text_spec_color.specs.push({\n                        text: v === null ? '' : String.fromCharCode(SYMBOLS[v]),\n                        lat: coords.lats[i],\n                        lon: coords.lons[i],\n                        min_zoom: zoom[i],\n                    });\n                });\n\n                const promises: Promise<TextCollection>[] = []\n\n                text_spec_data.forEach(tsd => {\n                    const tc_opts: TextCollectionOptions = {\n                        ...positionToAlignmentAndOffset(pos),\n                        font_size: this.opts.font_size, halo: halo, \n                        text_color: Color.normalizeColor(tsd.color), halo_color: halo_color,\n                    };\n\n                    if (tc_opts.offset_x !== undefined) tc_opts.offset_x -= 3;\n\n                    promises.push(TextCollection.make(gl, tsd.specs, wxsym_font_url, tc_opts));\n                });\n\n                sub_component_promises.push(promises);\n            }\n            else {\n                throw `Unknown station plot configuration type ${(config as any).type}`;\n            }\n        });\n\n        this.text_components = await Promise.all(sub_component_promises.map(p => Promise.all(p)));\n        map.triggerRepaint();\n    }\n\n    /** @internal */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        const barb_promises = Object.entries<SPConfig>(this.opts.config).map(async ([k_, config]) => {\n            const k = k_ as ObsFieldName;\n            if (config.type == 'barb') {\n                const comp = this.field.getVector(k);\n\n                const color = config.color === undefined ? '#000000' : config.color;\n                const barb_size = config.barb_size_multipler === undefined ? 1 : config.barb_size_multipler;\n                const barb_comp = new Barbs<Float16Array, GridType, MapType>(comp, {thin_fac: this.opts.thin_fac, color: color, barb_size_multiplier: barb_size});\n                await barb_comp.onAdd(map, gl);\n                return barb_comp;\n            }\n        });\n\n        type BarbComponent = Barbs<Float16Array, GridType, MapType>;\n        const barb_components = (await Promise.all(barb_promises)).filter((c: BarbComponent | undefined) : c is BarbComponent => c !== undefined);\n\n        this.gl_elems = {\n            map: map, gl: gl, barb_components: barb_components\n        }\n\n        this.updateField(this.field);\n    }\n\n    /** @internal */\n    public render(gl: WebGLAnyRenderingContext, arg: RenderMethodArg) {\n        if (this.gl_elems === null || this.text_components === null) return;\n\n        const gl_elems = this.gl_elems;\n\n        const text_components = this.text_components;\n        const barb_components = this.gl_elems.barb_components;\n\n        const map_width = gl_elems.map.getCanvas().width;\n        const map_height = gl_elems.map.getCanvas().height;\n        const map_zoom = gl_elems.map.getZoom();\n\n        let itext = 0, ibarb = 0;\n        Object.values<SPConfig>(this.opts.config).forEach((comp, idx) => {\n            if (comp.type == 'barb') {\n                barb_components[ibarb++].render(gl, arg);\n            }\n            else {\n                text_components[itext++].forEach(tc => tc.render(gl, arg, [map_width, map_height], map_zoom));\n            }\n        });\n    }\n}\n\nexport default StationPlot;\nexport type {StationPlotOptions, SPPosition, SPNumberConfig, SPStringConfig, SPBarbConfig, SPSymbolConfig, SPConfig, SPDataConfig, SPSymbol};","\nimport { RenderMethodArg, WebGLAnyRenderingContext } from './AutumnTypes';\nimport { MapLikeType } from './Map';\n\nimport { PlotComponent } from './PlotComponent';\n\nabstract class PlotLayerBase<MapType extends MapLikeType> {\n    public readonly type: 'custom';\n    public readonly id: string;\n    protected map: MapType | null;\n\n    constructor(id: string) {\n        this.type = 'custom';\n        this.id = id;\n        this.map = null;\n    }\n\n    public abstract onAdd(map: MapType, gl: WebGLAnyRenderingContext) : void;\n    public abstract render(gl: WebGLAnyRenderingContext, matrix: number[] | Float32Array) : void;\n\n    protected repaint() {\n        if (this.map !== null) {\n            this.map.triggerRepaint();\n        }\n    }\n}\n\n/** \n * A static map layer. The data are assumed to be static in time. If the data have a time component (e.g., a model forecast), a {@link MultiPlotLayer} \n * may be more appropriate.\n * @example\n * // Create map layers from provided fields\n * const height_layer = new PlotLayer('height-contours', height_contours);\n * const wind_speed_layer = new PlotLayer('wind-speed-fill', wind_speed_fill);\n * const barb_layer = new PlotLayer('barbs', wind_barbs);\n */\nclass PlotLayer<MapType extends MapLikeType> extends PlotLayerBase<MapType> {\n    private readonly field: PlotComponent<MapType>;\n\n    /**\n     * Create a map layer from a field\n     * @param id    - A unique id for this layer\n     * @param field - The field to plot in this layer\n     */\n    constructor(id: string, field: PlotComponent<MapType>) {\n        super(id);\n        this.field = field;\n    }\n\n    /**\n     * @internal\n     * Add this layer to a map\n     */\n    public async onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.map = map;\n        await this.field.onAdd(map, gl);\n    }\n\n    /**\n     * @internal\n     * Render this layer\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: RenderMethodArg) {\n        this.field.render(gl, matrix);\n    }\n}\n\n/**\n * A varying map layer. If the data don't have a varying component, such as over time, it might be easier to use a {@link PlotLayer} instead.\n * @example\n * // Create a varying map layer\n * height_layer = new MultiPlotLayer('height-contours');\n * \n * // Add some fields to it\n * height_layer.addField(height_contour_f00, '20230112_1200');\n * height_layer.addField(height_contour_f01, '20230112_1300');\n * height_layer.addField(height_contour_f02, '20230112_1400');\n * \n * // Set the date/time in the map layer\n * height_layer.setActiveKey('20230112_1200');\n */\nclass MultiPlotLayer<MapType extends MapLikeType> extends PlotLayerBase<MapType> {\n    private fields: Record<string, PlotComponent<MapType>>;\n    private field_key: string | null;\n\n    private gl: WebGLAnyRenderingContext | null;\n\n    /**\n     * Create a time-varying map layer\n     * @param id - A unique id for this layer\n     */\n    constructor(id: string) {\n        super(id);\n\n        this.fields = {};\n        this.field_key = null;\n        this.map = null;\n        this.gl = null;\n    }\n\n    /**\n     * @internal\n     * Add this layer to a map\n     */\n    public onAdd(map: MapType, gl: WebGLAnyRenderingContext) {\n        this.map = map;\n        this.gl = gl;\n\n        Object.values(this.fields).forEach(field => {\n            field.onAdd(map, gl).then(res => {\n                this.repaint();\n            });\n        });\n\n        this.repaint();\n    }\n\n    /**\n     * @internal\n     * Render this layer\n     */\n    public render(gl: WebGLAnyRenderingContext, matrix: RenderMethodArg) {\n        if (this.map !== null && this.gl !== null && this.field_key !== null \n            && this.fields.hasOwnProperty(this.field_key) && this.fields[this.field_key] !== null) {\n            this.fields[this.field_key].render(gl, matrix);\n        }\n    }\n\n    /**\n     * Set the active key\n     * @param key - The new key. The field with that key is plotted immediately.\n     */\n    public setActiveKey(key: string) {\n        const old_field_key = this.field_key;\n        this.field_key = key;\n\n        this.repaint();\n    }\n\n    /**\n     * Get a list of all dates/times that have been added to the layer\n     * @returns An array of dates/times\n     */\n    public getKeys() {\n        return Object.keys(this.fields);\n    }\n\n    /**\n     * Add a field with a given key\n     * @param field - The field to add\n     * @param key   - The key to associate with the field\n     */\n    public addField(field: PlotComponent<MapType>, key: string) {\n        const old_field_key = this.field_key;\n\n        if (this.map !== null && this.gl !== null && field !== null) {\n            field.onAdd(this.map, this.gl).then(res => {\n                this.repaint();\n            });\n        }\n\n        this.fields[key] = field;\n        \n        if (this.field_key === null) {\n            this.field_key = key;\n        }\n    }\n}\n\nexport {PlotLayer, MultiPlotLayer};","\nimport { ColorMap } from \"./Colormap\";\nimport { Color } from \"./Color\";\nimport { normalizeOptions } from \"./utils\";\n\n/** The orientation for color bars (horizontal or vertical) */\ntype ColorbarOrientation = 'horizontal' | 'vertical';\n\n/** Which side of a color bar the ticks are on */\ntype ColorbarTickDirection = 'top' | 'bottom' | 'left' | 'right';\n\n/** Options for {@link makeColorBar} */\ninterface ColorBarOptions {\n    /** The label to place along the color bar */\n    label?: string;\n\n    /** \n     * The size in pixels along the long axis of the colorbar \n     * @default 600\n     */\n    size_long?: number;\n\n    /**\n     * The size in pixels along the short axis of the colorbar\n     * @default size_long / 9\n     */\n    size_short?: number;\n\n    /** \n     * An array of numbers to use as the tick locations. \n     * @default Use all the levels in the color map provided to {@link makeColorBar}.\n     */\n    ticks?: number[];\n\n    /** \n     * The direction the ticks should face. Valid values are 'left' and 'right' if orientation is 'vertical' and 'top' and \n     * 'bottom' if orientation is 'horizontal'.\n     * @default 'left' if orientation is 'vertical' and 'bottom' if orientation is 'horizontal'\n     */\n    tick_direction?: ColorbarTickDirection;\n\n    /** \n     * The orientation for the color bar. Valid values are 'horizontal' and 'vertical'.\n     * @default 'vertical'\n     */\n    orientation?: ColorbarOrientation;\n\n    /** \n     * A font face to use for the label and tick values.\n     * @default 'sans-serif'\n     */\n    fontface?: string;\n\n    /**\n     * The font size (in points) to use for the tick labels\n     * @default 12\n     */\n    ticklabelsize?: number;\n\n    /**\n     * The color for the color bar outline and the text\n     * @default '#000000'\n     */\n    outline_and_text_color?: string;\n};\n\nconst createElement = (tagname: string, attributes?: Record<string, string | number>, parent?: SVGElement) => {\n    const elem = document.createElementNS('http://www.w3.org/2000/svg', tagname);\n\n    if (attributes !== undefined) {\n        Object.entries(attributes).forEach(([k, v]) => {\n            elem.setAttribute(k, v.toString());\n        });\n    }\n\n    if (parent !== undefined) {\n        parent.appendChild(elem);\n    }\n\n    return elem;\n};\n\n/**\n * Make an SVG containing a color bar. The color bar can either be oriented horizontal or vertical, and a label can be provided.\n * @param colormap - The color map to use\n * @param opts     - The options for creating the color bar\n * @returns An SVGElement containing the color bar image.\n * @example\n * // Create the color bar\n * const svg = makeColorBar(color_map, {label: 'Wind Speed (kts)', orientation: 'horizontal', \n *                                      fontface: 'Trebuchet MS'});\n * \n * // Add colorbar to the page\n * document.getElementById('colorbar-container').appendChild(svg);\n */\nfunction makeColorBar(colormap: ColorMap, opts: ColorBarOptions) {\n    const label = opts.label || \"\";\n    const ticks = opts.ticks || colormap.levels;\n    const orientation = opts.orientation || 'vertical';\n    const fontface = opts.fontface || 'sans-serif';\n    const tickfontsize = opts.ticklabelsize || 12;\n    const size_long = opts.size_long || 600;\n    const size_short = opts.size_short || size_long / 9;\n    const outline_and_text_color = opts.outline_and_text_color || '#000000';\n\n    const tick_dir = opts.tick_direction || (orientation == 'vertical' ? 'left' : 'bottom');\n\n    if (orientation == 'vertical' && (tick_dir == 'top' || tick_dir == 'bottom') ||\n        orientation == 'horizontal' && (tick_dir == 'left' || tick_dir == 'right')) {\n        throw `tick_direction of '${tick_dir} doesn't match an orientation of ${orientation}`;\n    }\n\n    const getNChar = (n: number) => {\n        return n.toString().length;\n    }\n\n    const chars_left = getNChar(ticks[0]);\n    const chars_right = getNChar(ticks[ticks.length - 1]);\n    const need_overflow = colormap.underflow_color !== null || colormap.overflow_color !== null;\n\n    const bar_long_size = size_long;\n    const bar_cross_size = size_short;\n    const bar_long_pad = Math.max(orientation == 'horizontal' ? Math.max(chars_left, chars_right) * 6 : 8, \n                                  need_overflow ? bar_cross_size / (2 * Math.sqrt(3)) : 0);\n    const bar_cross_pad = 3;\n    const bar_thickness = 10;\n\n    let height: number, width: number, bar_left: number, bar_top: number, bar_width: number, bar_height: number, bar_right: number, bar_bottom: number,\n        bar_middle: number, bar_low_arrow: number, bar_high_arrow: number;\n\n    if (orientation == 'vertical') {\n        height = bar_long_size;\n        width = bar_cross_size;\n\n        bar_left = tick_dir == 'left' ? bar_cross_size - bar_cross_pad - bar_thickness : bar_cross_pad;\n        bar_top = bar_long_pad;\n        bar_width = bar_thickness;\n        bar_height = bar_long_size - 2 * bar_long_pad;\n\n        bar_right = bar_left + bar_width;\n        bar_middle = bar_left + bar_width / 2;\n        bar_bottom = bar_top + bar_height;\n        bar_low_arrow = colormap.underflow_color === null ? bar_bottom : bar_bottom + bar_cross_size / (Math.sqrt(3) * 2);\n        bar_high_arrow = colormap.overflow_color === null ? bar_top : bar_top - bar_cross_size / (Math.sqrt(3) * 2);\n    }\n    else {\n        width = bar_long_size;\n        height = bar_cross_size - 6;\n\n        bar_left = bar_long_pad;\n        bar_top = tick_dir == 'bottom' ? bar_cross_pad : bar_cross_size - 6 - bar_cross_pad - bar_thickness;\n        bar_height = bar_thickness;\n        bar_width = bar_long_size - 2 * bar_long_pad;\n\n        bar_right = bar_left + bar_width;\n        bar_middle = bar_top + bar_height / 2;\n        bar_bottom = bar_top + bar_height;\n        bar_low_arrow = colormap.underflow_color === null ? bar_left : bar_left - bar_cross_size / (Math.sqrt(3) * 2);\n        bar_high_arrow = colormap.overflow_color === null ? bar_right : bar_right + bar_cross_size / (Math.sqrt(3) * 2);\n    }\n\n    const n_colors = colormap.colors.length;\n\n    const root = createElement('svg', {width: width, height: height});\n    const gbar = createElement('g', {}, root);\n\n    let gtickattrs;\n    if (orientation == 'vertical') {\n        gtickattrs = tick_dir == 'left' ? {'text-anchor': 'end', transform: `translate(${bar_left}, ${bar_top})`} : \n                                          {transform: `translate(${bar_left + bar_width}, ${bar_top})`}\n    }\n    else {\n        gtickattrs = tick_dir == 'bottom' ? {'text-anchor': 'middle', transform: `translate(${bar_left}, ${bar_top + bar_height})`} : \n                                            {'text-anchor': 'middle', transform: `translate(${bar_left}, ${bar_top})`}\n    }\n    const gticks = createElement('g', gtickattrs, root);\n\n    // Make the colored background\n    colormap.colors.forEach((color, icolor) => {\n        let attrs: Record<string, string | number> = {};\n\n        if (orientation == 'vertical') {\n            attrs = {\n                x: bar_left, y: bar_top + bar_height * (1 - (icolor + 1) / n_colors), width: bar_width, height: bar_height / n_colors};\n        }\n        else {\n            attrs = {x: bar_left + bar_width * icolor / n_colors, y: bar_top, width: bar_width / n_colors, height: bar_height};\n        }\n\n        createElement('rect', {...attrs, fill: color.toRGBHex(), opacity: color.a}, gbar);\n    });\n\n    // Make the overflow and underflow triangles\n    if (colormap.underflow_color !== null) {\n        let point_list: string;\n        if (orientation == 'vertical') {\n            point_list = `${bar_right} ${bar_bottom}, ${bar_middle} ${bar_low_arrow}, ${bar_left} ${bar_bottom}, ${bar_right} ${bar_bottom}`;\n        }\n        else {\n            point_list = `${bar_left} ${bar_bottom}, ${bar_low_arrow} ${bar_middle}, ${bar_left} ${bar_top}, ${bar_left} ${bar_bottom}`;\n        }\n\n        const underflow_attrs = {points: point_list, fill: colormap.underflow_color.toRGBHex(), opacity: colormap.underflow_color.a};\n        createElement('polygon', underflow_attrs, gbar);\n    }\n\n    if (colormap.overflow_color !== null) {\n        let point_list: string;\n        if (orientation == 'vertical') {\n            point_list = `${bar_left} ${bar_top}, ${bar_middle} ${bar_high_arrow}, ${bar_right} ${bar_top}, ${bar_left} ${bar_top}`;\n        }\n        else {\n            point_list = `${bar_right} ${bar_top}, ${bar_high_arrow} ${bar_middle}, ${bar_right} ${bar_bottom}, ${bar_right} ${bar_top}`;\n        }\n\n        const overflow_attrs = {points: point_list, fill: colormap.overflow_color.toRGBHex(), opacity: colormap.overflow_color.a};\n        createElement('polygon', overflow_attrs, gbar);\n    }\n\n    // Make the ticks marks and labels\n    const first_level = colormap.levels[0];\n    const last_level = colormap.levels[colormap.levels.length - 1];\n\n    ticks.filter(level => first_level <= level && level <= last_level).forEach(level => {\n        const diffs = colormap.levels.map(l => Math.abs(l - level));\n        let ilevel = diffs.indexOf(diffs.reduce((a, b) => Math.min(a, b)));\n        if (level <= colormap.levels[ilevel] && ilevel > 0)\n            ilevel -= 1;\n        ilevel += (level - colormap.levels[ilevel]) / (colormap.levels[ilevel + 1] - colormap.levels[ilevel]);\n        const tickattrs = orientation == 'vertical' ? {transform: `translate(0, ${bar_height * (1 - ilevel / n_colors)})`} : \n                                                      {transform: `translate(${bar_width * ilevel / n_colors}, 0)`};\n        const gtick = createElement('g', tickattrs, gticks);\n\n        let lineattrs;\n        if (orientation == 'vertical') {\n            lineattrs = tick_dir == 'left' ? {x2: -6} : {x2: 6};\n        }\n        else {\n            lineattrs = tick_dir == 'bottom' ? {y2 : 6} : {y2: -6};\n        }\n\n        createElement('line', {...lineattrs, stroke: outline_and_text_color, 'stroke-width': 1.5}, gtick);\n\n        let textattrs;\n        if (orientation == 'vertical') {\n            textattrs = tick_dir == 'left' ? {x: -9, dy: '0.32em'} : {x: 9, dy: '0.32em'};\n        }\n        else {\n            textattrs = tick_dir == 'bottom' ? {y: 9, dy: '0.8em'} : {y: -9, dy: '0em'};\n        }\n\n        const text = createElement('text', {...textattrs, fill: outline_and_text_color, style: `font-family: ${fontface}; font-size: ${tickfontsize}pt`}, gtick);\n        text.textContent = level.toString();\n    });\n\n    // Draw the outline\n    let point_list: string;\n    if (orientation == 'vertical') {\n        point_list = `${bar_left} ${bar_top}, ${bar_middle} ${bar_high_arrow}, ${bar_right} ${bar_top}, ${bar_right} ${bar_bottom}, ` +\n                     `${bar_middle} ${bar_low_arrow}, ${bar_left} ${bar_bottom}, ${bar_left} ${bar_top}`;\n    }\n    else {\n        point_list = `${bar_left} ${bar_top}, ${bar_right} ${bar_top}, ${bar_high_arrow} ${bar_middle}, ${bar_right} ${bar_bottom}, ` +\n                     `${bar_left} ${bar_bottom}, ${bar_low_arrow} ${bar_middle}, ${bar_left} ${bar_top}`;\n    }\n\n    const outline_attrs = {\n        points: point_list,\n        stroke: outline_and_text_color,\n        'stroke-width': 1.5,\n        fill: 'none'\n    };\n    createElement('polygon', outline_attrs, root);\n\n    // Draw the colorbar label\n    let labelattrs;\n    if (orientation == 'vertical') {\n        labelattrs = tick_dir == 'left' ? {transform: `translate(15, ${height / 2}) rotate(-90)`} : {transform: `translate(${width - 6}, ${height / 2}) rotate(-90)`};\n    }\n    else {\n        labelattrs = tick_dir == 'bottom' ? {transform: `translate(${width / 2}, ${height - 5})`} : {transform: `translate(${width / 2}, 15)`}\n    }\n    const label_elem = createElement('text', {...labelattrs, fill: outline_and_text_color, 'text-anchor': 'middle', style: `font-family: ${fontface};`}, root);\n    label_elem.textContent = label;\n\n    return root;\n}\n\n/** Options for {@link makePaintballKey | makePaintballKey()} */\ninterface PaintballKeyOptions {\n    /**\n     * The number of columns of entries in the key\n     * @default 1\n     */\n    n_cols?: number;\n\n    /**\n     * The space allocated for the text for each color swatch in pixels\n     * @default 100\n     */\n    swatch_text_space?: number;\n\n    /** \n     * A font face to use for the label and tick values.\n     * @default 'sans-serif'\n     */\n    fontface?: string;\n}\n\nconst paintball_key_opt_defaults: Required<PaintballKeyOptions> = {\n    n_cols: 1,\n    swatch_text_space: 100,\n    fontface: 'sans-serif',\n}\n\n/**\n * Make an SVG containing a color key for a paintball plot. The key can be split over any number of columns.\n * @param colors - A list of colors \n * @param labels - The labels corresponding to each color\n * @param opts   - The options for creating the color key\n * @returns An SVGElement containing the color bar image.\n * @example\n * // Create the color key\n * const svg = makePaintballKey(colors, labels, {n_cols: 2, fontface: 'Trebuchet MS'});\n * \n * // Add the color key to the page\n * document.getElementById('pb-key-container').appendChild(svg);\n */\nfunction makePaintballKey(colors: (Color | string)[], labels: string[], opts?: PaintballKeyOptions) {\n    if (colors.length != labels.length) {\n        throw `Mismatch between the number of colors (${colors.length}) and the number of labels (${labels.length})`;\n    }\n\n    const opts_ = normalizeOptions(opts, paintball_key_opt_defaults);\n\n    let height: number, width: number;\n\n    const swatch_width = 20;\n    const swatch_height = 20;\n    const swatch_text_pad = 3;\n    const swatch_text_space = opts_.swatch_text_space;\n    const swatch_width_pad = 5;\n    const swatch_height_pad = 5;\n    const n_cols = opts_.n_cols;\n    const fontface = opts_.fontface;\n\n    const n_rows = Math.ceil(colors.length / n_cols);\n\n    width = (swatch_width + swatch_text_pad + swatch_text_space) * n_cols + swatch_width_pad * (n_cols + 1);\n    height = swatch_height * n_rows + swatch_height_pad * (n_rows + 1);\n\n    const root = createElement('svg', {width: width, height: height});\n    const gbar = createElement('g', {}, root);\n\n    colors.forEach((color, icolor) => {\n        const label = labels[icolor];\n\n        const irow = icolor % n_rows;\n        const icol = Math.floor(icolor / n_rows);\n\n        let opacity = 1.;\n        if (typeof color != 'string') {\n            opacity = color.a;\n            color = color.toRGBHex();\n        }\n\n        const x = swatch_width_pad + icol * (swatch_width + swatch_text_pad + swatch_text_space + swatch_width_pad);\n        const y = swatch_height_pad + irow * (swatch_height + swatch_height_pad);\n\n        createElement('rect', {x: x, y: y, fill: color, opacity: opacity, width: swatch_width, height: swatch_height}, gbar);\n\n        let textattrs = {x: x + swatch_width + swatch_text_pad, y: y + swatch_height / 2, dy: '0.32em'};\n\n        const text = createElement('text', {...textattrs, fill: '#000000', style: `font-size: 0.8em; font-family: ${fontface};`}, gbar);\n        text.textContent = label;\n    })\n\n    return root;\n}\n\nexport {makeColorBar, makePaintballKey};\nexport type {ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions};","\nimport { Float16Array } from \"@petamoriken/float16\";\nimport { ContourData, TypedArray, TypedArrayStr, WebGLAnyRenderingContext, WindProfile, isContourable, isStormRelativeWindProfile } from \"./AutumnTypes\";\nimport { FieldContourOpts } from \"./ContourCreator.worker\";\nimport { Grid } from \"./grids/Grid\";\nimport { Cache, getArrayConstructor, zip } from \"./utils\";\nimport { WGLTexture, WGLTextureSpec } from \"autumn-wgl\";\nimport { getContourWorkerPool, getGLFormatTypeAlignment } from \"./PlotComponent\";\nimport { AutoZoomGrid } from \"./grids/AutoZoom\";\n\ntype TextureDataType<ArrayType> = ArrayType extends Float32Array ? Float32Array : \n                                 (ArrayType extends Uint8Array ? Uint8Array : \n                                 (ArrayType extends Uint32Array ? Uint32Array : \n                                 (ArrayType extends Int32Array ? Int32Array : \n                                 (ArrayType extends Int16Array ? Int16Array : Uint16Array))));\n\nfunction getArrayDType(ary: TypedArray) : TypedArrayStr {\n    if (ary instanceof Float32Array) {\n        return 'float32';\n    }\n    else if (ary instanceof Uint8Array) {\n        return 'uint8';\n    }\n    else if (ary instanceof Uint16Array) {\n        return 'uint16';\n    }\n    else if (ary instanceof Uint32Array) {\n        return 'uint32';\n    }\n    else if (ary instanceof Int16Array) {\n        return 'int16';\n    }\n    else if (ary instanceof Int32Array) {\n        return 'int32';\n    }\n    return 'float16';\n}\n\nabstract class ExpressionScalarField<ArrayType extends TypedArray, GridType extends Grid> {\n    public abstract updateTexImageData(gl: WebGLAnyRenderingContext, image_mag_filter: number, fill_textures: Map<string, WGLTexture> | null) : Map<string, WGLTexture>;\n    public abstract getSamplerIds(): string[];\n    public abstract getExpression(): string;\n    public abstract renderCPU(): RawScalarField<ArrayType, GridType>;\n    public abstract iterateCPU(): Generator<number, void, unknown>;\n\n    abstract get grid() : GridType;\n    abstract get aryConstructor() : new(...args: any[]) => ArrayType;\n    abstract get dtypes() : TypedArrayStr[];\n\n    private operand(other: ExpressionScalarField<ArrayType, GridType> | number, operand: '+' | '-' | '*' | '/'): ComputedScalarField<ArrayType, GridType> {\n        const FUNCS = {\n            '+': (a: number, b: number) => a + b,\n            '-': (a: number, b: number) => a - b,\n            '*': (a: number, b: number) => a * b,\n            '/': (a: number, b: number) => a / b,\n        };\n\n        if (typeof other === 'number') {\n            return new ComputedScalarField([this], `{0} ${operand} ${other.toFixed(100)}`, v => FUNCS[operand](v, other));\n        }\n\n        return new ComputedScalarField([this, other], `{0} ${operand} {1}`, FUNCS[operand]);\n    }\n\n    /**\n     * Multiply this field by another scalar. The computation occurs on the GPU if the resulting field is used in a plot component or on the CPU if \n     *  {@link ComputedScalarField.renderCPU | renderCPU()} is called on the resulting field.\n     * @param other - Scalar to multiply this field by\n     * @returns A `ComputedScalarField` representing the multiplied field\n     */\n    public multiply(other: ExpressionScalarField<ArrayType, GridType> | number): ComputedScalarField<ArrayType, GridType> {\n        return this.operand(other, '*');\n    }\n\n    /**\n     * Divide this field by another scalar. The computation occurs on the GPU if the resulting field is used in a plot component or on the CPU if\n     * {@link ComputedScalarField.renderCPU | renderCPU()} is called on the resulting field.\n     * @param other - Scalar to divide this field by\n     * @returns A `ComputedScalarField` representing the divided field\n     */\n    public divide(other: ExpressionScalarField<ArrayType, GridType> | number): ComputedScalarField<ArrayType, GridType> {\n        return this.operand(other, '/');\n    }\n\n    /**\n     * Add this field to another scalar. The computation occurs on the GPU if the resulting field is used in a plot component or on the CPU if \n     *  {@link ComputedScalarField.renderCPU | renderCPU()} is called on the resulting field.\n     * @param other - Scalar to add to this field\n     * @returns A `ComputedScalarField` representing the added field\n     */\n    public add(other: ExpressionScalarField<ArrayType, GridType> | number): ComputedScalarField<ArrayType, GridType> {\n        return this.operand(other, '+');\n    }\n\n    /**\n     * Subtract another scalar from this field. The computation occurs on the GPU if the resulting field is used in a plot component or on the CPU if\n     *  {@link ComputedScalarField.renderCPU | renderCPU()} is called on the resulting field.\n     * @param other - Scalar to subtract from this field\n     * @returns A `ComputedScalarField` representing the subtracted field\n     */\n    public subtract(other: ExpressionScalarField<ArrayType, GridType> | number): ComputedScalarField<ArrayType, GridType> {\n        return this.operand(other, '-');\n    }\n\n    public abstract getThinnedField(thin_fac: number, map_max_zoom: number) : this;\n\n    public abstract sampleField(lon: number, lat: number) : number;\n    public abstract sampleFieldWithCoord(lon: number, lat: number) : {sample: number, sample_lon: number, sample_lat: number};\n}\n\n/** A class representing a raw 2D field of gridded data, such as height or u wind. */\nclass RawScalarField<ArrayType extends TypedArray, GridType extends Grid> extends ExpressionScalarField<ArrayType, GridType> {\n    public readonly grid: GridType;\n    public readonly data: ArrayType;\n\n    private readonly contour_cache: Cache<[FieldContourOpts], Promise<ContourData>>;\n\n    /**\n     * Create a data field. \n     * @param grid - The grid on which the data are defined\n     * @param data - The data, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid.\n     */\n    constructor(grid: GridType, data: ArrayType) {\n        super();\n\n        this.grid = grid;\n        this.data = data;\n\n        if (grid.ni * grid.nj != data.length) {\n            throw `Data size (${data.length}) doesn't match the grid dimensions (${grid.ni} x ${grid.nj}; expected ${grid.ni * grid.nj} points)`;\n        }\n\n        this.contour_cache = new Cache(async (opts: FieldContourOpts) => {\n            if (getArrayDType(this.data) != 'float16' && getArrayDType(this.data) != 'float32') \n                throw `Grid is of type ${getArrayDType(this.data)}, which is not contourable (should be either float16 or float32)`;\n\n            const tex_data = this.getTextureData();\n            if (!isContourable(tex_data)) throw `Type check for contourable array failed`;\n\n            const pool = getContourWorkerPool(undefined, 1); // 1 worker is the default; if the user requests more, the pool will be pre-created with the correct number of workers\n            const contour_data = await pool.contourCreator(tex_data, grid.getGridCoords(), opts);\n\n            for (const v in contour_data) {\n                for (let ic = 0; ic < contour_data[v].length; ic++) {\n                    for (let ip = 0; ip < contour_data[v][ic].length; ip++) {\n                        const [x, y] = contour_data[v][ic][ip];\n                        contour_data[v][ic][ip] = grid.transform(x, y, {inverse: true});\n                    }\n                }\n            }\n\n            return contour_data;\n        });\n    }\n\n    /** @internal */\n    get aryConstructor() {\n        return getArrayConstructor(this.data);\n    }\n\n    /** @internal */\n    get dtypes() {\n        return [getArrayDType(this.data)];\n    }\n\n    /** @internal */\n    private getTextureData() : TextureDataType<ArrayType> {\n        // Need to give float16 data as uint16s to make WebGL happy: https://github.com/petamoriken/float16/issues/105\n        const raw_data = this.data;\n        const raw_data_type = getArrayDType(raw_data);\n        const data: any = ['float32', 'uint8', 'uint32', 'uint16', 'int32', 'int16'].includes(raw_data_type) ? raw_data : new Uint16Array(raw_data.buffer);\n        return data as TextureDataType<ArrayType>;\n    }\n\n    private getWGLTextureSpec(gl: WebGLAnyRenderingContext, image_mag_filter: number) : Map<string, WGLTextureSpec> {\n        const tex_data = this.getTextureData();\n        const {format, type, row_alignment} = getGLFormatTypeAlignment(gl, getArrayDType(this.data));\n    \n        return new Map([['_0', {'format': format, 'type': type,\n            'width': this.grid.ni, 'height': this.grid.nj, 'image': tex_data,\n            'mag_filter': image_mag_filter, 'min_filter': image_mag_filter, 'row_alignment': row_alignment,\n        }]]);\n    }\n\n    public updateTexImageData(gl: WebGLAnyRenderingContext, image_mag_filter: number, fill_textures: Map<string, WGLTexture> | null) {\n        const fill_texture_specs = this.getWGLTextureSpec(gl, image_mag_filter);\n\n        if (fill_textures === null) {\n            fill_textures = new Map(this.getSamplerIds().map(key => {\n                const key_fill_image = fill_texture_specs.get(key);\n\n                if (key_fill_image === undefined)\n                    throw `Missing key '${key}' in fill_texture_specs`;\n\n                return [key, new WGLTexture(gl, key_fill_image)];\n            }));\n        }\n        else {\n            this.getSamplerIds().forEach(key => {\n                const key_fill_image = fill_texture_specs.get(key);\n                if (key_fill_image === undefined)\n                    throw `Missing key '${key}' in fill_texture_specs`;\n\n                const tex = fill_textures?.get(key);\n                if (tex === undefined)\n                    throw `Missing key '${key}' in fill_textures`; \n\n                tex.setImageData(key_fill_image);\n            });\n        }\n\n        return fill_textures;\n    }\n\n    /** @internal */\n    public getSamplerIds() : string[] {\n        return ['_0'];\n    }\n\n    /** @internal */\n    public getExpression() : string {\n        return '_0';\n    }\n\n    /**\n     * Get contour data as an object with each contour level being a separate property. \n     * @param opts - Options for doing the contouring\n     * @returns contour data as an object\n     */\n    public async getContours(opts: FieldContourOpts) {\n        return await this.contour_cache.getValue(opts);\n    }\n\n    /**\n     * Create a new field by aggregating a number of fields using a specific function. This computation occurs on the CPU.\n     * @param func - A function that will be applied each element of the field. It should take the same number of arguments as fields you have and return a single number.\n     * @param args - The RawScalarFields to aggregate\n     * @returns a new gridded field\n     * @example\n     * // Compute wind speed from u and v\n     * wind_speed_field = RawScalarField.aggreateFields(Math.hypot, u_field, v_field);\n     */\n    public static aggregateFields<ArrayType extends TypedArray, GridType extends Grid>(func: (...args: number[]) => number, ...args: RawScalarField<ArrayType, GridType>[]) {\n        return (new ComputedScalarField(args, '', func)).renderCPU();\n    }\n\n    /**\n     * Run computations on a scalar field on the CPU (for a `RawScalarField`, this is a no-op). The function blocks the main thread, so avoid calling it if possible.\n     * @returns The computed grid in a `RawScalarField`\n     */\n    public renderCPU(): RawScalarField<ArrayType, GridType> {\n        return this;\n    }\n\n    /** @internal */\n    public *iterateCPU() {\n        for (let i = 0; i < this.data.length; i++) {\n            yield this.data[i];\n        }\n    }\n\n    /** @internal */\n    public getThinnedField(thin_fac: number, map_max_zoom: number) {\n        const new_grid = this.grid.getThinnedGrid(thin_fac, map_max_zoom)\n        const thin_data = new_grid.thinDataArray(this.grid, this.data);\n\n        return new RawScalarField(new_grid, thin_data) as this;\n    }\n\n    /**\n     * Sample this field at a given latitude and longitude.\n     * @param lon - Longitude of the sample in degrees east\n     * @param lat - Latitude of the sample in degrees north\n     * @returns The value of the nearest grid point along with the grid point latitude and longitude, or NaNs if the point is outside the grid.\n     */\n    public sampleFieldWithCoord(lon: number, lat: number) {\n        return this.grid.sampleNearestGridPoint(lon, lat, this.data);\n    }\n\n    /**\n     * Sample this field at a given latitude and longitude.\n     * @param lon - Longitude of the sample in degrees east\n     * @param lat - Latitude of the sample in degrees north\n     * @returns The value of the nearest grid point, or NaN if the point is outside the grid.\n     */\n    public sampleField(lon: number, lat: number) {\n        return this.sampleFieldWithCoord(lon, lat).sample;\n    }\n}\n\nconst chars = 'abcdefghijklmnopqrstuvwxyz';\n\nclass ComputedScalarField<ArrayType extends TypedArray, GridType extends Grid> extends ExpressionScalarField<ArrayType, GridType> {\n    private readonly raw_fields: ExpressionScalarField<ArrayType, GridType>[];\n    private readonly expression: string;\n    private readonly cpu_func: (...arg: number[]) => number;\n\n    constructor(raw_fields: ExpressionScalarField<ArrayType, GridType>[], expression: string, cpu_func: (...arg: number[]) => number) {\n        super();\n\n        this.raw_fields = raw_fields;\n        this.expression = expression;\n        this.cpu_func = cpu_func;\n    }\n\n    /** @internal */\n    get grid(): GridType {\n        return this.raw_fields[0].grid;\n    }\n\n    /** @internal */\n    get aryConstructor() {\n        return this.raw_fields[0].aryConstructor;\n    }\n\n    /** @internal */\n    get dtypes(): TypedArrayStr[] {\n        return this.raw_fields.map(f => f.dtypes).flat();\n    }\n\n    /** @internal */\n    public updateTexImageData(gl: WebGLAnyRenderingContext, image_mag_filter: number, fill_textures: Map<string, WGLTexture> | null) {\n        const fill_textures_ret: Map<string, WGLTexture> = new Map();\n\n        this.raw_fields.forEach((field, idx) => {\n            let fill_textures_pre_field: Map<string, WGLTexture> | null = null;\n            if (fill_textures !== null) {\n                fill_textures_pre_field = new Map();\n\n                for (let [key, val] of fill_textures) {\n                    if (key[key.length - 1] == chars[idx])\n                        fill_textures_pre_field.set(key.slice(0, -1), val);\n                }\n            }\n\n            const fill_textures_field = field.updateTexImageData(gl, image_mag_filter, fill_textures_pre_field);\n\n            for (let [key, val] of fill_textures_field) {\n                fill_textures_ret.set(`${key}${chars[idx]}`, val);\n            }\n\n        });\n\n        return fill_textures_ret;\n    }\n\n    /** @internal */\n    public getSamplerIds(): string[] {\n        return this.raw_fields.map((f, i) => f.getSamplerIds().map(id => `${id}${chars[i]}`)).flat();\n    }\n\n    /** @internal */\n    public getExpression(): string {\n        let expression = this.expression;\n        this.raw_fields.forEach((field, idx) => {\n            let field_expr = field.getExpression();\n            const matches = field_expr.match(/_0[a-z]*/g);\n            if (matches === null)\n                throw `Field expression not found`;\n\n            matches.forEach(m => field_expr = field_expr.replace(m, `${m}${chars[idx]}`));\n            expression = expression.replace(`{${idx}}`, field_expr);\n        });\n\n        return `(${expression})`;\n    }\n\n    /** @internal */\n    public getThinnedField(thin_fac: number, map_max_zoom: number) {\n        return new ComputedScalarField(this.raw_fields.map(f => f.getThinnedField(thin_fac, map_max_zoom)), this.expression, this.cpu_func) as this;\n    }\n\n    /**\n     * Sample this field at a given latitude and longitude.\n     * @param lon - Longitude of the sample in degrees east\n     * @param lat - Latitude of the sample in degrees north\n     * @returns The value of the nearest grid point along with the grid point latitude and longitude, or NaNs if the point is outside the grid.\n     */\n    public sampleFieldWithCoord(lon: number, lat: number) {\n        const field_samples = this.raw_fields.map(f => f.sampleFieldWithCoord(lon, lat));\n        return {sample: this.cpu_func(...field_samples.map(s => s.sample)), sample_lon: field_samples[0].sample_lon, sample_lat: field_samples[0].sample_lat};\n    }\n\n    /**\n     * Sample this field at a given latitude and longitude.\n     * @param lon - Longitude of the sample in degrees east\n     * @param lat - Latitude of the sample in degrees north\n     * @returns The value of the nearest grid point, or NaN if the point is outside the grid.\n     */\n    public sampleField(lon: number, lat: number) {\n        return this.sampleFieldWithCoord(lon, lat).sample;\n    }\n\n    /**\n     * Run computations on a scalar field on the CPU. The function blocks the main thread, so avoid calling it if possible.\n     * @returns The computed grid in a `RawScalarField`\n     */\n    public renderCPU(): RawScalarField<ArrayType, GridType> {\n        const ary = new this.aryConstructor([...this.iterateCPU()]);\n        return new RawScalarField<ArrayType, GridType>(this.grid, ary);\n    }\n\n    /** @internal */\n    public *iterateCPU(): Generator<number, void, unknown> {\n        function* mapGenerator<T extends any[], U>(gen: Generator<T>, func: (...arg: T) => U) {\n            for (const elem of gen) {\n                yield func(...elem);\n            }\n        }\n\n        const zipped_args = zip(...this.raw_fields.map(a => a.iterateCPU()));\n\n        for (const elem of mapGenerator(zipped_args, this.cpu_func)) {\n            yield elem;\n        }\n    }\n}\n\n/** The basis vectors for vector fields (i.e, whether vectors a relative to Earth or the grid) */\ntype VectorRelativeTo = 'earth' | 'grid';\n\n/** Options for {@link RawVectorField}s */\ninterface RawVectorFieldOptions {\n    /**\n     * Whether the vectors are relative to the grid ('grid') or Earth ('earth')\n     * @default 'grid'\n     */\n    relative_to?: VectorRelativeTo;\n}\n\nfunction scalarIdToVectorComponentId(id: string, component: 'u' | 'v') {\n    return `_${component}${id.slice(1)}`;\n}\n\nfunction vectorComponentIdToScalarId(id: string) {\n    return `_${id.slice(2)}`;\n}\n\nabstract class ExpressionVectorField<ArrayType extends TypedArray, GridType extends AutoZoomGrid> {\n    protected readonly u: ExpressionScalarField<ArrayType, GridType>;\n    protected readonly v: ExpressionScalarField<ArrayType, GridType>;\n    public readonly relative_to: VectorRelativeTo;\n\n    constructor(u: ExpressionScalarField<ArrayType, GridType>, v: ExpressionScalarField<ArrayType, GridType>, opts?: RawVectorFieldOptions) {\n        this.u = u;\n        this.v = v;\n\n        opts = opts === undefined ? {}: opts;\n        this.relative_to = opts.relative_to === undefined ? 'grid' : opts.relative_to;\n    }\n\n    private operandScalar(other: ExpressionScalarField<ArrayType, GridType> | number, operand: '*' | '/'): ComputedVectorField<ArrayType, GridType> {\n        const FUNCS = {\n            '*': (a: number, b: number) => a * b,\n            '/': (a: number, b: number) => a / b,\n        };\n\n        if (typeof other === 'number') {\n            const u = new ComputedScalarField([this.u], `{0} ${operand} ${other.toFixed(100)}`, v => FUNCS[operand](v, other));\n            const v = new ComputedScalarField([this.v], `{0} ${operand} ${other.toFixed(100)}`, v => FUNCS[operand](v, other));\n            return new ComputedVectorField(u, v, {relative_to: this.relative_to});\n        }\n\n        const u = new ComputedScalarField([this.u, other], `{0} ${operand} {1}`, FUNCS[operand]);\n        const v = new ComputedScalarField([this.v, other], `{0} ${operand} {1}`, FUNCS[operand]);\n        return new ComputedVectorField(u, v, {relative_to: this.relative_to});\n    }\n\n    private operandVector(other: ExpressionVectorField<ArrayType, GridType>, operand: '+' | '-'): ComputedVectorField<ArrayType, GridType> {\n        const FUNCS = {\n            '+': (a: number, b: number) => a + b,\n            '-': (a: number, b: number) => a - b,\n        };\n\n        const u = new ComputedScalarField([this.u, other.u], `{0} ${operand} {1}`, FUNCS[operand]);\n        const v = new ComputedScalarField([this.v, other.v], `{0} ${operand} {1}`, FUNCS[operand]);\n        return new ComputedVectorField(u, v, {relative_to: this.relative_to});\n    }\n\n    /**\n     * Multiply this vector field by a scalar. The multiplication occurs on the GPU if the resulting field is used in a plot component.\n     * @param other - Scalar to multiply by. Can be either a number or a scalar field.\n     * @returns A `ComputedVectorField` representing the multiplied vector field\n     */\n    public multiply(other: ExpressionScalarField<ArrayType, GridType> | number): ComputedVectorField<ArrayType, GridType> {\n        return this.operandScalar(other, '*');\n    }\n\n    /**\n     * Divide this vector field by a scalar. The division occurs on the GPU if the resulting field is used in a plot component.\n     * @param other - Scalar to divide by. Can be either a number or a scalar field.\n     * @returns A `ComputedVectorField` representing the divided vector field\n     */\n    public divide(other: ExpressionScalarField<ArrayType, GridType> | number): ComputedVectorField<ArrayType, GridType> {\n        return this.operandScalar(other, '/');\n    }\n\n    /**\n     * Add this vector field to another vector field. The addition occurs on the GPU if the resulting field is used in a plot component.\n     * @param other Vector field to add.\n     * @returns A `ComputedVectorField` representing the added vector field\n     */\n    public add(other: ExpressionVectorField<ArrayType, GridType>): ComputedVectorField<ArrayType, GridType> {\n        return this.operandVector(other, '+');\n    }\n\n    /**\n     * Subtract another vector field from this vector field. The subtraction occurs on the GPU if the resulting field is used in a plot component.\n     * @param other Vector field to subtract.\n     * @returns A `ComputedVectorField` representing the subtracted vector field\n     */\n    public subtract(other: ExpressionVectorField<ArrayType, GridType>): ComputedVectorField<ArrayType, GridType> {\n        return this.operandVector(other, '-');\n    }\n\n    /** @internal */\n    public updateTexImageData(gl: WebGLAnyRenderingContext, image_mag_filter: number, fill_textures: {u: Map<string, WGLTexture>, v: Map<string, WGLTexture>} | null) {\n        const translateKeys = <V>(map: Map<string, V>, component: 'u' | 'v', reverse: boolean) => {\n            const map_trans = new Map<string, V>();\n\n            const translator = reverse ? vectorComponentIdToScalarId : scalarIdToVectorComponentId;\n\n            map.forEach((value, key) => {\n                map_trans.set(translator(key, component), value);\n            })\n\n            return map_trans;\n        }\n\n        const tex_u = this.u.updateTexImageData(gl, image_mag_filter, fill_textures === null ? null : translateKeys(fill_textures.u, 'u', true));\n        const tex_v = this.v.updateTexImageData(gl, image_mag_filter, fill_textures === null ? null : translateKeys(fill_textures.v, 'v', true));\n\n        return {u: translateKeys(tex_u, 'u', false), v: translateKeys(tex_v, 'v', false)};\n    }\n\n    /**\n     * Get the magnitude of the vector field as a scalar field. The magnitude calculation occurs on the GPU if this field is used in a plot component.\n     * @returns A `ComputedScalarField` representing the subtracted vector field\n     */\n    public magnitude() {\n        return new ComputedScalarField([this.u, this.v], 'length(vec2({0}, {1}))', Math.hypot);\n    }\n\n    /** @internal */\n    public getThinnedField(thin_fac: number, map_max_zoom: number) {\n        const thin_u = this.u.getThinnedField(thin_fac, map_max_zoom);\n        const thin_v = this.v.getThinnedField(thin_fac, map_max_zoom);\n\n        return new ComputedVectorField(thin_u, thin_v, {relative_to: this.relative_to});\n    }\n\n    /** @internal */\n    public get grid() {\n        return this.u.grid\n    }\n\n    /**\n     * Sample this field at a given latitude and longitude.\n     * @param lon - Longitude of the sample in degrees east\n     * @param lat - Latitude of the sample in degrees north\n     * @returns A tuple containing the [`bearing`, `magnitude`] of the vector field at the nearest grid point. The bearing is given as degrees from north, increasing clockwise. \n     *  If the point is outside the grid, it returns [NaN, NaN] instead.\n     */\n    public sampleField(lon: number, lat: number) : [number, number] {\n        const u_sample = this.u.sampleFieldWithCoord(lon, lat);\n        const v_sample = this.v.sampleFieldWithCoord(lon, lat);\n\n        const rot = this.relative_to == 'earth' ? 0 : this.grid.getVectorRotationAtPoint(u_sample.sample_lon, u_sample.sample_lat);\n        const mag = Math.hypot(u_sample.sample, v_sample.sample);\n        let brg = (Math.PI / 2 - Math.atan2(-v_sample.sample, -u_sample.sample) + rot) * 180 / Math.PI;\n\n        if (brg > 360) brg -= 360;\n        if (brg < 0) brg += 360;\n\n        return [brg, mag];\n    }\n\n    /** @internal */\n    public getSamplerIds() : {u: string[], v: string[]} {\n        return {\n            u: this.u.getSamplerIds().map(id => scalarIdToVectorComponentId(id, 'u')), \n            v: this.v.getSamplerIds().map(id => scalarIdToVectorComponentId(id, 'v')),\n        };\n    }\n\n    /** @internal */\n    public getExpressions() : {u: string, v: string} {\n        const translateVariables = (expr: string, component: 'u' | 'v') => {\n            const matches = expr.match(/_0[a-z]*/g);\n            if (matches === null)\n                throw `Field expression not found`;\n\n            matches.forEach(m => expr = expr.replace(m, scalarIdToVectorComponentId(m, component)));\n            return expr;\n        }\n\n        return {\n            u: translateVariables(this.u.getExpression(), 'u'), \n            v: translateVariables(this.v.getExpression(), 'v'),\n        };\n    }\n}\n\n/** A class representing a 2D gridded field of vectors */\nclass RawVectorField<ArrayType extends TypedArray, GridType extends AutoZoomGrid> extends ExpressionVectorField<ArrayType, GridType> {\n    private readonly u_ary: ArrayType;\n    private readonly v_ary: ArrayType;\n\n    /**\n     * Create a vector field.\n     * @param grid - The grid on which the vector components are defined\n     * @param u_ary - The u (east/west) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid\n     * @param v_ary - The v (north/south) component of the vectors, which should be given as a 1D array in row-major order, with the first element being at the lower-left corner of the grid\n     * @param opts - Options for creating the vector field.\n     */\n    constructor(grid: GridType, u_ary: ArrayType, v_ary: ArrayType, opts?: RawVectorFieldOptions) {\n        const u = new RawScalarField(grid, u_ary);\n        const v = new RawScalarField(grid, v_ary);\n        super(u, v, opts);\n\n        this.u_ary = u_ary;\n        this.v_ary = v_ary;\n    }\n\n    /** @internal */\n    public getSamplerIds() : {u: string[], v: string[]} {\n        return {u: ['_u0'], v: ['_v0']};\n    }\n\n    /** @internal */\n    public getExpressions() : {u: string, v: string} {\n        return {u: '_u0', v: '_v0'};\n    }\n}\n\nclass ComputedVectorField<ArrayType extends TypedArray, GridType extends AutoZoomGrid> extends ExpressionVectorField<ArrayType, GridType> {}\n\n/** A class grid of wind profiles */\nclass RawProfileField<GridType extends AutoZoomGrid> {\n    public readonly profiles: WindProfile[];\n    public readonly grid: GridType;\n\n    /**\n     * Create a grid of wind profiles\n     * @param grid     - The grid on which the profiles are defined\n     * @param profiles - The wind profiles themselves, which should be given as a 1D array in row-major order, with the first profile being at the lower-left corner of the grid\n     */\n    constructor(grid: GridType, profiles: WindProfile[]) {\n        this.profiles = profiles;\n        this.grid = grid;\n    }\n\n    /** \n     * @internal\n     * Get the gridded storm motion vector field\n     */\n    public getStormMotionGrid() {\n        const profiles = this.profiles\n        const u = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));\n        const v = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));\n\n        profiles.forEach(prof => {\n            const idx = prof.ilon + this.grid.ni * prof.jlat;\n            if (isStormRelativeWindProfile(prof)) {\n                u[idx] = prof.smu;\n                v[idx] = prof.smv;\n            }\n            else {\n                u[idx] = 0;\n                v[idx] = 0;\n            }\n        });\n\n        return new RawVectorField(this.grid, u, v, {relative_to: 'grid'});\n    }\n\n    /** @internal */\n    public getProfileCoords() {\n        const {lats, lons} = this.grid.getEarthCoords();\n        const prof_lats = new Float32Array(this.profiles.length);\n        const prof_lons = new Float32Array(this.profiles.length);\n\n        this.profiles.forEach((prof, iprof) => {\n            const idx = prof.ilon + prof.jlat * this.grid.ni;\n            prof_lats[iprof] = lats[idx];\n            prof_lons[iprof] = lons[idx];\n        });\n\n        return {lats: prof_lats, lons: prof_lons};\n    }\n}\n\n/** \n * Type for an observation data point\n * @example\n * const obs : ObsRawData<'t' | 'td'> = {'t': 71, 'td': 66};\n */\ntype ObsRawData<ObsFieldName extends string> = Record<ObsFieldName, string | number | [number, number] | null>;\n\n/** Raw observation data, given as a list of objects */\nclass RawObsField<GridType extends AutoZoomGrid, ObsFieldName extends string> {\n    public readonly grid: GridType;\n    public readonly data: ObsRawData<ObsFieldName>[];\n\n    /**\n     * Create a field of observations\n     * @param grid - The grid on which the obs are defined (can be either a structured or unstructured grid)\n     * @param data - The observation data. Conceptually, obs are given as a list of individual observations.\n     */\n    constructor(grid: GridType, data: ObsRawData<ObsFieldName>[]) {\n        this.grid = grid;\n        this.data = data;\n    }\n\n    /** \n     * @internal\n     * Get observation element as a list of scalar numbers \n     */\n    getScalar(key: ObsFieldName) {\n        const field_data = this.data.map(d => d[key]);\n        if (!field_data.map(d => typeof d == 'number' || d === null).reduce((a, b) => a && b, true))\n            throw `It doesn't look like ${key} contains scalar numerical data`;\n\n        return field_data as (number | null)[];\n    }\n\n    /** \n     * @internal\n     * Get observed element as a list of strings (internal method)\n     */\n    getStrings(key: ObsFieldName) {\n        const field_data = this.data.map(d => d[key]);\n        if (!field_data.map(d => typeof d == 'string' || d === null).reduce((a, b) => a && b, true))\n            throw `It doesn't look like ${key} contains string data`;\n\n        return field_data as (string | null)[];\n    }\n\n    /** \n     * @internal\n     * Get observed element as a list of vectors (internal method) \n     */\n    getVector(key: ObsFieldName) {\n        const field_data = this.data.map(d => d[key]);\n        if (!field_data.map(d => Array.isArray(d)).reduce((a, b) => a && b, true))\n            throw `It doesn't look like ${key} contains vector data`;\n\n        const vector_field_data = field_data as [number | null, number | null][];\n\n        const vec2comp = (wspd: number, wdir: number) => {\n            const u = -wspd * Math.sin(wdir * Math.PI / 180);\n            const v = -wspd * Math.cos(wdir * Math.PI / 180);\n            return [u, v];\n        }\n\n        const u_data = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));\n        const v_data = new Float16Array(this.grid.ni * this.grid.nj).fill(parseFloat('nan'));\n\n        vector_field_data.forEach(([wspd, wdir], idat) => {\n            if (wspd === null || wdir === null) {\n                return;\n            }\n\n            const [u, v] = vec2comp(wspd, wdir);\n            u_data[idat] = u;\n            v_data[idat] = v;\n        });\n\n        return new RawVectorField(this.grid, u_data, v_data, {relative_to: 'earth'});\n    }\n}\n\nexport {RawScalarField, ComputedScalarField, RawVectorField, ComputedVectorField, RawProfileField, RawObsField};\nexport type {ExpressionScalarField, RawVectorFieldOptions, ExpressionVectorField, VectorRelativeTo, TextureDataType, ObsRawData};","import { WGLBuffer } from \"autumn-wgl\";\nimport { TypedArray, WebGLAnyRenderingContext } from \"../AutumnTypes\";\nimport { argMin, getArrayConstructor, getMinZoom } from \"../utils\";\nimport { EarthCoords, Grid, GridType } from \"./Grid\";\nimport { layer_worker } from \"../PlotComponent\";\nimport { domainBufferMixin } from \"./DomainBuffer\";\nimport { GridElement } from \"./GridCoordinates\";\n\nasync function makeCartesianDomainBuffers(gl: WebGLAnyRenderingContext, grid: StructuredGrid, simplify_ni: number, simplify_nj: number, opts?: {margin_r?: boolean, margin_s?: boolean}) {\n    opts = opts === undefined ? {} : opts;\n    const use_margin_r = opts.margin_r === undefined ? true : opts.margin_r;\n    const use_margin_s = opts.margin_s === undefined ? true : opts.margin_s;\n\n    const texcoord_margin_r = use_margin_r ? 1 / (2 * grid.ni) : 0;\n    const texcoord_margin_s = use_margin_s ? 1 / (2 * grid.nj) : 0;\n\n    const grid_element_i = use_margin_r ? 'center' : 'edge';\n    const grid_element_j = use_margin_s ? 'center' : 'edge';\n\n    const domain_ni = use_margin_r ? simplify_ni : simplify_ni + 1;\n    const domain_nj = use_margin_s ? simplify_nj : simplify_nj + 1;\n\n    const {lats: field_lats, lons: field_lons} = grid.getEarthCoords(simplify_ni, simplify_nj, grid_element_i, grid_element_j);\n    const domain_coords = await layer_worker.makeDomainVerticesAndTexCoords(field_lats, field_lons, domain_ni, domain_nj, texcoord_margin_r, texcoord_margin_s);\n\n    const vertices = new WGLBuffer(gl, domain_coords['vertices'], 2, gl.TRIANGLE_STRIP);\n    const texcoords = new WGLBuffer(gl, domain_coords['tex_coords'], 2, gl.TRIANGLE_STRIP);\n\n    return {'vertices': vertices, 'texcoords': texcoords};\n}\n\n/** A structured grid (in this case meaning a cartesian grid with i and j coordinates) */\nabstract class StructuredGrid extends domainBufferMixin(Grid) {\n    protected readonly thin_x: number;\n    protected readonly thin_y: number;\n\n    constructor(type: GridType, is_conformal: boolean, ni: number, nj: number, thin_x?: number, thin_y?: number) {\n        super(type, is_conformal, ni, nj);\n\n        this.thin_x = thin_x === undefined ? 1 : thin_x;\n        this.thin_y = thin_y === undefined ? 1 : thin_y;\n    }\n\n    public abstract getEarthCoords(ni?: number, nj?: number, which_i?: GridElement, which_j?: GridElement): EarthCoords;\n\n    /** @internal */\n    protected xyThinFromMaxZoom(thin_fac: number, map_max_zoom: number) {\n        const n_density_tiers = Math.log2(thin_fac);\n        const n_inaccessible_tiers = Math.max(n_density_tiers + 1 - map_max_zoom, 0);\n        const xy_thin = Math.pow(2, n_inaccessible_tiers);\n\n        return [xy_thin, xy_thin] as [number, number];\n    }\n\n    protected thinnedGridParameters(thin_fac: number, map_max_zoom: number, ll_x: number, ll_y: number, ur_x: number, ur_y: number) {\n        const [thin_x, thin_y] = this.xyThinFromMaxZoom(thin_fac, map_max_zoom);\n\n        const dx = (ur_x - ll_x) / this.ni;\n        const dy = (ur_y - ll_y) / this.nj;\n\n        const ni = Math.ceil(this.ni / thin_x);\n        const nj = Math.ceil(this.nj / thin_y);\n        const ni_remove = (this.ni - 1) % thin_x;\n        const nj_remove = (this.nj - 1) % thin_y;\n        const new_ll_x = ll_x;\n        const new_ll_y = ll_y;\n        const new_ur_x = ur_x - ni_remove * dx;\n        const new_ur_y = ur_y - nj_remove * dy;\n        return {ni, nj, thin_x, thin_y, ll_x: new_ll_x, ll_y: new_ll_y, ur_x: new_ur_x, ur_y: new_ur_y};\n    }\n\n    /** @internal */\n    public getMinVisibleZoom(thin_fac: number) {\n        const min_zoom = new Uint8Array(this.ni * this.nj);\n        const zoom_thin_fac = thin_fac / Math.max(this.thin_x, this.thin_y);\n        for (let ilat = 0; ilat < this.nj * this.thin_y; ilat++) {\n            for (let ilon = 0; ilon < this.ni * this.thin_x; ilon++) {\n                const idx = ilat * this.ni + ilon;\n                min_zoom[idx] = getMinZoom(ilat, ilon, zoom_thin_fac);\n            }\n        }\n\n        return min_zoom;\n    }\n\n    /** @internal */\n    public thinDataArray<ArrayType extends TypedArray>(original_grid: StructuredGrid, ary: ArrayType) {\n        const arrayType = getArrayConstructor(ary);\n        const new_data = new arrayType(this.ni * this.nj);\n\n        for (let i = 0; i < this.ni; i++) {\n            for (let j = 0 ; j < this.nj; j++) {\n                const idx_old = i * this.thin_x + original_grid.ni * j * this.thin_y;\n                const idx = i + this.ni * j;\n\n                new_data[idx] = ary[idx_old];\n            }\n        }\n\n        return new_data;\n    }\n\n    public abstract copy(opts?: {ni?: number, nj?: number}): Grid;\n\n    protected async makeDomainBuffers(gl: WebGLAnyRenderingContext) {\n        const simplify_ni = Math.max(Math.floor(this.ni / 20), 20);\n        const simplify_nj = Math.max(Math.floor(this.nj / 20), 20);\n        return makeCartesianDomainBuffers(gl, this, simplify_ni, simplify_nj);\n    }\n\n    public sampleNearestGridPoint(lon: number, lat: number, ary: TypedArray): {sample: number, sample_lon: number, sample_lat: number} {\n        const [x, y] = this.transform(lon, lat);\n        const {x: xs, y: ys} = this.getGridCoords();\n\n        let ll_x = xs[0];\n        let ur_x = xs[xs.length - 1];\n        const dx = xs[1] - xs[0];\n        let ll_y = ys[0];\n        let ur_y = ys[ys.length - 1];\n        const dy = ys[1] - ys[0];\n\n        if (dx < 0) [ll_x, ur_x] = [ur_x, ll_x];\n        if (dy < 0) [ll_y, ur_y] = [ur_y, ll_y];\n\n        if (x < ll_x - 0.5 * dx || x > ur_x + 0.5 * dx || y < ll_y - 0.5 * dy || y > ur_y + 0.5 * dy) {\n            return {sample: NaN, sample_lon: NaN, sample_lat: NaN};\n        }\n\n        const i_min = argMin(xs.map(xv => Math.abs(xv - x)));\n        const j_min = argMin(ys.map(yv => Math.abs(yv - y)));\n        const idx = i_min + j_min * this.ni;\n\n        const [lon_min, lat_min] = this.transform(xs[i_min], ys[j_min], {inverse: true});\n\n        return {sample: ary[idx], sample_lon: lon_min, sample_lat: lat_min};\n    }\n}\n\nexport {StructuredGrid, makeCartesianDomainBuffers};","import { WGLBuffer } from \"autumn-wgl\";\nimport { WebGLAnyRenderingContext } from \"../AutumnTypes\";\nimport { Cache } from \"../utils\";\nimport { AbstractConstructor, Grid } from \"./Grid\";\n\ntype DomainBuffers = {vertices: WGLBuffer, texcoords: WGLBuffer};\n\ninterface DomainBufferIntf {\n    getDomainBuffers(gl: WebGLAnyRenderingContext) : Promise<DomainBuffers>;\n}\n\nfunction domainBufferMixin<G extends AbstractConstructor<Grid>>(base: G) : AbstractConstructor<DomainBufferIntf> & G {\n    abstract class DomainBufferMixin extends base {\n        private readonly buffer_cache: Cache<[WebGLAnyRenderingContext], Promise<DomainBuffers>>;\n\n        constructor(...args: any[]) {\n            super(...args);\n\n            this.buffer_cache = new Cache((gl: WebGLAnyRenderingContext) => {\n                return this.makeDomainBuffers(gl);\n            });\n        }\n\n        protected abstract makeDomainBuffers(gl: WebGLAnyRenderingContext) : Promise<DomainBuffers>;\n\n        public async getDomainBuffers(gl: WebGLAnyRenderingContext) {\n            return await this.buffer_cache.getValue(gl);\n        }\n    }\n\n    return DomainBufferMixin;\n}\n\ntype DomainBufferGrid<T extends Grid = Grid> = InstanceType<ReturnType<typeof domainBufferMixin<AbstractConstructor<T>>>>;\n\nexport {domainBufferMixin};\nexport type {DomainBuffers, DomainBufferGrid, DomainBufferIntf};","import { Cache } from \"../utils\";\nimport { AbstractConstructor, EarthCoords, Grid, GridCoords } from \"./Grid\";\n\ntype GridElement = 'center' | 'edge';\n\ninterface GridCoordinateIntf {\n    setupCoordinateCaches(start_i: number, end_i: number, start_j: number, end_j: number): void;\n    getEarthCoords(ni?: number, nj?: number, which_i?: GridElement, which_j?: GridElement): EarthCoords;\n    getGridCoords(): GridCoords;\n}\n\nfunction gridCoordinateMixin<G extends AbstractConstructor<Grid>>(base: G) : AbstractConstructor<GridCoordinateIntf> & G {\n    abstract class GridCoordinates extends base {\n        private ll_cache: Cache<[number, number, GridElement, GridElement], EarthCoords> | null = null;\n        private gc_cache: Cache<[], GridCoords> | null = null;\n\n        public setupCoordinateCaches(start_i: number, end_i: number, start_j: number, end_j: number) {\n            const di = (end_i - start_i) / (this.ni - 1);\n            const dj = (end_j - start_j) / (this.nj - 1);\n\n            this.ll_cache = new Cache((ni: number, nj: number, which_i: GridElement, which_j: GridElement) => {\n                const ni_grid = which_i == 'center' ? ni : ni + 1;\n                const nj_grid = which_j == 'center' ? nj : nj + 1;\n                const ni_grid_full = which_i == 'center' ? this.ni : this.ni + 1;\n                const nj_grid_full = which_j == 'center' ? this.nj : this.nj + 1;\n                const ni_offset = which_i == 'center' ? 0 : -di / 2;\n                const nj_offset = which_j == 'center' ? 0 : -dj / 2;\n\n                const lons = new Float32Array(ni_grid * nj_grid);\n                const lats = new Float32Array(ni_grid * nj_grid);\n\n                const di_req = (ni_grid_full - 1) / (ni_grid - 1) * di;\n                const dj_req = (nj_grid_full - 1) / (nj_grid - 1) * dj;\n\n                for (let i = 0; i < ni_grid; i++) {\n                    const x = start_i + i * di_req + ni_offset;\n                    for (let j = 0; j < nj_grid; j++) {\n                        const y = start_j + j * dj_req + nj_offset;\n\n                        const [lon, lat] = this.transform(x, y, {inverse: true});\n                        const idx = i + j * ni_grid;\n                        lons[idx] = lon;\n                        lats[idx] = lat;\n                    }\n                }\n\n                return {lons: lons, lats: lats};\n            });\n\n            this.gc_cache = new Cache(() => {\n                const x = new Float32Array(this.ni);\n                const y = new Float32Array(this.nj);\n\n                for (let i = 0; i < this.ni; i++) {\n                    x[i] = start_i + i * di;\n                }\n\n                for (let j = 0; j < this.nj; j++) {\n                    y[j] = start_j + j * dj;\n                }\n\n                return {x: x, y: y};\n            });\n        }\n\n        public getEarthCoords(ni?: number, nj?: number, which_i?: GridElement, which_j?: GridElement): EarthCoords {\n            if (this.ll_cache === null) throw \"Need to set up coordinate caches first\";\n            ni = ni === undefined ? this.ni : ni;\n            nj = nj === undefined ? this.nj : nj;\n            which_i = which_i === undefined ? 'center' : which_i;\n            which_j = which_j === undefined ? 'center' : which_j;\n            return this.ll_cache.getValue(ni, nj, which_i, which_j);\n        }\n\n        public getGridCoords(): GridCoords {\n            if (this.gc_cache === null) throw \"Need to set up coordinate caches first\";\n            return this.gc_cache.getValue();\n        }\n    }\n\n    return GridCoordinates;\n}\n\nexport {gridCoordinateMixin};\nexport type {GridElement, GridCoordinateIntf};","import { autoZoomGridMixin } from \"./AutoZoom\";\nimport { gridCoordinateMixin } from \"./GridCoordinates\";\nimport { StructuredGrid } from \"./StructuredGrid\";\n\n/** \n * A plate carree (a.k.a. lat/lon) grid with uniform grid spacing \n *\n * ## Plot Component Compatibility\n * - :white_check_mark: `Fill`\n * - :white_check_mark: `Raster`\n * - :white_check_mark: `Contour`\n * - :white_check_mark: `Paintball`\n * - :white_check_mark: `Barbs`\n * - :white_check_mark: `Hodographs`\n * - :white_check_mark: `StationPlot`\n */\nclass PlateCarreeGrid extends autoZoomGridMixin(gridCoordinateMixin(StructuredGrid)) {\n    public readonly ll_lon: number;\n    public readonly ll_lat: number;\n    public readonly ur_lon: number;\n    public readonly ur_lat: number;\n\n    /**\n     * Create a plate carree grid\n     * @param ni     - The number of grid points in the i (longitude) direction\n     * @param nj     - The number of grid points in the j (latitude) direction\n     * @param ll_lon - The longitude of the lower left corner of the grid\n     * @param ll_lat - The latitude of the lower left corner of the grid\n     * @param ur_lon - The longitude of the upper right corner of the grid\n     * @param ur_lat - The latitude of the upper right corner of the grid\n     */\n    constructor(ni: number, nj: number, ll_lon: number, ll_lat: number, ur_lon: number, ur_lat: number, thin_x?: number, thin_y?: number) {\n        super('latlon', true, ni, nj, thin_x, thin_y);\n\n        this.ll_lon = ll_lon;\n        this.ll_lat = ll_lat;\n        this.ur_lon = ur_lon;\n        this.ur_lat = ur_lat;\n\n        this.setupCoordinateCaches(ll_lon, ur_lon, ll_lat, ur_lat);\n    }\n\n    /** @internal */\n    public copy(opts?: {ni?: number, nj?: number, ll_lon?: number, ll_lat?: number, ur_lon?: number, ur_lat?: number}) {\n        opts = opts !== undefined ? opts : {};\n        const ni = opts.ni !== undefined ? opts.ni : this.ni;\n        const nj = opts.nj !== undefined ? opts.nj : this.nj;\n        const ll_lon = opts.ll_lon !== undefined ? opts.ll_lon : this.ll_lon;\n        const ll_lat = opts.ll_lat !== undefined ? opts.ll_lat : this.ll_lat;\n        const ur_lon = opts.ur_lon !== undefined ? opts.ur_lon : this.ur_lon;\n        const ur_lat = opts.ur_lat !== undefined ? opts.ur_lat : this.ur_lat;\n\n        return new PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat);\n    }\n\n    /** @internal */\n    public transform(x: number, y: number, opts?: {inverse?: boolean}) {\n        return [x, y] as [number, number];\n    }\n\n    /** @internal */\n    public getThinnedGrid(thin_fac: number, map_max_zoom: number) {\n        const {ni, nj, thin_x, thin_y, ll_x: ll_lon, ll_y: ll_lat, ur_x: ur_lon, ur_y: ur_lat} = \n            this.thinnedGridParameters(thin_fac, map_max_zoom, this.ll_lon, this.ll_lat, this.ur_lon, this.ur_lat);\n\n        return new PlateCarreeGrid(ni, nj, ll_lon, ll_lat, ur_lon, ur_lat, this.thin_x * thin_x, this.thin_y * thin_y) as this;\n    }\n}\n\nexport {PlateCarreeGrid};","import { rotateSphere } from \"../Map\";\nimport { autoZoomGridMixin } from \"./AutoZoom\";\nimport { gridCoordinateMixin } from \"./GridCoordinates\";\nimport { StructuredGrid } from \"./StructuredGrid\";\n\n/** \n * A rotated lat-lon (plate carree) grid with uniform grid spacing \n *\n * ## Plot Component Compatibility\n * - :white_check_mark: `Fill`\n * - :white_check_mark: `Raster`\n * - :white_check_mark: `Contour`\n * - :white_check_mark: `Paintball`\n * - :white_check_mark: `Barbs`\n * - :white_check_mark: `Hodographs`\n * - :white_check_mark: `StationPlot`\n */\nclass PlateCarreeRotatedGrid extends autoZoomGridMixin(gridCoordinateMixin(StructuredGrid)) {\n    public readonly np_lon: number;\n    public readonly np_lat: number;\n    public readonly lon_shift: number;\n    public readonly ll_lon: number;\n    public readonly ll_lat: number;\n    public readonly ur_lon: number;\n    public readonly ur_lat: number;\n\n    private readonly llrot: (a: number, b: number, opts?: {inverse: boolean}) => [number, number];\n\n    /**\n     * Create a Lambert conformal conic grid\n     * @param ni        - The number of grid points in the i (longitude) direction\n     * @param nj        - The number of grid points in the j (latitude) direction\n     * @param np_lon    - The longitude of the north pole for the rotated grid\n     * @param np_lat    - The latitude of the north pole for the rotated grid\n     * @param lon_shift - The angle around the rotated north pole to shift the central meridian\n     * @param ll_lon    - The longitude of the lower left corner of the grid (on the rotated earth)\n     * @param ll_lat    - The latitude of the lower left corner of the grid (on the rotated earth)\n     * @param ur_lon    - The longitude of the upper right corner of the grid (on the rotated earth)\n     * @param ur_lat    - The latitude of the upper right corner of the grid (on the rotated earth)\n     */\n    constructor(ni: number, nj: number, np_lon: number, np_lat: number, lon_shift: number, ll_lon: number, ll_lat: number, ur_lon: number, ur_lat: number, thin_x?: number, thin_y?: number) {\n        super('latlonrot', true, ni, nj, thin_x, thin_y);\n\n        this.np_lon = np_lon;\n        this.np_lat = np_lat;\n        this.lon_shift = lon_shift;\n        this.ll_lon = ll_lon;\n        this.ll_lat = ll_lat;\n        this.ur_lon = ur_lon;\n        this.ur_lat = ur_lat;\n        this.llrot = rotateSphere({np_lon: np_lon, np_lat: np_lat, lon_shift: lon_shift});\n\n        this.setupCoordinateCaches(ll_lon, ur_lon, ll_lat, ur_lat);\n    }\n\n    /** @internal */\n    public copy(opts?: {ni?: number, nj?: number, ll_lon?: number, ll_lat?: number, ur_lon?: number, ur_lat?: number}) {\n        opts = opts !== undefined ? opts : {};\n        const ni = opts.ni !== undefined ? opts.ni : this.ni;\n        const nj = opts.nj !== undefined ? opts.nj : this.nj;\n        const ll_lon = opts.ll_lon !== undefined ? opts.ll_lon : this.ll_lon;\n        const ll_lat = opts.ll_lat !== undefined ? opts.ll_lat : this.ll_lat;\n        const ur_lon = opts.ur_lon !== undefined ? opts.ur_lon : this.ur_lon;\n        const ur_lat = opts.ur_lat !== undefined ? opts.ur_lat : this.ur_lat;\n\n        return new PlateCarreeRotatedGrid(ni, nj, this.np_lon, this.np_lat, this.lon_shift, ll_lon, ll_lat, ur_lon, ur_lat);\n    }\n\n    /** @internal */\n    public transform(x: number, y: number, opts?: {inverse?: boolean}) {\n        opts = opts === undefined ? {}: opts;\n        const inverse = 'inverse' in opts ? opts.inverse : false;\n\n        return this.llrot(x, y, {inverse: !inverse});\n    }\n\n    /** @internal */\n    public getThinnedGrid(thin_fac: number, map_max_zoom: number) {\n        const {ni, nj, thin_x, thin_y, ll_x: ll_lon, ll_y: ll_lat, ur_x: ur_lon, ur_y: ur_lat} = \n            this.thinnedGridParameters(thin_fac, map_max_zoom, this.ll_lon, this.ll_lat, this.ur_lon, this.ur_lat);\n\n        return new PlateCarreeRotatedGrid(ni, nj, this.np_lon, this.np_lat, this.lon_shift, ll_lon, ll_lat, ur_lon, ur_lat, this.thin_x * thin_x, this.thin_y * thin_y) as this;\n    }\n}\n\nexport {PlateCarreeRotatedGrid};","import { lambertConformalConic } from \"../Map\";\nimport { autoZoomGridMixin } from \"./AutoZoom\";\nimport { WGS84_SEMIMAJOR, WGS84_SEMIMINOR } from \"./Grid\";\nimport { gridCoordinateMixin } from \"./GridCoordinates\";\nimport { StructuredGrid } from \"./StructuredGrid\";\n\n/** \n * A Lambert conformal conic grid with uniform grid spacing \n *\n * ## Plot Component Compatibility\n * - :white_check_mark: `Fill`\n * - :white_check_mark: `Raster`\n * - :white_check_mark: `Contour`\n * - :white_check_mark: `Paintball`\n * - :white_check_mark: `Barbs`\n * - :white_check_mark: `Hodographs`\n * - :white_check_mark: `StationPlot`\n */\nclass LambertGrid extends autoZoomGridMixin(gridCoordinateMixin(StructuredGrid)) {\n    public readonly lon_0: number;\n    public readonly lat_0: number;\n    public readonly lat_std: [number, number];\n    public readonly ll_x: number;\n    public readonly ll_y: number;\n    public readonly ur_x: number;\n    public readonly ur_y: number;\n    public readonly a: number;\n    public readonly b: number;\n\n    private readonly lcc: (a: number, b: number, opts?: {inverse: boolean}) => [number, number];\n\n    /**\n     * Create a Lambert conformal conic grid from the lower-left and upper-right corner x/y values.\n     * @param ni      - The number of grid points in the i (longitude) direction\n     * @param nj      - The number of grid points in the j (latitude) direction\n     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection\n     * @param lat_0   - The center latitude for the projection\n     * @param lat_std - The standard latitudes for the projection\n     * @param ll_x    - The x coordinate in projection space of the lower-left corner of the grid\n     * @param ll_y    - The y coordinate in projection space of the lower-left corner of the grid\n     * @param ur_x    - The x coordinate in projection space of the upper-right corner of the grid\n     * @param ur_y    - The y coordinate in projection space of the upper-right corner of the grid\n     * @param a       - The semimajor axis of the assumed shape of Earth in meters\n     * @param b       - The semiminor axis of the assumed shape of Earth in meters\n     */\n    constructor(ni: number, nj: number, lon_0: number, lat_0: number, lat_std: [number, number], \n                ll_x: number, ll_y: number, ur_x: number, ur_y: number, a?: number, b?: number, thin_x?: number, thin_y?: number) {\n        super('lcc', true, ni, nj, thin_x, thin_y);\n\n        this.lon_0 = lon_0;\n        this.lat_0 = lat_0;\n        this.lat_std = lat_std;\n        this.ll_x = ll_x;\n        this.ll_y = ll_y;\n        this.ur_x = ur_x;\n        this.ur_y = ur_y;\n        this.a = a === undefined ? WGS84_SEMIMAJOR : a;\n        this.b = b === undefined ? WGS84_SEMIMINOR : b;\n        this.lcc = lambertConformalConic({lon_0: lon_0, lat_0: lat_0, lat_std: lat_std, a: this.a, b: this.b});\n\n        this.setupCoordinateCaches(ll_x, ur_x, ll_y, ur_y);\n    }\n\n    /**\n     * Create a Lambert conformal conic grid from the lower-left grid point coordinate and a dx and dy.\n     * @param ni      - The number of grid points in the i (longitude) direction\n     * @param nj      - The number of grid points in the j (latitude) direction\n     * @param lon_0   - The standard longitude for the projection; this is also the center longitude for the projection\n     * @param lat_0   - The center latitude for the projection\n     * @param lat_std - The standard latitudes for the projection\n     * @param ll_lon  - The longitude of the lower-left corner of the grid\n     * @param ll_lat  - The latitude of the lower-left corner of the grid\n     * @param dx      - The grid dx in meters\n     * @param dy      - The grid dy in meters\n     * @param a       - The semimajor axis of the assumed shape of Earth in meters\n     * @param b       - The semiminor axis of the assumed shape of Earth in meters\n     * @returns \n     */\n    public static fromLLCornerLonLat(ni: number, nj: number, lon_0: number, lat_0: number, lat_std: [number, number], \n                                     ll_lon: number, ll_lat: number, dx: number, dy: number, a?: number, b?: number) {\n\n        a = a === undefined ? WGS84_SEMIMAJOR : a;\n        b = b === undefined ? WGS84_SEMIMINOR : b;\n\n        const lcc = lambertConformalConic({lon_0: lon_0, lat_0: lat_0, lat_std: lat_std, a: a, b: b});\n        const [ll_x, ll_y] = lcc(ll_lon, ll_lat);\n\n        return new LambertGrid(ni, nj, lon_0, lat_0, lat_std, ll_x, ll_y, ll_x + ni * dx, ll_y + nj * dy, a, b);\n    }\n\n    /** @internal */\n    public copy(opts?: {ni?: number, nj?: number, ll_x?: number, ll_y?: number, ur_x?: number, ur_y?: number}) {\n        opts = opts !== undefined ? opts : {};\n        const ni = opts.ni !== undefined ? opts.ni : this.ni;\n        const nj = opts.nj !== undefined ? opts.nj : this.nj;\n        const ll_x = opts.ll_x !== undefined ? opts.ll_x : this.ll_x;\n        const ll_y = opts.ll_y !== undefined ? opts.ll_y : this.ll_y;\n        const ur_x = opts.ur_x !== undefined ? opts.ur_x : this.ur_x;\n        const ur_y = opts.ur_y !== undefined ? opts.ur_y : this.ur_y;\n\n        return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y, this.a, this.b);\n    }\n\n    /** @internal */\n    public transform(x: number, y: number, opts?: {inverse?: boolean}) {\n        opts = opts === undefined ? {}: opts;\n        const inverse = opts.inverse === undefined ? false : opts.inverse;\n\n        return this.lcc(x, y, {inverse: inverse});\n    }\n\n    /** @internal */\n    public getThinnedGrid(thin_fac: number, map_max_zoom: number) {\n        const {ni, nj, thin_x, thin_y, ll_x, ll_y, ur_x, ur_y} = \n            this.thinnedGridParameters(thin_fac, map_max_zoom, this.ll_x, this.ll_y, this.ur_x, this.ur_y);\n\n        return new LambertGrid(ni, nj, this.lon_0, this.lat_0, this.lat_std, ll_x, ll_y, ur_x, ur_y, this.a, this.b, this.thin_x * thin_x, this.thin_y * thin_y) as this;\n    }\n}\n\nexport {LambertGrid};","import { Geodesic, GeodesicClass } from \"geographiclib-geodesic\";\nimport { gridCoordinateMixin } from \"./GridCoordinates\";\nimport { StructuredGrid, makeCartesianDomainBuffers } from \"./StructuredGrid\";\nimport { WebGLAnyRenderingContext } from \"../AutumnTypes\";\n\n/**\n * A grid for a radar sweep centered at a certain latitude and longitude.\n * \n * ## Plot Component Compatibility\n * - :white_check_mark: `Fill`\n * - :white_check_mark: `Raster`\n * - :white_check_mark: `Contour`\n * - :white_check_mark: `Paintball`\n * - :x:                `Barbs`\n * - :x:                `Hodographs`\n * - :x:                `StationPlot`\n */\nclass RadarSweepGrid extends gridCoordinateMixin(StructuredGrid) {\n    readonly longitude: number;\n    readonly latitude: number;\n    readonly start_rn: number;\n    readonly end_rn: number;\n    readonly start_az: number;\n    readonly end_az: number;\n    readonly geod: GeodesicClass;\n\n    constructor(nr: number, nt: number, start_rn: number, end_rn: number, start_az: number, end_az: number, longitude: number, latitude: number, thin_x?: number, thin_y?: number) {\n        super('radar', true, nr, nt, thin_x, thin_y);\n\n        this.longitude = longitude;\n        this.latitude = latitude;\n        this.start_rn = start_rn;\n        this.end_rn = end_rn;\n        this.start_az = start_az;\n        this.end_az = end_az;\n\n        this.geod = Geodesic.WGS84;\n\n        this.setupCoordinateCaches(start_rn, end_rn, start_az, end_az);\n    }\n\n    public copy(opts?: {ni?: number, nj?: number, start_rn?: number, end_rn?: number, start_az?: number, end_az?: number, longitude?: number, latitude?: number}): RadarSweepGrid {\n        opts = opts === undefined ? {} : opts;\n\n        const nr = opts.ni === undefined ? this.ni : opts.ni;\n        const nt = opts.nj === undefined ? this.nj : opts.nj;\n        const longitude = opts.longitude === undefined ? this.longitude : opts.longitude;\n        const latitude = opts.latitude === undefined ? this.latitude : opts.latitude;\n        const start_rn = opts.start_rn === undefined ? this.start_rn : opts.start_rn;\n        const end_rn = opts.end_rn === undefined ? this.end_rn : opts.end_rn;\n        const start_az = opts.start_az === undefined ? this.start_az : opts.start_az;\n        const end_az = opts.end_az === undefined ? this.end_az : opts.end_az;\n\n        return new RadarSweepGrid(nr, nt, start_rn, end_rn, start_az, end_az, longitude, latitude);\n    }\n\n    protected async makeDomainBuffers(gl: WebGLAnyRenderingContext) {\n        return await makeCartesianDomainBuffers(gl, this as StructuredGrid, 16, this.nj, {margin_r: false, margin_s: false});\n    }\n\n    public transform(a: number, b: number, opts?: { inverse?: boolean | undefined; } | undefined): [number, number] {\n        opts = opts === undefined ? {} : opts;\n        const inverse = opts.inverse === undefined ? false : opts.inverse;\n\n        // geographiclib calls the \"forward\" transformation what the rest of my code calls the \"inverse\" transformation and vice versa\n        if (inverse) {\n            const ret = this.geod.Direct(this.latitude, this.longitude, b, a);\n            if (ret.lon2 === undefined || ret.lat2 === undefined)\n                throw \"Why are lon2 and lat2 not in the return value?\";\n            return [ret.lon2, ret.lat2];\n        }\n        else {\n            const ret = this.geod.Inverse(this.latitude, this.longitude, b, a);\n            if (ret.azi1 === undefined || ret.s12 === undefined)\n                throw \"Why are azi1 and s12 not in the return value?\";\n\n            if (!Number.isFinite(ret.azi1) || !Number.isFinite(ret.s12))\n                return [NaN, NaN];\n\n            const half_dt = 0.5 * (this.end_az - this.start_az) / this.ni;\n\n            let az1 = ret.azi1;\n            while (az1 < this.start_az - half_dt) az1 += 360;\n            while (az1 >= this.end_az + half_dt) az1 -= 360;\n            return [ret.s12, az1];\n        }\n    }\n\n    /** @internal */\n    public getThinnedGrid(thin_fac: number, map_max_zoom: number) {\n        const {ni: nr, nj: nt, thin_x, thin_y, ll_x: start_az, ll_y: start_rn, ur_x: end_az, ur_y: end_rn} = \n            this.thinnedGridParameters(thin_fac, map_max_zoom, this.end_az, this.end_rn, this.start_az, this.start_rn);\n\n        return new RadarSweepGrid(nr, nt, start_rn, end_rn, start_az, end_az, this.longitude, this.latitude, thin_x * this.thin_x, thin_y * this.thin_y) as this;\n    }\n}\n\nexport {RadarSweepGrid};","import { WebGLAnyRenderingContext } from \"../AutumnTypes\";\nimport { geostationaryProjection } from \"../Map\";\nimport { gridCoordinateMixin } from \"./GridCoordinates\";\nimport { StructuredGrid, makeCartesianDomainBuffers } from \"./StructuredGrid\";\n\n/**\n * Grid for geostationary satellite images\n * \n * ## Plot Component Compatibility\n * - :white_check_mark: `Fill`\n * - :white_check_mark: `Raster`\n * - :white_check_mark: `Contour`\n * - :white_check_mark: `Paintball`\n * - :x:                `Barbs`\n * - :x:                `Hodographs`\n * - :x:                `StationPlot`\n */\nclass GeostationaryImage extends gridCoordinateMixin(StructuredGrid) {\n    public readonly satellite_lon: number;\n    public readonly ll_x: number;\n    public readonly ll_y: number;\n    public readonly ur_x: number;\n    public readonly ur_y: number;\n\n    private readonly vpp: (a: number, b: number, opts?: {inverse: boolean}) => [number, number];\n\n    constructor(ni: number, nj: number, ll_x: number, ll_y: number, ur_x: number, ur_y: number, satellite_lon: number, thin_x?: number, thin_y?: number) {\n        super('geostationary', false, ni, nj, thin_x, thin_y);\n\n        this.satellite_lon = satellite_lon;\n        this.ll_x = ll_x;\n        this.ll_y = ll_y;\n        this.ur_x = ur_x;\n        this.ur_y = ur_y;\n\n        //this.vpp = verticalPerspective({lon_0: satellite_lon, lat_0: 0, alt: 35786023.0, a: 6378137.0, b: 6356752.31414});\n        this.vpp = geostationaryProjection({lon_0: satellite_lon, alt: 35786023.0 + 6378137.0, a: 6378137.0, b: 6356752.31414});\n\n        this.setupCoordinateCaches(ll_x, ur_x, ll_y, ur_y);\n    }\n\n    protected async makeDomainBuffers(gl: WebGLAnyRenderingContext) {\n        const simplify_ni = Math.max(Math.floor(this.ni / 20), 20);\n        const simplify_nj = Math.max(Math.floor(this.nj / 20), 20);\n        return await makeCartesianDomainBuffers(gl, this as StructuredGrid, simplify_ni, simplify_nj, {margin_r: false, margin_s: false});\n    }\n\n    public transform(x: number, y: number, opts?: {inverse?: boolean}): [number, number] {\n        opts = opts === undefined ? {}: opts;\n        const inverse = opts.inverse === undefined ? false : opts.inverse;\n\n        return this.vpp(x, y, {inverse: inverse});\n    }\n\n    public copy() {\n        return new GeostationaryImage(this.ni, this.nj, this.ll_x, this.ll_y, this.ur_x, this.ur_y, this.satellite_lon);\n    }\n\n    /** @internal */\n    public getThinnedGrid(thin_fac: number, map_max_zoom: number) {\n        const {ni, nj, thin_x, thin_y, ll_x, ll_y, ur_x, ur_y} = \n            this.thinnedGridParameters(thin_fac, map_max_zoom, this.ll_x, this.ll_y, this.ur_x, this.ur_y);\n\n        return new GeostationaryImage(ni, nj, ll_x, ll_y, ur_x, ur_y, this.satellite_lon, this.thin_x * thin_x, this.thin_y * thin_y) as this;\n    }\n}\n\nexport {GeostationaryImage};","import { PlotComponent, getContourWorkerPool } from \"./PlotComponent\";\nimport Contour, {ContourOptions, ContourLabels, ContourLabelOptions} from \"./Contour\";\nimport {ContourFill, Raster, ContourFillOptions, RasterOptions} from \"./Fill\";\nimport Barbs, {BarbsOptions} from \"./Barbs\";\nimport Paintball, {PaintballOptions} from \"./Paintball\";\nimport Hodographs, {HodographOptions} from './Hodographs';\nimport StationPlot, {StationPlotOptions, SPPosition, SPNumberConfig, SPStringConfig, SPBarbConfig, SPSymbolConfig, SPConfig, SPDataConfig, SPSymbol} from \"./StationPlot\";\n\nimport { PlotLayer, MultiPlotLayer } from './PlotLayer';\nimport { WindProfile, StormRelativeWindProfile, GroundRelativeWindProfile, WebGLAnyRenderingContext, TypedArray, ContourData } from \"./AutumnTypes\";\nimport { MapLikeType } from \"./Map\";\nimport { ColorMap, ColorMapOptions, bluered, redblue, pw_speed500mb, pw_speed850mb, pw_cape, pw_t2m, pw_td2m, nws_storm_clear_refl, wv_cimss } from './Colormap';\nimport { Color } from \"./Color\";\nimport { makeColorBar, makePaintballKey, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions } from \"./ColorBar\";\nimport { LineStyle } from \"./PolylineCollection\";\nimport { RawScalarField, ComputedScalarField, ExpressionScalarField, RawVectorField, ComputedVectorField, ExpressionVectorField, RawProfileField,\n         VectorRelativeTo, RawVectorFieldOptions, RawObsField, ObsRawData} from \"./RawField\";\nimport { Grid, GridType } from \"./grids/Grid\";\nimport { StructuredGrid } from \"./grids/StructuredGrid\";\nimport { PlateCarreeGrid } from \"./grids/PlateCarreeGrid\";\nimport { PlateCarreeRotatedGrid } from \"./grids/PlateCarreeRotatedGrid\";\nimport { LambertGrid } from \"./grids/LambertGrid\";\nimport { RadarSweepGrid } from \"./grids/RadarSweepGrid\";\nimport { GeostationaryImage } from \"./grids/Geostationary\";\nimport { UnstructuredGrid } from \"./grids/UnstructuredGrid\";\nimport { AutoZoomGrid } from \"./grids/AutoZoom\";\nimport { FieldContourOpts } from './ContourCreator.worker';\n\n/** All built-in colormaps */\nconst colormaps = {\n    bluered: bluered,\n    redblue: redblue,\n    pw_speed500mb: pw_speed500mb,\n    pw_speed850mb: pw_speed850mb,\n    pw_cape: pw_cape,\n    pw_t2m: pw_t2m,\n    pw_td2m: pw_td2m,\n    nws_storm_clear_refl: nws_storm_clear_refl,\n    wv_cimss: wv_cimss,\n}\n\n/** Options for initializing the autumnplot-gl library */\ninterface InitAutumnPlotOpts {\n    /** Base URL at which to find the WASM module (change with caution!) */\n    wasm_base_url?: string;\n\n    /** Number of worker threads to use for contouring */\n    contour_workers?: number;\n}\n\n/**\n * Initialize the WebAssembly module in autumnplot-gl. It's not strictly necessary to call it first, but if you call it\n * first, you can prevent races when you contour a bunch of fields at once.\n */\nfunction initAutumnPlot(opts?: InitAutumnPlotOpts) {\n    opts = opts === undefined ? {} : opts;\n    const contour_workers = opts.contour_workers === undefined ? 1 : opts.contour_workers;\n\n    getContourWorkerPool(opts.wasm_base_url, contour_workers);\n}\n\nexport {PlotComponent,\n        Barbs, BarbsOptions,\n        Contour, ContourOptions, ContourLabels, ContourLabelOptions,\n        ContourFill, Raster, ContourFillOptions, RasterOptions,\n        Paintball, PaintballOptions,\n        Hodographs, HodographOptions, WindProfile, StormRelativeWindProfile, GroundRelativeWindProfile,\n        StationPlot, StationPlotOptions, SPPosition, SPNumberConfig, SPStringConfig, SPBarbConfig, SPSymbolConfig, SPConfig, SPDataConfig, SPSymbol,\n        PlotLayer, MultiPlotLayer, \n        MapLikeType, LineStyle,\n        ColorMap, ColorMapOptions, colormaps, makeColorBar, makePaintballKey, Color, ColorbarOrientation, ColorbarTickDirection, ColorBarOptions, PaintballKeyOptions,\n        RawScalarField, ComputedScalarField, ExpressionScalarField, RawVectorField, ComputedVectorField, ExpressionVectorField, RawProfileField, RawObsField, ObsRawData,\n        Grid, GridType, StructuredGrid, VectorRelativeTo, RawVectorFieldOptions, PlateCarreeGrid, PlateCarreeRotatedGrid, LambertGrid, UnstructuredGrid, RadarSweepGrid, GeostationaryImage,\n        AutoZoomGrid,\n        WebGLAnyRenderingContext, TypedArray, ContourData,\n        initAutumnPlot, InitAutumnPlotOpts, FieldContourOpts};\n"],"names":["root","factory","exports","module","define","amd","this","read","buffer","offset","isLE","mLen","nBytes","e","m","eLen","eMax","eBias","nBits","i","d","s","NaN","Infinity","Math","pow","write","value","c","rt","abs","isNaN","floor","log","LN2","t","n","o","obj","left","right","parent","dimension","content","scoreFunction","prototype","push","bubbleUp","length","pop","sinkDown","peek","remove","Error","size","r","l","u","h","kdTree","Array","isArray","sort","slice","toJSON","insert","nearest","f","a","g","p","min","balanceFactor","max","BinaryHeap","Pbf","ieee754","buf","ArrayBuffer","isView","Uint8Array","pos","type","Varint","Fixed64","Bytes","Fixed32","SHIFT_LEFT_32","SHIFT_RIGHT_32","utf8TextDecoder","TextDecoder","readPackedEnd","pbf","readVarint","toNum","low","high","isSigned","makeRoomForExtraLength","startPos","len","extraLen","realloc","writePackedVarint","arr","writeVarint","writePackedSVarint","writeSVarint","writePackedFloat","writeFloat","writePackedDouble","writeDouble","writePackedBoolean","writeBoolean","writePackedFixed32","writeFixed32","writePackedSFixed32","writeSFixed32","writePackedFixed64","writeFixed64","writePackedSFixed64","writeSFixed64","readUInt32","writeInt32","val","readInt32","destroy","readFields","readField","result","end","tag","skip","readMessage","readFixed32","readSFixed32","readFixed64","readSFixed64","readFloat","readDouble","b","readVarintRemainder","readVarint64","readSVarint","num","readBoolean","Boolean","readString","decode","subarray","readUtf8TextDecoder","str","b1","b2","b3","b0","bytesPerSequence","String","fromCharCode","readUtf8","readBytes","readPackedVarint","readPackedSVarint","readPackedBoolean","readPackedFloat","readPackedDouble","readPackedFixed32","readPackedSFixed32","readPackedFixed64","readPackedSFixed64","writeTag","set","finish","writeBigVarintLow","lsb","writeBigVarintHigh","writeBigVarint","writeString","lead","charCodeAt","writeUtf8","writeBytes","writeRawMessage","fn","writeMessage","writeBytesField","writeFixed32Field","writeSFixed32Field","writeFixed64Field","writeSFixed64Field","writeVarintField","writeSVarintField","writeStringField","writeFloatField","writeDoubleField","writeBooleanField","geo","geodesic","Constants","Accumulator","WGS84","version","major","minor","patch","version_string","digits","epsilon","degree","PI","sq","x","hypot","y","sqrt","cbrt","log1p","z","atanh","copysign","sum","v","up","vpp","polyval","N","AngRound","remainder","AngNormalize","LatFix","AngDiff","sincosd","q","sinx","cosx","round","sin","cos","sincosde","atan2d","ang","atan2","Set","constructor","_s","_t","Add","Sum","Negate","Remainder","Geodesic","GeodesicLine","PolygonArea","nC3x_","nC4x_","astroid","A1m1f_coeff","C1f_coeff","C1pf_coeff","A2m1f_coeff","C2f_coeff","A3_coeff","C3_coeff","C4_coeff","maxit2_","tol0_","tol1_","tol2_","tolb_","xthresh_","tiny_","Number","MIN_VALUE","EPSILON","nC1_","nC1p_","nC2_","nC3_","nC4_","CAP_C1","CAP_C1p","CAP_C2","CAP_C3","CAP_C4","NONE","ARC","LATITUDE","LONGITUDE","AZIMUTH","DISTANCE","STANDARD","DISTANCE_IN","REDUCEDLENGTH","GEODESICSCALE","AREA","ALL","OUT_ALL","LONG_UNROLL","OUT_MASK","SinCosSeries","sinp","k","ar","y0","y1","S","r2","r3","disc","T3","T","uv","w","A1m1f","eps","nA1_","C1f","eps2","C1pf","A2m1f","nA2_","C2f","_f1","_e2","_ep2","_n","_b","_c2","atan","_etol2","isFinite","_A3x","_C3x","_C4x","A3coeff","C3coeff","C4coeff","j","nA3_","A3f","nA3x_","C3f","mult","C4f","Lengths","sig12","ssig1","csig1","dn1","ssig2","csig2","dn2","cbet1","cbet2","outmask","C1a","C2a","B1","csig12","vals","m0x","J12","A1","A2","s12b","m0","m12b","M12","M21","InverseStart","sbet1","sbet2","lam12","slam12","clam12","sbet12a","shortline","omg12","sbetm2","somg12","comg12","ssig12","lamscale","k2","cbet12a","bet12a","nvals","omg12a","lam12x","sbet12","cbet12","dnm","salp1","calp1","salp2","calp2","Lambda12","slam120","clam120","diffp","C3a","salp0","calp0","somg1","comg1","somg2","comg2","B312","eta","domg12","dlam12","Inverse","lat1","lon1","lat2","lon2","InverseInt","azi1","azi2","lon12","lon12s","lonsign","swapp","latsign","s12x","m12x","meridian","numit","salp1a","calp1a","salp1b","calp1b","tripn","tripb","dv","dalp1","sdalp1","cdalp1","nsalp1","lengthmask","alp12","A4","C4a","B41","B42","dbet1","dbet2","salp12","calp12","sdomg12","cdomg12","a12","s12","m12","S12","GenDirect","arcmode","s12_a12","GenPosition","Direct","ArcDirect","Line","caps","DirectLine","GenDirectLine","ArcDirectLine","GenSetDistance","InverseLine","SetArc","Polygon","polyline","geod","_dn1","_salp0","_calp0","_ssig1","_somg1","_csig1","_comg1","_k2","_A1m1","_C1a","_B11","_stau1","_ctau1","_C1pa","_A2m1","_C2a","_B21","_C3a","_A3c","_B31","_C4a","_A4","_B41","a13","s13","B12","AB1","tau12","E","B22","AB2","Position","ArcPosition","s13_a13","SetDistance","transit","transitdirect","AreaReduceA","AreaReduceB","area","area0","crossings","reverse","sign","_geod","_area0","_mask","_areasum","_perimetersum","Clear","_crossings","_lat0","_lon0","lat","lon","AddPoint","AddEdge","azi","Compute","tempsum","number","perimeter","TestPoint","TestEdge","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","call","getter","__esModule","definition","key","Object","defineProperty","enumerable","get","chunkId","globalThis","Function","window","prop","hasOwnProperty","Symbol","toStringTag","scriptUrl","importScripts","location","document","currentScript","tagName","toUpperCase","src","scripts","getElementsByTagName","test","replace","baseURI","self","href","proxyMarker","createEndpoint","releaseProxy","throwMarker","isObject","transferHandlers","Map","canHandle","serialize","port1","port2","MessageChannel","expose","deserialize","port","start","wrap","serialized","isError","message","name","stack","assign","ep","addEventListener","callback","ev","data","id","path","argumentList","map","fromWireValue","returnValue","reduce","rawValue","apply","proxy","transfers","transferCache","transfer","Promise","resolve","catch","then","wireValue","transferables","toWireValue","postMessage","removeEventListener","closeEndPoint","endpoint","isMessagePort","close","target","createProxy","throwIfProxyReleased","isReleased","isProxyReleased","Proxy","_target","requestResponseMessage","toString","bind","_thisArg","rawArgumentList","last","processArguments","construct","processed","concat","WeakMap","handler","serializedValue","msg","fill","random","MAX_SAFE_INTEGER","join","getMinZoom","jlat","ilon","thin_fac_base","zoom","thin_fac","Cache","compute_value","make_key","cached_values","args","JSON","stringify","getValue","normalizeOptions","opts","defaults","ret","entries","forEach","getArrayConstructor","ary","mergeShaderCode","snippet","main","ES3_SHADER_MAGIC","startsWith","applySamplerCodeScalar","sampler_names","sampler_expression","dtypes","SAMPLER_DTYPES","SHADER_DTYPES","samplers","sampler_get","replaceAll","argMin","minIndex","isStormRelativeWindProfile","isWebGL2Ctx","gl","getParameter","VERSION","includes","getRendererData","arg","defaultProjectionData","clippingPlane","fallbackMatrix","mainMatrix","projectionTransition","tileMercatorCoords","farZ","fov","modelViewProjectionMatrix","nearZ","projectionMatrix","shaderData","WorkerPool_","workers","init","wkr","worker","is_busy","queue","worker_idx","iw","filter","enqueue","dequeueAndStart","queueSize","queue_data","dequeue","startRun","path_str","new_queue","elem","shift","rem","pool","tgt","this_arg","func_args","reject","createWorkerPool","layer_worker","Worker","URL","c_worker_pool","getContourWorkerPool","wasm_base_url","n_workers","c_workers","PlotComponent","getGLFormatTypeAlignment","array_dtype","format","row_alignment","is_webgl2","ext","getExtension","ext_lin","R16F","HALF_FLOAT","LUMINANCE","HALF_FLOAT_OES","userAgent","navigator","platform","macosPlatforms","os","indexOf","maxTouchPoints","getOS","R32F","FLOAT","R16UI","UNSIGNED_SHORT","R32UI","UNSIGNED_INT","R16I","SHORT","R32I","INT","R8","UNSIGNED_BYTE","lambertConformalConic","params","compute_t","sin_lat","tan","eccen","compute_m","semimajor","semiminor","radians","F","lon_0","lat_0","lat_std","t_0","lat_1","lat_2","t_1","t_2","m_1","m_2","rho_0","eccen2","eccen4","eccen6","eccen8","Ap","Bp","Cp","Dp","inverse","rho","chi","sin_2chi","cos_2chi","compute_lcc_inverse","theta","compute_lcc","mercatorYfromLat","LngLat","lng","toMercatorCoord","fromMercatorCoord","lngFromMercatorX","sinh","latFromMercatorY","WGLBufferBase","verts","n_coords_per_vert","draw_mode","bind_target","usage","dtype","getGLDtype","n_verts","createBuffer","bindBuffer","bufferData","getDataSync","view","Float32Array","ARRAY_BUFFER","getBufferSubData","STATIC_DRAW","super","is_per_instance","per_instance","vadFunc","vertexAttribDivisor","vertexAttribDivisorANGLE","setPerInstance","bindToProgram","prog_attr_location","enableVertexAttribArray","vertexAttribPointer","instance_skip","bindToTransformFeedback","feedback","bindTransformFeedback","TRANSFORM_FEEDBACK","bindBufferBase","TRANSFORM_FEEDBACK_BUFFER","WGLTexture","image","texture","createTexture","tex_num","setImageData","mag_filter","LINEAR","min_filter","texParameteri","TEXTURE_2D","TEXTURE_WRAP_S","CLAMP_TO_EDGE","TEXTURE_WRAP_T","TEXTURE_MIN_FILTER","TEXTURE_MAG_FILTER","spec","bindTexture","internal_format","data_type","RGBA","RGBA_INTEGER","RGB","RGB_INTEGER","RG","RG_INTEGER","RED","RED_INTEGER","LUMINANCE_ALPHA","ALPHA","DEPTH_COMPONENT","DEPTH_STENCIL","getWebGL2Format","pixelStorei","UNPACK_ALIGNMENT","texImage2D","prog_uni_location","gl_tex_num","activate","uniform1i","activeTexture","TEXTURE0","deactivate","deleteTexture","preprocessShader","shader_src","defines","current_defines","define_truth","processed_shader_src","split","line","match_define","match","match_ifdef","match_ifndef","def","vertex_shader_src","fragment_shader_src","tf_varyings","prog","frag_shader_src","vertexShader","createShader","VERTEX_SHADER","shaderSource","compileShader","getShaderParameter","COMPILE_STATUS","compilationLog","getShaderInfoLog","console","fragmentShader","FRAGMENT_SHADER","program","createProgram","attachShader","transformFeedbackVaryings","INTERLEAVED_ATTRIBS","linkProgram","getProgramParameter","LINK_STATUS","linkLog","getProgramInfoLog","compileAndLinkShaders","attributes","uniforms","index_buffer","instance_count","remove_comments","comment_idx","vtx_shader_match","matchAll","full_match","a_name","getAttribLocation","u_name","type_parts","uniform_loc","getUniformLocation","uniform","toLowerCase","endsWith","daiFunc","drawArraysInstanced","deiFunc","drawElementsInstanced","drawArraysInstancedANGLE","drawElementsInstancedANGLE","use","attribute_buffers","uniform_values","textures","useProgram","bindAttributes","setUniforms","bindTextures","warn","uniform1f","uniform1fv","uniform2fv","uniform3fv","uniform4fv","uniformMatrix4fv","sampler_name","draw","drawArrays","drawElements","WGLFramebufferBase","framebuffer","clear","color","clearColor","bindFramebuffer","FRAMEBUFFER","COLOR_BUFFER_BIT","renderTo","width","height","viewport","copyToTexture","copyTexImage2D","SCREEN","registerGLContext","WGLFramebuffer","createFramebuffer","framebufferTexture2D","COLOR_ATTACHMENT0","screen","THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY","THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT","ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER","CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT","CANNOT_MIX_BIGINT_AND_OTHER_TYPES","ITERATOR_PROPERTY_IS_NOT_CALLABLE","REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE","OFFSET_IS_OUT_OF_BOUNDS","uncurryThis","thisArg","ReflectApply","uncurryThisGetter","ReflectGetOwnPropertyDescriptor","ReflectConstruct","ReflectDefineProperty","ReflectGet","getOwnPropertyDescriptor","getPrototypeOf","ReflectGetPrototypeOf","has","ReflectHas","ownKeys","ReflectOwnKeys","ReflectSet","setPrototypeOf","ReflectSetPrototypeOf","Reflect","NativeProxy","NumberIsFinite","NumberIsNaN","iterator","SymbolIterator","species","SymbolSpecies","SymbolToStringTag","for","SymbolFor","NativeObject","create","ObjectCreate","ObjectDefineProperty","freeze","ObjectFreeze","is","ObjectIs","ObjectPrototype","ObjectPrototype__lookupGetter__","__lookupGetter__","object","NativeTypeError","descriptor","ObjectHasOwn","hasOwn","NativeArray","ArrayIsArray","ArrayPrototype","ArrayPrototypeJoin","ArrayPrototypePush","ArrayPrototypeToLocaleString","toLocaleString","NativeArrayPrototypeSymbolIterator","ArrayPrototypeSymbolIterator","MathAbs","trunc","MathTrunc","NativeArrayBuffer","ArrayBufferIsView","ArrayBufferPrototype","ArrayBufferPrototypeSlice","ArrayBufferPrototypeGetByteLength","NativeSharedArrayBuffer","SharedArrayBuffer","SharedArrayBufferPrototypeGetByteLength","TypedArray","TypedArrayFrom","from","TypedArrayPrototype","NativeTypedArrayPrototypeSymbolIterator","TypedArrayPrototypeKeys","keys","TypedArrayPrototypeValues","values","TypedArrayPrototypeEntries","TypedArrayPrototypeSet","TypedArrayPrototypeReverse","TypedArrayPrototypeFill","TypedArrayPrototypeCopyWithin","copyWithin","TypedArrayPrototypeSort","TypedArrayPrototypeSlice","TypedArrayPrototypeSubarray","TypedArrayPrototypeGetBuffer","TypedArrayPrototypeGetByteOffset","TypedArrayPrototypeGetLength","TypedArrayPrototypeGetSymbolToStringTag","NativeUint8Array","NativeUint16Array","Uint16Array","Uint16ArrayFrom","NativeUint32Array","Uint32Array","NativeFloat32Array","ArrayIteratorPrototype","ArrayIteratorPrototypeNext","next","GeneratorPrototypeNext","IteratorPrototype","DataViewPrototype","DataView","getUint16","setUint16","TypeError","NativeRangeError","RangeError","NativeWeakSet","WeakSet","WeakSetPrototype","WeakSetPrototypeAdd","add","WeakSetPrototypeHas","NativeWeakMap","WeakMapPrototype","WeakMapPrototypeGet","WeakMapPrototypeHas","WeakMapPrototypeSet","arrayIterators","SafeIteratorPrototype","arrayIterator","safeIfNeeded","array","safe","generators","DummyArrayIteratorPrototype","generator","writable","configurable","dummy","isObjectLike","isNativeTypedArray","isNativeBigIntTypedArray","typedArrayName","isSharedArrayBuffer","isOrdinaryArray","isCanonicalIntegerIndexString","brand","INVERSE_OF_EPSILON","FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE","FLOAT16_EPSILON","FLOAT16_EPSILON_DEVIDED_BY_EPSILON","floatView","uint32View","baseTable","shiftTable","roundToFloat16Bits","absolute","roundTiesToEven","temp","roundToFloat16","mantissaTable","exponentTable","offsetTable","convertToNumber","float16bits","ToIntegerOrInfinity","ToLength","SpeciesConstructor","defaultConstructor","IsDetachedBuffer","defaultCompare","isXNaN","isYNaN","isXPlusZero","isYPlusZero","float16bitsArrays","isFloat16Array","hasFloat16ArrayBrand","assertFloat16Array","assertSpeciesTypedArray","count","isTargetFloat16Array","isTargetTypedArray","float16bitsArray","getFloat16BitsArray","float16","cloned","Float16Array","byteOffset","copyToArray","TypedArrayPrototypeGetters","receiver","input","_byteOffset","_length","isArrayBuffer","arguments","list","Constructor","uint16","mapFunc","of","items","at","index","relativeIndex","kept","accumulator","reduceRight","find","findIndex","findLast","findLastIndex","every","some","targetOffset","targetLength","srcLength","toReversed","clonedFloat16bitsArray","compareFn","sortCompare","toSorted","relativeStart","relativeEnd","final","begin","uint16Subarray","element","lastIndexOf","separator","Float16ArrayPrototype","Color","rgba","withOpacity","opacity","toRGBHex","toRGBAHex","in_type","rgba_","padStart","rgba2hex","toRGBATuple","toHSVTuple","rgb","Cmax","Delta","H","rgb2hsv","fromHex","hex","hexstr","out_type","parseInt","hex2rgba","fromHSVTuple","hsv","V","C","X","r_prime","g_prime","b_prime","hsv2rgb","normalizeColor","colormap_shader_src","ColorMap","levels","colors","overflow_color","underflow_color","getColors","getOpacities","getColor","ilev","func","new_colors","new_levels","ic","level_lower","level_upper","new_opacity","new_color","underflow_opacity","overflow_opacity","diverging","color1","color2","level_min","level_max","n_colors","stops","level_step","crossover","crossover_hsv","color1_hsv","color2_hsv","istop","level","interp_fac","buildColormap","cm_data","overflow","pw_speed500mb","levl","levu","pw_speed850mb","pw_cape","pw_t2m","pw_td2m","nws_storm_clear_refl","wv_cimss","ColorMapGPUInterface","colormap","gl_elems","applyShader","setupShaderVariables","index_map","map_norm","n_lev","input_norm","lev","cmap_norm","inv_cmap_norm","jlev","alpha","makeIndexMap","cmap_image","createElement","ctx","getContext","stop","fillStyle","fillRect","makeTextureImage","format_nonlin","type_nonlin","row_alignment_nonlin","cmap_image_spec","cmap_texture","cmap_nonlin_image","cmap_nonlin_texture","bindShaderVariables","cmap","ShaderProgramManager","shader_defines","program_map","getShaderProgram","shader_data","shader_key","variantName","cached_program","vertex_src","vertexShaderPrelude","getShaderUniforms","render_data","polyline_vertex_src","polyline_fragment_src","dash_arrays","PolylineCollection","color_hex","line_width","line_style","offset_rotates_with_map","vertices","TRIANGLE_STRIP","extrusion","offsets","scale","offset_scale","min_zoom","fragment_src","line_data","cmap_gpu","NEAREST","n_dash","dash_texture","dash_array","fill_image","makeDashTexture","shader_manager","make","lines","polylines","makePolyLines","render","map_width","map_height","map_zoom","map_bearing","map_pitch","enable","BLEND","blendFuncSeparate","SRC_ALPHA","ONE_MINUS_SRC_ALPHA","ONE","text_vertex_shader_src","text_fragment_shader_src","FONT_ATLAS_CACHE","async","urls","promises","url","resp","fetch","status","blob","data_buffer","arrayBuffer","readGlyph","glyph","top","advance","readFontStack","glyphs","parseFontPBF","pbf_glyphs","pbf_glyphs_filtered","glyph_bins","bins","bin","img_width","img_height","boxes","maxWidth","box","spaces","ceil","space","potpack","atlas_data","max_glyph_height","glyph_bin","atlas_i","atlas_j","glyph_idx","atlas_idx","glyph_M","baseline","atlas","atlas_width","atlas_height","glyph_info","createAtlas","all","flat","text_collection_opt_defaults","horizontal_align","vertical_align","font_size","text_color","halo_color","halo","offset_x","offset_y","TextCollection","text_locs","font_atlas","text_color_hex","empty_atlas","tl","text","anchor_data","offset_data","tc_data","value_data","i_anch","i_off","i_tc","i_dat","has_data","loc","data_value","anchor_x","anchor_y","x_offset","y_offset","init_i_off","glyph_code","anchors","texcoords","fontstack_url_template","FONT_GROUP_SIZE","characters","stack_start","stack_end","char_code_min","char_code_max","fontstack_urls","istack","autoZoomGridMixin","base","billboard_buffer_cache","max_zoom","grid","map_max_zoom","lats","field_lats","lons","field_lons","getEarthCoords","getMinVisibleZoom","bb_elements","makeBBElements","ni","nj","POINTS","makeWGLBillboardBuffers","vector_rotation_cache","data_are_earth_relative","coords","rot_vals","parseFloat","is_conformal","icd","getVectorRotationAtPoint","rot_img","makeVectorRotationTexture","getWGLBillboardBuffers","getVectorRotationTexture","transform","x_pertlon","y_pertlon","WGS84_SEMIMAJOR","WGS84_SEMIMINOR","Grid","UnstructuredGrid","zoom_arg","zoom_cache","log2","kd_nodes","tree","recursiveThin","depth","nodes","node","dist","copy","getGridCoords","getThinnedGrid","ll","ill","thinDataArray","original_grid","i_new","new_data","sampleNearestGridPoint","idx","sample","sample_lon","sample_lat","contour_opt_defaults","interval","quad_as_tri","contour_label_opt_defaults","n_decimal_places","font_face","font_url_template","label_formatter","density","ContourLabels","contours","text_collection","updateField","map_style","getStyle","font_url","label_pos","contour_data","getContours","contour_levels","getMaxZoom","contour_label_spacing","icntr","level_str","contour","c_map","v_ll","v_last","this_dist","n_labels_placed","idist","target_dist","pt1","pt2","pt_lon","pt_lat","coord","lp","text_specs","ilp","tc_opts","triggerRepaint","onAdd","getCanvas","getZoom","field","cv","cd","cv_","contour_style","contour_width","polyline_data","ld","line_data_filtered","contour_line_data","plc_opts","bearing","getBearing","pitch","getPitch","cnt","contourfill_vertex_shader_src","contourfill_fragment_shader_src","contour_fill_opt_defaults","cmap_mask","PlotComponentFill","cm","fill_texture","mask_texture","image_mag_filter","cmap_mag_filter","mask","updateTexImageData","mask_image","getDomainBuffers","cmg","sampler_keys","getSamplerIds","getExpression","data_types","shader_manger","fromEntries","icmg","Raster","matrix","ContourFill","billboard_vertex_shader_src","billboard_fragment_shader_src","BillboardCollection","billboard_image","billboard_spec","billboard_size_mult","rotate_with_map","size_multiplier","wind_textures","getThinnedField","setup","thinned_grid","geom_verts","geom_buffer","rotation","proj_rotation_tex","relative_to","sampler_expressions","getExpressions","sampler_u_get","sampler_v_get","sampler_expression_u","sampler_expression_v","applySamplerCodeVector","geom_vertices","proj_rot_texture","bb_size","BB_HEIGHT","bb_width","BB_WIDTH","BB_TEX_WIDTH","bb_height","BB_TEX_HEIGHT","BB_MAG_BIN_SIZE","BB_MAG_WRAP","BASE_BARB_DIMS","BB_MAG_MAX","barb_opt_defaults","barb_size_multiplier","fields","barb_texture","dimensions","canvas","drawWindBarb","tipx","tipy","mag","elem_full_size","elem_spacing","beginPath","arc","stroke","elem_pos","mag_countdown","staff_length","n_flags","n_full_barbs","moveTo","lineTo","last_was_flag","first_elem","lineWidth","miterLimit","ibarb","createBarbTexture","barb_billboards","barb_image","paintball_step1_vertex_shader_src","paintball_step2_vertex_shader_src","paintball_step1_fragment_shader_src","paintball_step2_fragment_shader_src","paintball_opt_defaults","color_components","vertices_step1","vertices_step2","texcoords_step2","step1_frag_shader_src","shader_program_step1","shader_manager_step2","fb_texture","fb","shader_program_1","shader_manager_2","viewport_width","viewport_height","program_step1","program_step2","icolor","HODO_BG_DIMS","hodograph_opt_defaults","bgcolor","hodo_line_width","background_line_width","height_cmap","max_wind_speed_ring","profile_field","hodo_bg_texture","arrow_head","irng","ctr_x","ctr_y","arrow_size","_createHodoBackgroundTexture","profiles","hodo_scale","bg_size","line_elems","bg_billboard","getStormMotionGrid","getProfileCoords","min_visible_zoom","hodo_polyline","prof","iprof","ipt","hodo_line","sm_polyline","sm_mag","sm_ang","sm_line","bg_image","SYMBOLS","station_plot_opts_defaults","config","positionToAlignmentAndOffset","off_size","ha","va","xoff","yoff","text_components","barb_components","sub_component_promises","k_","comp","getScalar","formatter","getStrings","getVector","wxsym_font_url","text_spec_data","v_cat","symbol","sym","symbolCategory","text_spec_data_filtered","tsd","text_spec_color","specs","barb_promises","barb_size","barb_size_multipler","barb_comp","itext","tc","PlotLayerBase","repaint","PlotLayer","MultiPlotLayer","field_key","res","setActiveKey","getKeys","addField","tagname","createElementNS","setAttribute","appendChild","makeColorBar","label","ticks","orientation","fontface","tickfontsize","ticklabelsize","size_long","size_short","outline_and_text_color","tick_dir","tick_direction","getNChar","chars_left","chars_right","need_overflow","bar_long_size","bar_cross_size","bar_long_pad","bar_left","bar_top","bar_width","bar_height","bar_right","bar_bottom","bar_middle","bar_low_arrow","bar_high_arrow","gbar","gtickattrs","gticks","attrs","point_list","underflow_attrs","points","overflow_attrs","first_level","last_level","labelattrs","diffs","ilevel","gtick","lineattrs","textattrs","x2","y2","dy","style","textContent","paintball_key_opt_defaults","n_cols","swatch_text_space","makePaintballKey","labels","opts_","n_rows","swatch_width","irow","icol","swatch_height","getArrayDType","Int16Array","Int32Array","ExpressionScalarField","operand","other","FUNCS","ComputedScalarField","toFixed","multiply","divide","subtract","RawScalarField","contour_cache","tex_data","getTextureData","contourCreator","ip","aryConstructor","raw_data","raw_data_type","getWGLTextureSpec","fill_textures","fill_texture_specs","key_fill_image","tex","aggregateFields","renderCPU","iterateCPU","new_grid","thin_data","sampleFieldWithCoord","sampleField","chars","raw_fields","expression","cpu_func","fill_textures_ret","fill_textures_pre_field","fill_textures_field","field_expr","matches","field_samples","zipped_args","iterators","current","done","zip","gen","mapGenerator","scalarIdToVectorComponentId","component","vectorComponentIdToScalarId","ExpressionVectorField","operandScalar","ComputedVectorField","operandVector","translateKeys","map_trans","translator","tex_u","tex_v","magnitude","thin_u","thin_v","u_sample","v_sample","rot","brg","translateVariables","expr","RawVectorField","u_ary","v_ary","RawProfileField","smu","smv","prof_lats","prof_lons","RawObsField","field_data","vector_field_data","u_data","v_data","wspd","wdir","idat","vec2comp","makeCartesianDomainBuffers","simplify_ni","simplify_nj","use_margin_r","margin_r","use_margin_s","margin_s","texcoord_margin_r","texcoord_margin_s","grid_element_i","grid_element_j","domain_ni","domain_nj","domain_coords","makeDomainVerticesAndTexCoords","StructuredGrid","buffer_cache","makeDomainBuffers","domainBufferMixin","thin_x","thin_y","xyThinFromMaxZoom","n_density_tiers","n_inaccessible_tiers","xy_thin","thinnedGridParameters","ll_x","ll_y","ur_x","ur_y","dx","zoom_thin_fac","ilat","idx_old","xs","ys","i_min","xv","j_min","yv","lon_min","lat_min","gridCoordinateMixin","ll_cache","gc_cache","setupCoordinateCaches","start_i","end_i","start_j","end_j","di","dj","which_i","which_j","ni_grid","nj_grid","ni_grid_full","nj_grid_full","ni_offset","nj_offset","di_req","dj_req","PlateCarreeGrid","ll_lon","ll_lat","ur_lon","ur_lat","PlateCarreeRotatedGrid","np_lon","np_lat","lon_shift","llrot","sin_np_lat","cos_np_lat","lon_p","lat_p","sin_lat_p","cos_lat_p","sin_lon_p_diff","cos_lon_p_diff","asin","compute_rotation_inverse","cos_lat","sin_lon_diff","cos_lon_diff","compute_rotation","rotateSphere","LambertGrid","lcc","fromLLCornerLonLat","RadarSweepGrid","nr","nt","start_rn","end_rn","start_az","end_az","longitude","latitude","half_dt","az1","GeostationaryImage","satellite_lon","alt","lambda_0","a2","forward","cos_lon","sin_lon","rc","sx","sy","sz","sin_x","cos_x","sin_y","cos_y","a_var","b_var","rs","geostationaryProjection","colormaps","bluered","redblue","initAutumnPlot","contour_workers"],"sourceRoot":""}