@maticoapp/deck.gl-pmtiles
Version:
This repo provides a typed Deck.gl layer and loader for PMTiles data. PMTiles data provides a serverless and compact way to store tile geospatial data. Combined with Deck.gl's rendering, this provides a flexible and powerful way to cheaply manage geospati
1,440 lines (1,422 loc) • 447 kB
JavaScript
"use strict";
(() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b ||= {})
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x2) => x2.done ? resolve(x2.value) : Promise.resolve(x2.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// node_modules/fflate/esm/browser.js
function inflateSync(data, out) {
return inflt(data, out);
}
function gunzipSync(data, out) {
return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
}
function unzlibSync(data, out) {
return inflt((zlv(data), data.subarray(2, -4)), out);
}
function decompressSync(data, out) {
return data[0] == 31 && data[1] == 139 && data[2] == 8 ? gunzipSync(data, out) : (data[0] & 15) != 8 || data[0] >> 4 > 7 || (data[0] << 8 | data[1]) % 31 ? inflateSync(data, out) : unzlibSync(data, out);
}
var u8, u16, u32, fleb, fdeb, clim, freb, _a, fl, revfl, _b, fd, revfd, rev, x2, i, hMap, flt, i, i, i, i, fdt, i, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, et, gzs, gzl, zlv, td, tds;
var init_browser = __esm({
"node_modules/fflate/esm/browser.js"() {
u8 = Uint8Array;
u16 = Uint16Array;
u32 = Uint32Array;
fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
freb = function(eb, start) {
var b = new u16(31);
for (var i = 0; i < 31; ++i) {
b[i] = start += 1 << eb[i - 1];
}
var r = new u32(b[30]);
for (var i = 1; i < 30; ++i) {
for (var j = b[i]; j < b[i + 1]; ++j) {
r[j] = j - b[i] << 5 | i;
}
}
return [b, r];
};
_a = freb(fleb, 2);
fl = _a[0];
revfl = _a[1];
fl[28] = 258, revfl[258] = 28;
_b = freb(fdeb, 0);
fd = _b[0];
revfd = _b[1];
rev = new u16(32768);
for (i = 0; i < 32768; ++i) {
x2 = (i & 43690) >>> 1 | (i & 21845) << 1;
x2 = (x2 & 52428) >>> 2 | (x2 & 13107) << 2;
x2 = (x2 & 61680) >>> 4 | (x2 & 3855) << 4;
rev[i] = ((x2 & 65280) >>> 8 | (x2 & 255) << 8) >>> 1;
}
hMap = function(cd, mb, r) {
var s = cd.length;
var i = 0;
var l = new u16(mb);
for (; i < s; ++i) {
if (cd[i])
++l[cd[i] - 1];
}
var le = new u16(mb);
for (i = 0; i < mb; ++i) {
le[i] = le[i - 1] + l[i - 1] << 1;
}
var co;
if (r) {
co = new u16(1 << mb);
var rvb = 15 - mb;
for (i = 0; i < s; ++i) {
if (cd[i]) {
var sv = i << 4 | cd[i];
var r_1 = mb - cd[i];
var v = le[cd[i] - 1]++ << r_1;
for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
co[rev[v] >>> rvb] = sv;
}
}
}
} else {
co = new u16(s);
for (i = 0; i < s; ++i) {
if (cd[i]) {
co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
}
}
}
return co;
};
flt = new u8(288);
for (i = 0; i < 144; ++i)
flt[i] = 8;
for (i = 144; i < 256; ++i)
flt[i] = 9;
for (i = 256; i < 280; ++i)
flt[i] = 7;
for (i = 280; i < 288; ++i)
flt[i] = 8;
fdt = new u8(32);
for (i = 0; i < 32; ++i)
fdt[i] = 5;
flrm = /* @__PURE__ */ hMap(flt, 9, 1);
fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
max = function(a) {
var m = a[0];
for (var i = 1; i < a.length; ++i) {
if (a[i] > m)
m = a[i];
}
return m;
};
bits = function(d, p, m) {
var o = p / 8 | 0;
return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
};
bits16 = function(d, p) {
var o = p / 8 | 0;
return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
};
shft = function(p) {
return (p + 7) / 8 | 0;
};
slc = function(v, s, e) {
if (s == null || s < 0)
s = 0;
if (e == null || e > v.length)
e = v.length;
var n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
n.set(v.subarray(s, e));
return n;
};
ec = [
"unexpected EOF",
"invalid block type",
"invalid length/literal",
"invalid distance",
"stream finished",
"no stream handler",
,
"no callback",
"invalid UTF-8 data",
"extra field too long",
"date not in range 1980-2099",
"filename too long",
"stream finishing",
"invalid zip data"
];
err = function(ind, msg, nt) {
var e = new Error(msg || ec[ind]);
e.code = ind;
if (Error.captureStackTrace)
Error.captureStackTrace(e, err);
if (!nt)
throw e;
return e;
};
inflt = function(dat, buf, st) {
var sl = dat.length;
if (!sl || st && st.f && !st.l)
return buf || new u8(0);
var noBuf = !buf || st;
var noSt = !st || st.i;
if (!st)
st = {};
if (!buf)
buf = new u8(sl * 3);
var cbuf = function(l2) {
var bl = buf.length;
if (l2 > bl) {
var nbuf = new u8(Math.max(bl * 2, l2));
nbuf.set(buf);
buf = nbuf;
}
};
var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
var tbts = sl * 8;
do {
if (!lm) {
final = bits(dat, pos, 1);
var type = bits(dat, pos + 1, 3);
pos += 3;
if (!type) {
var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
if (t > sl) {
if (noSt)
err(0);
break;
}
if (noBuf)
cbuf(bt + l);
buf.set(dat.subarray(s, t), bt);
st.b = bt += l, st.p = pos = t * 8, st.f = final;
continue;
} else if (type == 1)
lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
else if (type == 2) {
var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
var tl = hLit + bits(dat, pos + 5, 31) + 1;
pos += 14;
var ldt = new u8(tl);
var clt = new u8(19);
for (var i = 0; i < hcLen; ++i) {
clt[clim[i]] = bits(dat, pos + i * 3, 7);
}
pos += hcLen * 3;
var clb = max(clt), clbmsk = (1 << clb) - 1;
var clm = hMap(clt, clb, 1);
for (var i = 0; i < tl; ) {
var r = clm[bits(dat, pos, clbmsk)];
pos += r & 15;
var s = r >>> 4;
if (s < 16) {
ldt[i++] = s;
} else {
var c = 0, n = 0;
if (s == 16)
n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
else if (s == 17)
n = 3 + bits(dat, pos, 7), pos += 3;
else if (s == 18)
n = 11 + bits(dat, pos, 127), pos += 7;
while (n--)
ldt[i++] = c;
}
}
var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
lbt = max(lt);
dbt = max(dt);
lm = hMap(lt, lbt, 1);
dm = hMap(dt, dbt, 1);
} else
err(1);
if (pos > tbts) {
if (noSt)
err(0);
break;
}
}
if (noBuf)
cbuf(bt + 131072);
var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
var lpos = pos;
for (; ; lpos = pos) {
var c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
pos += c & 15;
if (pos > tbts) {
if (noSt)
err(0);
break;
}
if (!c)
err(2);
if (sym < 256)
buf[bt++] = sym;
else if (sym == 256) {
lpos = pos, lm = null;
break;
} else {
var add = sym - 254;
if (sym > 264) {
var i = sym - 257, b = fleb[i];
add = bits(dat, pos, (1 << b) - 1) + fl[i];
pos += b;
}
var d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
if (!d)
err(3);
pos += d & 15;
var dt = fd[dsym];
if (dsym > 3) {
var b = fdeb[dsym];
dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
}
if (pos > tbts) {
if (noSt)
err(0);
break;
}
if (noBuf)
cbuf(bt + 131072);
var end = bt + add;
for (; bt < end; bt += 4) {
buf[bt] = buf[bt - dt];
buf[bt + 1] = buf[bt + 1 - dt];
buf[bt + 2] = buf[bt + 2 - dt];
buf[bt + 3] = buf[bt + 3 - dt];
}
bt = end;
}
}
st.l = lm, st.p = lpos, st.b = bt, st.f = final;
if (lm)
final = 1, st.m = lbt, st.d = dm, st.n = dbt;
} while (!final);
return bt == buf.length ? buf : slc(buf, 0, bt);
};
et = /* @__PURE__ */ new u8(0);
gzs = function(d) {
if (d[0] != 31 || d[1] != 139 || d[2] != 8)
err(6, "invalid gzip data");
var flg = d[3];
var st = 10;
if (flg & 4)
st += d[10] | (d[11] << 8) + 2;
for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
;
return st + (flg & 2);
};
gzl = function(d) {
var l = d.length;
return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
};
zlv = function(d) {
if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31)
err(6, "invalid zlib data");
if (d[1] & 32)
err(6, "invalid zlib data: preset dictionaries not supported");
};
td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
tds = 0;
try {
td.decode(et, { stream: true });
tds = 1;
} catch (e) {
}
}
});
// node_modules/@babel/runtime/helpers/interopRequireDefault.js
var require_interopRequireDefault = __commonJS({
"node_modules/@babel/runtime/helpers/interopRequireDefault.js"(exports, module) {
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
"default": obj
};
}
module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/defineProperty.js
var require_defineProperty = __commonJS({
"node_modules/@babel/runtime/helpers/defineProperty.js"(exports, module) {
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/classCallCheck.js
var require_classCallCheck = __commonJS({
"node_modules/@babel/runtime/helpers/classCallCheck.js"(exports, module) {
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/createClass.js
var require_createClass = __commonJS({
"node_modules/@babel/runtime/helpers/createClass.js"(exports, module) {
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor)
descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps)
_defineProperties(Constructor.prototype, protoProps);
if (staticProps)
_defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/typeof.js
var require_typeof = __commonJS({
"node_modules/@babel/runtime/helpers/typeof.js"(exports, module) {
function _typeof(obj) {
"@babel/helpers - typeof";
return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
return typeof obj2;
} : function(obj2) {
return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
}, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(obj);
}
module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/setPrototypeOf.js
var require_setPrototypeOf = __commonJS({
"node_modules/@babel/runtime/helpers/setPrototypeOf.js"(exports, module) {
function _setPrototypeOf(o, p) {
module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
o2.__proto__ = p2;
return o2;
}, module.exports.__esModule = true, module.exports["default"] = module.exports;
return _setPrototypeOf(o, p);
}
module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/inherits.js
var require_inherits = __commonJS({
"node_modules/@babel/runtime/helpers/inherits.js"(exports, module) {
var setPrototypeOf = require_setPrototypeOf();
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
Object.defineProperty(subClass, "prototype", {
writable: false
});
if (superClass)
setPrototypeOf(subClass, superClass);
}
module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/assertThisInitialized.js
var require_assertThisInitialized = __commonJS({
"node_modules/@babel/runtime/helpers/assertThisInitialized.js"(exports, module) {
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/possibleConstructorReturn.js
var require_possibleConstructorReturn = __commonJS({
"node_modules/@babel/runtime/helpers/possibleConstructorReturn.js"(exports, module) {
var _typeof = require_typeof()["default"];
var assertThisInitialized = require_assertThisInitialized();
function _possibleConstructorReturn(self, call) {
if (call && (_typeof(call) === "object" || typeof call === "function")) {
return call;
} else if (call !== void 0) {
throw new TypeError("Derived constructors may only return object or undefined");
}
return assertThisInitialized(self);
}
module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@babel/runtime/helpers/getPrototypeOf.js
var require_getPrototypeOf = __commonJS({
"node_modules/@babel/runtime/helpers/getPrototypeOf.js"(exports, module) {
function _getPrototypeOf(o) {
module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
return o2.__proto__ || Object.getPrototypeOf(o2);
}, module.exports.__esModule = true, module.exports["default"] = module.exports;
return _getPrototypeOf(o);
}
module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
}
});
// node_modules/@math.gl/core/dist/es5/lib/assert.js
var require_assert = __commonJS({
"node_modules/@math.gl/core/dist/es5/lib/assert.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = assert;
function assert(condition, message) {
if (!condition) {
throw new Error("math.gl assertion ".concat(message));
}
}
}
});
// node_modules/@math.gl/core/dist/es5/lib/common.js
var require_common = __commonJS({
"node_modules/@math.gl/core/dist/es5/lib/common.js"(exports) {
"use strict";
var _interopRequireDefault = require_interopRequireDefault();
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.configure = configure;
exports.formatValue = formatValue;
exports.isArray = isArray;
exports.clone = clone;
exports.toRadians = toRadians;
exports.toDegrees = toDegrees;
exports.radians = radians;
exports.degrees = degrees;
exports.sin = sin;
exports.cos = cos;
exports.tan = tan;
exports.asin = asin;
exports.acos = acos;
exports.atan = atan;
exports.clamp = clamp;
exports.lerp = lerp;
exports.equals = equals;
exports.exactEquals = exactEquals;
exports.withEpsilon = withEpsilon;
exports.config = void 0;
var _typeof2 = _interopRequireDefault(require_typeof());
var _assert = _interopRequireDefault(require_assert());
var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
var config = {
EPSILON: 1e-12,
debug: false,
precision: 4,
printTypes: false,
printDegrees: false,
printRowMajor: true
};
exports.config = config;
function configure(options) {
for (var key in options) {
(0, _assert.default)(key in config);
config[key] = options[key];
}
return config;
}
function formatValue(value) {
var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref$precision = _ref.precision, precision = _ref$precision === void 0 ? config.precision : _ref$precision;
value = round(value);
return "".concat(parseFloat(value.toPrecision(precision)));
}
function isArray(value) {
return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
}
function clone(array) {
return "clone" in array ? array.clone() : array.slice();
}
function toRadians(degrees2) {
return radians(degrees2);
}
function toDegrees(radians2) {
return degrees(radians2);
}
function radians(degrees2, result) {
return map(degrees2, function(degrees3) {
return degrees3 * DEGREES_TO_RADIANS;
}, result);
}
function degrees(radians2, result) {
return map(radians2, function(radians3) {
return radians3 * RADIANS_TO_DEGREES;
}, result);
}
function sin(radians2, result) {
return map(radians2, function(angle) {
return Math.sin(angle);
}, result);
}
function cos(radians2, result) {
return map(radians2, function(angle) {
return Math.cos(angle);
}, result);
}
function tan(radians2, result) {
return map(radians2, function(angle) {
return Math.tan(angle);
}, result);
}
function asin(radians2, result) {
return map(radians2, function(angle) {
return Math.asin(angle);
}, result);
}
function acos(radians2, result) {
return map(radians2, function(angle) {
return Math.acos(angle);
}, result);
}
function atan(radians2, result) {
return map(radians2, function(angle) {
return Math.atan(angle);
}, result);
}
function clamp(value, min, max2) {
return map(value, function(value2) {
return Math.max(min, Math.min(max2, value2));
});
}
function lerp(a, b, t) {
if (isArray(a)) {
return a.map(function(ai, i) {
return lerp(ai, b[i], t);
});
}
return t * b + (1 - t) * a;
}
function equals(a, b, epsilon) {
var oldEpsilon = config.EPSILON;
if (epsilon) {
config.EPSILON = epsilon;
}
try {
if (a === b) {
return true;
}
if (isArray(a) && isArray(b)) {
if (a.length !== b.length) {
return false;
}
for (var i = 0; i < a.length; ++i) {
if (!equals(a[i], b[i])) {
return false;
}
}
return true;
}
if (a && a.equals) {
return a.equals(b);
}
if (b && b.equals) {
return b.equals(a);
}
if (typeof a === "number" && typeof b === "number") {
return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
}
return false;
} finally {
config.EPSILON = oldEpsilon;
}
}
function exactEquals(a, b) {
if (a === b) {
return true;
}
if (a && (0, _typeof2.default)(a) === "object" && b && (0, _typeof2.default)(b) === "object") {
if (a.constructor !== b.constructor) {
return false;
}
if (a.exactEquals) {
return a.exactEquals(b);
}
}
if (isArray(a) && isArray(b)) {
if (a.length !== b.length) {
return false;
}
for (var i = 0; i < a.length; ++i) {
if (!exactEquals(a[i], b[i])) {
return false;
}
}
return true;
}
return false;
}
function withEpsilon(epsilon, func) {
var oldPrecision = config.EPSILON;
config.EPSILON = epsilon;
var value;
try {
value = func();
} finally {
config.EPSILON = oldPrecision;
}
return value;
}
function round(value) {
return Math.round(value / config.EPSILON) * config.EPSILON;
}
function duplicateArray(array) {
return array.clone ? array.clone() : new Array(array.length);
}
function map(value, func, result) {
if (isArray(value)) {
var array = value;
result = result || duplicateArray(array);
for (var i = 0; i < result.length && i < array.length; ++i) {
result[i] = func(value[i], i, result);
}
return result;
}
return func(value);
}
}
});
// node_modules/@math.gl/core/dist/es5/classes/base/math-array.js
var require_math_array = __commonJS({
"node_modules/@math.gl/core/dist/es5/classes/base/math-array.js"(exports) {
"use strict";
var _interopRequireDefault = require_interopRequireDefault();
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
var _createClass2 = _interopRequireDefault(require_createClass());
var _inherits2 = _interopRequireDefault(require_inherits());
var _possibleConstructorReturn2 = _interopRequireDefault(require_possibleConstructorReturn());
var _getPrototypeOf2 = _interopRequireDefault(require_getPrototypeOf());
var _common = require_common();
function _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = (0, _getPrototypeOf2.default)(Derived), result;
if (hasNativeReflectConstruct) {
var NewTarget = (0, _getPrototypeOf2.default)(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return (0, _possibleConstructorReturn2.default)(this, result);
};
}
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct)
return false;
if (Reflect.construct.sham)
return false;
if (typeof Proxy === "function")
return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
}));
return true;
} catch (e) {
return false;
}
}
function _extendableBuiltin(cls) {
function ExtendableBuiltin() {
var instance = Reflect.construct(cls, Array.from(arguments));
Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
return instance;
}
ExtendableBuiltin.prototype = Object.create(cls.prototype, {
constructor: {
value: cls,
enumerable: false,
writable: true,
configurable: true
}
});
if (Object.setPrototypeOf) {
Object.setPrototypeOf(ExtendableBuiltin, cls);
} else {
ExtendableBuiltin.__proto__ = cls;
}
return ExtendableBuiltin;
}
var MathArray = function(_extendableBuiltin2) {
(0, _inherits2.default)(MathArray2, _extendableBuiltin2);
var _super = _createSuper(MathArray2);
function MathArray2() {
(0, _classCallCheck2.default)(this, MathArray2);
return _super.apply(this, arguments);
}
(0, _createClass2.default)(MathArray2, [{
key: "clone",
value: function clone() {
return new this.constructor().copy(this);
}
}, {
key: "fromArray",
value: function fromArray(array) {
var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] = array[i + offset];
}
return this.check();
}
}, {
key: "toArray",
value: function toArray() {
var targetArray = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
for (var i = 0; i < this.ELEMENTS; ++i) {
targetArray[offset + i] = this[i];
}
return targetArray;
}
}, {
key: "from",
value: function from(arrayOrObject) {
return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
}
}, {
key: "to",
value: function to(arrayOrObject) {
if (arrayOrObject === this) {
return this;
}
return (0, _common.isArray)(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
}
}, {
key: "toTarget",
value: function toTarget(target) {
return target ? this.to(target) : this;
}
}, {
key: "toFloat32Array",
value: function toFloat32Array() {
return new Float32Array(this);
}
}, {
key: "toString",
value: function toString() {
return this.formatString(_common.config);
}
}, {
key: "formatString",
value: function formatString(opts) {
var string = "";
for (var i = 0; i < this.ELEMENTS; ++i) {
string += (i > 0 ? ", " : "") + (0, _common.formatValue)(this[i], opts);
}
return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
}
}, {
key: "equals",
value: function equals(array) {
if (!array || this.length !== array.length) {
return false;
}
for (var i = 0; i < this.ELEMENTS; ++i) {
if (!(0, _common.equals)(this[i], array[i])) {
return false;
}
}
return true;
}
}, {
key: "exactEquals",
value: function exactEquals(array) {
if (!array || this.length !== array.length) {
return false;
}
for (var i = 0; i < this.ELEMENTS; ++i) {
if (this[i] !== array[i]) {
return false;
}
}
return true;
}
}, {
key: "negate",
value: function negate() {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] = -this[i];
}
return this.check();
}
}, {
key: "lerp",
value: function lerp(a, b, t) {
if (t === void 0) {
return this.lerp(this, a, b);
}
for (var i = 0; i < this.ELEMENTS; ++i) {
var ai = a[i];
this[i] = ai + t * (b[i] - ai);
}
return this.check();
}
}, {
key: "min",
value: function min(vector) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] = Math.min(vector[i], this[i]);
}
return this.check();
}
}, {
key: "max",
value: function max2(vector) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] = Math.max(vector[i], this[i]);
}
return this.check();
}
}, {
key: "clamp",
value: function clamp(minVector, maxVector) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
}
return this.check();
}
}, {
key: "add",
value: function add() {
for (var _len = arguments.length, vectors = new Array(_len), _key = 0; _key < _len; _key++) {
vectors[_key] = arguments[_key];
}
for (var _i = 0, _vectors = vectors; _i < _vectors.length; _i++) {
var _vector = _vectors[_i];
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] += _vector[i];
}
}
return this.check();
}
}, {
key: "subtract",
value: function subtract() {
for (var _len2 = arguments.length, vectors = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
vectors[_key2] = arguments[_key2];
}
for (var _i2 = 0, _vectors2 = vectors; _i2 < _vectors2.length; _i2++) {
var _vector2 = _vectors2[_i2];
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] -= _vector2[i];
}
}
return this.check();
}
}, {
key: "scale",
value: function scale(_scale) {
if (typeof _scale === "number") {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] *= _scale;
}
} else {
for (var _i3 = 0; _i3 < this.ELEMENTS && _i3 < _scale.length; ++_i3) {
this[_i3] *= _scale[_i3];
}
}
return this.check();
}
}, {
key: "multiplyByScalar",
value: function multiplyByScalar(scalar) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] *= scalar;
}
return this.check();
}
}, {
key: "check",
value: function check() {
if (_common.config.debug && !this.validate()) {
throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
}
return this;
}
}, {
key: "validate",
value: function validate() {
var valid = this.length === this.ELEMENTS;
for (var i = 0; i < this.ELEMENTS; ++i) {
valid = valid && Number.isFinite(this[i]);
}
return valid;
}
}, {
key: "sub",
value: function sub(a) {
return this.subtract(a);
}
}, {
key: "setScalar",
value: function setScalar(a) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] = a;
}
return this.check();
}
}, {
key: "addScalar",
value: function addScalar(a) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] += a;
}
return this.check();
}
}, {
key: "subScalar",
value: function subScalar(a) {
return this.addScalar(-a);
}
}, {
key: "multiplyScalar",
value: function multiplyScalar(scalar) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] *= scalar;
}
return this.check();
}
}, {
key: "divideScalar",
value: function divideScalar(a) {
return this.multiplyByScalar(1 / a);
}
}, {
key: "clampScalar",
value: function clampScalar(min, max2) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] = Math.min(Math.max(this[i], min), max2);
}
return this.check();
}
}, {
key: "elements",
get: function get() {
return this;
}
}]);
return MathArray2;
}(_extendableBuiltin(Array));
exports.default = MathArray;
}
});
// node_modules/@math.gl/core/dist/es5/lib/validators.js
var require_validators = __commonJS({
"node_modules/@math.gl/core/dist/es5/lib/validators.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.validateVector = validateVector;
exports.checkNumber = checkNumber;
exports.checkVector = checkVector;
exports.deprecated = deprecated;
var _common = require_common();
function validateVector(v, length) {
if (v.length !== length) {
return false;
}
for (var i = 0; i < v.length; ++i) {
if (!Number.isFinite(v[i])) {
return false;
}
}
return true;
}
function checkNumber(value) {
if (!Number.isFinite(value)) {
throw new Error("Invalid number ".concat(value));
}
return value;
}
function checkVector(v, length) {
var callerName = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
if (_common.config.debug && !validateVector(v, length)) {
throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
}
return v;
}
var map = {};
function deprecated(method, version) {
if (!map[method]) {
map[method] = true;
console.warn("".concat(method, " has been removed in version ").concat(version, ", see upgrade guide for more information"));
}
}
}
});
// node_modules/@math.gl/core/dist/es5/classes/base/vector.js
var require_vector = __commonJS({
"node_modules/@math.gl/core/dist/es5/classes/base/vector.js"(exports) {
"use strict";
var _interopRequireDefault = require_interopRequireDefault();
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
var _createClass2 = _interopRequireDefault(require_createClass());
var _inherits2 = _interopRequireDefault(require_inherits());
var _possibleConstructorReturn2 = _interopRequireDefault(require_possibleConstructorReturn());
var _getPrototypeOf2 = _interopRequireDefault(require_getPrototypeOf());
var _mathArray = _interopRequireDefault(require_math_array());
var _validators = require_validators();
var _assert = _interopRequireDefault(require_assert());
function _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = (0, _getPrototypeOf2.default)(Derived), result;
if (hasNativeReflectConstruct) {
var NewTarget = (0, _getPrototypeOf2.default)(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return (0, _possibleConstructorReturn2.default)(this, result);
};
}
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct)
return false;
if (Reflect.construct.sham)
return false;
if (typeof Proxy === "function")
return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
}));
return true;
} catch (e) {
return false;
}
}
var Vector = function(_MathArray) {
(0, _inherits2.default)(Vector2, _MathArray);
var _super = _createSuper(Vector2);
function Vector2() {
(0, _classCallCheck2.default)(this, Vector2);
return _super.apply(this, arguments);
}
(0, _createClass2.default)(Vector2, [{
key: "x",
get: function get() {
return this[0];
},
set: function set(value) {
this[0] = (0, _validators.checkNumber)(value);
}
}, {
key: "y",
get: function get() {
return this[1];
},
set: function set(value) {
this[1] = (0, _validators.checkNumber)(value);
}
}, {
key: "len",
value: function len() {
return Math.sqrt(this.lengthSquared());
}
}, {
key: "magnitude",
value: function magnitude() {
return this.len();
}
}, {
key: "lengthSquared",
value: function lengthSquared() {
var length = 0;
for (var i = 0; i < this.ELEMENTS; ++i) {
length += this[i] * this[i];
}
return length;
}
}, {
key: "magnitudeSquared",
value: function magnitudeSquared() {
return this.lengthSquared();
}
}, {
key: "distance",
value: function distance(mathArray) {
return Math.sqrt(this.distanceSquared(mathArray));
}
}, {
key: "distanceSquared",
value: function distanceSquared(mathArray) {
var length = 0;
for (var i = 0; i < this.ELEMENTS; ++i) {
var dist = this[i] - mathArray[i];
length += dist * dist;
}
return (0, _validators.checkNumber)(length);
}
}, {
key: "dot",
value: function dot(mathArray) {
var product = 0;
for (var i = 0; i < this.ELEMENTS; ++i) {
product += this[i] * mathArray[i];
}
return (0, _validators.checkNumber)(product);
}
}, {
key: "normalize",
value: function normalize() {
var length = this.magnitude();
if (length !== 0) {
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] /= length;
}
}
return this.check();
}
}, {
key: "multiply",
value: function multiply() {
for (var _len = arguments.length, vectors = new Array(_len), _key = 0; _key < _len; _key++) {
vectors[_key] = arguments[_key];
}
for (var _i = 0, _vectors = vectors; _i < _vectors.length; _i++) {
var vector = _vectors[_i];
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] *= vector[i];
}
}
return this.check();
}
}, {
key: "divide",
value: function divide() {
for (var _len2 = arguments.length, vectors = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
vectors[_key2] = arguments[_key2];
}
for (var _i2 = 0, _vectors2 = vectors; _i2 < _vectors2.length; _i2++) {
var vector = _vectors2[_i2];
for (var i = 0; i < this.ELEMENTS; ++i) {
this[i] /= vector[i];
}
}
return this.check();
}
}, {
key: "lengthSq",
value: function lengthSq() {
return this.lengthSquared();
}
}, {
key: "distanceTo",
value: function distanceTo(vector) {
return this.distance(vector);
}
}, {
key: "distanceToSquared",
value: function distanceToSquared(vector) {
return this.distanceSquared(vector);
}
}, {
key: "getComponent",
value: function getComponent(i) {
(0, _assert.default)(i >= 0 && i < this.ELEMENTS, "index is out of range");
return (0, _validators.checkNumber)(this[i]);
}
}, {
key: "setComponent",
value: function setComponent(i, value) {
(0, _assert.default)(i >= 0 && i < this.ELEMENTS, "index is out of range");
this[i] = value;
return this.check();
}
}, {
key: "addVectors",
value: function addVectors(a, b) {
return this.copy(a).add(b);
}
}, {
key: "subVectors",
value: function subVectors(a, b) {
return this.copy(a).subtract(b);
}
}, {
key: "multiplyVectors",
value: function multiplyVectors(a, b) {
return this.copy(a).multiply(b);
}
}, {
key: "addScaledVector",
value: function addScaledVector(a, b) {
return this.add(new this.constructor(a).multiplyScalar(b));
}
}]);
return Vector2;
}(_mathArray.default);
exports.default = Vector;
}
});
// node_modules/gl-matrix/cjs/common.js
var require_common2 = __commonJS({
"node_modules/gl-matrix/cjs/common.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.setMatrixArrayType = setMatrixArrayType;
exports.toRadian = toRadian;
exports.equals = equals;
exports.RANDOM = exports.ARRAY_TYPE = exports.EPSILON = void 0;
var EPSILON = 1e-6;
exports.EPSILON = EPSILON;
var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
exports.ARRAY_TYPE = ARRAY_TYPE;
var RANDOM = Math.random;
exports.RANDOM = RANDOM;
function setMatrixArrayType(type) {
exports.ARRAY_TYPE = ARRAY_TYPE = type;
}
var degree = Math.PI / 180;
function toRadian(a) {
return a * degree;
}
function equals(a, b) {
return Math.abs(a - b) <= EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
}
if (!Math.hypot)
Math.hypot = function() {
var y = 0, i = arguments.length;
while (i--) {
y += arguments[i] * arguments[i];
}
return Math.sqrt(y);
};
}
});
// node_modules/gl-matrix/cjs/vec2.js
var require_vec2 = __commonJS({
"node_modules/gl-matrix/cjs/vec2.js"(exports) {
"use strict";
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof(obj);
}
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.create = create;
exports.clone = clone;
exports.fromValues = fromValues;
exports.copy = copy;
exports.set = set;
exports.add = add;
exports.subtract = subtract;
exports.multiply = multiply;
exports.divide = divide;
exports.ceil = ceil;
exports.floor = floor;
exports.min = min;
exports.max =