diff --git a/docs/hra-node-dist-vis.wc.js b/docs/hra-node-dist-vis.wc.js index 54581cd..d818443 100644 --- a/docs/hra-node-dist-vis.wc.js +++ b/docs/hra-node-dist-vis.wc.js @@ -5,6 +5,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames; var __getProtoOf = Object.getPrototypeOf; var __hasOwnProp = Object.prototype.hasOwnProperty; + var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; + }; var __commonJS = (cb, mod3) => function __require() { return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports; }; @@ -51,21 +54,21 @@ return false; } function each(obj, iterator, context) { - var i2; + var i3; if (!obj) { return; } if (obj.forEach) { obj.forEach(iterator, context); } else if (obj.length !== undefined2) { - i2 = 0; - while (i2 < obj.length) { - iterator.call(context, obj[i2], i2, obj); - i2++; + i3 = 0; + while (i3 < obj.length) { + iterator.call(context, obj[i3], i3, obj); + i3++; } } else { - for (i2 in obj) { - obj.hasOwnProperty(i2) && iterator.call(context, obj[i2], i2, obj); + for (i3 in obj) { + obj.hasOwnProperty(i3) && iterator.call(context, obj[i3], i3, obj); } } } @@ -81,9 +84,9 @@ return method.apply(this, arguments); }; } - var assign; + var assign3; if (typeof Object.assign !== "function") { - assign = function assign2(target) { + assign3 = function assign4(target) { if (target === undefined2 || target === null) { throw new TypeError("Cannot convert undefined or null to object"); } @@ -101,16 +104,16 @@ return output; }; } else { - assign = Object.assign; + assign3 = Object.assign; } var extend = deprecate(function extend2(dest, src, merge2) { var keys = Object.keys(src); - var i2 = 0; - while (i2 < keys.length) { - if (!merge2 || merge2 && dest[keys[i2]] === undefined2) { - dest[keys[i2]] = src[keys[i2]]; + var i3 = 0; + while (i3 < keys.length) { + if (!merge2 || merge2 && dest[keys[i3]] === undefined2) { + dest[keys[i3]] = src[keys[i3]]; } - i2++; + i3++; } return dest; }, "extend", "Use `assign`."); @@ -123,7 +126,7 @@ childP.constructor = child; childP._super = baseP; if (properties) { - assign(childP, properties); + assign3(childP, properties); } } function bindFn(fn, context) { @@ -169,12 +172,12 @@ if (src.indexOf && !findByKey) { return src.indexOf(find); } else { - var i2 = 0; - while (i2 < src.length) { - if (findByKey && src[i2][findByKey] == find || !findByKey && src[i2] === find) { - return i2; + var i3 = 0; + while (i3 < src.length) { + if (findByKey && src[i3][findByKey] == find || !findByKey && src[i3] === find) { + return i3; } - i2++; + i3++; } return -1; } @@ -185,14 +188,14 @@ function uniqueArray(src, key, sort) { var results = []; var values = []; - var i2 = 0; - while (i2 < src.length) { - var val = key ? src[i2][key] : src[i2]; + var i3 = 0; + while (i3 < src.length) { + var val = key ? src[i3][key] : src[i3]; if (inArray(values, val) < 0) { - results.push(src[i2]); + results.push(src[i3]); } - values[i2] = val; - i2++; + values[i3] = val; + i3++; } if (sort) { if (!key) { @@ -208,14 +211,14 @@ function prefixed(obj, property) { var prefix, prop; var camelProp = property[0].toUpperCase() + property.slice(1); - var i2 = 0; - while (i2 < VENDOR_PREFIXES.length) { - prefix = VENDOR_PREFIXES[i2]; + var i3 = 0; + while (i3 < VENDOR_PREFIXES.length) { + prefix = VENDOR_PREFIXES[i3]; prop = prefix ? prefix + camelProp : property; if (prop in obj) { return prop; } - i2++; + i3++; } return undefined2; } @@ -345,7 +348,7 @@ input.overallVelocityX = overallVelocity.x; input.overallVelocityY = overallVelocity.y; input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y; - input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1; + input.scale = firstMultiple ? getScale2(firstMultiple.pointers, pointers) : 1; input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0; input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers; computeIntervalInputData(session, input); @@ -397,13 +400,13 @@ } function simpleCloneInputData(input) { var pointers = []; - var i2 = 0; - while (i2 < input.pointers.length) { - pointers[i2] = { - clientX: round2(input.pointers[i2].clientX), - clientY: round2(input.pointers[i2].clientY) + var i3 = 0; + while (i3 < input.pointers.length) { + pointers[i3] = { + clientX: round2(input.pointers[i3].clientX), + clientY: round2(input.pointers[i3].clientY) }; - i2++; + i3++; } return { timeStamp: now(), @@ -421,11 +424,11 @@ y: round2(pointers[0].clientY) }; } - var x2 = 0, y2 = 0, i2 = 0; - while (i2 < pointersLength) { - x2 += pointers[i2].clientX; - y2 += pointers[i2].clientY; - i2++; + var x2 = 0, y2 = 0, i3 = 0; + while (i3 < pointersLength) { + x2 += pointers[i3].clientX; + y2 += pointers[i3].clientY; + i3++; } return { x: round2(x2 / pointersLength), @@ -464,7 +467,7 @@ function getRotation(start, end) { return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY); } - function getScale(start, end) { + function getScale2(start, end) { return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY); } var MOUSE_INPUT_MAP2 = { @@ -646,26 +649,26 @@ targetIds[allTouches[0].identifier] = true; return [allTouches, allTouches]; } - var i2, targetTouches, changedTouches = toArray(ev.changedTouches), changedTargetTouches = [], target = this.target; + var i3, targetTouches, changedTouches = toArray(ev.changedTouches), changedTargetTouches = [], target = this.target; targetTouches = allTouches.filter(function(touch) { return hasParent(touch.target, target); }); if (type === INPUT_START2) { - i2 = 0; - while (i2 < targetTouches.length) { - targetIds[targetTouches[i2].identifier] = true; - i2++; + i3 = 0; + while (i3 < targetTouches.length) { + targetIds[targetTouches[i3].identifier] = true; + i3++; } } - i2 = 0; - while (i2 < changedTouches.length) { - if (targetIds[changedTouches[i2].identifier]) { - changedTargetTouches.push(changedTouches[i2]); + i3 = 0; + while (i3 < changedTouches.length) { + if (targetIds[changedTouches[i3].identifier]) { + changedTargetTouches.push(changedTouches[i3]); } if (type & (INPUT_END2 | INPUT_CANCEL)) { - delete targetIds[changedTouches[i2].identifier]; + delete targetIds[changedTouches[i3].identifier]; } - i2++; + i3++; } if (!changedTargetTouches.length) { return; @@ -728,9 +731,9 @@ this.lastTouches.push(lastTouch); var lts = this.lastTouches; var removeLastTouch = function() { - var i2 = lts.indexOf(lastTouch); - if (i2 > -1) { - lts.splice(i2, 1); + var i3 = lts.indexOf(lastTouch); + if (i3 > -1) { + lts.splice(i3, 1); } }; setTimeout(removeLastTouch, DEDUP_TIMEOUT); @@ -738,8 +741,8 @@ } function isSyntheticEvent(eventData) { var x2 = eventData.srcEvent.clientX, y2 = eventData.srcEvent.clientY; - for (var i2 = 0; i2 < this.lastTouches.length; i2++) { - var t2 = this.lastTouches[i2]; + for (var i3 = 0; i3 < this.lastTouches.length; i3++) { + var t2 = this.lastTouches[i3]; var dx = Math.abs(x2 - t2.x), dy = Math.abs(y2 - t2.y); if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) { return true; @@ -868,7 +871,7 @@ var STATE_CANCELLED = 16; var STATE_FAILED = 32; function Recognizer(options) { - this.options = assign({}, this.defaults, options || {}); + this.options = assign3({}, this.defaults, options || {}); this.id = uniqueId(); this.manager = null; this.options.enable = ifUndefined(this.options.enable, true); @@ -888,7 +891,7 @@ * @return {Recognizer} */ set: function(options) { - assign(this.options, options); + assign3(this.options, options); this.manager && this.manager.touchAction.update(); return this; }, @@ -1009,12 +1012,12 @@ * @returns {boolean} */ canEmit: function() { - var i2 = 0; - while (i2 < this.requireFail.length) { - if (!(this.requireFail[i2].state & (STATE_FAILED | STATE_POSSIBLE))) { + var i3 = 0; + while (i3 < this.requireFail.length) { + if (!(this.requireFail[i3].state & (STATE_FAILED | STATE_POSSIBLE))) { return false; } - i2++; + i3++; } return true; }, @@ -1023,7 +1026,7 @@ * @param {Object} inputData */ recognize: function(inputData) { - var inputDataClone = assign({}, inputData); + var inputDataClone = assign3({}, inputData); if (!boolOrFn(this.options.enable, [this, inputDataClone])) { this.reset(); this.state = STATE_FAILED; @@ -1128,10 +1131,10 @@ var state = this.state; var eventType = input.eventType; var isRecognized = state & (STATE_BEGAN | STATE_CHANGED); - var isValid = this.attrTest(input); - if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) { + var isValid2 = this.attrTest(input); + if (isRecognized && (eventType & INPUT_CANCEL || !isValid2)) { return state | STATE_CANCELLED; - } else if (isRecognized || isValid) { + } else if (isRecognized || isValid2) { if (eventType & INPUT_END2) { return state | STATE_ENDED; } else if (!(state & STATE_BEGAN)) { @@ -1531,7 +1534,7 @@ var STOP = 1; var FORCED_STOP = 2; function Manager3(element, options) { - this.options = assign({}, Hammer.defaults, options || {}); + this.options = assign3({}, Hammer.defaults, options || {}); this.options.inputTarget = this.options.inputTarget || element; this.handlers = {}; this.session = {}; @@ -1554,7 +1557,7 @@ * @returns {Manager} */ set: function(options) { - assign(this.options, options); + assign3(this.options, options); if (options.touchAction) { this.touchAction.update(); } @@ -1592,9 +1595,9 @@ if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) { curRecognizer = session.curRecognizer = null; } - var i2 = 0; - while (i2 < recognizers.length) { - recognizer = recognizers[i2]; + var i3 = 0; + while (i3 < recognizers.length) { + recognizer = recognizers[i3]; if (session.stopped !== FORCED_STOP && // 1 (!curRecognizer || recognizer == curRecognizer || // 2 recognizer.canRecognizeWith(curRecognizer))) { @@ -1605,7 +1608,7 @@ if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) { curRecognizer = session.curRecognizer = recognizer; } - i2++; + i3++; } }, /** @@ -1618,9 +1621,9 @@ return recognizer; } var recognizers = this.recognizers; - for (var i2 = 0; i2 < recognizers.length; i2++) { - if (recognizers[i2].options.event == recognizer) { - return recognizers[i2]; + for (var i3 = 0; i3 < recognizers.length; i3++) { + if (recognizers[i3].options.event == recognizer) { + return recognizers[i3]; } } return null; @@ -1721,10 +1724,10 @@ data.preventDefault = function() { data.srcEvent.preventDefault(); }; - var i2 = 0; - while (i2 < handlers.length) { - handlers[i2](data); - i2++; + var i3 = 0; + while (i3 < handlers.length) { + handlers[i3](data); + i3++; } }, /** @@ -1739,7 +1742,7 @@ this.element = null; } }; - function toggleCssProps(manager, add3) { + function toggleCssProps(manager, add5) { var element = manager.element; if (!element.style) { return; @@ -1747,14 +1750,14 @@ var prop; each(manager.options.cssProps, function(value, name) { prop = prefixed(element.style, name); - if (add3) { + if (add5) { manager.oldCssProps[prop] = element.style[prop]; element.style[prop] = value; } else { element.style[prop] = manager.oldCssProps[prop] || ""; } }); - if (!add3) { + if (!add5) { manager.oldCssProps = {}; } } @@ -1764,7 +1767,7 @@ gestureEvent.gesture = data; data.target.dispatchEvent(gestureEvent); } - assign(Hammer, { + assign3(Hammer, { INPUT_START: INPUT_START2, INPUT_MOVE: INPUT_MOVE2, INPUT_END: INPUT_END2, @@ -1805,7 +1808,7 @@ each, merge, extend, - assign, + assign: assign3, inherit, bindFn, prefixed @@ -1825,6 +1828,472 @@ } }); + // node_modules/earcut/src/earcut.js + var require_earcut = __commonJS({ + "node_modules/earcut/src/earcut.js"(exports, module) { + "use strict"; + module.exports = earcut3; + module.exports.default = earcut3; + function earcut3(data, holeIndices, dim) { + dim = dim || 2; + var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = []; + if (!outerNode || outerNode.next === outerNode.prev) + return triangles; + var minX, minY, maxX, maxY, x2, y2, invSize; + if (hasHoles) + outerNode = eliminateHoles(data, holeIndices, outerNode, dim); + if (data.length > 80 * dim) { + minX = maxX = data[0]; + minY = maxY = data[1]; + for (var i3 = dim; i3 < outerLen; i3 += dim) { + x2 = data[i3]; + y2 = data[i3 + 1]; + if (x2 < minX) + minX = x2; + if (y2 < minY) + minY = y2; + if (x2 > maxX) + maxX = x2; + if (y2 > maxY) + maxY = y2; + } + invSize = Math.max(maxX - minX, maxY - minY); + invSize = invSize !== 0 ? 32767 / invSize : 0; + } + earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0); + return triangles; + } + function linkedList(data, start, end, dim, clockwise) { + var i3, last; + if (clockwise === signedArea(data, start, end, dim) > 0) { + for (i3 = start; i3 < end; i3 += dim) + last = insertNode(i3, data[i3], data[i3 + 1], last); + } else { + for (i3 = end - dim; i3 >= start; i3 -= dim) + last = insertNode(i3, data[i3], data[i3 + 1], last); + } + if (last && equals3(last, last.next)) { + removeNode(last); + last = last.next; + } + return last; + } + function filterPoints(start, end) { + if (!start) + return start; + if (!end) + end = start; + var p2 = start, again; + do { + again = false; + if (!p2.steiner && (equals3(p2, p2.next) || area(p2.prev, p2, p2.next) === 0)) { + removeNode(p2); + p2 = end = p2.prev; + if (p2 === p2.next) + break; + again = true; + } else { + p2 = p2.next; + } + } while (again || p2 !== end); + return end; + } + function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) { + if (!ear) + return; + if (!pass && invSize) + indexCurve(ear, minX, minY, invSize); + var stop = ear, prev, next; + while (ear.prev !== ear.next) { + prev = ear.prev; + next = ear.next; + if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) { + triangles.push(prev.i / dim | 0); + triangles.push(ear.i / dim | 0); + triangles.push(next.i / dim | 0); + removeNode(ear); + ear = next.next; + stop = next.next; + continue; + } + ear = next; + if (ear === stop) { + if (!pass) { + earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1); + } else if (pass === 1) { + ear = cureLocalIntersections(filterPoints(ear), triangles, dim); + earcutLinked(ear, triangles, dim, minX, minY, invSize, 2); + } else if (pass === 2) { + splitEarcut(ear, triangles, dim, minX, minY, invSize); + } + break; + } + } + } + function isEar(ear) { + var a2 = ear.prev, b2 = ear, c2 = ear.next; + if (area(a2, b2, c2) >= 0) + return false; + var ax = a2.x, bx = b2.x, cx = c2.x, ay = a2.y, by = b2.y, cy = c2.y; + var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; + var p2 = c2.next; + while (p2 !== a2) { + if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) + return false; + p2 = p2.next; + } + return true; + } + function isEarHashed(ear, minX, minY, invSize) { + var a2 = ear.prev, b2 = ear, c2 = ear.next; + if (area(a2, b2, c2) >= 0) + return false; + var ax = a2.x, bx = b2.x, cx = c2.x, ay = a2.y, by = b2.y, cy = c2.y; + var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; + var minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize); + var p2 = ear.prevZ, n2 = ear.nextZ; + while (p2 && p2.z >= minZ && n2 && n2.z <= maxZ) { + if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && p2 !== a2 && p2 !== c2 && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) + return false; + p2 = p2.prevZ; + if (n2.x >= x0 && n2.x <= x1 && n2.y >= y0 && n2.y <= y1 && n2 !== a2 && n2 !== c2 && pointInTriangle(ax, ay, bx, by, cx, cy, n2.x, n2.y) && area(n2.prev, n2, n2.next) >= 0) + return false; + n2 = n2.nextZ; + } + while (p2 && p2.z >= minZ) { + if (p2.x >= x0 && p2.x <= x1 && p2.y >= y0 && p2.y <= y1 && p2 !== a2 && p2 !== c2 && pointInTriangle(ax, ay, bx, by, cx, cy, p2.x, p2.y) && area(p2.prev, p2, p2.next) >= 0) + return false; + p2 = p2.prevZ; + } + while (n2 && n2.z <= maxZ) { + if (n2.x >= x0 && n2.x <= x1 && n2.y >= y0 && n2.y <= y1 && n2 !== a2 && n2 !== c2 && pointInTriangle(ax, ay, bx, by, cx, cy, n2.x, n2.y) && area(n2.prev, n2, n2.next) >= 0) + return false; + n2 = n2.nextZ; + } + return true; + } + function cureLocalIntersections(start, triangles, dim) { + var p2 = start; + do { + var a2 = p2.prev, b2 = p2.next.next; + if (!equals3(a2, b2) && intersects(a2, p2, p2.next, b2) && locallyInside(a2, b2) && locallyInside(b2, a2)) { + triangles.push(a2.i / dim | 0); + triangles.push(p2.i / dim | 0); + triangles.push(b2.i / dim | 0); + removeNode(p2); + removeNode(p2.next); + p2 = start = b2; + } + p2 = p2.next; + } while (p2 !== start); + return filterPoints(p2); + } + function splitEarcut(start, triangles, dim, minX, minY, invSize) { + var a2 = start; + do { + var b2 = a2.next.next; + while (b2 !== a2.prev) { + if (a2.i !== b2.i && isValidDiagonal(a2, b2)) { + var c2 = splitPolygon(a2, b2); + a2 = filterPoints(a2, a2.next); + c2 = filterPoints(c2, c2.next); + earcutLinked(a2, triangles, dim, minX, minY, invSize, 0); + earcutLinked(c2, triangles, dim, minX, minY, invSize, 0); + return; + } + b2 = b2.next; + } + a2 = a2.next; + } while (a2 !== start); + } + function eliminateHoles(data, holeIndices, outerNode, dim) { + var queue = [], i3, len2, start, end, list; + for (i3 = 0, len2 = holeIndices.length; i3 < len2; i3++) { + start = holeIndices[i3] * dim; + end = i3 < len2 - 1 ? holeIndices[i3 + 1] * dim : data.length; + list = linkedList(data, start, end, dim, false); + if (list === list.next) + list.steiner = true; + queue.push(getLeftmost(list)); + } + queue.sort(compareX); + for (i3 = 0; i3 < queue.length; i3++) { + outerNode = eliminateHole(queue[i3], outerNode); + } + return outerNode; + } + function compareX(a2, b2) { + return a2.x - b2.x; + } + function eliminateHole(hole, outerNode) { + var bridge = findHoleBridge(hole, outerNode); + if (!bridge) { + return outerNode; + } + var bridgeReverse = splitPolygon(bridge, hole); + filterPoints(bridgeReverse, bridgeReverse.next); + return filterPoints(bridge, bridge.next); + } + function findHoleBridge(hole, outerNode) { + var p2 = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m; + do { + if (hy <= p2.y && hy >= p2.next.y && p2.next.y !== p2.y) { + var x2 = p2.x + (hy - p2.y) * (p2.next.x - p2.x) / (p2.next.y - p2.y); + if (x2 <= hx && x2 > qx) { + qx = x2; + m = p2.x < p2.next.x ? p2 : p2.next; + if (x2 === hx) + return m; + } + } + p2 = p2.next; + } while (p2 !== outerNode); + if (!m) + return null; + var stop = m, mx = m.x, my = m.y, tanMin = Infinity, tan2; + p2 = m; + do { + if (hx >= p2.x && p2.x >= mx && hx !== p2.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p2.x, p2.y)) { + tan2 = Math.abs(hy - p2.y) / (hx - p2.x); + if (locallyInside(p2, hole) && (tan2 < tanMin || tan2 === tanMin && (p2.x > m.x || p2.x === m.x && sectorContainsSector(m, p2)))) { + m = p2; + tanMin = tan2; + } + } + p2 = p2.next; + } while (p2 !== stop); + return m; + } + function sectorContainsSector(m, p2) { + return area(m.prev, m, p2.prev) < 0 && area(p2.next, m, m.next) < 0; + } + function indexCurve(start, minX, minY, invSize) { + var p2 = start; + do { + if (p2.z === 0) + p2.z = zOrder(p2.x, p2.y, minX, minY, invSize); + p2.prevZ = p2.prev; + p2.nextZ = p2.next; + p2 = p2.next; + } while (p2 !== start); + p2.prevZ.nextZ = null; + p2.prevZ = null; + sortLinked(p2); + } + function sortLinked(list) { + var i3, p2, q, e2, tail, numMerges, pSize, qSize, inSize = 1; + do { + p2 = list; + list = null; + tail = null; + numMerges = 0; + while (p2) { + numMerges++; + q = p2; + pSize = 0; + for (i3 = 0; i3 < inSize; i3++) { + pSize++; + q = q.nextZ; + if (!q) + break; + } + qSize = inSize; + while (pSize > 0 || qSize > 0 && q) { + if (pSize !== 0 && (qSize === 0 || !q || p2.z <= q.z)) { + e2 = p2; + p2 = p2.nextZ; + pSize--; + } else { + e2 = q; + q = q.nextZ; + qSize--; + } + if (tail) + tail.nextZ = e2; + else + list = e2; + e2.prevZ = tail; + tail = e2; + } + p2 = q; + } + tail.nextZ = null; + inSize *= 2; + } while (numMerges > 1); + return list; + } + function zOrder(x2, y2, minX, minY, invSize) { + x2 = (x2 - minX) * invSize | 0; + y2 = (y2 - minY) * invSize | 0; + x2 = (x2 | x2 << 8) & 16711935; + x2 = (x2 | x2 << 4) & 252645135; + x2 = (x2 | x2 << 2) & 858993459; + x2 = (x2 | x2 << 1) & 1431655765; + y2 = (y2 | y2 << 8) & 16711935; + y2 = (y2 | y2 << 4) & 252645135; + y2 = (y2 | y2 << 2) & 858993459; + y2 = (y2 | y2 << 1) & 1431655765; + return x2 | y2 << 1; + } + function getLeftmost(start) { + var p2 = start, leftmost = start; + do { + if (p2.x < leftmost.x || p2.x === leftmost.x && p2.y < leftmost.y) + leftmost = p2; + p2 = p2.next; + } while (p2 !== start); + return leftmost; + } + function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) { + return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py); + } + function isValidDiagonal(a2, b2) { + return a2.next.i !== b2.i && a2.prev.i !== b2.i && !intersectsPolygon(a2, b2) && // dones't intersect other edges + (locallyInside(a2, b2) && locallyInside(b2, a2) && middleInside(a2, b2) && // locally visible + (area(a2.prev, a2, b2.prev) || area(a2, b2.prev, b2)) || // does not create opposite-facing sectors + equals3(a2, b2) && area(a2.prev, a2, a2.next) > 0 && area(b2.prev, b2, b2.next) > 0); + } + function area(p2, q, r2) { + return (q.y - p2.y) * (r2.x - q.x) - (q.x - p2.x) * (r2.y - q.y); + } + function equals3(p1, p2) { + return p1.x === p2.x && p1.y === p2.y; + } + function intersects(p1, q1, p2, q2) { + var o1 = sign(area(p1, q1, p2)); + var o22 = sign(area(p1, q1, q2)); + var o3 = sign(area(p2, q2, p1)); + var o4 = sign(area(p2, q2, q1)); + if (o1 !== o22 && o3 !== o4) + return true; + if (o1 === 0 && onSegment(p1, p2, q1)) + return true; + if (o22 === 0 && onSegment(p1, q2, q1)) + return true; + if (o3 === 0 && onSegment(p2, p1, q2)) + return true; + if (o4 === 0 && onSegment(p2, q1, q2)) + return true; + return false; + } + function onSegment(p2, q, r2) { + return q.x <= Math.max(p2.x, r2.x) && q.x >= Math.min(p2.x, r2.x) && q.y <= Math.max(p2.y, r2.y) && q.y >= Math.min(p2.y, r2.y); + } + function sign(num) { + return num > 0 ? 1 : num < 0 ? -1 : 0; + } + function intersectsPolygon(a2, b2) { + var p2 = a2; + do { + if (p2.i !== a2.i && p2.next.i !== a2.i && p2.i !== b2.i && p2.next.i !== b2.i && intersects(p2, p2.next, a2, b2)) + return true; + p2 = p2.next; + } while (p2 !== a2); + return false; + } + function locallyInside(a2, b2) { + return area(a2.prev, a2, a2.next) < 0 ? area(a2, b2, a2.next) >= 0 && area(a2, a2.prev, b2) >= 0 : area(a2, b2, a2.prev) < 0 || area(a2, a2.next, b2) < 0; + } + function middleInside(a2, b2) { + var p2 = a2, inside = false, px = (a2.x + b2.x) / 2, py = (a2.y + b2.y) / 2; + do { + if (p2.y > py !== p2.next.y > py && p2.next.y !== p2.y && px < (p2.next.x - p2.x) * (py - p2.y) / (p2.next.y - p2.y) + p2.x) + inside = !inside; + p2 = p2.next; + } while (p2 !== a2); + return inside; + } + function splitPolygon(a2, b2) { + var a22 = new Node(a2.i, a2.x, a2.y), b22 = new Node(b2.i, b2.x, b2.y), an = a2.next, bp = b2.prev; + a2.next = b2; + b2.prev = a2; + a22.next = an; + an.prev = a22; + b22.next = a22; + a22.prev = b22; + bp.next = b22; + b22.prev = bp; + return b22; + } + function insertNode(i3, x2, y2, last) { + var p2 = new Node(i3, x2, y2); + if (!last) { + p2.prev = p2; + p2.next = p2; + } else { + p2.next = last.next; + p2.prev = last; + last.next.prev = p2; + last.next = p2; + } + return p2; + } + function removeNode(p2) { + p2.next.prev = p2.prev; + p2.prev.next = p2.next; + if (p2.prevZ) + p2.prevZ.nextZ = p2.nextZ; + if (p2.nextZ) + p2.nextZ.prevZ = p2.prevZ; + } + function Node(i3, x2, y2) { + this.i = i3; + this.x = x2; + this.y = y2; + this.prev = null; + this.next = null; + this.z = 0; + this.prevZ = null; + this.nextZ = null; + this.steiner = false; + } + earcut3.deviation = function(data, holeIndices, dim, triangles) { + var hasHoles = holeIndices && holeIndices.length; + var outerLen = hasHoles ? holeIndices[0] * dim : data.length; + var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim)); + if (hasHoles) { + for (var i3 = 0, len2 = holeIndices.length; i3 < len2; i3++) { + var start = holeIndices[i3] * dim; + var end = i3 < len2 - 1 ? holeIndices[i3 + 1] * dim : data.length; + polygonArea -= Math.abs(signedArea(data, start, end, dim)); + } + } + var trianglesArea = 0; + for (i3 = 0; i3 < triangles.length; i3 += 3) { + var a2 = triangles[i3] * dim; + var b2 = triangles[i3 + 1] * dim; + var c2 = triangles[i3 + 2] * dim; + trianglesArea += Math.abs( + (data[a2] - data[c2]) * (data[b2 + 1] - data[a2 + 1]) - (data[a2] - data[b2]) * (data[c2 + 1] - data[a2 + 1]) + ); + } + return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea); + }; + function signedArea(data, start, end, dim) { + var sum = 0; + for (var i3 = start, j = end - dim; i3 < end; i3 += dim) { + sum += (data[j] - data[i3]) * (data[i3 + 1] + data[j + 1]); + j = i3; + } + return sum; + } + earcut3.flatten = function(data) { + var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0; + for (var i3 = 0; i3 < data.length; i3++) { + for (var j = 0; j < data[i3].length; j++) { + for (var d2 = 0; d2 < dim; d2++) + result.vertices.push(data[i3][j][d2]); + } + if (i3 > 0) { + holeIndex += data[i3 - 1].length; + result.holes.push(holeIndex); + } + } + return result; + }; + } + }); + // node_modules/colorbrewer/colorbrewer.js var require_colorbrewer = __commonJS({ "node_modules/colorbrewer/colorbrewer.js"(exports, module) { @@ -4006,8 +4475,8 @@ for (var r2 in colorbrewer) { var ramps = colorbrewer[r2]; var augmentedRamps = {}; - for (var i2 in ramps) { - augmentedRamps[i2] = ramps[i2]; + for (var i3 in ramps) { + augmentedRamps[i3] = ramps[i3]; } if (r2 in colorbrewer_tags) { augmentedRamps.tags = colorbrewer_tags[r2].tags; @@ -4032,1421 +4501,9392 @@ } }); - // node_modules/papaparse/papaparse.min.js - var require_papaparse_min = __commonJS({ - "node_modules/papaparse/papaparse.min.js"(exports, module) { - !function(e2, t2) { - "function" == typeof define && define.amd ? define([], t2) : "object" == typeof module && "undefined" != typeof exports ? module.exports = t2() : e2.Papa = t2(); - }(exports, function s() { - "use strict"; - var f2 = "undefined" != typeof self ? self : "undefined" != typeof window ? window : void 0 !== f2 ? f2 : {}; - var n2 = !f2.document && !!f2.postMessage, o2 = f2.IS_PAPA_WORKER || false, a2 = {}, u2 = 0, b2 = { parse: function(e2, t2) { - var r3 = (t2 = t2 || {}).dynamicTyping || false; - J(r3) && (t2.dynamicTypingFunction = r3, r3 = {}); - if (t2.dynamicTyping = r3, t2.transform = !!J(t2.transform) && t2.transform, t2.worker && b2.WORKERS_SUPPORTED) { - var i2 = function() { - if (!b2.WORKERS_SUPPORTED) - return false; - var e3 = (r4 = f2.URL || f2.webkitURL || null, i3 = s.toString(), b2.BLOB_URL || (b2.BLOB_URL = r4.createObjectURL(new Blob(["var global = (function() { if (typeof self !== 'undefined') { return self; } if (typeof window !== 'undefined') { return window; } if (typeof global !== 'undefined') { return global; } return {}; })(); global.IS_PAPA_WORKER=true; ", "(", i3, ")();"], { type: "text/javascript" })))), t3 = new f2.Worker(e3); - var r4, i3; - return t3.onmessage = _2, t3.id = u2++, a2[t3.id] = t3; - }(); - return i2.userStep = t2.step, i2.userChunk = t2.chunk, i2.userComplete = t2.complete, i2.userError = t2.error, t2.step = J(t2.step), t2.chunk = J(t2.chunk), t2.complete = J(t2.complete), t2.error = J(t2.error), delete t2.worker, void i2.postMessage({ input: e2, config: t2, workerId: i2.id }); + // node_modules/geotiff/dist-module/globals.js + var fieldTagNames, fieldTags, arrayFields, fieldTypeNames, fieldTypes, LercParameters, LercAddCompression, geoKeyNames, geoKeys; + var init_globals = __esm({ + "node_modules/geotiff/dist-module/globals.js"() { + fieldTagNames = { + // TIFF Baseline + 315: "Artist", + 258: "BitsPerSample", + 265: "CellLength", + 264: "CellWidth", + 320: "ColorMap", + 259: "Compression", + 33432: "Copyright", + 306: "DateTime", + 338: "ExtraSamples", + 266: "FillOrder", + 289: "FreeByteCounts", + 288: "FreeOffsets", + 291: "GrayResponseCurve", + 290: "GrayResponseUnit", + 316: "HostComputer", + 270: "ImageDescription", + 257: "ImageLength", + 256: "ImageWidth", + 271: "Make", + 281: "MaxSampleValue", + 280: "MinSampleValue", + 272: "Model", + 254: "NewSubfileType", + 274: "Orientation", + 262: "PhotometricInterpretation", + 284: "PlanarConfiguration", + 296: "ResolutionUnit", + 278: "RowsPerStrip", + 277: "SamplesPerPixel", + 305: "Software", + 279: "StripByteCounts", + 273: "StripOffsets", + 255: "SubfileType", + 263: "Threshholding", + 282: "XResolution", + 283: "YResolution", + // TIFF Extended + 326: "BadFaxLines", + 327: "CleanFaxData", + 343: "ClipPath", + 328: "ConsecutiveBadFaxLines", + 433: "Decode", + 434: "DefaultImageColor", + 269: "DocumentName", + 336: "DotRange", + 321: "HalftoneHints", + 346: "Indexed", + 347: "JPEGTables", + 285: "PageName", + 297: "PageNumber", + 317: "Predictor", + 319: "PrimaryChromaticities", + 532: "ReferenceBlackWhite", + 339: "SampleFormat", + 340: "SMinSampleValue", + 341: "SMaxSampleValue", + 559: "StripRowCounts", + 330: "SubIFDs", + 292: "T4Options", + 293: "T6Options", + 325: "TileByteCounts", + 323: "TileLength", + 324: "TileOffsets", + 322: "TileWidth", + 301: "TransferFunction", + 318: "WhitePoint", + 344: "XClipPathUnits", + 286: "XPosition", + 529: "YCbCrCoefficients", + 531: "YCbCrPositioning", + 530: "YCbCrSubSampling", + 345: "YClipPathUnits", + 287: "YPosition", + // EXIF + 37378: "ApertureValue", + 40961: "ColorSpace", + 36868: "DateTimeDigitized", + 36867: "DateTimeOriginal", + 34665: "Exif IFD", + 36864: "ExifVersion", + 33434: "ExposureTime", + 41728: "FileSource", + 37385: "Flash", + 40960: "FlashpixVersion", + 33437: "FNumber", + 42016: "ImageUniqueID", + 37384: "LightSource", + 37500: "MakerNote", + 37377: "ShutterSpeedValue", + 37510: "UserComment", + // IPTC + 33723: "IPTC", + // ICC + 34675: "ICC Profile", + // XMP + 700: "XMP", + // GDAL + 42112: "GDAL_METADATA", + 42113: "GDAL_NODATA", + // Photoshop + 34377: "Photoshop", + // GeoTiff + 33550: "ModelPixelScale", + 33922: "ModelTiepoint", + 34264: "ModelTransformation", + 34735: "GeoKeyDirectory", + 34736: "GeoDoubleParams", + 34737: "GeoAsciiParams", + // LERC + 50674: "LercParameters" + }; + fieldTags = {}; + for (const key in fieldTagNames) { + if (fieldTagNames.hasOwnProperty(key)) { + fieldTags[fieldTagNames[key]] = parseInt(key, 10); + } + } + arrayFields = [ + fieldTags.BitsPerSample, + fieldTags.ExtraSamples, + fieldTags.SampleFormat, + fieldTags.StripByteCounts, + fieldTags.StripOffsets, + fieldTags.StripRowCounts, + fieldTags.TileByteCounts, + fieldTags.TileOffsets, + fieldTags.SubIFDs + ]; + fieldTypeNames = { + 1: "BYTE", + 2: "ASCII", + 3: "SHORT", + 4: "LONG", + 5: "RATIONAL", + 6: "SBYTE", + 7: "UNDEFINED", + 8: "SSHORT", + 9: "SLONG", + 10: "SRATIONAL", + 11: "FLOAT", + 12: "DOUBLE", + // IFD offset, suggested by https://owl.phy.queensu.ca/~phil/exiftool/standards.html + 13: "IFD", + // introduced by BigTIFF + 16: "LONG8", + 17: "SLONG8", + 18: "IFD8" + }; + fieldTypes = {}; + for (const key in fieldTypeNames) { + if (fieldTypeNames.hasOwnProperty(key)) { + fieldTypes[fieldTypeNames[key]] = parseInt(key, 10); + } + } + LercParameters = { + Version: 0, + AddCompression: 1 + }; + LercAddCompression = { + None: 0, + Deflate: 1, + Zstandard: 2 + }; + geoKeyNames = { + 1024: "GTModelTypeGeoKey", + 1025: "GTRasterTypeGeoKey", + 1026: "GTCitationGeoKey", + 2048: "GeographicTypeGeoKey", + 2049: "GeogCitationGeoKey", + 2050: "GeogGeodeticDatumGeoKey", + 2051: "GeogPrimeMeridianGeoKey", + 2052: "GeogLinearUnitsGeoKey", + 2053: "GeogLinearUnitSizeGeoKey", + 2054: "GeogAngularUnitsGeoKey", + 2055: "GeogAngularUnitSizeGeoKey", + 2056: "GeogEllipsoidGeoKey", + 2057: "GeogSemiMajorAxisGeoKey", + 2058: "GeogSemiMinorAxisGeoKey", + 2059: "GeogInvFlatteningGeoKey", + 2060: "GeogAzimuthUnitsGeoKey", + 2061: "GeogPrimeMeridianLongGeoKey", + 2062: "GeogTOWGS84GeoKey", + 3072: "ProjectedCSTypeGeoKey", + 3073: "PCSCitationGeoKey", + 3074: "ProjectionGeoKey", + 3075: "ProjCoordTransGeoKey", + 3076: "ProjLinearUnitsGeoKey", + 3077: "ProjLinearUnitSizeGeoKey", + 3078: "ProjStdParallel1GeoKey", + 3079: "ProjStdParallel2GeoKey", + 3080: "ProjNatOriginLongGeoKey", + 3081: "ProjNatOriginLatGeoKey", + 3082: "ProjFalseEastingGeoKey", + 3083: "ProjFalseNorthingGeoKey", + 3084: "ProjFalseOriginLongGeoKey", + 3085: "ProjFalseOriginLatGeoKey", + 3086: "ProjFalseOriginEastingGeoKey", + 3087: "ProjFalseOriginNorthingGeoKey", + 3088: "ProjCenterLongGeoKey", + 3089: "ProjCenterLatGeoKey", + 3090: "ProjCenterEastingGeoKey", + 3091: "ProjCenterNorthingGeoKey", + 3092: "ProjScaleAtNatOriginGeoKey", + 3093: "ProjScaleAtCenterGeoKey", + 3094: "ProjAzimuthAngleGeoKey", + 3095: "ProjStraightVertPoleLongGeoKey", + 3096: "ProjRectifiedGridAngleGeoKey", + 4096: "VerticalCSTypeGeoKey", + 4097: "VerticalCitationGeoKey", + 4098: "VerticalDatumGeoKey", + 4099: "VerticalUnitsGeoKey" + }; + geoKeys = {}; + for (const key in geoKeyNames) { + if (geoKeyNames.hasOwnProperty(key)) { + geoKeys[geoKeyNames[key]] = parseInt(key, 10); + } + } + } + }); + + // node_modules/geotiff/dist-module/predictor.js + function decodeRowAcc(row, stride) { + let length4 = row.length - stride; + let offset = 0; + do { + for (let i3 = stride; i3 > 0; i3--) { + row[offset + stride] += row[offset]; + offset++; + } + length4 -= stride; + } while (length4 > 0); + } + function decodeRowFloatingPoint(row, stride, bytesPerSample) { + let index = 0; + let count2 = row.length; + const wc = count2 / bytesPerSample; + while (count2 > stride) { + for (let i3 = stride; i3 > 0; --i3) { + row[index + stride] += row[index]; + ++index; + } + count2 -= stride; + } + const copy3 = row.slice(); + for (let i3 = 0; i3 < wc; ++i3) { + for (let b2 = 0; b2 < bytesPerSample; ++b2) { + row[bytesPerSample * i3 + b2] = copy3[(bytesPerSample - b2 - 1) * wc + i3]; + } + } + } + function applyPredictor(block, predictor, width, height, bitsPerSample, planarConfiguration) { + if (!predictor || predictor === 1) { + return block; + } + for (let i3 = 0; i3 < bitsPerSample.length; ++i3) { + if (bitsPerSample[i3] % 8 !== 0) { + throw new Error("When decoding with predictor, only multiple of 8 bits are supported."); + } + if (bitsPerSample[i3] !== bitsPerSample[0]) { + throw new Error("When decoding with predictor, all samples must have the same size."); + } + } + const bytesPerSample = bitsPerSample[0] / 8; + const stride = planarConfiguration === 2 ? 1 : bitsPerSample.length; + for (let i3 = 0; i3 < height; ++i3) { + if (i3 * stride * width * bytesPerSample >= block.byteLength) { + break; + } + let row; + if (predictor === 2) { + switch (bitsPerSample[0]) { + case 8: + row = new Uint8Array( + block, + i3 * stride * width * bytesPerSample, + stride * width * bytesPerSample + ); + break; + case 16: + row = new Uint16Array( + block, + i3 * stride * width * bytesPerSample, + stride * width * bytesPerSample / 2 + ); + break; + case 32: + row = new Uint32Array( + block, + i3 * stride * width * bytesPerSample, + stride * width * bytesPerSample / 4 + ); + break; + default: + throw new Error(`Predictor 2 not allowed with ${bitsPerSample[0]} bits per sample.`); + } + decodeRowAcc(row, stride, bytesPerSample); + } else if (predictor === 3) { + row = new Uint8Array( + block, + i3 * stride * width * bytesPerSample, + stride * width * bytesPerSample + ); + decodeRowFloatingPoint(row, stride, bytesPerSample); + } + } + return block; + } + var init_predictor = __esm({ + "node_modules/geotiff/dist-module/predictor.js"() { + } + }); + + // node_modules/geotiff/dist-module/compression/basedecoder.js + var BaseDecoder; + var init_basedecoder = __esm({ + "node_modules/geotiff/dist-module/compression/basedecoder.js"() { + init_predictor(); + BaseDecoder = class { + async decode(fileDirectory, buffer) { + const decoded = await this.decodeBlock(buffer); + const predictor = fileDirectory.Predictor || 1; + if (predictor !== 1) { + const isTiled = !fileDirectory.StripOffsets; + const tileWidth = isTiled ? fileDirectory.TileWidth : fileDirectory.ImageWidth; + const tileHeight = isTiled ? fileDirectory.TileLength : fileDirectory.RowsPerStrip || fileDirectory.ImageLength; + return applyPredictor( + decoded, + predictor, + tileWidth, + tileHeight, + fileDirectory.BitsPerSample, + fileDirectory.PlanarConfiguration + ); } - var n3 = null; - b2.NODE_STREAM_INPUT, "string" == typeof e2 ? (e2 = function(e3) { - if (65279 === e3.charCodeAt(0)) - return e3.slice(1); - return e3; - }(e2), n3 = t2.download ? new l2(t2) : new p2(t2)) : true === e2.readable && J(e2.read) && J(e2.on) ? n3 = new g2(t2) : (f2.File && e2 instanceof File || e2 instanceof Object) && (n3 = new c2(t2)); - return n3.stream(e2); - }, unparse: function(e2, t2) { - var n3 = false, _3 = true, m2 = ",", y3 = "\r\n", s2 = '"', a3 = s2 + s2, r3 = false, i2 = null, o3 = false; - !function() { - if ("object" != typeof t2) - return; - "string" != typeof t2.delimiter || b2.BAD_DELIMITERS.filter(function(e3) { - return -1 !== t2.delimiter.indexOf(e3); - }).length || (m2 = t2.delimiter); - ("boolean" == typeof t2.quotes || "function" == typeof t2.quotes || Array.isArray(t2.quotes)) && (n3 = t2.quotes); - "boolean" != typeof t2.skipEmptyLines && "string" != typeof t2.skipEmptyLines || (r3 = t2.skipEmptyLines); - "string" == typeof t2.newline && (y3 = t2.newline); - "string" == typeof t2.quoteChar && (s2 = t2.quoteChar); - "boolean" == typeof t2.header && (_3 = t2.header); - if (Array.isArray(t2.columns)) { - if (0 === t2.columns.length) - throw new Error("Option columns is empty"); - i2 = t2.columns; - } - void 0 !== t2.escapeChar && (a3 = t2.escapeChar + s2); - ("boolean" == typeof t2.escapeFormulae || t2.escapeFormulae instanceof RegExp) && (o3 = t2.escapeFormulae instanceof RegExp ? t2.escapeFormulae : /^[=+\-@\t\r].*$/); - }(); - var u3 = new RegExp(Q(s2), "g"); - "string" == typeof e2 && (e2 = JSON.parse(e2)); - if (Array.isArray(e2)) { - if (!e2.length || Array.isArray(e2[0])) - return h2(null, e2, r3); - if ("object" == typeof e2[0]) - return h2(i2 || Object.keys(e2[0]), e2, r3); - } else if ("object" == typeof e2) - return "string" == typeof e2.data && (e2.data = JSON.parse(e2.data)), Array.isArray(e2.data) && (e2.fields || (e2.fields = e2.meta && e2.meta.fields || i2), e2.fields || (e2.fields = Array.isArray(e2.data[0]) ? e2.fields : "object" == typeof e2.data[0] ? Object.keys(e2.data[0]) : []), Array.isArray(e2.data[0]) || "object" == typeof e2.data[0] || (e2.data = [e2.data])), h2(e2.fields || [], e2.data || [], r3); - throw new Error("Unable to serialize unrecognized input"); - function h2(e3, t3, r4) { - var i3 = ""; - "string" == typeof e3 && (e3 = JSON.parse(e3)), "string" == typeof t3 && (t3 = JSON.parse(t3)); - var n4 = Array.isArray(e3) && 0 < e3.length, s3 = !Array.isArray(t3[0]); - if (n4 && _3) { - for (var a4 = 0; a4 < e3.length; a4++) - 0 < a4 && (i3 += m2), i3 += v3(e3[a4], a4); - 0 < t3.length && (i3 += y3); - } - for (var o4 = 0; o4 < t3.length; o4++) { - var u4 = n4 ? e3.length : t3[o4].length, h3 = false, f3 = n4 ? 0 === Object.keys(t3[o4]).length : 0 === t3[o4].length; - if (r4 && !n4 && (h3 = "greedy" === r4 ? "" === t3[o4].join("").trim() : 1 === t3[o4].length && 0 === t3[o4][0].length), "greedy" === r4 && n4) { - for (var d3 = [], l3 = 0; l3 < u4; l3++) { - var c3 = s3 ? e3[l3] : l3; - d3.push(t3[o4][c3]); - } - h3 = "" === d3.join("").trim(); + return decoded; + } + }; + } + }); + + // node_modules/geotiff/dist-module/compression/raw.js + var raw_exports = {}; + __export(raw_exports, { + default: () => RawDecoder + }); + var RawDecoder; + var init_raw = __esm({ + "node_modules/geotiff/dist-module/compression/raw.js"() { + init_basedecoder(); + RawDecoder = class extends BaseDecoder { + decodeBlock(buffer) { + return buffer; + } + }; + } + }); + + // node_modules/geotiff/dist-module/compression/lzw.js + var lzw_exports = {}; + __export(lzw_exports, { + default: () => LZWDecoder + }); + function getByte(array, position, length4) { + const d2 = position % 8; + const a2 = Math.floor(position / 8); + const de = 8 - d2; + const ef = position + length4 - (a2 + 1) * 8; + let fg = 8 * (a2 + 2) - (position + length4); + const dg = (a2 + 2) * 8 - position; + fg = Math.max(0, fg); + if (a2 >= array.length) { + console.warn("ran off the end of the buffer before finding EOI_CODE (end on input code)"); + return EOI_CODE; + } + let chunk1 = array[a2] & 2 ** (8 - d2) - 1; + chunk1 <<= length4 - de; + let chunks = chunk1; + if (a2 + 1 < array.length) { + let chunk2 = array[a2 + 1] >>> fg; + chunk2 <<= Math.max(0, length4 - dg); + chunks += chunk2; + } + if (ef > 8 && a2 + 2 < array.length) { + const hi = (a2 + 3) * 8 - (position + length4); + const chunk3 = array[a2 + 2] >>> hi; + chunks += chunk3; + } + return chunks; + } + function appendReversed(dest, source) { + for (let i3 = source.length - 1; i3 >= 0; i3--) { + dest.push(source[i3]); + } + return dest; + } + function decompress(input) { + const dictionaryIndex = new Uint16Array(4093); + const dictionaryChar = new Uint8Array(4093); + for (let i3 = 0; i3 <= 257; i3++) { + dictionaryIndex[i3] = 4096; + dictionaryChar[i3] = i3; + } + let dictionaryLength = 258; + let byteLength = MIN_BITS; + let position = 0; + function initDictionary() { + dictionaryLength = 258; + byteLength = MIN_BITS; + } + function getNext(array2) { + const byte = getByte(array2, position, byteLength); + position += byteLength; + return byte; + } + function addToDictionary(i3, c2) { + dictionaryChar[dictionaryLength] = c2; + dictionaryIndex[dictionaryLength] = i3; + dictionaryLength++; + return dictionaryLength - 1; + } + function getDictionaryReversed(n2) { + const rev = []; + for (let i3 = n2; i3 !== 4096; i3 = dictionaryIndex[i3]) { + rev.push(dictionaryChar[i3]); + } + return rev; + } + const result = []; + initDictionary(); + const array = new Uint8Array(input); + let code = getNext(array); + let oldCode; + while (code !== EOI_CODE) { + if (code === CLEAR_CODE) { + initDictionary(); + code = getNext(array); + while (code === CLEAR_CODE) { + code = getNext(array); + } + if (code === EOI_CODE) { + break; + } else if (code > CLEAR_CODE) { + throw new Error(`corrupted code at scanline ${code}`); + } else { + const val = getDictionaryReversed(code); + appendReversed(result, val); + oldCode = code; + } + } else if (code < dictionaryLength) { + const val = getDictionaryReversed(code); + appendReversed(result, val); + addToDictionary(oldCode, val[val.length - 1]); + oldCode = code; + } else { + const oldVal = getDictionaryReversed(oldCode); + if (!oldVal) { + throw new Error(`Bogus entry. Not in dictionary, ${oldCode} / ${dictionaryLength}, position: ${position}`); + } + appendReversed(result, oldVal); + result.push(oldVal[oldVal.length - 1]); + addToDictionary(oldCode, oldVal[oldVal.length - 1]); + oldCode = code; + } + if (dictionaryLength + 1 >= 2 ** byteLength) { + if (byteLength === MAX_BYTELENGTH) { + oldCode = void 0; + } else { + byteLength++; + } + } + code = getNext(array); + } + return new Uint8Array(result); + } + var MIN_BITS, CLEAR_CODE, EOI_CODE, MAX_BYTELENGTH, LZWDecoder; + var init_lzw = __esm({ + "node_modules/geotiff/dist-module/compression/lzw.js"() { + init_basedecoder(); + MIN_BITS = 9; + CLEAR_CODE = 256; + EOI_CODE = 257; + MAX_BYTELENGTH = 12; + LZWDecoder = class extends BaseDecoder { + decodeBlock(buffer) { + return decompress(buffer, false).buffer; + } + }; + } + }); + + // node_modules/geotiff/dist-module/compression/jpeg.js + var jpeg_exports = {}; + __export(jpeg_exports, { + default: () => JpegDecoder + }); + function buildHuffmanTable(codeLengths, values) { + let k = 0; + const code = []; + let length4 = 16; + while (length4 > 0 && !codeLengths[length4 - 1]) { + --length4; + } + code.push({ children: [], index: 0 }); + let p2 = code[0]; + let q; + for (let i3 = 0; i3 < length4; i3++) { + for (let j = 0; j < codeLengths[i3]; j++) { + p2 = code.pop(); + p2.children[p2.index] = values[k]; + while (p2.index > 0) { + p2 = code.pop(); + } + p2.index++; + code.push(p2); + while (code.length <= i3) { + code.push(q = { children: [], index: 0 }); + p2.children[p2.index] = q.children; + p2 = q; + } + k++; + } + if (i3 + 1 < length4) { + code.push(q = { children: [], index: 0 }); + p2.children[p2.index] = q.children; + p2 = q; + } + } + return code[0].children; + } + function decodeScan(data, initialOffset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) { + const { mcusPerLine, progressive } = frame; + const startOffset = initialOffset; + let offset = initialOffset; + let bitsData = 0; + let bitsCount = 0; + function readBit() { + if (bitsCount > 0) { + bitsCount--; + return bitsData >> bitsCount & 1; + } + bitsData = data[offset++]; + if (bitsData === 255) { + const nextByte = data[offset++]; + if (nextByte) { + throw new Error(`unexpected marker: ${(bitsData << 8 | nextByte).toString(16)}`); + } + } + bitsCount = 7; + return bitsData >>> 7; + } + function decodeHuffman(tree) { + let node = tree; + let bit; + while ((bit = readBit()) !== null) { + node = node[bit]; + if (typeof node === "number") { + return node; + } + if (typeof node !== "object") { + throw new Error("invalid huffman sequence"); + } + } + return null; + } + function receive(initialLength) { + let length4 = initialLength; + let n3 = 0; + while (length4 > 0) { + const bit = readBit(); + if (bit === null) { + return void 0; + } + n3 = n3 << 1 | bit; + --length4; + } + return n3; + } + function receiveAndExtend(length4) { + const n3 = receive(length4); + if (n3 >= 1 << length4 - 1) { + return n3; + } + return n3 + (-1 << length4) + 1; + } + function decodeBaseline(component2, zz) { + const t2 = decodeHuffman(component2.huffmanTableDC); + const diff = t2 === 0 ? 0 : receiveAndExtend(t2); + component2.pred += diff; + zz[0] = component2.pred; + let k2 = 1; + while (k2 < 64) { + const rs = decodeHuffman(component2.huffmanTableAC); + const s = rs & 15; + const r2 = rs >> 4; + if (s === 0) { + if (r2 < 15) { + break; + } + k2 += 16; + } else { + k2 += r2; + const z = dctZigZag[k2]; + zz[z] = receiveAndExtend(s); + k2++; + } + } + } + function decodeDCFirst(component2, zz) { + const t2 = decodeHuffman(component2.huffmanTableDC); + const diff = t2 === 0 ? 0 : receiveAndExtend(t2) << successive; + component2.pred += diff; + zz[0] = component2.pred; + } + function decodeDCSuccessive(component2, zz) { + zz[0] |= readBit() << successive; + } + let eobrun = 0; + function decodeACFirst(component2, zz) { + if (eobrun > 0) { + eobrun--; + return; + } + let k2 = spectralStart; + const e2 = spectralEnd; + while (k2 <= e2) { + const rs = decodeHuffman(component2.huffmanTableAC); + const s = rs & 15; + const r2 = rs >> 4; + if (s === 0) { + if (r2 < 15) { + eobrun = receive(r2) + (1 << r2) - 1; + break; + } + k2 += 16; + } else { + k2 += r2; + const z = dctZigZag[k2]; + zz[z] = receiveAndExtend(s) * (1 << successive); + k2++; + } + } + } + let successiveACState = 0; + let successiveACNextValue; + function decodeACSuccessive(component2, zz) { + let k2 = spectralStart; + const e2 = spectralEnd; + let r2 = 0; + while (k2 <= e2) { + const z = dctZigZag[k2]; + const direction = zz[z] < 0 ? -1 : 1; + switch (successiveACState) { + case 0: { + const rs = decodeHuffman(component2.huffmanTableAC); + const s = rs & 15; + r2 = rs >> 4; + if (s === 0) { + if (r2 < 15) { + eobrun = receive(r2) + (1 << r2); + successiveACState = 4; + } else { + r2 = 16; + successiveACState = 1; } - if (!h3) { - for (var p3 = 0; p3 < u4; p3++) { - 0 < p3 && !f3 && (i3 += m2); - var g3 = n4 && s3 ? e3[p3] : p3; - i3 += v3(t3[o4][g3], p3); - } - o4 < t3.length - 1 && (!r4 || 0 < u4 && !f3) && (i3 += y3); + } else { + if (s !== 1) { + throw new Error("invalid ACn encoding"); } + successiveACNextValue = receiveAndExtend(s); + successiveACState = r2 ? 2 : 3; } - return i3; - } - function v3(e3, t3) { - if (null == e3) - return ""; - if (e3.constructor === Date) - return JSON.stringify(e3).slice(1, 25); - var r4 = false; - o3 && "string" == typeof e3 && o3.test(e3) && (e3 = "'" + e3, r4 = true); - var i3 = e3.toString().replace(u3, a3); - return (r4 = r4 || true === n3 || "function" == typeof n3 && n3(e3, t3) || Array.isArray(n3) && n3[t3] || function(e4, t4) { - for (var r5 = 0; r5 < t4.length; r5++) - if (-1 < e4.indexOf(t4[r5])) - return true; - return false; - }(i3, b2.BAD_DELIMITERS) || -1 < i3.indexOf(m2) || " " === i3.charAt(0) || " " === i3.charAt(i3.length - 1)) ? s2 + i3 + s2 : i3; + continue; } - } }; - if (b2.RECORD_SEP = String.fromCharCode(30), b2.UNIT_SEP = String.fromCharCode(31), b2.BYTE_ORDER_MARK = "\uFEFF", b2.BAD_DELIMITERS = ["\r", "\n", '"', b2.BYTE_ORDER_MARK], b2.WORKERS_SUPPORTED = !n2 && !!f2.Worker, b2.NODE_STREAM_INPUT = 1, b2.LocalChunkSize = 10485760, b2.RemoteChunkSize = 5242880, b2.DefaultDelimiter = ",", b2.Parser = E2, b2.ParserHandle = r2, b2.NetworkStreamer = l2, b2.FileStreamer = c2, b2.StringStreamer = p2, b2.ReadableStreamStreamer = g2, f2.jQuery) { - var d2 = f2.jQuery; - d2.fn.parse = function(o3) { - var r3 = o3.config || {}, u3 = []; - return this.each(function(e3) { - if (!("INPUT" === d2(this).prop("tagName").toUpperCase() && "file" === d2(this).attr("type").toLowerCase() && f2.FileReader) || !this.files || 0 === this.files.length) - return true; - for (var t2 = 0; t2 < this.files.length; t2++) - u3.push({ file: this.files[t2], inputElem: this, instanceConfig: d2.extend({}, r3) }); - }), e2(), this; - function e2() { - if (0 !== u3.length) { - var e3, t2, r4, i2, n3 = u3[0]; - if (J(o3.before)) { - var s2 = o3.before(n3.file, n3.inputElem); - if ("object" == typeof s2) { - if ("abort" === s2.action) - return e3 = "AbortError", t2 = n3.file, r4 = n3.inputElem, i2 = s2.reason, void (J(o3.error) && o3.error({ name: e3 }, t2, r4, i2)); - if ("skip" === s2.action) - return void h2(); - "object" == typeof s2.config && (n3.instanceConfig = d2.extend(n3.instanceConfig, s2.config)); - } else if ("skip" === s2) - return void h2(); - } - var a3 = n3.instanceConfig.complete; - n3.instanceConfig.complete = function(e4) { - J(a3) && a3(e4, n3.file, n3.inputElem), h2(); - }, b2.parse(n3.file, n3.instanceConfig); - } else - J(o3.complete) && o3.complete(); - } - function h2() { - u3.splice(0, 1), e2(); + case 1: + case 2: + if (zz[z]) { + zz[z] += (readBit() << successive) * direction; + } else { + r2--; + if (r2 === 0) { + successiveACState = successiveACState === 2 ? 3 : 0; + } } - }; - } - function h(e2) { - this._handle = null, this._finished = false, this._completed = false, this._halted = false, this._input = null, this._baseIndex = 0, this._partialLine = "", this._rowCount = 0, this._start = 0, this._nextChunk = null, this.isFirstChunk = true, this._completeResults = { data: [], errors: [], meta: {} }, function(e3) { - var t2 = w2(e3); - t2.chunkSize = parseInt(t2.chunkSize), e3.step || e3.chunk || (t2.chunkSize = null); - this._handle = new r2(t2), (this._handle.streamer = this)._config = t2; - }.call(this, e2), this.parseChunk = function(e3, t2) { - if (this.isFirstChunk && J(this._config.beforeFirstChunk)) { - var r3 = this._config.beforeFirstChunk(e3); - void 0 !== r3 && (e3 = r3); + break; + case 3: + if (zz[z]) { + zz[z] += (readBit() << successive) * direction; + } else { + zz[z] = successiveACNextValue << successive; + successiveACState = 0; } - this.isFirstChunk = false, this._halted = false; - var i2 = this._partialLine + e3; - this._partialLine = ""; - var n3 = this._handle.parse(i2, this._baseIndex, !this._finished); - if (!this._handle.paused() && !this._handle.aborted()) { - var s2 = n3.meta.cursor; - this._finished || (this._partialLine = i2.substring(s2 - this._baseIndex), this._baseIndex = s2), n3 && n3.data && (this._rowCount += n3.data.length); - var a3 = this._finished || this._config.preview && this._rowCount >= this._config.preview; - if (o2) - f2.postMessage({ results: n3, workerId: b2.WORKER_ID, finished: a3 }); - else if (J(this._config.chunk) && !t2) { - if (this._config.chunk(n3, this._handle), this._handle.paused() || this._handle.aborted()) - return void (this._halted = true); - n3 = void 0, this._completeResults = void 0; - } - return this._config.step || this._config.chunk || (this._completeResults.data = this._completeResults.data.concat(n3.data), this._completeResults.errors = this._completeResults.errors.concat(n3.errors), this._completeResults.meta = n3.meta), this._completed || !a3 || !J(this._config.complete) || n3 && n3.meta.aborted || (this._config.complete(this._completeResults, this._input), this._completed = true), a3 || n3 && n3.meta.paused || this._nextChunk(), n3; + break; + case 4: + if (zz[z]) { + zz[z] += (readBit() << successive) * direction; } - this._halted = true; - }, this._sendError = function(e3) { - J(this._config.error) ? this._config.error(e3) : o2 && this._config.error && f2.postMessage({ workerId: b2.WORKER_ID, error: e3, finished: false }); - }; + break; + default: + break; } - function l2(e2) { - var i2; - (e2 = e2 || {}).chunkSize || (e2.chunkSize = b2.RemoteChunkSize), h.call(this, e2), this._nextChunk = n2 ? function() { - this._readChunk(), this._chunkLoaded(); - } : function() { - this._readChunk(); - }, this.stream = function(e3) { - this._input = e3, this._nextChunk(); - }, this._readChunk = function() { - if (this._finished) - this._chunkLoaded(); - else { - if (i2 = new XMLHttpRequest(), this._config.withCredentials && (i2.withCredentials = this._config.withCredentials), n2 || (i2.onload = v2(this._chunkLoaded, this), i2.onerror = v2(this._chunkError, this)), i2.open(this._config.downloadRequestBody ? "POST" : "GET", this._input, !n2), this._config.downloadRequestHeaders) { - var e3 = this._config.downloadRequestHeaders; - for (var t2 in e3) - i2.setRequestHeader(t2, e3[t2]); - } - if (this._config.chunkSize) { - var r3 = this._start + this._config.chunkSize - 1; - i2.setRequestHeader("Range", "bytes=" + this._start + "-" + r3); - } - try { - i2.send(this._config.downloadRequestBody); - } catch (e4) { - this._chunkError(e4.message); + k2++; + } + if (successiveACState === 4) { + eobrun--; + if (eobrun === 0) { + successiveACState = 0; + } + } + } + function decodeMcu(component2, decodeFunction, mcu2, row, col) { + const mcuRow = mcu2 / mcusPerLine | 0; + const mcuCol = mcu2 % mcusPerLine; + const blockRow = mcuRow * component2.v + row; + const blockCol = mcuCol * component2.h + col; + decodeFunction(component2, component2.blocks[blockRow][blockCol]); + } + function decodeBlock(component2, decodeFunction, mcu2) { + const blockRow = mcu2 / component2.blocksPerLine | 0; + const blockCol = mcu2 % component2.blocksPerLine; + decodeFunction(component2, component2.blocks[blockRow][blockCol]); + } + const componentsLength = components.length; + let component; + let i3; + let j; + let k; + let n2; + let decodeFn; + if (progressive) { + if (spectralStart === 0) { + decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; + } else { + decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; + } + } else { + decodeFn = decodeBaseline; + } + let mcu = 0; + let marker; + let mcuExpected; + if (componentsLength === 1) { + mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn; + } else { + mcuExpected = mcusPerLine * frame.mcusPerColumn; + } + const usedResetInterval = resetInterval || mcuExpected; + while (mcu < mcuExpected) { + for (i3 = 0; i3 < componentsLength; i3++) { + components[i3].pred = 0; + } + eobrun = 0; + if (componentsLength === 1) { + component = components[0]; + for (n2 = 0; n2 < usedResetInterval; n2++) { + decodeBlock(component, decodeFn, mcu); + mcu++; + } + } else { + for (n2 = 0; n2 < usedResetInterval; n2++) { + for (i3 = 0; i3 < componentsLength; i3++) { + component = components[i3]; + const { h, v: v2 } = component; + for (j = 0; j < v2; j++) { + for (k = 0; k < h; k++) { + decodeMcu(component, decodeFn, mcu, j, k); } - n2 && 0 === i2.status && this._chunkError(); } - }, this._chunkLoaded = function() { - 4 === i2.readyState && (i2.status < 200 || 400 <= i2.status ? this._chunkError() : (this._start += this._config.chunkSize ? this._config.chunkSize : i2.responseText.length, this._finished = !this._config.chunkSize || this._start >= function(e3) { - var t2 = e3.getResponseHeader("Content-Range"); - if (null === t2) - return -1; - return parseInt(t2.substring(t2.lastIndexOf("/") + 1)); - }(i2), this.parseChunk(i2.responseText))); - }, this._chunkError = function(e3) { - var t2 = i2.statusText || e3; - this._sendError(new Error(t2)); - }; + } + mcu++; + if (mcu === mcuExpected) { + break; + } } - function c2(e2) { - var i2, n3; - (e2 = e2 || {}).chunkSize || (e2.chunkSize = b2.LocalChunkSize), h.call(this, e2); - var s2 = "undefined" != typeof FileReader; - this.stream = function(e3) { - this._input = e3, n3 = e3.slice || e3.webkitSlice || e3.mozSlice, s2 ? ((i2 = new FileReader()).onload = v2(this._chunkLoaded, this), i2.onerror = v2(this._chunkError, this)) : i2 = new FileReaderSync(), this._nextChunk(); - }, this._nextChunk = function() { - this._finished || this._config.preview && !(this._rowCount < this._config.preview) || this._readChunk(); - }, this._readChunk = function() { - var e3 = this._input; - if (this._config.chunkSize) { - var t2 = Math.min(this._start + this._config.chunkSize, this._input.size); - e3 = n3.call(e3, this._start, t2); - } - var r3 = i2.readAsText(e3, this._config.encoding); - s2 || this._chunkLoaded({ target: { result: r3 } }); - }, this._chunkLoaded = function(e3) { - this._start += this._config.chunkSize, this._finished = !this._config.chunkSize || this._start >= this._input.size, this.parseChunk(e3.target.result); - }, this._chunkError = function() { - this._sendError(i2.error); - }; + } + bitsCount = 0; + marker = data[offset] << 8 | data[offset + 1]; + if (marker < 65280) { + throw new Error("marker was not found"); + } + if (marker >= 65488 && marker <= 65495) { + offset += 2; + } else { + break; + } + } + return offset - startOffset; + } + function buildComponentData(frame, component) { + const lines = []; + const { blocksPerLine, blocksPerColumn } = component; + const samplesPerLine = blocksPerLine << 3; + const R = new Int32Array(64); + const r2 = new Uint8Array(64); + function quantizeAndInverse(zz, dataOut, dataIn) { + const qt = component.quantizationTable; + let v0; + let v1; + let v2; + let v3; + let v4; + let v5; + let v6; + let v7; + let t2; + const p2 = dataIn; + let i3; + for (i3 = 0; i3 < 64; i3++) { + p2[i3] = zz[i3] * qt[i3]; + } + for (i3 = 0; i3 < 8; ++i3) { + const row = 8 * i3; + if (p2[1 + row] === 0 && p2[2 + row] === 0 && p2[3 + row] === 0 && p2[4 + row] === 0 && p2[5 + row] === 0 && p2[6 + row] === 0 && p2[7 + row] === 0) { + t2 = dctSqrt2 * p2[0 + row] + 512 >> 10; + p2[0 + row] = t2; + p2[1 + row] = t2; + p2[2 + row] = t2; + p2[3 + row] = t2; + p2[4 + row] = t2; + p2[5 + row] = t2; + p2[6 + row] = t2; + p2[7 + row] = t2; + continue; } - function p2(e2) { - var r3; - h.call(this, e2 = e2 || {}), this.stream = function(e3) { - return r3 = e3, this._nextChunk(); - }, this._nextChunk = function() { - if (!this._finished) { - var e3, t2 = this._config.chunkSize; - return t2 ? (e3 = r3.substring(0, t2), r3 = r3.substring(t2)) : (e3 = r3, r3 = ""), this._finished = !r3, this.parseChunk(e3); - } - }; + v0 = dctSqrt2 * p2[0 + row] + 128 >> 8; + v1 = dctSqrt2 * p2[4 + row] + 128 >> 8; + v2 = p2[2 + row]; + v3 = p2[6 + row]; + v4 = dctSqrt1d2 * (p2[1 + row] - p2[7 + row]) + 128 >> 8; + v7 = dctSqrt1d2 * (p2[1 + row] + p2[7 + row]) + 128 >> 8; + v5 = p2[3 + row] << 4; + v6 = p2[5 + row] << 4; + t2 = v0 - v1 + 1 >> 1; + v0 = v0 + v1 + 1 >> 1; + v1 = t2; + t2 = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8; + v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8; + v3 = t2; + t2 = v4 - v6 + 1 >> 1; + v4 = v4 + v6 + 1 >> 1; + v6 = t2; + t2 = v7 + v5 + 1 >> 1; + v5 = v7 - v5 + 1 >> 1; + v7 = t2; + t2 = v0 - v3 + 1 >> 1; + v0 = v0 + v3 + 1 >> 1; + v3 = t2; + t2 = v1 - v2 + 1 >> 1; + v1 = v1 + v2 + 1 >> 1; + v2 = t2; + t2 = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12; + v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12; + v7 = t2; + t2 = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12; + v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12; + v6 = t2; + p2[0 + row] = v0 + v7; + p2[7 + row] = v0 - v7; + p2[1 + row] = v1 + v6; + p2[6 + row] = v1 - v6; + p2[2 + row] = v2 + v5; + p2[5 + row] = v2 - v5; + p2[3 + row] = v3 + v4; + p2[4 + row] = v3 - v4; + } + for (i3 = 0; i3 < 8; ++i3) { + const col = i3; + if (p2[1 * 8 + col] === 0 && p2[2 * 8 + col] === 0 && p2[3 * 8 + col] === 0 && p2[4 * 8 + col] === 0 && p2[5 * 8 + col] === 0 && p2[6 * 8 + col] === 0 && p2[7 * 8 + col] === 0) { + t2 = dctSqrt2 * dataIn[i3 + 0] + 8192 >> 14; + p2[0 * 8 + col] = t2; + p2[1 * 8 + col] = t2; + p2[2 * 8 + col] = t2; + p2[3 * 8 + col] = t2; + p2[4 * 8 + col] = t2; + p2[5 * 8 + col] = t2; + p2[6 * 8 + col] = t2; + p2[7 * 8 + col] = t2; + continue; } - function g2(e2) { - h.call(this, e2 = e2 || {}); - var t2 = [], r3 = true, i2 = false; - this.pause = function() { - h.prototype.pause.apply(this, arguments), this._input.pause(); - }, this.resume = function() { - h.prototype.resume.apply(this, arguments), this._input.resume(); - }, this.stream = function(e3) { - this._input = e3, this._input.on("data", this._streamData), this._input.on("end", this._streamEnd), this._input.on("error", this._streamError); - }, this._checkIsFinished = function() { - i2 && 1 === t2.length && (this._finished = true); - }, this._nextChunk = function() { - this._checkIsFinished(), t2.length ? this.parseChunk(t2.shift()) : r3 = true; - }, this._streamData = v2(function(e3) { - try { - t2.push("string" == typeof e3 ? e3 : e3.toString(this._config.encoding)), r3 && (r3 = false, this._checkIsFinished(), this.parseChunk(t2.shift())); - } catch (e4) { - this._streamError(e4); - } - }, this), this._streamError = v2(function(e3) { - this._streamCleanUp(), this._sendError(e3); - }, this), this._streamEnd = v2(function() { - this._streamCleanUp(), i2 = true, this._streamData(""); - }, this), this._streamCleanUp = v2(function() { - this._input.removeListener("data", this._streamData), this._input.removeListener("end", this._streamEnd), this._input.removeListener("error", this._streamError); - }, this); + v0 = dctSqrt2 * p2[0 * 8 + col] + 2048 >> 12; + v1 = dctSqrt2 * p2[4 * 8 + col] + 2048 >> 12; + v2 = p2[2 * 8 + col]; + v3 = p2[6 * 8 + col]; + v4 = dctSqrt1d2 * (p2[1 * 8 + col] - p2[7 * 8 + col]) + 2048 >> 12; + v7 = dctSqrt1d2 * (p2[1 * 8 + col] + p2[7 * 8 + col]) + 2048 >> 12; + v5 = p2[3 * 8 + col]; + v6 = p2[5 * 8 + col]; + t2 = v0 - v1 + 1 >> 1; + v0 = v0 + v1 + 1 >> 1; + v1 = t2; + t2 = v2 * dctSin6 + v3 * dctCos6 + 2048 >> 12; + v2 = v2 * dctCos6 - v3 * dctSin6 + 2048 >> 12; + v3 = t2; + t2 = v4 - v6 + 1 >> 1; + v4 = v4 + v6 + 1 >> 1; + v6 = t2; + t2 = v7 + v5 + 1 >> 1; + v5 = v7 - v5 + 1 >> 1; + v7 = t2; + t2 = v0 - v3 + 1 >> 1; + v0 = v0 + v3 + 1 >> 1; + v3 = t2; + t2 = v1 - v2 + 1 >> 1; + v1 = v1 + v2 + 1 >> 1; + v2 = t2; + t2 = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12; + v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12; + v7 = t2; + t2 = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12; + v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12; + v6 = t2; + p2[0 * 8 + col] = v0 + v7; + p2[7 * 8 + col] = v0 - v7; + p2[1 * 8 + col] = v1 + v6; + p2[6 * 8 + col] = v1 - v6; + p2[2 * 8 + col] = v2 + v5; + p2[5 * 8 + col] = v2 - v5; + p2[3 * 8 + col] = v3 + v4; + p2[4 * 8 + col] = v3 - v4; + } + for (i3 = 0; i3 < 64; ++i3) { + const sample = 128 + (p2[i3] + 8 >> 4); + if (sample < 0) { + dataOut[i3] = 0; + } else if (sample > 255) { + dataOut[i3] = 255; + } else { + dataOut[i3] = sample; } - function r2(m2) { - var a3, o3, u3, i2 = Math.pow(2, 53), n3 = -i2, s2 = /^\s*-?(\d+\.?|\.\d+|\d+\.\d+)([eE][-+]?\d+)?\s*$/, h2 = /^((\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)))$/, t2 = this, r3 = 0, f3 = 0, d3 = false, e2 = false, l3 = [], c3 = { data: [], errors: [], meta: {} }; - if (J(m2.step)) { - var p3 = m2.step; - m2.step = function(e3) { - if (c3 = e3, _3()) - g3(); - else { - if (g3(), 0 === c3.data.length) - return; - r3 += e3.data.length, m2.preview && r3 > m2.preview ? o3.abort() : (c3.data = c3.data[0], p3(c3, t2)); - } - }; + } + } + for (let blockRow = 0; blockRow < blocksPerColumn; blockRow++) { + const scanLine = blockRow << 3; + for (let i3 = 0; i3 < 8; i3++) { + lines.push(new Uint8Array(samplesPerLine)); + } + for (let blockCol = 0; blockCol < blocksPerLine; blockCol++) { + quantizeAndInverse(component.blocks[blockRow][blockCol], r2, R); + let offset = 0; + const sample = blockCol << 3; + for (let j = 0; j < 8; j++) { + const line = lines[scanLine + j]; + for (let i3 = 0; i3 < 8; i3++) { + line[sample + i3] = r2[offset++]; } - function y3(e3) { - return "greedy" === m2.skipEmptyLines ? "" === e3.join("").trim() : 1 === e3.length && 0 === e3[0].length; + } + } + } + return lines; + } + var dctZigZag, dctCos1, dctSin1, dctCos3, dctSin3, dctCos6, dctSin6, dctSqrt2, dctSqrt1d2, JpegStreamReader, JpegDecoder; + var init_jpeg = __esm({ + "node_modules/geotiff/dist-module/compression/jpeg.js"() { + init_basedecoder(); + dctZigZag = new Int32Array([ + 0, + 1, + 8, + 16, + 9, + 2, + 3, + 10, + 17, + 24, + 32, + 25, + 18, + 11, + 4, + 5, + 12, + 19, + 26, + 33, + 40, + 48, + 41, + 34, + 27, + 20, + 13, + 6, + 7, + 14, + 21, + 28, + 35, + 42, + 49, + 56, + 57, + 50, + 43, + 36, + 29, + 22, + 15, + 23, + 30, + 37, + 44, + 51, + 58, + 59, + 52, + 45, + 38, + 31, + 39, + 46, + 53, + 60, + 61, + 54, + 47, + 55, + 62, + 63 + ]); + dctCos1 = 4017; + dctSin1 = 799; + dctCos3 = 3406; + dctSin3 = 2276; + dctCos6 = 1567; + dctSin6 = 3784; + dctSqrt2 = 5793; + dctSqrt1d2 = 2896; + JpegStreamReader = class { + constructor() { + this.jfif = null; + this.adobe = null; + this.quantizationTables = []; + this.huffmanTablesAC = []; + this.huffmanTablesDC = []; + this.resetFrames(); + } + resetFrames() { + this.frames = []; + } + parse(data) { + let offset = 0; + function readUint16() { + const value = data[offset] << 8 | data[offset + 1]; + offset += 2; + return value; } - function g3() { - return c3 && u3 && (k("Delimiter", "UndetectableDelimiter", "Unable to auto-detect delimiting character; defaulted to '" + b2.DefaultDelimiter + "'"), u3 = false), m2.skipEmptyLines && (c3.data = c3.data.filter(function(e3) { - return !y3(e3); - })), _3() && function() { - if (!c3) - return; - function e3(e4, t4) { - J(m2.transformHeader) && (e4 = m2.transformHeader(e4, t4)), l3.push(e4); + function readDataBlock() { + const length4 = readUint16(); + const array = data.subarray(offset, offset + length4 - 2); + offset += array.length; + return array; + } + function prepareComponents(frame) { + let maxH = 0; + let maxV = 0; + let component; + let componentId; + for (componentId in frame.components) { + if (frame.components.hasOwnProperty(componentId)) { + component = frame.components[componentId]; + if (maxH < component.h) { + maxH = component.h; + } + if (maxV < component.v) { + maxV = component.v; + } } - if (Array.isArray(c3.data[0])) { - for (var t3 = 0; _3() && t3 < c3.data.length; t3++) - c3.data[t3].forEach(e3); - c3.data.splice(0, 1); - } else - c3.data.forEach(e3); - }(), function() { - if (!c3 || !m2.header && !m2.dynamicTyping && !m2.transform) - return c3; - function e3(e4, t4) { - var r4, i3 = m2.header ? {} : []; - for (r4 = 0; r4 < e4.length; r4++) { - var n4 = r4, s3 = e4[r4]; - m2.header && (n4 = r4 >= l3.length ? "__parsed_extra" : l3[r4]), m2.transform && (s3 = m2.transform(s3, n4)), s3 = v3(n4, s3), "__parsed_extra" === n4 ? (i3[n4] = i3[n4] || [], i3[n4].push(s3)) : i3[n4] = s3; + } + const mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH); + const mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV); + for (componentId in frame.components) { + if (frame.components.hasOwnProperty(componentId)) { + component = frame.components[componentId]; + const blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH); + const blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV); + const blocksPerLineForMcu = mcusPerLine * component.h; + const blocksPerColumnForMcu = mcusPerColumn * component.v; + const blocks = []; + for (let i3 = 0; i3 < blocksPerColumnForMcu; i3++) { + const row = []; + for (let j = 0; j < blocksPerLineForMcu; j++) { + row.push(new Int32Array(64)); + } + blocks.push(row); } - return m2.header && (r4 > l3.length ? k("FieldMismatch", "TooManyFields", "Too many fields: expected " + l3.length + " fields but parsed " + r4, f3 + t4) : r4 < l3.length && k("FieldMismatch", "TooFewFields", "Too few fields: expected " + l3.length + " fields but parsed " + r4, f3 + t4)), i3; + component.blocksPerLine = blocksPerLine; + component.blocksPerColumn = blocksPerColumn; + component.blocks = blocks; } - var t3 = 1; - !c3.data.length || Array.isArray(c3.data[0]) ? (c3.data = c3.data.map(e3), t3 = c3.data.length) : c3.data = e3(c3.data, 0); - m2.header && c3.meta && (c3.meta.fields = l3); - return f3 += t3, c3; - }(); + } + frame.maxH = maxH; + frame.maxV = maxV; + frame.mcusPerLine = mcusPerLine; + frame.mcusPerColumn = mcusPerColumn; } - function _3() { - return m2.header && 0 === l3.length; + let fileMarker = readUint16(); + if (fileMarker !== 65496) { + throw new Error("SOI not found"); } - function v3(e3, t3) { - return r4 = e3, m2.dynamicTypingFunction && void 0 === m2.dynamicTyping[r4] && (m2.dynamicTyping[r4] = m2.dynamicTypingFunction(r4)), true === (m2.dynamicTyping[r4] || m2.dynamicTyping) ? "true" === t3 || "TRUE" === t3 || "false" !== t3 && "FALSE" !== t3 && (function(e4) { - if (s2.test(e4)) { - var t4 = parseFloat(e4); - if (n3 < t4 && t4 < i2) - return true; + fileMarker = readUint16(); + while (fileMarker !== 65497) { + switch (fileMarker) { + case 65280: + break; + case 65504: + case 65505: + case 65506: + case 65507: + case 65508: + case 65509: + case 65510: + case 65511: + case 65512: + case 65513: + case 65514: + case 65515: + case 65516: + case 65517: + case 65518: + case 65519: + case 65534: { + const appData = readDataBlock(); + if (fileMarker === 65504) { + if (appData[0] === 74 && appData[1] === 70 && appData[2] === 73 && appData[3] === 70 && appData[4] === 0) { + this.jfif = { + version: { major: appData[5], minor: appData[6] }, + densityUnits: appData[7], + xDensity: appData[8] << 8 | appData[9], + yDensity: appData[10] << 8 | appData[11], + thumbWidth: appData[12], + thumbHeight: appData[13], + thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13]) + }; + } + } + if (fileMarker === 65518) { + if (appData[0] === 65 && appData[1] === 100 && appData[2] === 111 && appData[3] === 98 && appData[4] === 101 && appData[5] === 0) { + this.adobe = { + version: appData[6], + flags0: appData[7] << 8 | appData[8], + flags1: appData[9] << 8 | appData[10], + transformCode: appData[11] + }; + } + } + break; } - return false; - }(t3) ? parseFloat(t3) : h2.test(t3) ? new Date(t3) : "" === t3 ? null : t3) : t3; - var r4; - } - function k(e3, t3, r4, i3) { - var n4 = { type: e3, code: t3, message: r4 }; - void 0 !== i3 && (n4.row = i3), c3.errors.push(n4); - } - this.parse = function(e3, t3, r4) { - var i3 = m2.quoteChar || '"'; - if (m2.newline || (m2.newline = function(e4, t4) { - e4 = e4.substring(0, 1048576); - var r5 = new RegExp(Q(t4) + "([^]*?)" + Q(t4), "gm"), i4 = (e4 = e4.replace(r5, "")).split("\r"), n5 = e4.split("\n"), s4 = 1 < n5.length && n5[0].length < i4[0].length; - if (1 === i4.length || s4) - return "\n"; - for (var a4 = 0, o4 = 0; o4 < i4.length; o4++) - "\n" === i4[o4][0] && a4++; - return a4 >= i4.length / 2 ? "\r\n" : "\r"; - }(e3, i3)), u3 = false, m2.delimiter) - J(m2.delimiter) && (m2.delimiter = m2.delimiter(e3), c3.meta.delimiter = m2.delimiter); - else { - var n4 = function(e4, t4, r5, i4, n5) { - var s4, a4, o4, u4; - n5 = n5 || [",", " ", "|", ";", b2.RECORD_SEP, b2.UNIT_SEP]; - for (var h3 = 0; h3 < n5.length; h3++) { - var f4 = n5[h3], d4 = 0, l4 = 0, c4 = 0; - o4 = void 0; - for (var p4 = new E2({ comments: i4, delimiter: f4, newline: t4, preview: 10 }).parse(e4), g4 = 0; g4 < p4.data.length; g4++) - if (r5 && y3(p4.data[g4])) - c4++; - else { - var _4 = p4.data[g4].length; - l4 += _4, void 0 !== o4 ? 0 < _4 && (d4 += Math.abs(_4 - o4), o4 = _4) : o4 = _4; + case 65499: { + const quantizationTablesLength = readUint16(); + const quantizationTablesEnd = quantizationTablesLength + offset - 2; + while (offset < quantizationTablesEnd) { + const quantizationTableSpec = data[offset++]; + const tableData = new Int32Array(64); + if (quantizationTableSpec >> 4 === 0) { + for (let j = 0; j < 64; j++) { + const z = dctZigZag[j]; + tableData[z] = data[offset++]; } - 0 < p4.data.length && (l4 /= p4.data.length - c4), (void 0 === a4 || d4 <= a4) && (void 0 === u4 || u4 < l4) && 1.99 < l4 && (a4 = d4, s4 = f4, u4 = l4); + } else if (quantizationTableSpec >> 4 === 1) { + for (let j = 0; j < 64; j++) { + const z = dctZigZag[j]; + tableData[z] = readUint16(); + } + } else { + throw new Error("DQT: invalid table spec"); + } + this.quantizationTables[quantizationTableSpec & 15] = tableData; } - return { successful: !!(m2.delimiter = s4), bestDelimiter: s4 }; - }(e3, m2.newline, m2.skipEmptyLines, m2.comments, m2.delimitersToGuess); - n4.successful ? m2.delimiter = n4.bestDelimiter : (u3 = true, m2.delimiter = b2.DefaultDelimiter), c3.meta.delimiter = m2.delimiter; - } - var s3 = w2(m2); - return m2.preview && m2.header && s3.preview++, a3 = e3, o3 = new E2(s3), c3 = o3.parse(a3, t3, r4), g3(), d3 ? { meta: { paused: true } } : c3 || { meta: { paused: false } }; - }, this.paused = function() { - return d3; - }, this.pause = function() { - d3 = true, o3.abort(), a3 = J(m2.chunk) ? "" : a3.substring(o3.getCharIndex()); - }, this.resume = function() { - t2.streamer._halted ? (d3 = false, t2.streamer.parseChunk(a3, true)) : setTimeout(t2.resume, 3); - }, this.aborted = function() { - return e2; - }, this.abort = function() { - e2 = true, o3.abort(), c3.meta.aborted = true, J(m2.complete) && m2.complete(c3), a3 = ""; - }; - } - function Q(e2) { - return e2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); - } - function E2(j) { - var z, M = (j = j || {}).delimiter, P = j.newline, U = j.comments, q = j.step, N = j.preview, B = j.fastMode, K = z = void 0 === j.quoteChar || null === j.quoteChar ? '"' : j.quoteChar; - if (void 0 !== j.escapeChar && (K = j.escapeChar), ("string" != typeof M || -1 < b2.BAD_DELIMITERS.indexOf(M)) && (M = ","), U === M) - throw new Error("Comment character same as delimiter"); - true === U ? U = "#" : ("string" != typeof U || -1 < b2.BAD_DELIMITERS.indexOf(U)) && (U = false), "\n" !== P && "\r" !== P && "\r\n" !== P && (P = "\n"); - var W = 0, H = false; - this.parse = function(i2, t2, r3) { - if ("string" != typeof i2) - throw new Error("Input must be a string"); - var n3 = i2.length, e2 = M.length, s2 = P.length, a3 = U.length, o3 = J(q), u3 = [], h2 = [], f3 = [], d3 = W = 0; - if (!i2) - return L(); - if (j.header && !t2) { - var l3 = i2.split(P)[0].split(M), c3 = [], p3 = {}, g3 = false; - for (var _3 in l3) { - var m2 = l3[_3]; - J(j.transformHeader) && (m2 = j.transformHeader(m2, _3)); - var y3 = m2, v3 = p3[m2] || 0; - for (0 < v3 && (g3 = true, y3 = m2 + "_" + v3), p3[m2] = v3 + 1; c3.includes(y3); ) - y3 = y3 + "_" + v3; - c3.push(y3); + break; } - if (g3) { - var k = i2.split(P); - k[0] = c3.join(M), i2 = k.join(P); + case 65472: + case 65473: + case 65474: { + readUint16(); + const frame = { + extended: fileMarker === 65473, + progressive: fileMarker === 65474, + precision: data[offset++], + scanLines: readUint16(), + samplesPerLine: readUint16(), + components: {}, + componentsOrder: [] + }; + const componentsCount = data[offset++]; + let componentId; + for (let i3 = 0; i3 < componentsCount; i3++) { + componentId = data[offset]; + const h = data[offset + 1] >> 4; + const v2 = data[offset + 1] & 15; + const qId = data[offset + 2]; + frame.componentsOrder.push(componentId); + frame.components[componentId] = { + h, + v: v2, + quantizationIdx: qId + }; + offset += 3; + } + prepareComponents(frame); + this.frames.push(frame); + break; } - } - if (B || false !== B && -1 === i2.indexOf(z)) { - for (var b3 = i2.split(P), E3 = 0; E3 < b3.length; E3++) { - if (f3 = b3[E3], W += f3.length, E3 !== b3.length - 1) - W += P.length; - else if (r3) - return L(); - if (!U || f3.substring(0, a3) !== U) { - if (o3) { - if (u3 = [], I(f3.split(M)), F(), H) - return L(); - } else - I(f3.split(M)); - if (N && N <= E3) - return u3 = u3.slice(0, N), L(true); + case 65476: { + const huffmanLength = readUint16(); + for (let i3 = 2; i3 < huffmanLength; ) { + const huffmanTableSpec = data[offset++]; + const codeLengths = new Uint8Array(16); + let codeLengthSum = 0; + for (let j = 0; j < 16; j++, offset++) { + codeLengths[j] = data[offset]; + codeLengthSum += codeLengths[j]; + } + const huffmanValues = new Uint8Array(codeLengthSum); + for (let j = 0; j < codeLengthSum; j++, offset++) { + huffmanValues[j] = data[offset]; + } + i3 += 17 + codeLengthSum; + if (huffmanTableSpec >> 4 === 0) { + this.huffmanTablesDC[huffmanTableSpec & 15] = buildHuffmanTable( + codeLengths, + huffmanValues + ); + } else { + this.huffmanTablesAC[huffmanTableSpec & 15] = buildHuffmanTable( + codeLengths, + huffmanValues + ); + } } + break; } - return L(); + case 65501: + readUint16(); + this.resetInterval = readUint16(); + break; + case 65498: { + readUint16(); + const selectorsCount = data[offset++]; + const components = []; + const frame = this.frames[0]; + for (let i3 = 0; i3 < selectorsCount; i3++) { + const component = frame.components[data[offset++]]; + const tableSpec = data[offset++]; + component.huffmanTableDC = this.huffmanTablesDC[tableSpec >> 4]; + component.huffmanTableAC = this.huffmanTablesAC[tableSpec & 15]; + components.push(component); + } + const spectralStart = data[offset++]; + const spectralEnd = data[offset++]; + const successiveApproximation = data[offset++]; + const processed = decodeScan( + data, + offset, + frame, + components, + this.resetInterval, + spectralStart, + spectralEnd, + successiveApproximation >> 4, + successiveApproximation & 15 + ); + offset += processed; + break; + } + case 65535: + if (data[offset] !== 255) { + offset--; + } + break; + default: + if (data[offset - 3] === 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) { + offset -= 3; + break; + } + throw new Error(`unknown JPEG marker ${fileMarker.toString(16)}`); } - for (var w3 = i2.indexOf(M, W), R = i2.indexOf(P, W), C = new RegExp(Q(K) + Q(z), "g"), S = i2.indexOf(z, W); ; ) - if (i2[W] !== z) - if (U && 0 === f3.length && i2.substring(W, W + a3) === U) { - if (-1 === R) - return L(); - W = R + s2, R = i2.indexOf(P, W), w3 = i2.indexOf(M, W); - } else if (-1 !== w3 && (w3 < R || -1 === R)) - f3.push(i2.substring(W, w3)), W = w3 + e2, w3 = i2.indexOf(M, W); - else { - if (-1 === R) - break; - if (f3.push(i2.substring(W, R)), D(R + s2), o3 && (F(), H)) - return L(); - if (N && u3.length >= N) - return L(true); - } - else - for (S = W, W++; ; ) { - if (-1 === (S = i2.indexOf(z, S + 1))) - return r3 || h2.push({ type: "Quotes", code: "MissingQuotes", message: "Quoted field unterminated", row: u3.length, index: W }), T(); - if (S === n3 - 1) - return T(i2.substring(W, S).replace(C, z)); - if (z !== K || i2[S + 1] !== K) { - if (z === K || 0 === S || i2[S - 1] !== K) { - -1 !== w3 && w3 < S + 1 && (w3 = i2.indexOf(M, S + 1)), -1 !== R && R < S + 1 && (R = i2.indexOf(P, S + 1)); - var O2 = A(-1 === R ? w3 : Math.min(w3, R)); - if (i2.substr(S + 1 + O2, e2) === M) { - f3.push(i2.substring(W, S).replace(C, z)), i2[W = S + 1 + O2 + e2] !== z && (S = i2.indexOf(z, W)), w3 = i2.indexOf(M, W), R = i2.indexOf(P, W); - break; - } - var x2 = A(R); - if (i2.substring(S + 1 + x2, S + 1 + x2 + s2) === P) { - if (f3.push(i2.substring(W, S).replace(C, z)), D(S + 1 + x2 + s2), w3 = i2.indexOf(M, W), S = i2.indexOf(z, W), o3 && (F(), H)) - return L(); - if (N && u3.length >= N) - return L(true); - break; - } - h2.push({ type: "Quotes", code: "InvalidQuotes", message: "Trailing quote on quoted field is malformed", row: u3.length, index: W }), S++; - } - } else - S++; - } - return T(); - function I(e3) { - u3.push(e3), d3 = W; + fileMarker = readUint16(); + } + } + getResult() { + const { frames } = this; + if (this.frames.length === 0) { + throw new Error("no frames were decoded"); + } else if (this.frames.length > 1) { + console.warn("more than one frame is not supported"); + } + for (let i3 = 0; i3 < this.frames.length; i3++) { + const cp = this.frames[i3].components; + for (const j of Object.keys(cp)) { + cp[j].quantizationTable = this.quantizationTables[cp[j].quantizationIdx]; + delete cp[j].quantizationIdx; } - function A(e3) { - var t3 = 0; - if (-1 !== e3) { - var r4 = i2.substring(S + 1, e3); - r4 && "" === r4.trim() && (t3 = r4.length); + } + const frame = frames[0]; + const { components, componentsOrder } = frame; + const outComponents = []; + const width = frame.samplesPerLine; + const height = frame.scanLines; + for (let i3 = 0; i3 < componentsOrder.length; i3++) { + const component = components[componentsOrder[i3]]; + outComponents.push({ + lines: buildComponentData(frame, component), + scaleX: component.h / frame.maxH, + scaleY: component.v / frame.maxV + }); + } + const out = new Uint8Array(width * height * outComponents.length); + let oi = 0; + for (let y2 = 0; y2 < height; ++y2) { + for (let x2 = 0; x2 < width; ++x2) { + for (let i3 = 0; i3 < outComponents.length; ++i3) { + const component = outComponents[i3]; + out[oi] = component.lines[0 | y2 * component.scaleY][0 | x2 * component.scaleX]; + ++oi; } - return t3; - } - function T(e3) { - return r3 || (void 0 === e3 && (e3 = i2.substring(W)), f3.push(e3), W = n3, I(f3), o3 && F()), L(); - } - function D(e3) { - W = e3, I(f3), f3 = [], R = i2.indexOf(P, W); - } - function L(e3) { - return { data: u3, errors: h2, meta: { delimiter: M, linebreak: P, aborted: H, truncated: !!e3, cursor: d3 + (t2 || 0) } }; - } - function F() { - q(L()), u3 = [], h2 = []; } - }, this.abort = function() { - H = true; - }, this.getCharIndex = function() { - return W; - }; - } - function _2(e2) { - var t2 = e2.data, r3 = a2[t2.workerId], i2 = false; - if (t2.error) - r3.userError(t2.error, t2.file); - else if (t2.results && t2.results.data) { - var n3 = { abort: function() { - i2 = true, m(t2.workerId, { data: [], errors: [], meta: { aborted: true } }); - }, pause: y2, resume: y2 }; - if (J(r3.userStep)) { - for (var s2 = 0; s2 < t2.results.data.length && (r3.userStep({ data: t2.results.data[s2], errors: t2.results.errors, meta: t2.results.meta }, n3), !i2); s2++) - ; - delete t2.results; - } else - J(r3.userChunk) && (r3.userChunk(t2.results, n3, t2.file), delete t2.results); } - t2.finished && !i2 && m(t2.workerId, t2.results); - } - function m(e2, t2) { - var r3 = a2[e2]; - J(r3.userComplete) && r3.userComplete(t2), r3.terminate(), delete a2[e2]; - } - function y2() { - throw new Error("Not implemented."); - } - function w2(e2) { - if ("object" != typeof e2 || null === e2) - return e2; - var t2 = Array.isArray(e2) ? [] : {}; - for (var r3 in e2) - t2[r3] = w2(e2[r3]); - return t2; + return out; } - function v2(e2, t2) { - return function() { - e2.apply(t2, arguments); - }; + }; + JpegDecoder = class extends BaseDecoder { + constructor(fileDirectory) { + super(); + this.reader = new JpegStreamReader(); + if (fileDirectory.JPEGTables) { + this.reader.parse(fileDirectory.JPEGTables); + } } - function J(e2) { - return "function" == typeof e2; + decodeBlock(buffer) { + this.reader.resetFrames(); + this.reader.parse(new Uint8Array(buffer)); + return this.reader.getResult().buffer; } - return o2 && (f2.onmessage = function(e2) { - var t2 = e2.data; - void 0 === b2.WORKER_ID && t2 && (b2.WORKER_ID = t2.workerId); - if ("string" == typeof t2.input) - f2.postMessage({ workerId: b2.WORKER_ID, results: b2.parse(t2.input, t2.config), finished: true }); - else if (f2.File && t2.input instanceof File || t2.input instanceof Object) { - var r3 = b2.parse(t2.input, t2.config); - r3 && f2.postMessage({ workerId: b2.WORKER_ID, results: r3, finished: true }); - } - }), (l2.prototype = Object.create(h.prototype)).constructor = l2, (c2.prototype = Object.create(h.prototype)).constructor = c2, (p2.prototype = Object.create(p2.prototype)).constructor = p2, (g2.prototype = Object.create(h.prototype)).constructor = g2, b2; - }); + }; } }); - // node_modules/@babel/runtime/helpers/esm/typeof.js - function _typeof(o2) { - "@babel/helpers - typeof"; - return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o3) { - return typeof o3; - } : function(o3) { - return o3 && "function" == typeof Symbol && o3.constructor === Symbol && o3 !== Symbol.prototype ? "symbol" : typeof o3; - }, _typeof(o2); - } - - // node_modules/@babel/runtime/helpers/esm/toPrimitive.js - function toPrimitive(t2, r2) { - if ("object" != _typeof(t2) || !t2) - return t2; - var e2 = t2[Symbol.toPrimitive]; - if (void 0 !== e2) { - var i2 = e2.call(t2, r2 || "default"); - if ("object" != _typeof(i2)) - return i2; - throw new TypeError("@@toPrimitive must return a primitive value."); - } - return ("string" === r2 ? String : Number)(t2); - } - - // node_modules/@babel/runtime/helpers/esm/toPropertyKey.js - function toPropertyKey(t2) { - var i2 = toPrimitive(t2, "string"); - return "symbol" == _typeof(i2) ? i2 : String(i2); - } - - // node_modules/@babel/runtime/helpers/esm/defineProperty.js - function _defineProperty(obj, key, value) { - key = toPropertyKey(key); - if (key in obj) { - Object.defineProperty(obj, key, { - value, - enumerable: true, - configurable: true, - writable: true - }); - } else { - obj[key] = value; - } - return obj; - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/env-utils/assert.js - function assert(condition, message) { - if (!condition) { - throw new Error(message || "loader assertion failed."); - } - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/env-utils/globals.js - var globals = { - self: typeof self !== "undefined" && self, - window: typeof window !== "undefined" && window, - global: typeof global !== "undefined" && global, - document: typeof document !== "undefined" && document - }; - var self_ = globals.self || globals.window || globals.global || {}; - var window_ = globals.window || globals.self || globals.global || {}; - var global_ = globals.global || globals.self || globals.window || {}; - var document_ = globals.document || {}; - var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser); - var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); - var nodeVersion = matches && parseFloat(matches[1]) || 0; - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/env-utils/version.js - var VERSION = true ? "3.4.14" : DEFAULT_VERSION; - if (false) { - console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."); - } - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/env-utils/assert.js - function assert2(condition, message) { - if (!condition) { - throw new Error(message || "loaders.gl assertion failed."); - } - } - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/env-utils/globals.js - var globals2 = { - self: typeof self !== "undefined" && self, - window: typeof window !== "undefined" && window, - global: typeof global !== "undefined" && global, - document: typeof document !== "undefined" && document - }; - var self_2 = globals2.self || globals2.window || globals2.global || {}; - var window_2 = globals2.window || globals2.self || globals2.global || {}; - var global_2 = globals2.global || globals2.self || globals2.window || {}; - var document_2 = globals2.document || {}; - var isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser; - var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined"; - var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); - var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0; - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-job.js - var WorkerJob = class { - constructor(jobName, workerThread) { - _defineProperty(this, "name", void 0); - _defineProperty(this, "workerThread", void 0); - _defineProperty(this, "isRunning", true); - _defineProperty(this, "result", void 0); - _defineProperty(this, "_resolve", () => { - }); - _defineProperty(this, "_reject", () => { - }); - this.name = jobName; - this.workerThread = workerThread; - this.result = new Promise((resolve2, reject) => { - this._resolve = resolve2; - this._reject = reject; - }); - } - postMessage(type, payload) { - this.workerThread.postMessage({ - source: "loaders.gl", - type, - payload - }); - } - done(value) { - assert2(this.isRunning); - this.isRunning = false; - this._resolve(value); - } - error(error2) { - assert2(this.isRunning); - this.isRunning = false; - this._reject(error2); - } - }; - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/node/worker_threads-browser.js - var Worker2 = class { - terminate() { - } - }; - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-utils/get-loadable-worker-url.js - var workerURLCache = /* @__PURE__ */ new Map(); - function getLoadableWorkerURL(props) { - assert2(props.source && !props.url || !props.source && props.url); - let workerURL = workerURLCache.get(props.source || props.url); - if (!workerURL) { - if (props.url) { - workerURL = getLoadableWorkerURLFromURL(props.url); - workerURLCache.set(props.url, workerURL); + // node_modules/pako/dist/pako.esm.mjs + function zero$1(buf) { + let len2 = buf.length; + while (--len2 >= 0) { + buf[len2] = 0; + } + } + function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) { + this.static_tree = static_tree; + this.extra_bits = extra_bits; + this.extra_base = extra_base; + this.elems = elems; + this.max_length = max_length; + this.has_stree = static_tree && static_tree.length; + } + function TreeDesc(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; + this.max_code = 0; + this.stat_desc = stat_desc; + } + function Config(good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; + } + function DeflateState() { + this.strm = null; + this.status = 0; + this.pending_buf = null; + this.pending_buf_size = 0; + this.pending_out = 0; + this.pending = 0; + this.wrap = 0; + this.gzhead = null; + this.gzindex = 0; + this.method = Z_DEFLATED$2; + this.last_flush = -1; + this.w_size = 0; + this.w_bits = 0; + this.w_mask = 0; + this.window = null; + this.window_size = 0; + this.prev = null; + this.head = null; + this.ins_h = 0; + this.hash_size = 0; + this.hash_bits = 0; + this.hash_mask = 0; + this.hash_shift = 0; + this.block_start = 0; + this.match_length = 0; + this.prev_match = 0; + this.match_available = 0; + this.strstart = 0; + this.match_start = 0; + this.lookahead = 0; + this.prev_length = 0; + this.max_chain_length = 0; + this.max_lazy_match = 0; + this.level = 0; + this.strategy = 0; + this.good_match = 0; + this.nice_match = 0; + this.dyn_ltree = new Uint16Array(HEAP_SIZE * 2); + this.dyn_dtree = new Uint16Array((2 * D_CODES + 1) * 2); + this.bl_tree = new Uint16Array((2 * BL_CODES + 1) * 2); + zero(this.dyn_ltree); + zero(this.dyn_dtree); + zero(this.bl_tree); + this.l_desc = null; + this.d_desc = null; + this.bl_desc = null; + this.bl_count = new Uint16Array(MAX_BITS + 1); + this.heap = new Uint16Array(2 * L_CODES + 1); + zero(this.heap); + this.heap_len = 0; + this.heap_max = 0; + this.depth = new Uint16Array(2 * L_CODES + 1); + zero(this.depth); + this.sym_buf = 0; + this.lit_bufsize = 0; + this.sym_next = 0; + this.sym_end = 0; + this.opt_len = 0; + this.static_len = 0; + this.matches = 0; + this.insert = 0; + this.bi_buf = 0; + this.bi_valid = 0; + } + function ZStream() { + this.input = null; + this.next_in = 0; + this.avail_in = 0; + this.total_in = 0; + this.output = null; + this.next_out = 0; + this.avail_out = 0; + this.total_out = 0; + this.msg = ""; + this.state = null; + this.data_type = 2; + this.adler = 0; + } + function Deflate$1(options) { + this.options = common.assign({ + level: Z_DEFAULT_COMPRESSION, + method: Z_DEFLATED$1, + chunkSize: 16384, + windowBits: 15, + memLevel: 8, + strategy: Z_DEFAULT_STRATEGY + }, options || {}); + let opt = this.options; + if (opt.raw && opt.windowBits > 0) { + opt.windowBits = -opt.windowBits; + } else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) { + opt.windowBits += 16; + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new zstream(); + this.strm.avail_out = 0; + let status = deflate_1$2.deflateInit2( + this.strm, + opt.level, + opt.method, + opt.windowBits, + opt.memLevel, + opt.strategy + ); + if (status !== Z_OK$2) { + throw new Error(messages[status]); + } + if (opt.header) { + deflate_1$2.deflateSetHeader(this.strm, opt.header); + } + if (opt.dictionary) { + let dict; + if (typeof opt.dictionary === "string") { + dict = strings.string2buf(opt.dictionary); + } else if (toString$1.call(opt.dictionary) === "[object ArrayBuffer]") { + dict = new Uint8Array(opt.dictionary); + } else { + dict = opt.dictionary; } - if (props.source) { - workerURL = getLoadableWorkerURLFromSource(props.source); - workerURLCache.set(props.source, workerURL); + status = deflate_1$2.deflateSetDictionary(this.strm, dict); + if (status !== Z_OK$2) { + throw new Error(messages[status]); } + this._dict_set = true; } - assert2(workerURL); - return workerURL; - } - function getLoadableWorkerURLFromURL(url) { - if (!url.startsWith("http")) { - return url; - } - const workerSource = buildScriptSource(url); - return getLoadableWorkerURLFromSource(workerSource); - } - function getLoadableWorkerURLFromSource(workerSource) { - const blob = new Blob([workerSource], { - type: "application/javascript" - }); - return URL.createObjectURL(blob); - } - function buildScriptSource(workerUrl) { - return "try {\n importScripts('".concat(workerUrl, "');\n} catch (error) {\n console.error(error);\n throw error;\n}"); } - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-utils/get-transfer-list.js - function getTransferList(object) { - let recursive = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true; - let transfers = arguments.length > 2 ? arguments[2] : void 0; - const transfersSet = transfers || /* @__PURE__ */ new Set(); - if (!object) { - } else if (isTransferable(object)) { - transfersSet.add(object); - } else if (isTransferable(object.buffer)) { - transfersSet.add(object.buffer); - } else if (ArrayBuffer.isView(object)) { - } else if (recursive && typeof object === "object") { - for (const key in object) { - getTransferList(object[key], recursive, transfersSet); - } + function deflate$1(input, options) { + const deflator = new Deflate$1(options); + deflator.push(input, true); + if (deflator.err) { + throw deflator.msg || messages[deflator.err]; } - return transfers === void 0 ? Array.from(transfersSet) : []; + return deflator.result; } - function isTransferable(object) { - if (!object) { - return false; - } - if (object instanceof ArrayBuffer) { - return true; - } - if (typeof MessagePort !== "undefined" && object instanceof MessagePort) { - return true; - } - if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) { - return true; - } - if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) { - return true; - } - return false; + function deflateRaw$1(input, options) { + options = options || {}; + options.raw = true; + return deflate$1(input, options); } - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-thread.js - var NOOP = () => { - }; - var WorkerThread = class { - static isSupported() { - return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== "undefined" && !isBrowser2; - } - constructor(props) { - _defineProperty(this, "name", void 0); - _defineProperty(this, "source", void 0); - _defineProperty(this, "url", void 0); - _defineProperty(this, "terminated", false); - _defineProperty(this, "worker", void 0); - _defineProperty(this, "onMessage", void 0); - _defineProperty(this, "onError", void 0); - _defineProperty(this, "_loadableURL", ""); - const { - name, - source, - url - } = props; - assert2(source || url); - this.name = name; - this.source = source; - this.url = url; - this.onMessage = NOOP; - this.onError = (error2) => console.log(error2); - this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker(); - } - destroy() { - this.onMessage = NOOP; - this.onError = NOOP; - this.worker.terminate(); - this.terminated = true; - } - get isRunning() { - return Boolean(this.onMessage); - } - postMessage(data, transferList) { - transferList = transferList || getTransferList(data); - this.worker.postMessage(data, transferList); - } - _getErrorFromErrorEvent(event) { - let message = "Failed to load "; - message += "worker ".concat(this.name, " from ").concat(this.url, ". "); - if (event.message) { - message += "".concat(event.message, " in "); - } - if (event.lineno) { - message += ":".concat(event.lineno, ":").concat(event.colno); - } - return new Error(message); - } - _createBrowserWorker() { - this._loadableURL = getLoadableWorkerURL({ - source: this.source, - url: this.url - }); - const worker = new Worker(this._loadableURL, { - name: this.name - }); - worker.onmessage = (event) => { - if (!event.data) { - this.onError(new Error("No data received")); + function gzip$1(input, options) { + options = options || {}; + options.gzip = true; + return deflate$1(input, options); + } + function InflateState() { + this.strm = null; + this.mode = 0; + this.last = false; + this.wrap = 0; + this.havedict = false; + this.flags = 0; + this.dmax = 0; + this.check = 0; + this.total = 0; + this.head = null; + this.wbits = 0; + this.wsize = 0; + this.whave = 0; + this.wnext = 0; + this.window = null; + this.hold = 0; + this.bits = 0; + this.length = 0; + this.offset = 0; + this.extra = 0; + this.lencode = null; + this.distcode = null; + this.lenbits = 0; + this.distbits = 0; + this.ncode = 0; + this.nlen = 0; + this.ndist = 0; + this.have = 0; + this.next = null; + this.lens = new Uint16Array(320); + this.work = new Uint16Array(288); + this.lendyn = null; + this.distdyn = null; + this.sane = 0; + this.back = 0; + this.was = 0; + } + function GZheader() { + this.text = 0; + this.time = 0; + this.xflags = 0; + this.os = 0; + this.extra = null; + this.extra_len = 0; + this.name = ""; + this.comment = ""; + this.hcrc = 0; + this.done = false; + } + function Inflate$1(options) { + this.options = common.assign({ + chunkSize: 1024 * 64, + windowBits: 15, + to: "" + }, options || {}); + const opt = this.options; + if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) { + opt.windowBits = -opt.windowBits; + if (opt.windowBits === 0) { + opt.windowBits = -15; + } + } + if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) { + opt.windowBits += 32; + } + if (opt.windowBits > 15 && opt.windowBits < 48) { + if ((opt.windowBits & 15) === 0) { + opt.windowBits |= 15; + } + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new zstream(); + this.strm.avail_out = 0; + let status = inflate_1$2.inflateInit2( + this.strm, + opt.windowBits + ); + if (status !== Z_OK) { + throw new Error(messages[status]); + } + this.header = new gzheader(); + inflate_1$2.inflateGetHeader(this.strm, this.header); + if (opt.dictionary) { + if (typeof opt.dictionary === "string") { + opt.dictionary = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") { + opt.dictionary = new Uint8Array(opt.dictionary); + } + if (opt.raw) { + status = inflate_1$2.inflateSetDictionary(this.strm, opt.dictionary); + if (status !== Z_OK) { + throw new Error(messages[status]); + } + } + } + } + function inflate$1(input, options) { + const inflator = new Inflate$1(options); + inflator.push(input); + if (inflator.err) + throw inflator.msg || messages[inflator.err]; + return inflator.result; + } + function inflateRaw$1(input, options) { + options = options || {}; + options.raw = true; + return inflate$1(input, options); + } + var Z_FIXED$1, Z_BINARY, Z_TEXT, Z_UNKNOWN$1, STORED_BLOCK, STATIC_TREES, DYN_TREES, MIN_MATCH$1, MAX_MATCH$1, LENGTH_CODES$1, LITERALS$1, L_CODES$1, D_CODES$1, BL_CODES$1, HEAP_SIZE$1, MAX_BITS$1, Buf_size, MAX_BL_BITS, END_BLOCK, REP_3_6, REPZ_3_10, REPZ_11_138, extra_lbits, extra_dbits, extra_blbits, bl_order, DIST_CODE_LEN, static_ltree, static_dtree, _dist_code, _length_code, base_length, base_dist, static_l_desc, static_d_desc, static_bl_desc, d_code, put_short, send_bits, send_code, bi_reverse, bi_flush, gen_bitlen, gen_codes, tr_static_init, init_block, bi_windup, smaller, pqdownheap, compress_block, build_tree, scan_tree, send_tree, build_bl_tree, send_all_trees, detect_data_type, static_init_done, _tr_init$1, _tr_stored_block$1, _tr_align$1, _tr_flush_block$1, _tr_tally$1, _tr_init_1, _tr_stored_block_1, _tr_flush_block_1, _tr_tally_1, _tr_align_1, trees, adler32, adler32_1, makeTable, crcTable, crc32, crc32_1, messages, constants$2, _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align, Z_NO_FLUSH$2, Z_PARTIAL_FLUSH, Z_FULL_FLUSH$1, Z_FINISH$3, Z_BLOCK$1, Z_OK$3, Z_STREAM_END$3, Z_STREAM_ERROR$2, Z_DATA_ERROR$2, Z_BUF_ERROR$1, Z_DEFAULT_COMPRESSION$1, Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED, Z_DEFAULT_STRATEGY$1, Z_UNKNOWN, Z_DEFLATED$2, MAX_MEM_LEVEL, MAX_WBITS$1, DEF_MEM_LEVEL, LENGTH_CODES, LITERALS, L_CODES, D_CODES, BL_CODES, HEAP_SIZE, MAX_BITS, MIN_MATCH, MAX_MATCH, MIN_LOOKAHEAD, PRESET_DICT, INIT_STATE, GZIP_STATE, EXTRA_STATE, NAME_STATE, COMMENT_STATE, HCRC_STATE, BUSY_STATE, FINISH_STATE, BS_NEED_MORE, BS_BLOCK_DONE, BS_FINISH_STARTED, BS_FINISH_DONE, OS_CODE, err, rank, zero, slide_hash, HASH_ZLIB, HASH, flush_pending, flush_block_only, put_byte, putShortMSB, read_buf, longest_match, fill_window, deflate_stored, deflate_fast, deflate_slow, deflate_rle, deflate_huff, configuration_table, lm_init, deflateStateCheck, deflateResetKeep, deflateReset, deflateSetHeader, deflateInit2, deflateInit, deflate$2, deflateEnd, deflateSetDictionary, deflateInit_1, deflateInit2_1, deflateReset_1, deflateResetKeep_1, deflateSetHeader_1, deflate_2$1, deflateEnd_1, deflateSetDictionary_1, deflateInfo, deflate_1$2, _has, assign, flattenChunks, common, STR_APPLY_UIA_OK, _utf8len, string2buf, buf2binstring, buf2string, utf8border, strings, zstream, toString$1, Z_NO_FLUSH$1, Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH$2, Z_OK$2, Z_STREAM_END$2, Z_DEFAULT_COMPRESSION, Z_DEFAULT_STRATEGY, Z_DEFLATED$1, Deflate_1$1, deflate_2, deflateRaw_1$1, gzip_1$1, constants$1, deflate_1$1, BAD$1, TYPE$1, inffast, MAXBITS, ENOUGH_LENS$1, ENOUGH_DISTS$1, CODES$1, LENS$1, DISTS$1, lbase, lext, dbase, dext, inflate_table, inftrees, CODES, LENS, DISTS, Z_FINISH$1, Z_BLOCK, Z_TREES, Z_OK$1, Z_STREAM_END$1, Z_NEED_DICT$1, Z_STREAM_ERROR$1, Z_DATA_ERROR$1, Z_MEM_ERROR$1, Z_BUF_ERROR, Z_DEFLATED, HEAD, FLAGS, TIME, OS, EXLEN, EXTRA, NAME, COMMENT, HCRC, DICTID, DICT, TYPE, TYPEDO, STORED, COPY_, COPY, TABLE, LENLENS, CODELENS, LEN_, LEN, LENEXT, DIST, DISTEXT, MATCH, LIT, CHECK, LENGTH, DONE, BAD, MEM, SYNC, ENOUGH_LENS, ENOUGH_DISTS, MAX_WBITS, DEF_WBITS, zswap32, inflateStateCheck, inflateResetKeep, inflateReset, inflateReset2, inflateInit2, inflateInit, virgin, lenfix, distfix, fixedtables, updatewindow, inflate$2, inflateEnd, inflateGetHeader, inflateSetDictionary, inflateReset_1, inflateReset2_1, inflateResetKeep_1, inflateInit_1, inflateInit2_1, inflate_2$1, inflateEnd_1, inflateGetHeader_1, inflateSetDictionary_1, inflateInfo, inflate_1$2, gzheader, toString, Z_NO_FLUSH, Z_FINISH, Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR, Inflate_1$1, inflate_2, inflateRaw_1$1, ungzip$1, constants, inflate_1$1, Deflate, deflate, deflateRaw, gzip, Inflate, inflate, inflateRaw, ungzip, inflate_1; + var init_pako_esm = __esm({ + "node_modules/pako/dist/pako.esm.mjs"() { + Z_FIXED$1 = 4; + Z_BINARY = 0; + Z_TEXT = 1; + Z_UNKNOWN$1 = 2; + STORED_BLOCK = 0; + STATIC_TREES = 1; + DYN_TREES = 2; + MIN_MATCH$1 = 3; + MAX_MATCH$1 = 258; + LENGTH_CODES$1 = 29; + LITERALS$1 = 256; + L_CODES$1 = LITERALS$1 + 1 + LENGTH_CODES$1; + D_CODES$1 = 30; + BL_CODES$1 = 19; + HEAP_SIZE$1 = 2 * L_CODES$1 + 1; + MAX_BITS$1 = 15; + Buf_size = 16; + MAX_BL_BITS = 7; + END_BLOCK = 256; + REP_3_6 = 16; + REPZ_3_10 = 17; + REPZ_11_138 = 18; + extra_lbits = /* extra bits for each length code */ + new Uint8Array([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]); + extra_dbits = /* extra bits for each distance code */ + new Uint8Array([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]); + extra_blbits = /* extra bits for each bit length code */ + new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]); + bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]); + DIST_CODE_LEN = 512; + static_ltree = new Array((L_CODES$1 + 2) * 2); + zero$1(static_ltree); + static_dtree = new Array(D_CODES$1 * 2); + zero$1(static_dtree); + _dist_code = new Array(DIST_CODE_LEN); + zero$1(_dist_code); + _length_code = new Array(MAX_MATCH$1 - MIN_MATCH$1 + 1); + zero$1(_length_code); + base_length = new Array(LENGTH_CODES$1); + zero$1(base_length); + base_dist = new Array(D_CODES$1); + zero$1(base_dist); + d_code = (dist) => { + return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; + }; + put_short = (s, w3) => { + s.pending_buf[s.pending++] = w3 & 255; + s.pending_buf[s.pending++] = w3 >>> 8 & 255; + }; + send_bits = (s, value, length4) => { + if (s.bi_valid > Buf_size - length4) { + s.bi_buf |= value << s.bi_valid & 65535; + put_short(s, s.bi_buf); + s.bi_buf = value >> Buf_size - s.bi_valid; + s.bi_valid += length4 - Buf_size; } else { - this.onMessage(event.data); + s.bi_buf |= value << s.bi_valid & 65535; + s.bi_valid += length4; } }; - worker.onerror = (error2) => { - this.onError(this._getErrorFromErrorEvent(error2)); - this.terminated = true; + send_code = (s, c2, tree) => { + send_bits( + s, + tree[c2 * 2], + tree[c2 * 2 + 1] + /*.Len*/ + ); }; - worker.onmessageerror = (event) => console.error(event); - return worker; - } - _createNodeWorker() { - let worker; - if (this.url) { - const absolute = this.url.includes(":/") || this.url.startsWith("/"); - const url = absolute ? this.url : "./".concat(this.url); - worker = new Worker2(url, { - eval: false - }); - } else if (this.source) { - worker = new Worker2(this.source, { - eval: true - }); - } else { - throw new Error("no worker"); - } - worker.on("message", (data) => { - this.onMessage(data); - }); - worker.on("error", (error2) => { - this.onError(error2); - }); - worker.on("exit", (code) => { - }); - return worker; - } - }; - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-pool.js - var WorkerPool = class { - static isSupported() { - return WorkerThread.isSupported(); - } - constructor(props) { - _defineProperty(this, "name", "unnamed"); - _defineProperty(this, "source", void 0); - _defineProperty(this, "url", void 0); - _defineProperty(this, "maxConcurrency", 1); - _defineProperty(this, "maxMobileConcurrency", 1); - _defineProperty(this, "onDebug", () => { - }); - _defineProperty(this, "reuseWorkers", true); - _defineProperty(this, "props", {}); - _defineProperty(this, "jobQueue", []); - _defineProperty(this, "idleQueue", []); - _defineProperty(this, "count", 0); - _defineProperty(this, "isDestroyed", false); - this.source = props.source; - this.url = props.url; - this.setProps(props); - } - destroy() { - this.idleQueue.forEach((worker) => worker.destroy()); - this.isDestroyed = true; - } - setProps(props) { - this.props = { - ...this.props, - ...props + bi_reverse = (code, len2) => { + let res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len2 > 0); + return res >>> 1; }; - if (props.name !== void 0) { - this.name = props.name; - } - if (props.maxConcurrency !== void 0) { - this.maxConcurrency = props.maxConcurrency; - } - if (props.maxMobileConcurrency !== void 0) { - this.maxMobileConcurrency = props.maxMobileConcurrency; - } - if (props.reuseWorkers !== void 0) { - this.reuseWorkers = props.reuseWorkers; - } - if (props.onDebug !== void 0) { - this.onDebug = props.onDebug; - } - } - async startJob(name) { - let onMessage2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : (job, type, data) => job.done(data); - let onError = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : (job, error2) => job.error(error2); - const startPromise = new Promise((onStart) => { - this.jobQueue.push({ - name, - onMessage: onMessage2, - onError, - onStart - }); - return this; - }); - this._startQueuedJob(); - return await startPromise; - } - async _startQueuedJob() { - if (!this.jobQueue.length) { - return; - } - const workerThread = this._getAvailableWorker(); - if (!workerThread) { - return; - } - const queuedJob = this.jobQueue.shift(); - if (queuedJob) { - this.onDebug({ - message: "Starting job", - name: queuedJob.name, - workerThread, - backlog: this.jobQueue.length - }); - const job = new WorkerJob(queuedJob.name, workerThread); - workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload); - workerThread.onError = (error2) => queuedJob.onError(job, error2); - queuedJob.onStart(job); - try { - await job.result; - } finally { - this.returnWorkerToQueue(workerThread); + bi_flush = (s) => { + if (s.bi_valid === 16) { + put_short(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 255; + s.bi_buf >>= 8; + s.bi_valid -= 8; } - } - } - returnWorkerToQueue(worker) { - const shouldDestroyWorker = this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency(); - if (shouldDestroyWorker) { - worker.destroy(); - this.count--; - } else { - this.idleQueue.push(worker); - } - if (!this.isDestroyed) { - this._startQueuedJob(); - } - } - _getAvailableWorker() { - if (this.idleQueue.length > 0) { - return this.idleQueue.shift() || null; - } - if (this.count < this._getMaxConcurrency()) { - this.count++; - const name = "".concat(this.name.toLowerCase(), " (#").concat(this.count, " of ").concat(this.maxConcurrency, ")"); - return new WorkerThread({ - name, - source: this.source, - url: this.url - }); - } - return null; - } - _getMaxConcurrency() { - return isMobile ? this.maxMobileConcurrency : this.maxConcurrency; - } - }; - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-farm.js - var DEFAULT_PROPS = { - maxConcurrency: 3, - maxMobileConcurrency: 1, - reuseWorkers: true, - onDebug: () => { - } - }; - var WorkerFarm = class _WorkerFarm { - static isSupported() { - return WorkerThread.isSupported(); - } - static getWorkerFarm() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({}); - _WorkerFarm._workerFarm.setProps(props); - return _WorkerFarm._workerFarm; - } - constructor(props) { - _defineProperty(this, "props", void 0); - _defineProperty(this, "workerPools", /* @__PURE__ */ new Map()); - this.props = { - ...DEFAULT_PROPS }; - this.setProps(props); - this.workerPools = /* @__PURE__ */ new Map(); - } - destroy() { - for (const workerPool of this.workerPools.values()) { - workerPool.destroy(); - } - this.workerPools = /* @__PURE__ */ new Map(); - } - setProps(props) { - this.props = { - ...this.props, - ...props + gen_bitlen = (s, desc) => { + const tree = desc.dyn_tree; + const max_code = desc.max_code; + const stree = desc.stat_desc.static_tree; + const has_stree = desc.stat_desc.has_stree; + const extra = desc.stat_desc.extra_bits; + const base = desc.stat_desc.extra_base; + const max_length = desc.stat_desc.max_length; + let h; + let n2, m; + let bits; + let xbits; + let f2; + let overflow = 0; + for (bits = 0; bits <= MAX_BITS$1; bits++) { + s.bl_count[bits] = 0; + } + tree[s.heap[s.heap_max] * 2 + 1] = 0; + for (h = s.heap_max + 1; h < HEAP_SIZE$1; h++) { + n2 = s.heap[h]; + bits = tree[tree[n2 * 2 + 1] * 2 + 1] + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n2 * 2 + 1] = bits; + if (n2 > max_code) { + continue; + } + s.bl_count[bits]++; + xbits = 0; + if (n2 >= base) { + xbits = extra[n2 - base]; + } + f2 = tree[n2 * 2]; + s.opt_len += f2 * (bits + xbits); + if (has_stree) { + s.static_len += f2 * (stree[n2 * 2 + 1] + xbits); + } + } + if (overflow === 0) { + return; + } + do { + bits = max_length - 1; + while (s.bl_count[bits] === 0) { + bits--; + } + s.bl_count[bits]--; + s.bl_count[bits + 1] += 2; + s.bl_count[max_length]--; + overflow -= 2; + } while (overflow > 0); + for (bits = max_length; bits !== 0; bits--) { + n2 = s.bl_count[bits]; + while (n2 !== 0) { + m = s.heap[--h]; + if (m > max_code) { + continue; + } + if (tree[m * 2 + 1] !== bits) { + s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2]; + tree[m * 2 + 1] = bits; + } + n2--; + } + } }; - for (const workerPool of this.workerPools.values()) { - workerPool.setProps(this._getWorkerPoolProps()); - } - } - getWorkerPool(options) { - const { - name, - source, - url - } = options; - let workerPool = this.workerPools.get(name); - if (!workerPool) { - workerPool = new WorkerPool({ - name, - source, - url - }); - workerPool.setProps(this._getWorkerPoolProps()); - this.workerPools.set(name, workerPool); - } - return workerPool; - } - _getWorkerPoolProps() { - return { - maxConcurrency: this.props.maxConcurrency, - maxMobileConcurrency: this.props.maxMobileConcurrency, - reuseWorkers: this.props.reuseWorkers, - onDebug: this.props.onDebug + gen_codes = (tree, max_code, bl_count) => { + const next_code = new Array(MAX_BITS$1 + 1); + let code = 0; + let bits; + let n2; + for (bits = 1; bits <= MAX_BITS$1; bits++) { + code = code + bl_count[bits - 1] << 1; + next_code[bits] = code; + } + for (n2 = 0; n2 <= max_code; n2++) { + let len2 = tree[n2 * 2 + 1]; + if (len2 === 0) { + continue; + } + tree[n2 * 2] = bi_reverse(next_code[len2]++, len2); + } }; - } - }; - _defineProperty(WorkerFarm, "_workerFarm", void 0); - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-api/get-worker-url.js - var NPM_TAG = "latest"; - function getWorkerURL(worker) { - let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const workerOptions = options[worker.id] || {}; - const workerFile = "".concat(worker.id, "-worker.js"); - let url = workerOptions.workerUrl; - if (!url && worker.id === "compression") { - url = options.workerUrl; - } - if (options._workerType === "test") { - url = "modules/".concat(worker.module, "/dist/").concat(workerFile); - } - if (!url) { - let version = worker.version; - if (version === "latest") { - version = NPM_TAG; - } - const versionTag = version ? "@".concat(version) : ""; - url = "https://unpkg.com/@loaders.gl/".concat(worker.module).concat(versionTag, "/dist/").concat(workerFile); - } - assert2(url); - return url; - } - - // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-api/validate-worker-version.js - function validateWorkerVersion(worker) { - let coreVersion = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : VERSION; - assert2(worker, "no worker provided"); - const workerVersion = worker.version; - if (!coreVersion || !workerVersion) { - return false; - } - return true; - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/worker-loader-utils/parse-with-worker.js - function canParseWithWorker(loader, options) { - if (!WorkerFarm.isSupported()) { - return false; - } - if (!isBrowser2 && !(options !== null && options !== void 0 && options._nodeWorkers)) { - return false; - } - return loader.worker && (options === null || options === void 0 ? void 0 : options.worker); - } - async function parseWithWorker(loader, data, options, context, parseOnMainThread) { - const name = loader.id; - const url = getWorkerURL(loader, options); - const workerFarm = WorkerFarm.getWorkerFarm(options); - const workerPool = workerFarm.getWorkerPool({ - name, - url - }); - options = JSON.parse(JSON.stringify(options)); - context = JSON.parse(JSON.stringify(context || {})); - const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread)); - job.postMessage("process", { - input: data, - options, - context - }); - const result = await job.result; - return await result.result; - } - async function onMessage(parseOnMainThread, job, type, payload) { - switch (type) { - case "done": - job.done(payload); - break; - case "error": - job.error(new Error(payload.error)); - break; - case "process": - const { - id, - input, - options - } = payload; - try { - const result = await parseOnMainThread(input, options); - job.postMessage("done", { - id, - result - }); - } catch (error2) { - const message = error2 instanceof Error ? error2.message : "unknown error"; - job.postMessage("error", { - id, - error: message - }); + tr_static_init = () => { + let n2; + let bits; + let length4; + let code; + let dist; + const bl_count = new Array(MAX_BITS$1 + 1); + length4 = 0; + for (code = 0; code < LENGTH_CODES$1 - 1; code++) { + base_length[code] = length4; + for (n2 = 0; n2 < 1 << extra_lbits[code]; n2++) { + _length_code[length4++] = code; + } } - break; - default: - console.warn("parse-with-worker unknown message ".concat(type)); - } - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/binary-utils/array-buffer-utils.js - function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) { - byteLength = byteLength || arrayBuffer1.byteLength; - if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) { - return false; - } - const array12 = new Uint8Array(arrayBuffer1); - const array2 = new Uint8Array(arrayBuffer2); - for (let i2 = 0; i2 < array12.length; ++i2) { - if (array12[i2] !== array2[i2]) { - return false; - } - } - return true; - } - function concatenateArrayBuffers() { - for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) { - sources[_key] = arguments[_key]; - } - const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2); - const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0); - const result = new Uint8Array(byteLength); - let offset = 0; - for (const sourceArray of sourceArrays) { - result.set(sourceArray, offset); - offset += sourceArray.byteLength; - } - return result.buffer; - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/iterators/async-iteration.js - async function concatenateArrayBuffersAsync(asyncIterator) { - const arrayBuffers = []; - for await (const chunk of asyncIterator) { - arrayBuffers.push(chunk); - } - return concatenateArrayBuffers(...arrayBuffers); - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/path-utils/file-aliases.js - var pathPrefix = ""; - var fileAliases = {}; - function resolvePath(filename2) { - for (const alias in fileAliases) { - if (filename2.startsWith(alias)) { - const replacement = fileAliases[alias]; - filename2 = filename2.replace(alias, replacement); - } - } - if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) { - filename2 = "".concat(pathPrefix).concat(filename2); - } - return filename2; - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/node/buffer.browser.js - function toArrayBuffer(buffer) { - return buffer; - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/binary-utils/memory-conversion-utils.js - function isBuffer(value) { - return value && typeof value === "object" && value.isBuffer; - } - function toArrayBuffer2(data) { - if (isBuffer(data)) { - return toArrayBuffer(data); - } - if (data instanceof ArrayBuffer) { - return data; - } - if (ArrayBuffer.isView(data)) { - if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) { - return data.buffer; - } - return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength); - } - if (typeof data === "string") { - const text = data; - const uint8Array = new TextEncoder().encode(text); - return uint8Array.buffer; - } - if (data && typeof data === "object" && data._toArrayBuffer) { - return data._toArrayBuffer(); - } - throw new Error("toArrayBuffer"); - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/path-utils/path.js - var path_exports = {}; - __export(path_exports, { - dirname: () => dirname, - filename: () => filename, - join: () => join, - resolve: () => resolve - }); - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/path-utils/get-cwd.js - function getCWD() { - var _window$location; - if (typeof process !== "undefined" && typeof process.cwd !== "undefined") { - return process.cwd(); - } - const pathname = (_window$location = window.location) === null || _window$location === void 0 ? void 0 : _window$location.pathname; - return (pathname === null || pathname === void 0 ? void 0 : pathname.slice(0, pathname.lastIndexOf("/") + 1)) || ""; - } - - // node_modules/@loaders.gl/loader-utils/dist/esm/lib/path-utils/path.js - function filename(url) { - const slashIndex = url ? url.lastIndexOf("/") : -1; - return slashIndex >= 0 ? url.substr(slashIndex + 1) : ""; - } - function dirname(url) { - const slashIndex = url ? url.lastIndexOf("/") : -1; - return slashIndex >= 0 ? url.substr(0, slashIndex) : ""; - } - function join() { - for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) { - parts[_key] = arguments[_key]; - } - const separator = "/"; - parts = parts.map((part, index) => { - if (index) { - part = part.replace(new RegExp("^".concat(separator)), ""); - } - if (index !== parts.length - 1) { - part = part.replace(new RegExp("".concat(separator, "$")), ""); - } - return part; - }); - return parts.join(separator); - } - function resolve() { - const paths = []; - for (let _i = 0; _i < arguments.length; _i++) { - paths[_i] = _i < 0 || arguments.length <= _i ? void 0 : arguments[_i]; - } - let resolvedPath = ""; - let resolvedAbsolute = false; - let cwd; - for (let i2 = paths.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) { - let path; - if (i2 >= 0) { - path = paths[i2]; - } else { - if (cwd === void 0) { - cwd = getCWD(); + _length_code[length4 - 1] = code; + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n2 = 0; n2 < 1 << extra_dbits[code]; n2++) { + _dist_code[dist++] = code; + } } - path = cwd; - } - if (path.length === 0) { - continue; - } - resolvedPath = "".concat(path, "/").concat(resolvedPath); - resolvedAbsolute = path.charCodeAt(0) === SLASH; - } - resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute); - if (resolvedAbsolute) { - return "/".concat(resolvedPath); - } else if (resolvedPath.length > 0) { - return resolvedPath; - } - return "."; - } - var SLASH = 47; - var DOT = 46; - function normalizeStringPosix(path, allowAboveRoot) { - let res = ""; - let lastSlash = -1; - let dots = 0; - let code; - let isAboveRoot = false; - for (let i2 = 0; i2 <= path.length; ++i2) { - if (i2 < path.length) { - code = path.charCodeAt(i2); - } else if (code === SLASH) { - break; - } else { - code = SLASH; - } - if (code === SLASH) { - if (lastSlash === i2 - 1 || dots === 1) { - } else if (lastSlash !== i2 - 1 && dots === 2) { - if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) { - if (res.length > 2) { - const start = res.length - 1; - let j = start; - for (; j >= 0; --j) { - if (res.charCodeAt(j) === SLASH) { - break; - } + dist >>= 7; + for (; code < D_CODES$1; code++) { + base_dist[code] = dist << 7; + for (n2 = 0; n2 < 1 << extra_dbits[code] - 7; n2++) { + _dist_code[256 + dist++] = code; + } + } + for (bits = 0; bits <= MAX_BITS$1; bits++) { + bl_count[bits] = 0; + } + n2 = 0; + while (n2 <= 143) { + static_ltree[n2 * 2 + 1] = 8; + n2++; + bl_count[8]++; + } + while (n2 <= 255) { + static_ltree[n2 * 2 + 1] = 9; + n2++; + bl_count[9]++; + } + while (n2 <= 279) { + static_ltree[n2 * 2 + 1] = 7; + n2++; + bl_count[7]++; + } + while (n2 <= 287) { + static_ltree[n2 * 2 + 1] = 8; + n2++; + bl_count[8]++; + } + gen_codes(static_ltree, L_CODES$1 + 1, bl_count); + for (n2 = 0; n2 < D_CODES$1; n2++) { + static_dtree[n2 * 2 + 1] = 5; + static_dtree[n2 * 2] = bi_reverse(n2, 5); + } + static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS$1 + 1, L_CODES$1, MAX_BITS$1); + static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES$1, MAX_BITS$1); + static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES$1, MAX_BL_BITS); + }; + init_block = (s) => { + let n2; + for (n2 = 0; n2 < L_CODES$1; n2++) { + s.dyn_ltree[n2 * 2] = 0; + } + for (n2 = 0; n2 < D_CODES$1; n2++) { + s.dyn_dtree[n2 * 2] = 0; + } + for (n2 = 0; n2 < BL_CODES$1; n2++) { + s.bl_tree[n2 * 2] = 0; + } + s.dyn_ltree[END_BLOCK * 2] = 1; + s.opt_len = s.static_len = 0; + s.sym_next = s.matches = 0; + }; + bi_windup = (s) => { + if (s.bi_valid > 8) { + put_short(s, s.bi_buf); + } else if (s.bi_valid > 0) { + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; + }; + smaller = (tree, n2, m, depth) => { + const _n2 = n2 * 2; + const _m2 = m * 2; + return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n2] <= depth[m]; + }; + pqdownheap = (s, tree, k) => { + const v2 = s.heap[k]; + let j = k << 1; + while (j <= s.heap_len) { + if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) { + j++; + } + if (smaller(tree, v2, s.heap[j], s.depth)) { + break; + } + s.heap[k] = s.heap[j]; + k = j; + j <<= 1; + } + s.heap[k] = v2; + }; + compress_block = (s, ltree, dtree) => { + let dist; + let lc; + let sx = 0; + let code; + let extra; + if (s.sym_next !== 0) { + do { + dist = s.pending_buf[s.sym_buf + sx++] & 255; + dist += (s.pending_buf[s.sym_buf + sx++] & 255) << 8; + lc = s.pending_buf[s.sym_buf + sx++]; + if (dist === 0) { + send_code(s, lc, ltree); + } else { + code = _length_code[lc]; + send_code(s, code + LITERALS$1 + 1, ltree); + extra = extra_lbits[code]; + if (extra !== 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); } - if (j !== start) { - res = j === -1 ? "" : res.slice(0, j); - lastSlash = i2; - dots = 0; - isAboveRoot = false; - continue; + dist--; + code = d_code(dist); + send_code(s, code, dtree); + extra = extra_dbits[code]; + if (extra !== 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); } - } else if (res.length === 2 || res.length === 1) { - res = ""; - lastSlash = i2; - dots = 0; - isAboveRoot = false; - continue; } + } while (sx < s.sym_next); + } + send_code(s, END_BLOCK, ltree); + }; + build_tree = (s, desc) => { + const tree = desc.dyn_tree; + const stree = desc.stat_desc.static_tree; + const has_stree = desc.stat_desc.has_stree; + const elems = desc.stat_desc.elems; + let n2, m; + let max_code = -1; + let node; + s.heap_len = 0; + s.heap_max = HEAP_SIZE$1; + for (n2 = 0; n2 < elems; n2++) { + if (tree[n2 * 2] !== 0) { + s.heap[++s.heap_len] = max_code = n2; + s.depth[n2] = 0; + } else { + tree[n2 * 2 + 1] = 0; + } + } + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0; + tree[node * 2] = 1; + s.depth[node] = 0; + s.opt_len--; + if (has_stree) { + s.static_len -= stree[node * 2 + 1]; + } + } + desc.max_code = max_code; + for (n2 = s.heap_len >> 1; n2 >= 1; n2--) { + pqdownheap(s, tree, n2); + } + node = elems; + do { + n2 = s.heap[ + 1 + /*SMALLEST*/ + ]; + s.heap[ + 1 + /*SMALLEST*/ + ] = s.heap[s.heap_len--]; + pqdownheap( + s, + tree, + 1 + /*SMALLEST*/ + ); + m = s.heap[ + 1 + /*SMALLEST*/ + ]; + s.heap[--s.heap_max] = n2; + s.heap[--s.heap_max] = m; + tree[node * 2] = tree[n2 * 2] + tree[m * 2]; + s.depth[node] = (s.depth[n2] >= s.depth[m] ? s.depth[n2] : s.depth[m]) + 1; + tree[n2 * 2 + 1] = tree[m * 2 + 1] = node; + s.heap[ + 1 + /*SMALLEST*/ + ] = node++; + pqdownheap( + s, + tree, + 1 + /*SMALLEST*/ + ); + } while (s.heap_len >= 2); + s.heap[--s.heap_max] = s.heap[ + 1 + /*SMALLEST*/ + ]; + gen_bitlen(s, desc); + gen_codes(tree, max_code, s.bl_count); + }; + scan_tree = (s, tree, max_code) => { + let n2; + let prevlen = -1; + let curlen; + let nextlen = tree[0 * 2 + 1]; + let count2 = 0; + let max_count = 7; + let min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code + 1) * 2 + 1] = 65535; + for (n2 = 0; n2 <= max_code; n2++) { + curlen = nextlen; + nextlen = tree[(n2 + 1) * 2 + 1]; + if (++count2 < max_count && curlen === nextlen) { + continue; + } else if (count2 < min_count) { + s.bl_tree[curlen * 2] += count2; + } else if (curlen !== 0) { + if (curlen !== prevlen) { + s.bl_tree[curlen * 2]++; + } + s.bl_tree[REP_3_6 * 2]++; + } else if (count2 <= 10) { + s.bl_tree[REPZ_3_10 * 2]++; + } else { + s.bl_tree[REPZ_11_138 * 2]++; } - if (allowAboveRoot) { - if (res.length > 0) { - res += "/.."; - } else { - res = ".."; + count2 = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; + } + } + }; + send_tree = (s, tree, max_code) => { + let n2; + let prevlen = -1; + let curlen; + let nextlen = tree[0 * 2 + 1]; + let count2 = 0; + let max_count = 7; + let min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + for (n2 = 0; n2 <= max_code; n2++) { + curlen = nextlen; + nextlen = tree[(n2 + 1) * 2 + 1]; + if (++count2 < max_count && curlen === nextlen) { + continue; + } else if (count2 < min_count) { + do { + send_code(s, curlen, s.bl_tree); + } while (--count2 !== 0); + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code(s, curlen, s.bl_tree); + count2--; } - isAboveRoot = true; + send_code(s, REP_3_6, s.bl_tree); + send_bits(s, count2 - 3, 2); + } else if (count2 <= 10) { + send_code(s, REPZ_3_10, s.bl_tree); + send_bits(s, count2 - 3, 3); + } else { + send_code(s, REPZ_11_138, s.bl_tree); + send_bits(s, count2 - 11, 7); + } + count2 = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; + } + } + }; + build_bl_tree = (s) => { + let max_blindex; + scan_tree(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree(s, s.dyn_dtree, s.d_desc.max_code); + build_tree(s, s.bl_desc); + for (max_blindex = BL_CODES$1 - 1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) { + break; + } + } + s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + return max_blindex; + }; + send_all_trees = (s, lcodes, dcodes, blcodes) => { + let rank3; + send_bits(s, lcodes - 257, 5); + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); + for (rank3 = 0; rank3 < blcodes; rank3++) { + send_bits(s, s.bl_tree[bl_order[rank3] * 2 + 1], 3); + } + send_tree(s, s.dyn_ltree, lcodes - 1); + send_tree(s, s.dyn_dtree, dcodes - 1); + }; + detect_data_type = (s) => { + let block_mask = 4093624447; + let n2; + for (n2 = 0; n2 <= 31; n2++, block_mask >>>= 1) { + if (block_mask & 1 && s.dyn_ltree[n2 * 2] !== 0) { + return Z_BINARY; + } + } + if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 || s.dyn_ltree[13 * 2] !== 0) { + return Z_TEXT; + } + for (n2 = 32; n2 < LITERALS$1; n2++) { + if (s.dyn_ltree[n2 * 2] !== 0) { + return Z_TEXT; + } + } + return Z_BINARY; + }; + static_init_done = false; + _tr_init$1 = (s) => { + if (!static_init_done) { + tr_static_init(); + static_init_done = true; + } + s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); + s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); + s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); + s.bi_buf = 0; + s.bi_valid = 0; + init_block(s); + }; + _tr_stored_block$1 = (s, buf, stored_len, last) => { + send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); + bi_windup(s); + put_short(s, stored_len); + put_short(s, ~stored_len); + if (stored_len) { + s.pending_buf.set(s.window.subarray(buf, buf + stored_len), s.pending); + } + s.pending += stored_len; + }; + _tr_align$1 = (s) => { + send_bits(s, STATIC_TREES << 1, 3); + send_code(s, END_BLOCK, static_ltree); + bi_flush(s); + }; + _tr_flush_block$1 = (s, buf, stored_len, last) => { + let opt_lenb, static_lenb; + let max_blindex = 0; + if (s.level > 0) { + if (s.strm.data_type === Z_UNKNOWN$1) { + s.strm.data_type = detect_data_type(s); + } + build_tree(s, s.l_desc); + build_tree(s, s.d_desc); + max_blindex = build_bl_tree(s); + opt_lenb = s.opt_len + 3 + 7 >>> 3; + static_lenb = s.static_len + 3 + 7 >>> 3; + if (static_lenb <= opt_lenb) { + opt_lenb = static_lenb; } } else { - const slice = path.slice(lastSlash + 1, i2); - if (res.length > 0) { - res += "/".concat(slice); + opt_lenb = static_lenb = stored_len + 5; + } + if (stored_len + 4 <= opt_lenb && buf !== -1) { + _tr_stored_block$1(s, buf, stored_len, last); + } else if (s.strategy === Z_FIXED$1 || static_lenb === opt_lenb) { + send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + } else { + send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3); + send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1); + compress_block(s, s.dyn_ltree, s.dyn_dtree); + } + init_block(s); + if (last) { + bi_windup(s); + } + }; + _tr_tally$1 = (s, dist, lc) => { + s.pending_buf[s.sym_buf + s.sym_next++] = dist; + s.pending_buf[s.sym_buf + s.sym_next++] = dist >> 8; + s.pending_buf[s.sym_buf + s.sym_next++] = lc; + if (dist === 0) { + s.dyn_ltree[lc * 2]++; + } else { + s.matches++; + dist--; + s.dyn_ltree[(_length_code[lc] + LITERALS$1 + 1) * 2]++; + s.dyn_dtree[d_code(dist) * 2]++; + } + return s.sym_next === s.sym_end; + }; + _tr_init_1 = _tr_init$1; + _tr_stored_block_1 = _tr_stored_block$1; + _tr_flush_block_1 = _tr_flush_block$1; + _tr_tally_1 = _tr_tally$1; + _tr_align_1 = _tr_align$1; + trees = { + _tr_init: _tr_init_1, + _tr_stored_block: _tr_stored_block_1, + _tr_flush_block: _tr_flush_block_1, + _tr_tally: _tr_tally_1, + _tr_align: _tr_align_1 + }; + adler32 = (adler, buf, len2, pos) => { + let s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n2 = 0; + while (len2 !== 0) { + n2 = len2 > 2e3 ? 2e3 : len2; + len2 -= n2; + do { + s1 = s1 + buf[pos++] | 0; + s2 = s2 + s1 | 0; + } while (--n2); + s1 %= 65521; + s2 %= 65521; + } + return s1 | s2 << 16 | 0; + }; + adler32_1 = adler32; + makeTable = () => { + let c2, table = []; + for (var n2 = 0; n2 < 256; n2++) { + c2 = n2; + for (var k = 0; k < 8; k++) { + c2 = c2 & 1 ? 3988292384 ^ c2 >>> 1 : c2 >>> 1; + } + table[n2] = c2; + } + return table; + }; + crcTable = new Uint32Array(makeTable()); + crc32 = (crc, buf, len2, pos) => { + const t2 = crcTable; + const end = pos + len2; + crc ^= -1; + for (let i3 = pos; i3 < end; i3++) { + crc = crc >>> 8 ^ t2[(crc ^ buf[i3]) & 255]; + } + return crc ^ -1; + }; + crc32_1 = crc32; + messages = { + 2: "need dictionary", + /* Z_NEED_DICT 2 */ + 1: "stream end", + /* Z_STREAM_END 1 */ + 0: "", + /* Z_OK 0 */ + "-1": "file error", + /* Z_ERRNO (-1) */ + "-2": "stream error", + /* Z_STREAM_ERROR (-2) */ + "-3": "data error", + /* Z_DATA_ERROR (-3) */ + "-4": "insufficient memory", + /* Z_MEM_ERROR (-4) */ + "-5": "buffer error", + /* Z_BUF_ERROR (-5) */ + "-6": "incompatible version" + /* Z_VERSION_ERROR (-6) */ + }; + constants$2 = { + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + /* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + //Z_VERSION_ERROR: -6, + /* compression levels */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + /* Possible values of the data_type field (though see inflate()) */ + Z_BINARY: 0, + Z_TEXT: 1, + //Z_ASCII: 1, // = Z_TEXT (deprecated) + Z_UNKNOWN: 2, + /* The deflate compression method */ + Z_DEFLATED: 8 + //Z_NULL: null // Use -1 or null inline, depending on var type + }; + ({ _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = trees); + ({ + Z_NO_FLUSH: Z_NO_FLUSH$2, + Z_PARTIAL_FLUSH, + Z_FULL_FLUSH: Z_FULL_FLUSH$1, + Z_FINISH: Z_FINISH$3, + Z_BLOCK: Z_BLOCK$1, + Z_OK: Z_OK$3, + Z_STREAM_END: Z_STREAM_END$3, + Z_STREAM_ERROR: Z_STREAM_ERROR$2, + Z_DATA_ERROR: Z_DATA_ERROR$2, + Z_BUF_ERROR: Z_BUF_ERROR$1, + Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$1, + Z_FILTERED, + Z_HUFFMAN_ONLY, + Z_RLE, + Z_FIXED, + Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$1, + Z_UNKNOWN, + Z_DEFLATED: Z_DEFLATED$2 + } = constants$2); + MAX_MEM_LEVEL = 9; + MAX_WBITS$1 = 15; + DEF_MEM_LEVEL = 8; + LENGTH_CODES = 29; + LITERALS = 256; + L_CODES = LITERALS + 1 + LENGTH_CODES; + D_CODES = 30; + BL_CODES = 19; + HEAP_SIZE = 2 * L_CODES + 1; + MAX_BITS = 15; + MIN_MATCH = 3; + MAX_MATCH = 258; + MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1; + PRESET_DICT = 32; + INIT_STATE = 42; + GZIP_STATE = 57; + EXTRA_STATE = 69; + NAME_STATE = 73; + COMMENT_STATE = 91; + HCRC_STATE = 103; + BUSY_STATE = 113; + FINISH_STATE = 666; + BS_NEED_MORE = 1; + BS_BLOCK_DONE = 2; + BS_FINISH_STARTED = 3; + BS_FINISH_DONE = 4; + OS_CODE = 3; + err = (strm, errorCode) => { + strm.msg = messages[errorCode]; + return errorCode; + }; + rank = (f2) => { + return f2 * 2 - (f2 > 4 ? 9 : 0); + }; + zero = (buf) => { + let len2 = buf.length; + while (--len2 >= 0) { + buf[len2] = 0; + } + }; + slide_hash = (s) => { + let n2, m; + let p2; + let wsize = s.w_size; + n2 = s.hash_size; + p2 = n2; + do { + m = s.head[--p2]; + s.head[p2] = m >= wsize ? m - wsize : 0; + } while (--n2); + n2 = wsize; + p2 = n2; + do { + m = s.prev[--p2]; + s.prev[p2] = m >= wsize ? m - wsize : 0; + } while (--n2); + }; + HASH_ZLIB = (s, prev, data) => (prev << s.hash_shift ^ data) & s.hash_mask; + HASH = HASH_ZLIB; + flush_pending = (strm) => { + const s = strm.state; + let len2 = s.pending; + if (len2 > strm.avail_out) { + len2 = strm.avail_out; + } + if (len2 === 0) { + return; + } + strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len2), strm.next_out); + strm.next_out += len2; + s.pending_out += len2; + strm.total_out += len2; + strm.avail_out -= len2; + s.pending -= len2; + if (s.pending === 0) { + s.pending_out = 0; + } + }; + flush_block_only = (s, last) => { + _tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last); + s.block_start = s.strstart; + flush_pending(s.strm); + }; + put_byte = (s, b2) => { + s.pending_buf[s.pending++] = b2; + }; + putShortMSB = (s, b2) => { + s.pending_buf[s.pending++] = b2 >>> 8 & 255; + s.pending_buf[s.pending++] = b2 & 255; + }; + read_buf = (strm, buf, start, size) => { + let len2 = strm.avail_in; + if (len2 > size) { + len2 = size; + } + if (len2 === 0) { + return 0; + } + strm.avail_in -= len2; + buf.set(strm.input.subarray(strm.next_in, strm.next_in + len2), start); + if (strm.state.wrap === 1) { + strm.adler = adler32_1(strm.adler, buf, len2, start); + } else if (strm.state.wrap === 2) { + strm.adler = crc32_1(strm.adler, buf, len2, start); + } + strm.next_in += len2; + strm.total_in += len2; + return len2; + }; + longest_match = (s, cur_match) => { + let chain_length = s.max_chain_length; + let scan = s.strstart; + let match; + let len2; + let best_len = s.prev_length; + let nice_match = s.nice_match; + const limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0; + const _win = s.window; + const wmask = s.w_mask; + const prev = s.prev; + const strend = s.strstart + MAX_MATCH; + let scan_end1 = _win[scan + best_len - 1]; + let scan_end = _win[scan + best_len]; + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + if (nice_match > s.lookahead) { + nice_match = s.lookahead; + } + do { + match = cur_match; + if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) { + continue; + } + scan += 2; + match++; + do { + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend); + len2 = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + if (len2 > best_len) { + s.match_start = cur_match; + best_len = len2; + if (len2 >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; + } + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; + }; + fill_window = (s) => { + const _w_size = s.w_size; + let n2, more, str; + do { + more = s.window_size - s.lookahead - s.strstart; + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { + s.window.set(s.window.subarray(_w_size, _w_size + _w_size - more), 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + s.block_start -= _w_size; + if (s.insert > s.strstart) { + s.insert = s.strstart; + } + slide_hash(s); + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + n2 = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n2; + if (s.lookahead + s.insert >= MIN_MATCH) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + s.ins_h = HASH(s, s.ins_h, s.window[str + 1]); + while (s.insert) { + s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]); + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH) { + break; + } + } + } + } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); + }; + deflate_stored = (s, flush) => { + let min_block = s.pending_buf_size - 5 > s.w_size ? s.w_size : s.pending_buf_size - 5; + let len2, left, have, last = 0; + let used = s.strm.avail_in; + do { + len2 = 65535; + have = s.bi_valid + 42 >> 3; + if (s.strm.avail_out < have) { + break; + } + have = s.strm.avail_out - have; + left = s.strstart - s.block_start; + if (len2 > left + s.strm.avail_in) { + len2 = left + s.strm.avail_in; + } + if (len2 > have) { + len2 = have; + } + if (len2 < min_block && (len2 === 0 && flush !== Z_FINISH$3 || flush === Z_NO_FLUSH$2 || len2 !== left + s.strm.avail_in)) { + break; + } + last = flush === Z_FINISH$3 && len2 === left + s.strm.avail_in ? 1 : 0; + _tr_stored_block(s, 0, 0, last); + s.pending_buf[s.pending - 4] = len2; + s.pending_buf[s.pending - 3] = len2 >> 8; + s.pending_buf[s.pending - 2] = ~len2; + s.pending_buf[s.pending - 1] = ~len2 >> 8; + flush_pending(s.strm); + if (left) { + if (left > len2) { + left = len2; + } + s.strm.output.set(s.window.subarray(s.block_start, s.block_start + left), s.strm.next_out); + s.strm.next_out += left; + s.strm.avail_out -= left; + s.strm.total_out += left; + s.block_start += left; + len2 -= left; + } + if (len2) { + read_buf(s.strm, s.strm.output, s.strm.next_out, len2); + s.strm.next_out += len2; + s.strm.avail_out -= len2; + s.strm.total_out += len2; + } + } while (last === 0); + used -= s.strm.avail_in; + if (used) { + if (used >= s.w_size) { + s.matches = 2; + s.window.set(s.strm.input.subarray(s.strm.next_in - s.w_size, s.strm.next_in), 0); + s.strstart = s.w_size; + s.insert = s.strstart; } else { - res = slice; + if (s.window_size - s.strstart <= used) { + s.strstart -= s.w_size; + s.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0); + if (s.matches < 2) { + s.matches++; + } + if (s.insert > s.strstart) { + s.insert = s.strstart; + } + } + s.window.set(s.strm.input.subarray(s.strm.next_in - used, s.strm.next_in), s.strstart); + s.strstart += used; + s.insert += used > s.w_size - s.insert ? s.w_size - s.insert : used; } - isAboveRoot = false; + s.block_start = s.strstart; } - lastSlash = i2; - dots = 0; - } else if (code === DOT && dots !== -1) { - ++dots; - } else { - dots = -1; - } - } - return res; - } - - // node_modules/@loaders.gl/core/dist/esm/javascript-utils/is-type.js - var isBoolean = (x2) => typeof x2 === "boolean"; - var isFunction = (x2) => typeof x2 === "function"; - var isObject = (x2) => x2 !== null && typeof x2 === "object"; - var isPureObject = (x2) => isObject(x2) && x2.constructor === {}.constructor; - var isIterable = (x2) => x2 && typeof x2[Symbol.iterator] === "function"; - var isAsyncIterable = (x2) => x2 && typeof x2[Symbol.asyncIterator] === "function"; - var isResponse = (x2) => typeof Response !== "undefined" && x2 instanceof Response || x2 && x2.arrayBuffer && x2.text && x2.json; - var isBlob = (x2) => typeof Blob !== "undefined" && x2 instanceof Blob; - var isBuffer2 = (x2) => x2 && typeof x2 === "object" && x2.isBuffer; - var isReadableDOMStream = (x2) => typeof ReadableStream !== "undefined" && x2 instanceof ReadableStream || isObject(x2) && isFunction(x2.tee) && isFunction(x2.cancel) && isFunction(x2.getReader); - var isReadableNodeStream = (x2) => isObject(x2) && isFunction(x2.read) && isFunction(x2.pipe) && isBoolean(x2.readable); - var isReadableStream = (x2) => isReadableDOMStream(x2) || isReadableNodeStream(x2); - - // node_modules/@loaders.gl/core/dist/esm/lib/utils/mime-type-utils.js + if (s.high_water < s.strstart) { + s.high_water = s.strstart; + } + if (last) { + return BS_FINISH_DONE; + } + if (flush !== Z_NO_FLUSH$2 && flush !== Z_FINISH$3 && s.strm.avail_in === 0 && s.strstart === s.block_start) { + return BS_BLOCK_DONE; + } + have = s.window_size - s.strstart; + if (s.strm.avail_in > have && s.block_start >= s.w_size) { + s.block_start -= s.w_size; + s.strstart -= s.w_size; + s.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0); + if (s.matches < 2) { + s.matches++; + } + have += s.w_size; + if (s.insert > s.strstart) { + s.insert = s.strstart; + } + } + if (have > s.strm.avail_in) { + have = s.strm.avail_in; + } + if (have) { + read_buf(s.strm, s.window, s.strstart, have); + s.strstart += have; + s.insert += have > s.w_size - s.insert ? s.w_size - s.insert : have; + } + if (s.high_water < s.strstart) { + s.high_water = s.strstart; + } + have = s.bi_valid + 42 >> 3; + have = s.pending_buf_size - have > 65535 ? 65535 : s.pending_buf_size - have; + min_block = have > s.w_size ? s.w_size : have; + left = s.strstart - s.block_start; + if (left >= min_block || (left || flush === Z_FINISH$3) && flush !== Z_NO_FLUSH$2 && s.strm.avail_in === 0 && left <= have) { + len2 = left > have ? have : left; + last = flush === Z_FINISH$3 && s.strm.avail_in === 0 && len2 === left ? 1 : 0; + _tr_stored_block(s, s.block_start, len2, last); + s.block_start += len2; + flush_pending(s.strm); + } + return last ? BS_FINISH_STARTED : BS_NEED_MORE; + }; + deflate_fast = (s, flush) => { + let hash_head; + let bflush; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH$2) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH) { + s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]); + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { + s.match_length = longest_match(s, hash_head); + } + if (s.match_length >= MIN_MATCH) { + bflush = _tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); + s.lookahead -= s.match_length; + if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) { + s.match_length--; + do { + s.strstart++; + s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]); + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } while (--s.match_length !== 0); + s.strstart++; + } else { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]); + } + } else { + bflush = _tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH$3) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.sym_next) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + }; + deflate_slow = (s, flush) => { + let hash_head; + let bflush; + let max_insert; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH$2) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH) { + s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]); + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH - 1; + if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { + s.match_length = longest_match(s, hash_head); + if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) { + s.match_length = MIN_MATCH - 1; + } + } + if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH; + bflush = _tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH); + s.lookahead -= s.prev_length - 1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]); + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH - 1; + s.strstart++; + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } else if (s.match_available) { + bflush = _tr_tally(s, 0, s.window[s.strstart - 1]); + if (bflush) { + flush_block_only(s, false); + } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } else { + s.match_available = 1; + s.strstart++; + s.lookahead--; + } + } + if (s.match_available) { + bflush = _tr_tally(s, 0, s.window[s.strstart - 1]); + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH$3) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.sym_next) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + }; + deflate_rle = (s, flush) => { + let bflush; + let prev; + let scan, strend; + const _win = s.window; + for (; ; ) { + if (s.lookahead <= MAX_MATCH) { + fill_window(s); + if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH$2) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + s.match_length = 0; + if (s.lookahead >= MIN_MATCH && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH; + do { + } while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend); + s.match_length = MAX_MATCH - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } + } + } + if (s.match_length >= MIN_MATCH) { + bflush = _tr_tally(s, 1, s.match_length - MIN_MATCH); + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + bflush = _tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush === Z_FINISH$3) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.sym_next) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + }; + deflate_huff = (s, flush) => { + let bflush; + for (; ; ) { + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush === Z_NO_FLUSH$2) { + return BS_NEED_MORE; + } + break; + } + } + s.match_length = 0; + bflush = _tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush === Z_FINISH$3) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.sym_next) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + }; + configuration_table = [ + /* good lazy nice chain */ + new Config(0, 0, 0, 0, deflate_stored), + /* 0 store only */ + new Config(4, 4, 8, 4, deflate_fast), + /* 1 max speed, no lazy matches */ + new Config(4, 5, 16, 8, deflate_fast), + /* 2 */ + new Config(4, 6, 32, 32, deflate_fast), + /* 3 */ + new Config(4, 4, 16, 16, deflate_slow), + /* 4 lazy matches */ + new Config(8, 16, 32, 32, deflate_slow), + /* 5 */ + new Config(8, 16, 128, 128, deflate_slow), + /* 6 */ + new Config(8, 32, 128, 256, deflate_slow), + /* 7 */ + new Config(32, 128, 258, 1024, deflate_slow), + /* 8 */ + new Config(32, 258, 258, 4096, deflate_slow) + /* 9 max compression */ + ]; + lm_init = (s) => { + s.window_size = 2 * s.w_size; + zero(s.head); + s.max_lazy_match = configuration_table[s.level].max_lazy; + s.good_match = configuration_table[s.level].good_length; + s.nice_match = configuration_table[s.level].nice_length; + s.max_chain_length = configuration_table[s.level].max_chain; + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + s.ins_h = 0; + }; + deflateStateCheck = (strm) => { + if (!strm) { + return 1; + } + const s = strm.state; + if (!s || s.strm !== strm || s.status !== INIT_STATE && //#ifdef GZIP + s.status !== GZIP_STATE && //#endif + s.status !== EXTRA_STATE && s.status !== NAME_STATE && s.status !== COMMENT_STATE && s.status !== HCRC_STATE && s.status !== BUSY_STATE && s.status !== FINISH_STATE) { + return 1; + } + return 0; + }; + deflateResetKeep = (strm) => { + if (deflateStateCheck(strm)) { + return err(strm, Z_STREAM_ERROR$2); + } + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN; + const s = strm.state; + s.pending = 0; + s.pending_out = 0; + if (s.wrap < 0) { + s.wrap = -s.wrap; + } + s.status = //#ifdef GZIP + s.wrap === 2 ? GZIP_STATE : ( + //#endif + s.wrap ? INIT_STATE : BUSY_STATE + ); + strm.adler = s.wrap === 2 ? 0 : 1; + s.last_flush = -2; + _tr_init(s); + return Z_OK$3; + }; + deflateReset = (strm) => { + const ret = deflateResetKeep(strm); + if (ret === Z_OK$3) { + lm_init(strm.state); + } + return ret; + }; + deflateSetHeader = (strm, head) => { + if (deflateStateCheck(strm) || strm.state.wrap !== 2) { + return Z_STREAM_ERROR$2; + } + strm.state.gzhead = head; + return Z_OK$3; + }; + deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => { + if (!strm) { + return Z_STREAM_ERROR$2; + } + let wrap = 1; + if (level === Z_DEFAULT_COMPRESSION$1) { + level = 6; + } + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else if (windowBits > 15) { + wrap = 2; + windowBits -= 16; + } + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED$2 || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED || windowBits === 8 && wrap !== 1) { + return err(strm, Z_STREAM_ERROR$2); + } + if (windowBits === 8) { + windowBits = 9; + } + const s = new DeflateState(); + strm.state = s; + s.strm = strm; + s.status = INIT_STATE; + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); + s.window = new Uint8Array(s.w_size * 2); + s.head = new Uint16Array(s.hash_size); + s.prev = new Uint16Array(s.w_size); + s.lit_bufsize = 1 << memLevel + 6; + s.pending_buf_size = s.lit_bufsize * 4; + s.pending_buf = new Uint8Array(s.pending_buf_size); + s.sym_buf = s.lit_bufsize; + s.sym_end = (s.lit_bufsize - 1) * 3; + s.level = level; + s.strategy = strategy; + s.method = method; + return deflateReset(strm); + }; + deflateInit = (strm, level) => { + return deflateInit2(strm, level, Z_DEFLATED$2, MAX_WBITS$1, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY$1); + }; + deflate$2 = (strm, flush) => { + if (deflateStateCheck(strm) || flush > Z_BLOCK$1 || flush < 0) { + return strm ? err(strm, Z_STREAM_ERROR$2) : Z_STREAM_ERROR$2; + } + const s = strm.state; + if (!strm.output || strm.avail_in !== 0 && !strm.input || s.status === FINISH_STATE && flush !== Z_FINISH$3) { + return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR$1 : Z_STREAM_ERROR$2); + } + const old_flush = s.last_flush; + s.last_flush = flush; + if (s.pending !== 0) { + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK$3; + } + } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH$3) { + return err(strm, Z_BUF_ERROR$1); + } + if (s.status === FINISH_STATE && strm.avail_in !== 0) { + return err(strm, Z_BUF_ERROR$1); + } + if (s.status === INIT_STATE && s.wrap === 0) { + s.status = BUSY_STATE; + } + if (s.status === INIT_STATE) { + let header = Z_DEFLATED$2 + (s.w_bits - 8 << 4) << 8; + let level_flags = -1; + if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= level_flags << 6; + if (s.strstart !== 0) { + header |= PRESET_DICT; + } + header += 31 - header % 31; + putShortMSB(s, header); + if (s.strstart !== 0) { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 65535); + } + strm.adler = 1; + s.status = BUSY_STATE; + flush_pending(strm); + if (s.pending !== 0) { + s.last_flush = -1; + return Z_OK$3; + } + } + if (s.status === GZIP_STATE) { + strm.adler = 0; + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (!s.gzhead) { + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0); + put_byte(s, OS_CODE); + s.status = BUSY_STATE; + flush_pending(strm); + if (s.pending !== 0) { + s.last_flush = -1; + return Z_OK$3; + } + } else { + put_byte( + s, + (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16) + ); + put_byte(s, s.gzhead.time & 255); + put_byte(s, s.gzhead.time >> 8 & 255); + put_byte(s, s.gzhead.time >> 16 & 255); + put_byte(s, s.gzhead.time >> 24 & 255); + put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0); + put_byte(s, s.gzhead.os & 255); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte(s, s.gzhead.extra.length & 255); + put_byte(s, s.gzhead.extra.length >> 8 & 255); + } + if (s.gzhead.hcrc) { + strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE; + } + } + if (s.status === EXTRA_STATE) { + if (s.gzhead.extra) { + let beg = s.pending; + let left = (s.gzhead.extra.length & 65535) - s.gzindex; + while (s.pending + left > s.pending_buf_size) { + let copy3 = s.pending_buf_size - s.pending; + s.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy3), s.pending); + s.pending = s.pending_buf_size; + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg); + } + s.gzindex += copy3; + flush_pending(strm); + if (s.pending !== 0) { + s.last_flush = -1; + return Z_OK$3; + } + beg = 0; + left -= copy3; + } + let gzhead_extra = new Uint8Array(s.gzhead.extra); + s.pending_buf.set(gzhead_extra.subarray(s.gzindex, s.gzindex + left), s.pending); + s.pending += left; + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg); + } + s.gzindex = 0; + } + s.status = NAME_STATE; + } + if (s.status === NAME_STATE) { + if (s.gzhead.name) { + let beg = s.pending; + let val; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + if (s.pending !== 0) { + s.last_flush = -1; + return Z_OK$3; + } + beg = 0; + } + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg); + } + s.gzindex = 0; + } + s.status = COMMENT_STATE; + } + if (s.status === COMMENT_STATE) { + if (s.gzhead.comment) { + let beg = s.pending; + let val; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + if (s.pending !== 0) { + s.last_flush = -1; + return Z_OK$3; + } + beg = 0; + } + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg); + } + } + s.status = HCRC_STATE; + } + if (s.status === HCRC_STATE) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending(strm); + if (s.pending !== 0) { + s.last_flush = -1; + return Z_OK$3; + } + } + put_byte(s, strm.adler & 255); + put_byte(s, strm.adler >> 8 & 255); + strm.adler = 0; + } + s.status = BUSY_STATE; + flush_pending(strm); + if (s.pending !== 0) { + s.last_flush = -1; + return Z_OK$3; + } + } + if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH$2 && s.status !== FINISH_STATE) { + let bstate = s.level === 0 ? deflate_stored(s, flush) : s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush); + if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { + s.status = FINISH_STATE; + } + if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { + if (strm.avail_out === 0) { + s.last_flush = -1; + } + return Z_OK$3; + } + if (bstate === BS_BLOCK_DONE) { + if (flush === Z_PARTIAL_FLUSH) { + _tr_align(s); + } else if (flush !== Z_BLOCK$1) { + _tr_stored_block(s, 0, 0, false); + if (flush === Z_FULL_FLUSH$1) { + zero(s.head); + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK$3; + } + } + } + if (flush !== Z_FINISH$3) { + return Z_OK$3; + } + if (s.wrap <= 0) { + return Z_STREAM_END$3; + } + if (s.wrap === 2) { + put_byte(s, strm.adler & 255); + put_byte(s, strm.adler >> 8 & 255); + put_byte(s, strm.adler >> 16 & 255); + put_byte(s, strm.adler >> 24 & 255); + put_byte(s, strm.total_in & 255); + put_byte(s, strm.total_in >> 8 & 255); + put_byte(s, strm.total_in >> 16 & 255); + put_byte(s, strm.total_in >> 24 & 255); + } else { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 65535); + } + flush_pending(strm); + if (s.wrap > 0) { + s.wrap = -s.wrap; + } + return s.pending !== 0 ? Z_OK$3 : Z_STREAM_END$3; + }; + deflateEnd = (strm) => { + if (deflateStateCheck(strm)) { + return Z_STREAM_ERROR$2; + } + const status = strm.state.status; + strm.state = null; + return status === BUSY_STATE ? err(strm, Z_DATA_ERROR$2) : Z_OK$3; + }; + deflateSetDictionary = (strm, dictionary) => { + let dictLength = dictionary.length; + if (deflateStateCheck(strm)) { + return Z_STREAM_ERROR$2; + } + const s = strm.state; + const wrap = s.wrap; + if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) { + return Z_STREAM_ERROR$2; + } + if (wrap === 1) { + strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0); + } + s.wrap = 0; + if (dictLength >= s.w_size) { + if (wrap === 0) { + zero(s.head); + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + let tmpDict = new Uint8Array(s.w_size); + tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0); + dictionary = tmpDict; + dictLength = s.w_size; + } + const avail = strm.avail_in; + const next = strm.next_in; + const input = strm.input; + strm.avail_in = dictLength; + strm.next_in = 0; + strm.input = dictionary; + fill_window(s); + while (s.lookahead >= MIN_MATCH) { + let str = s.strstart; + let n2 = s.lookahead - (MIN_MATCH - 1); + do { + s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]); + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + } while (--n2); + s.strstart = str; + s.lookahead = MIN_MATCH - 1; + fill_window(s); + } + s.strstart += s.lookahead; + s.block_start = s.strstart; + s.insert = s.lookahead; + s.lookahead = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + strm.next_in = next; + strm.input = input; + strm.avail_in = avail; + s.wrap = wrap; + return Z_OK$3; + }; + deflateInit_1 = deflateInit; + deflateInit2_1 = deflateInit2; + deflateReset_1 = deflateReset; + deflateResetKeep_1 = deflateResetKeep; + deflateSetHeader_1 = deflateSetHeader; + deflate_2$1 = deflate$2; + deflateEnd_1 = deflateEnd; + deflateSetDictionary_1 = deflateSetDictionary; + deflateInfo = "pako deflate (from Nodeca project)"; + deflate_1$2 = { + deflateInit: deflateInit_1, + deflateInit2: deflateInit2_1, + deflateReset: deflateReset_1, + deflateResetKeep: deflateResetKeep_1, + deflateSetHeader: deflateSetHeader_1, + deflate: deflate_2$1, + deflateEnd: deflateEnd_1, + deflateSetDictionary: deflateSetDictionary_1, + deflateInfo + }; + _has = (obj, key) => { + return Object.prototype.hasOwnProperty.call(obj, key); + }; + assign = function(obj) { + const sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + const source = sources.shift(); + if (!source) { + continue; + } + if (typeof source !== "object") { + throw new TypeError(source + "must be non-object"); + } + for (const p2 in source) { + if (_has(source, p2)) { + obj[p2] = source[p2]; + } + } + } + return obj; + }; + flattenChunks = (chunks) => { + let len2 = 0; + for (let i3 = 0, l2 = chunks.length; i3 < l2; i3++) { + len2 += chunks[i3].length; + } + const result = new Uint8Array(len2); + for (let i3 = 0, pos = 0, l2 = chunks.length; i3 < l2; i3++) { + let chunk = chunks[i3]; + result.set(chunk, pos); + pos += chunk.length; + } + return result; + }; + common = { + assign, + flattenChunks + }; + STR_APPLY_UIA_OK = true; + try { + String.fromCharCode.apply(null, new Uint8Array(1)); + } catch (__) { + STR_APPLY_UIA_OK = false; + } + _utf8len = new Uint8Array(256); + for (let q = 0; q < 256; q++) { + _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1; + } + _utf8len[254] = _utf8len[254] = 1; + string2buf = (str) => { + if (typeof TextEncoder === "function" && TextEncoder.prototype.encode) { + return new TextEncoder().encode(str); + } + let buf, c2, c22, m_pos, i3, str_len = str.length, buf_len = 0; + for (m_pos = 0; m_pos < str_len; m_pos++) { + c2 = str.charCodeAt(m_pos); + if ((c2 & 64512) === 55296 && m_pos + 1 < str_len) { + c22 = str.charCodeAt(m_pos + 1); + if ((c22 & 64512) === 56320) { + c2 = 65536 + (c2 - 55296 << 10) + (c22 - 56320); + m_pos++; + } + } + buf_len += c2 < 128 ? 1 : c2 < 2048 ? 2 : c2 < 65536 ? 3 : 4; + } + buf = new Uint8Array(buf_len); + for (i3 = 0, m_pos = 0; i3 < buf_len; m_pos++) { + c2 = str.charCodeAt(m_pos); + if ((c2 & 64512) === 55296 && m_pos + 1 < str_len) { + c22 = str.charCodeAt(m_pos + 1); + if ((c22 & 64512) === 56320) { + c2 = 65536 + (c2 - 55296 << 10) + (c22 - 56320); + m_pos++; + } + } + if (c2 < 128) { + buf[i3++] = c2; + } else if (c2 < 2048) { + buf[i3++] = 192 | c2 >>> 6; + buf[i3++] = 128 | c2 & 63; + } else if (c2 < 65536) { + buf[i3++] = 224 | c2 >>> 12; + buf[i3++] = 128 | c2 >>> 6 & 63; + buf[i3++] = 128 | c2 & 63; + } else { + buf[i3++] = 240 | c2 >>> 18; + buf[i3++] = 128 | c2 >>> 12 & 63; + buf[i3++] = 128 | c2 >>> 6 & 63; + buf[i3++] = 128 | c2 & 63; + } + } + return buf; + }; + buf2binstring = (buf, len2) => { + if (len2 < 65534) { + if (buf.subarray && STR_APPLY_UIA_OK) { + return String.fromCharCode.apply(null, buf.length === len2 ? buf : buf.subarray(0, len2)); + } + } + let result = ""; + for (let i3 = 0; i3 < len2; i3++) { + result += String.fromCharCode(buf[i3]); + } + return result; + }; + buf2string = (buf, max) => { + const len2 = max || buf.length; + if (typeof TextDecoder === "function" && TextDecoder.prototype.decode) { + return new TextDecoder().decode(buf.subarray(0, max)); + } + let i3, out; + const utf16buf = new Array(len2 * 2); + for (out = 0, i3 = 0; i3 < len2; ) { + let c2 = buf[i3++]; + if (c2 < 128) { + utf16buf[out++] = c2; + continue; + } + let c_len = _utf8len[c2]; + if (c_len > 4) { + utf16buf[out++] = 65533; + i3 += c_len - 1; + continue; + } + c2 &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7; + while (c_len > 1 && i3 < len2) { + c2 = c2 << 6 | buf[i3++] & 63; + c_len--; + } + if (c_len > 1) { + utf16buf[out++] = 65533; + continue; + } + if (c2 < 65536) { + utf16buf[out++] = c2; + } else { + c2 -= 65536; + utf16buf[out++] = 55296 | c2 >> 10 & 1023; + utf16buf[out++] = 56320 | c2 & 1023; + } + } + return buf2binstring(utf16buf, out); + }; + utf8border = (buf, max) => { + max = max || buf.length; + if (max > buf.length) { + max = buf.length; + } + let pos = max - 1; + while (pos >= 0 && (buf[pos] & 192) === 128) { + pos--; + } + if (pos < 0) { + return max; + } + if (pos === 0) { + return max; + } + return pos + _utf8len[buf[pos]] > max ? pos : max; + }; + strings = { + string2buf, + buf2string, + utf8border + }; + zstream = ZStream; + toString$1 = Object.prototype.toString; + ({ + Z_NO_FLUSH: Z_NO_FLUSH$1, + Z_SYNC_FLUSH, + Z_FULL_FLUSH, + Z_FINISH: Z_FINISH$2, + Z_OK: Z_OK$2, + Z_STREAM_END: Z_STREAM_END$2, + Z_DEFAULT_COMPRESSION, + Z_DEFAULT_STRATEGY, + Z_DEFLATED: Z_DEFLATED$1 + } = constants$2); + Deflate$1.prototype.push = function(data, flush_mode) { + const strm = this.strm; + const chunkSize = this.options.chunkSize; + let status, _flush_mode; + if (this.ended) { + return false; + } + if (flush_mode === ~~flush_mode) + _flush_mode = flush_mode; + else + _flush_mode = flush_mode === true ? Z_FINISH$2 : Z_NO_FLUSH$1; + if (typeof data === "string") { + strm.input = strings.string2buf(data); + } else if (toString$1.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + for (; ; ) { + if (strm.avail_out === 0) { + strm.output = new Uint8Array(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH) && strm.avail_out <= 6) { + this.onData(strm.output.subarray(0, strm.next_out)); + strm.avail_out = 0; + continue; + } + status = deflate_1$2.deflate(strm, _flush_mode); + if (status === Z_STREAM_END$2) { + if (strm.next_out > 0) { + this.onData(strm.output.subarray(0, strm.next_out)); + } + status = deflate_1$2.deflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === Z_OK$2; + } + if (strm.avail_out === 0) { + this.onData(strm.output); + continue; + } + if (_flush_mode > 0 && strm.next_out > 0) { + this.onData(strm.output.subarray(0, strm.next_out)); + strm.avail_out = 0; + continue; + } + if (strm.avail_in === 0) + break; + } + return true; + }; + Deflate$1.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Deflate$1.prototype.onEnd = function(status) { + if (status === Z_OK$2) { + this.result = common.flattenChunks(this.chunks); + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + Deflate_1$1 = Deflate$1; + deflate_2 = deflate$1; + deflateRaw_1$1 = deflateRaw$1; + gzip_1$1 = gzip$1; + constants$1 = constants$2; + deflate_1$1 = { + Deflate: Deflate_1$1, + deflate: deflate_2, + deflateRaw: deflateRaw_1$1, + gzip: gzip_1$1, + constants: constants$1 + }; + BAD$1 = 16209; + TYPE$1 = 16191; + inffast = function inflate_fast(strm, start) { + let _in; + let last; + let _out; + let beg; + let end; + let dmax; + let wsize; + let whave; + let wnext; + let s_window; + let hold; + let bits; + let lcode; + let dcode; + let lmask; + let dmask; + let here; + let op; + let len2; + let dist; + let from; + let from_source; + let input, output; + const state = strm.state; + _in = strm.next_in; + input = strm.input; + last = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); + dmax = state.dmax; + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = lcode[hold & lmask]; + dolen: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op === 0) { + output[_out++] = here & 65535; + } else if (op & 16) { + len2 = here & 65535; + op &= 15; + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len2 += hold & (1 << op) - 1; + hold >>>= op; + bits -= op; + } + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + dodist: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op & 16) { + dist = here & 65535; + op &= 15; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & (1 << op) - 1; + if (dist > dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD$1; + break top; + } + hold >>>= op; + bits -= op; + op = _out - beg; + if (dist > op) { + op = dist - op; + if (op > whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD$1; + break top; + } + } + from = 0; + from_source = s_window; + if (wnext === 0) { + from += wsize - op; + if (op < len2) { + len2 -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } else if (wnext < op) { + from += wsize + wnext - op; + op -= wnext; + if (op < len2) { + len2 -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len2) { + op = wnext; + len2 -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + } else { + from += wnext - op; + if (op < len2) { + len2 -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + while (len2 > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len2 -= 3; + } + if (len2) { + output[_out++] = from_source[from++]; + if (len2 > 1) { + output[_out++] = from_source[from++]; + } + } + } else { + from = _out - dist; + do { + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len2 -= 3; + } while (len2 > 2); + if (len2) { + output[_out++] = output[from++]; + if (len2 > 1) { + output[_out++] = output[from++]; + } + } + } + } else if ((op & 64) === 0) { + here = dcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dodist; + } else { + strm.msg = "invalid distance code"; + state.mode = BAD$1; + break top; + } + break; + } + } else if ((op & 64) === 0) { + here = lcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dolen; + } else if (op & 32) { + state.mode = TYPE$1; + break top; + } else { + strm.msg = "invalid literal/length code"; + state.mode = BAD$1; + break top; + } + break; + } + } while (_in < last && _out < end); + len2 = bits >> 3; + _in -= len2; + bits -= len2 << 3; + hold &= (1 << bits) - 1; + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last); + strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end); + state.hold = hold; + state.bits = bits; + return; + }; + MAXBITS = 15; + ENOUGH_LENS$1 = 852; + ENOUGH_DISTS$1 = 592; + CODES$1 = 0; + LENS$1 = 1; + DISTS$1 = 2; + lbase = new Uint16Array([ + /* Length codes 257..285 base */ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 13, + 15, + 17, + 19, + 23, + 27, + 31, + 35, + 43, + 51, + 59, + 67, + 83, + 99, + 115, + 131, + 163, + 195, + 227, + 258, + 0, + 0 + ]); + lext = new Uint8Array([ + /* Length codes 257..285 extra */ + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 17, + 17, + 17, + 17, + 18, + 18, + 18, + 18, + 19, + 19, + 19, + 19, + 20, + 20, + 20, + 20, + 21, + 21, + 21, + 21, + 16, + 72, + 78 + ]); + dbase = new Uint16Array([ + /* Distance codes 0..29 base */ + 1, + 2, + 3, + 4, + 5, + 7, + 9, + 13, + 17, + 25, + 33, + 49, + 65, + 97, + 129, + 193, + 257, + 385, + 513, + 769, + 1025, + 1537, + 2049, + 3073, + 4097, + 6145, + 8193, + 12289, + 16385, + 24577, + 0, + 0 + ]); + dext = new Uint8Array([ + /* Distance codes 0..29 extra */ + 16, + 16, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 64, + 64 + ]); + inflate_table = (type, lens2, lens_index, codes, table, table_index, work, opts) => { + const bits = opts.bits; + let len2 = 0; + let sym = 0; + let min = 0, max = 0; + let root = 0; + let curr = 0; + let drop = 0; + let left = 0; + let used = 0; + let huff = 0; + let incr; + let fill; + let low; + let mask; + let next; + let base = null; + let match; + const count2 = new Uint16Array(MAXBITS + 1); + const offs = new Uint16Array(MAXBITS + 1); + let extra = null; + let here_bits, here_op, here_val; + for (len2 = 0; len2 <= MAXBITS; len2++) { + count2[len2] = 0; + } + for (sym = 0; sym < codes; sym++) { + count2[lens2[lens_index + sym]]++; + } + root = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count2[max] !== 0) { + break; + } + } + if (root > max) { + root = max; + } + if (max === 0) { + table[table_index++] = 1 << 24 | 64 << 16 | 0; + table[table_index++] = 1 << 24 | 64 << 16 | 0; + opts.bits = 1; + return 0; + } + for (min = 1; min < max; min++) { + if (count2[min] !== 0) { + break; + } + } + if (root < min) { + root = min; + } + left = 1; + for (len2 = 1; len2 <= MAXBITS; len2++) { + left <<= 1; + left -= count2[len2]; + if (left < 0) { + return -1; + } + } + if (left > 0 && (type === CODES$1 || max !== 1)) { + return -1; + } + offs[1] = 0; + for (len2 = 1; len2 < MAXBITS; len2++) { + offs[len2 + 1] = offs[len2] + count2[len2]; + } + for (sym = 0; sym < codes; sym++) { + if (lens2[lens_index + sym] !== 0) { + work[offs[lens2[lens_index + sym]]++] = sym; + } + } + if (type === CODES$1) { + base = extra = work; + match = 20; + } else if (type === LENS$1) { + base = lbase; + extra = lext; + match = 257; + } else { + base = dbase; + extra = dext; + match = 0; + } + huff = 0; + sym = 0; + len2 = min; + next = table_index; + curr = root; + drop = 0; + low = -1; + used = 1 << root; + mask = used - 1; + if (type === LENS$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) { + return 1; + } + for (; ; ) { + here_bits = len2 - drop; + if (work[sym] + 1 < match) { + here_op = 0; + here_val = work[sym]; + } else if (work[sym] >= match) { + here_op = extra[work[sym] - match]; + here_val = base[work[sym] - match]; + } else { + here_op = 32 + 64; + here_val = 0; + } + incr = 1 << len2 - drop; + fill = 1 << curr; + min = fill; + do { + fill -= incr; + table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0; + } while (fill !== 0); + incr = 1 << len2 - 1; + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + sym++; + if (--count2[len2] === 0) { + if (len2 === max) { + break; + } + len2 = lens2[lens_index + work[sym]]; + } + if (len2 > root && (huff & mask) !== low) { + if (drop === 0) { + drop = root; + } + next += min; + curr = len2 - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count2[curr + drop]; + if (left <= 0) { + break; + } + curr++; + left <<= 1; + } + used += 1 << curr; + if (type === LENS$1 && used > ENOUGH_LENS$1 || type === DISTS$1 && used > ENOUGH_DISTS$1) { + return 1; + } + low = huff & mask; + table[low] = root << 24 | curr << 16 | next - table_index | 0; + } + } + if (huff !== 0) { + table[next + huff] = len2 - drop << 24 | 64 << 16 | 0; + } + opts.bits = root; + return 0; + }; + inftrees = inflate_table; + CODES = 0; + LENS = 1; + DISTS = 2; + ({ + Z_FINISH: Z_FINISH$1, + Z_BLOCK, + Z_TREES, + Z_OK: Z_OK$1, + Z_STREAM_END: Z_STREAM_END$1, + Z_NEED_DICT: Z_NEED_DICT$1, + Z_STREAM_ERROR: Z_STREAM_ERROR$1, + Z_DATA_ERROR: Z_DATA_ERROR$1, + Z_MEM_ERROR: Z_MEM_ERROR$1, + Z_BUF_ERROR, + Z_DEFLATED + } = constants$2); + HEAD = 16180; + FLAGS = 16181; + TIME = 16182; + OS = 16183; + EXLEN = 16184; + EXTRA = 16185; + NAME = 16186; + COMMENT = 16187; + HCRC = 16188; + DICTID = 16189; + DICT = 16190; + TYPE = 16191; + TYPEDO = 16192; + STORED = 16193; + COPY_ = 16194; + COPY = 16195; + TABLE = 16196; + LENLENS = 16197; + CODELENS = 16198; + LEN_ = 16199; + LEN = 16200; + LENEXT = 16201; + DIST = 16202; + DISTEXT = 16203; + MATCH = 16204; + LIT = 16205; + CHECK = 16206; + LENGTH = 16207; + DONE = 16208; + BAD = 16209; + MEM = 16210; + SYNC = 16211; + ENOUGH_LENS = 852; + ENOUGH_DISTS = 592; + MAX_WBITS = 15; + DEF_WBITS = MAX_WBITS; + zswap32 = (q) => { + return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24); + }; + inflateStateCheck = (strm) => { + if (!strm) { + return 1; + } + const state = strm.state; + if (!state || state.strm !== strm || state.mode < HEAD || state.mode > SYNC) { + return 1; + } + return 0; + }; + inflateResetKeep = (strm) => { + if (inflateStateCheck(strm)) { + return Z_STREAM_ERROR$1; + } + const state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ""; + if (state.wrap) { + strm.adler = state.wrap & 1; + } + state.mode = HEAD; + state.last = 0; + state.havedict = 0; + state.flags = -1; + state.dmax = 32768; + state.head = null; + state.hold = 0; + state.bits = 0; + state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS); + state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS); + state.sane = 1; + state.back = -1; + return Z_OK$1; + }; + inflateReset = (strm) => { + if (inflateStateCheck(strm)) { + return Z_STREAM_ERROR$1; + } + const state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep(strm); + }; + inflateReset2 = (strm, windowBits) => { + let wrap; + if (inflateStateCheck(strm)) { + return Z_STREAM_ERROR$1; + } + const state = strm.state; + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else { + wrap = (windowBits >> 4) + 5; + if (windowBits < 48) { + windowBits &= 15; + } + } + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR$1; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset(strm); + }; + inflateInit2 = (strm, windowBits) => { + if (!strm) { + return Z_STREAM_ERROR$1; + } + const state = new InflateState(); + strm.state = state; + state.strm = strm; + state.window = null; + state.mode = HEAD; + const ret = inflateReset2(strm, windowBits); + if (ret !== Z_OK$1) { + strm.state = null; + } + return ret; + }; + inflateInit = (strm) => { + return inflateInit2(strm, DEF_WBITS); + }; + virgin = true; + fixedtables = (state) => { + if (virgin) { + lenfix = new Int32Array(512); + distfix = new Int32Array(32); + let sym = 0; + while (sym < 144) { + state.lens[sym++] = 8; + } + while (sym < 256) { + state.lens[sym++] = 9; + } + while (sym < 280) { + state.lens[sym++] = 7; + } + while (sym < 288) { + state.lens[sym++] = 8; + } + inftrees(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 }); + sym = 0; + while (sym < 32) { + state.lens[sym++] = 5; + } + inftrees(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 }); + virgin = false; + } + state.lencode = lenfix; + state.lenbits = 9; + state.distcode = distfix; + state.distbits = 5; + }; + updatewindow = (strm, src, end, copy3) => { + let dist; + const state = strm.state; + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + state.window = new Uint8Array(state.wsize); + } + if (copy3 >= state.wsize) { + state.window.set(src.subarray(end - state.wsize, end), 0); + state.wnext = 0; + state.whave = state.wsize; + } else { + dist = state.wsize - state.wnext; + if (dist > copy3) { + dist = copy3; + } + state.window.set(src.subarray(end - copy3, end - copy3 + dist), state.wnext); + copy3 -= dist; + if (copy3) { + state.window.set(src.subarray(end - copy3, end), 0); + state.wnext = copy3; + state.whave = state.wsize; + } else { + state.wnext += dist; + if (state.wnext === state.wsize) { + state.wnext = 0; + } + if (state.whave < state.wsize) { + state.whave += dist; + } + } + } + return 0; + }; + inflate$2 = (strm, flush) => { + let state; + let input, output; + let next; + let put; + let have, left; + let hold; + let bits; + let _in, _out; + let copy3; + let from; + let from_source; + let here = 0; + let here_bits, here_op, here_val; + let last_bits, last_op, last_val; + let len2; + let ret; + const hbuf = new Uint8Array(4); + let opts; + let n2; + const order = ( + /* permutation of code lengths */ + new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]) + ); + if (inflateStateCheck(strm) || !strm.output || !strm.input && strm.avail_in !== 0) { + return Z_STREAM_ERROR$1; + } + state = strm.state; + if (state.mode === TYPE) { + state.mode = TYPEDO; + } + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + _in = have; + _out = left; + ret = Z_OK$1; + inf_leave: + for (; ; ) { + switch (state.mode) { + case HEAD: + if (state.wrap === 0) { + state.mode = TYPEDO; + break; + } + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.wrap & 2 && hold === 35615) { + if (state.wbits === 0) { + state.wbits = 15; + } + state.check = 0; + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32_1(state.check, hbuf, 2, 0); + hold = 0; + bits = 0; + state.mode = FLAGS; + break; + } + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || /* check if zlib header allowed */ + (((hold & 255) << 8) + (hold >> 8)) % 31) { + strm.msg = "incorrect header check"; + state.mode = BAD; + break; + } + if ((hold & 15) !== Z_DEFLATED) { + strm.msg = "unknown compression method"; + state.mode = BAD; + break; + } + hold >>>= 4; + bits -= 4; + len2 = (hold & 15) + 8; + if (state.wbits === 0) { + state.wbits = len2; + } + if (len2 > 15 || len2 > state.wbits) { + strm.msg = "invalid window size"; + state.mode = BAD; + break; + } + state.dmax = 1 << state.wbits; + state.flags = 0; + strm.adler = state.check = 1; + state.mode = hold & 512 ? DICTID : TYPE; + hold = 0; + bits = 0; + break; + case FLAGS: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.flags = hold; + if ((state.flags & 255) !== Z_DEFLATED) { + strm.msg = "unknown compression method"; + state.mode = BAD; + break; + } + if (state.flags & 57344) { + strm.msg = "unknown header flags set"; + state.mode = BAD; + break; + } + if (state.head) { + state.head.text = hold >> 8 & 1; + } + if (state.flags & 512 && state.wrap & 4) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32_1(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = TIME; + case TIME: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.time = hold; + } + if (state.flags & 512 && state.wrap & 4) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + hbuf[2] = hold >>> 16 & 255; + hbuf[3] = hold >>> 24 & 255; + state.check = crc32_1(state.check, hbuf, 4, 0); + } + hold = 0; + bits = 0; + state.mode = OS; + case OS: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.xflags = hold & 255; + state.head.os = hold >> 8; + } + if (state.flags & 512 && state.wrap & 4) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32_1(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = EXLEN; + case EXLEN: + if (state.flags & 1024) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 512 && state.wrap & 4) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32_1(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + } else if (state.head) { + state.head.extra = null; + } + state.mode = EXTRA; + case EXTRA: + if (state.flags & 1024) { + copy3 = state.length; + if (copy3 > have) { + copy3 = have; + } + if (copy3) { + if (state.head) { + len2 = state.head.extra_len - state.length; + if (!state.head.extra) { + state.head.extra = new Uint8Array(state.head.extra_len); + } + state.head.extra.set( + input.subarray( + next, + // extra field is limited to 65536 bytes + // - no need for additional size check + next + copy3 + ), + /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ + len2 + ); + } + if (state.flags & 512 && state.wrap & 4) { + state.check = crc32_1(state.check, input, copy3, next); + } + have -= copy3; + next += copy3; + state.length -= copy3; + } + if (state.length) { + break inf_leave; + } + } + state.length = 0; + state.mode = NAME; + case NAME: + if (state.flags & 2048) { + if (have === 0) { + break inf_leave; + } + copy3 = 0; + do { + len2 = input[next + copy3++]; + if (state.head && len2 && state.length < 65536) { + state.head.name += String.fromCharCode(len2); + } + } while (len2 && copy3 < have); + if (state.flags & 512 && state.wrap & 4) { + state.check = crc32_1(state.check, input, copy3, next); + } + have -= copy3; + next += copy3; + if (len2) { + break inf_leave; + } + } else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + case COMMENT: + if (state.flags & 4096) { + if (have === 0) { + break inf_leave; + } + copy3 = 0; + do { + len2 = input[next + copy3++]; + if (state.head && len2 && state.length < 65536) { + state.head.comment += String.fromCharCode(len2); + } + } while (len2 && copy3 < have); + if (state.flags & 512 && state.wrap & 4) { + state.check = crc32_1(state.check, input, copy3, next); + } + have -= copy3; + next += copy3; + if (len2) { + break inf_leave; + } + } else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + case HCRC: + if (state.flags & 512) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.wrap & 4 && hold !== (state.check & 65535)) { + strm.msg = "header crc mismatch"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + if (state.head) { + state.head.hcrc = state.flags >> 9 & 1; + state.head.done = true; + } + strm.adler = state.check = 0; + state.mode = TYPE; + break; + case DICTID: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + strm.adler = state.check = zswap32(hold); + hold = 0; + bits = 0; + state.mode = DICT; + case DICT: + if (state.havedict === 0) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + return Z_NEED_DICT$1; + } + strm.adler = state.check = 1; + state.mode = TYPE; + case TYPE: + if (flush === Z_BLOCK || flush === Z_TREES) { + break inf_leave; + } + case TYPEDO: + if (state.last) { + hold >>>= bits & 7; + bits -= bits & 7; + state.mode = CHECK; + break; + } + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.last = hold & 1; + hold >>>= 1; + bits -= 1; + switch (hold & 3) { + case 0: + state.mode = STORED; + break; + case 1: + fixedtables(state); + state.mode = LEN_; + if (flush === Z_TREES) { + hold >>>= 2; + bits -= 2; + break inf_leave; + } + break; + case 2: + state.mode = TABLE; + break; + case 3: + strm.msg = "invalid block type"; + state.mode = BAD; + } + hold >>>= 2; + bits -= 2; + break; + case STORED: + hold >>>= bits & 7; + bits -= bits & 7; + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((hold & 65535) !== (hold >>> 16 ^ 65535)) { + strm.msg = "invalid stored block lengths"; + state.mode = BAD; + break; + } + state.length = hold & 65535; + hold = 0; + bits = 0; + state.mode = COPY_; + if (flush === Z_TREES) { + break inf_leave; + } + case COPY_: + state.mode = COPY; + case COPY: + copy3 = state.length; + if (copy3) { + if (copy3 > have) { + copy3 = have; + } + if (copy3 > left) { + copy3 = left; + } + if (copy3 === 0) { + break inf_leave; + } + output.set(input.subarray(next, next + copy3), put); + have -= copy3; + next += copy3; + left -= copy3; + put += copy3; + state.length -= copy3; + break; + } + state.mode = TYPE; + break; + case TABLE: + while (bits < 14) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.nlen = (hold & 31) + 257; + hold >>>= 5; + bits -= 5; + state.ndist = (hold & 31) + 1; + hold >>>= 5; + bits -= 5; + state.ncode = (hold & 15) + 4; + hold >>>= 4; + bits -= 4; + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = "too many length or distance symbols"; + state.mode = BAD; + break; + } + state.have = 0; + state.mode = LENLENS; + case LENLENS: + while (state.have < state.ncode) { + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.lens[order[state.have++]] = hold & 7; + hold >>>= 3; + bits -= 3; + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + state.lencode = state.lendyn; + state.lenbits = 7; + opts = { bits: state.lenbits }; + ret = inftrees(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid code lengths set"; + state.mode = BAD; + break; + } + state.have = 0; + state.mode = CODELENS; + case CODELENS: + while (state.have < state.nlen + state.ndist) { + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_val < 16) { + hold >>>= here_bits; + bits -= here_bits; + state.lens[state.have++] = here_val; + } else { + if (here_val === 16) { + n2 = here_bits + 2; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + if (state.have === 0) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + len2 = state.lens[state.have - 1]; + copy3 = 3 + (hold & 3); + hold >>>= 2; + bits -= 2; + } else if (here_val === 17) { + n2 = here_bits + 3; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len2 = 0; + copy3 = 3 + (hold & 7); + hold >>>= 3; + bits -= 3; + } else { + n2 = here_bits + 7; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len2 = 0; + copy3 = 11 + (hold & 127); + hold >>>= 7; + bits -= 7; + } + if (state.have + copy3 > state.nlen + state.ndist) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + while (copy3--) { + state.lens[state.have++] = len2; + } + } + } + if (state.mode === BAD) { + break; + } + if (state.lens[256] === 0) { + strm.msg = "invalid code -- missing end-of-block"; + state.mode = BAD; + break; + } + state.lenbits = 9; + opts = { bits: state.lenbits }; + ret = inftrees(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid literal/lengths set"; + state.mode = BAD; + break; + } + state.distbits = 6; + state.distcode = state.distdyn; + opts = { bits: state.distbits }; + ret = inftrees(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + state.distbits = opts.bits; + if (ret) { + strm.msg = "invalid distances set"; + state.mode = BAD; + break; + } + state.mode = LEN_; + if (flush === Z_TREES) { + break inf_leave; + } + case LEN_: + state.mode = LEN; + case LEN: + if (have >= 6 && left >= 258) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + inffast(strm, _out); + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + if (state.mode === TYPE) { + state.back = -1; + } + break; + } + state.back = 0; + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_op && (here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + state.mode = LIT; + break; + } + if (here_op & 32) { + state.back = -1; + state.mode = TYPE; + break; + } + if (here_op & 64) { + strm.msg = "invalid literal/length code"; + state.mode = BAD; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT; + case LENEXT: + if (state.extra) { + n2 = state.extra; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + state.was = state.length; + state.mode = DIST; + case DIST: + for (; ; ) { + here = state.distcode[hold & (1 << state.distbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + if (here_op & 64) { + strm.msg = "invalid distance code"; + state.mode = BAD; + break; + } + state.offset = here_val; + state.extra = here_op & 15; + state.mode = DISTEXT; + case DISTEXT: + if (state.extra) { + n2 = state.extra; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.offset += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + if (state.offset > state.dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + state.mode = MATCH; + case MATCH: + if (left === 0) { + break inf_leave; + } + copy3 = _out - left; + if (state.offset > copy3) { + copy3 = state.offset - copy3; + if (copy3 > state.whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + } + if (copy3 > state.wnext) { + copy3 -= state.wnext; + from = state.wsize - copy3; + } else { + from = state.wnext - copy3; + } + if (copy3 > state.length) { + copy3 = state.length; + } + from_source = state.window; + } else { + from_source = output; + from = put - state.offset; + copy3 = state.length; + } + if (copy3 > left) { + copy3 = left; + } + left -= copy3; + state.length -= copy3; + do { + output[put++] = from_source[from++]; + } while (--copy3); + if (state.length === 0) { + state.mode = LEN; + } + break; + case LIT: + if (left === 0) { + break inf_leave; + } + output[put++] = state.length; + left--; + state.mode = LEN; + break; + case CHECK: + if (state.wrap) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold |= input[next++] << bits; + bits += 8; + } + _out -= left; + strm.total_out += _out; + state.total += _out; + if (state.wrap & 4 && _out) { + strm.adler = state.check = /*UPDATE_CHECK(state.check, put - _out, _out);*/ + state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out); + } + _out = left; + if (state.wrap & 4 && (state.flags ? hold : zswap32(hold)) !== state.check) { + strm.msg = "incorrect data check"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + state.mode = LENGTH; + case LENGTH: + if (state.wrap && state.flags) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.wrap & 4 && hold !== (state.total & 4294967295)) { + strm.msg = "incorrect length check"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + state.mode = DONE; + case DONE: + ret = Z_STREAM_END$1; + break inf_leave; + case BAD: + ret = Z_DATA_ERROR$1; + break inf_leave; + case MEM: + return Z_MEM_ERROR$1; + case SYNC: + default: + return Z_STREAM_ERROR$1; + } + } + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + if (state.wsize || _out !== strm.avail_out && state.mode < BAD && (state.mode < CHECK || flush !== Z_FINISH$1)) { + if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) + ; + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap & 4 && _out) { + strm.adler = state.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/ + state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); + if ((_in === 0 && _out === 0 || flush === Z_FINISH$1) && ret === Z_OK$1) { + ret = Z_BUF_ERROR; + } + return ret; + }; + inflateEnd = (strm) => { + if (inflateStateCheck(strm)) { + return Z_STREAM_ERROR$1; + } + let state = strm.state; + if (state.window) { + state.window = null; + } + strm.state = null; + return Z_OK$1; + }; + inflateGetHeader = (strm, head) => { + if (inflateStateCheck(strm)) { + return Z_STREAM_ERROR$1; + } + const state = strm.state; + if ((state.wrap & 2) === 0) { + return Z_STREAM_ERROR$1; + } + state.head = head; + head.done = false; + return Z_OK$1; + }; + inflateSetDictionary = (strm, dictionary) => { + const dictLength = dictionary.length; + let state; + let dictid; + let ret; + if (inflateStateCheck(strm)) { + return Z_STREAM_ERROR$1; + } + state = strm.state; + if (state.wrap !== 0 && state.mode !== DICT) { + return Z_STREAM_ERROR$1; + } + if (state.mode === DICT) { + dictid = 1; + dictid = adler32_1(dictid, dictionary, dictLength, 0); + if (dictid !== state.check) { + return Z_DATA_ERROR$1; + } + } + ret = updatewindow(strm, dictionary, dictLength, dictLength); + if (ret) { + state.mode = MEM; + return Z_MEM_ERROR$1; + } + state.havedict = 1; + return Z_OK$1; + }; + inflateReset_1 = inflateReset; + inflateReset2_1 = inflateReset2; + inflateResetKeep_1 = inflateResetKeep; + inflateInit_1 = inflateInit; + inflateInit2_1 = inflateInit2; + inflate_2$1 = inflate$2; + inflateEnd_1 = inflateEnd; + inflateGetHeader_1 = inflateGetHeader; + inflateSetDictionary_1 = inflateSetDictionary; + inflateInfo = "pako inflate (from Nodeca project)"; + inflate_1$2 = { + inflateReset: inflateReset_1, + inflateReset2: inflateReset2_1, + inflateResetKeep: inflateResetKeep_1, + inflateInit: inflateInit_1, + inflateInit2: inflateInit2_1, + inflate: inflate_2$1, + inflateEnd: inflateEnd_1, + inflateGetHeader: inflateGetHeader_1, + inflateSetDictionary: inflateSetDictionary_1, + inflateInfo + }; + gzheader = GZheader; + toString = Object.prototype.toString; + ({ + Z_NO_FLUSH, + Z_FINISH, + Z_OK, + Z_STREAM_END, + Z_NEED_DICT, + Z_STREAM_ERROR, + Z_DATA_ERROR, + Z_MEM_ERROR + } = constants$2); + Inflate$1.prototype.push = function(data, flush_mode) { + const strm = this.strm; + const chunkSize = this.options.chunkSize; + const dictionary = this.options.dictionary; + let status, _flush_mode, last_avail_out; + if (this.ended) + return false; + if (flush_mode === ~~flush_mode) + _flush_mode = flush_mode; + else + _flush_mode = flush_mode === true ? Z_FINISH : Z_NO_FLUSH; + if (toString.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + for (; ; ) { + if (strm.avail_out === 0) { + strm.output = new Uint8Array(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status = inflate_1$2.inflate(strm, _flush_mode); + if (status === Z_NEED_DICT && dictionary) { + status = inflate_1$2.inflateSetDictionary(strm, dictionary); + if (status === Z_OK) { + status = inflate_1$2.inflate(strm, _flush_mode); + } else if (status === Z_DATA_ERROR) { + status = Z_NEED_DICT; + } + } + while (strm.avail_in > 0 && status === Z_STREAM_END && strm.state.wrap > 0 && data[strm.next_in] !== 0) { + inflate_1$2.inflateReset(strm); + status = inflate_1$2.inflate(strm, _flush_mode); + } + switch (status) { + case Z_STREAM_ERROR: + case Z_DATA_ERROR: + case Z_NEED_DICT: + case Z_MEM_ERROR: + this.onEnd(status); + this.ended = true; + return false; + } + last_avail_out = strm.avail_out; + if (strm.next_out) { + if (strm.avail_out === 0 || status === Z_STREAM_END) { + if (this.options.to === "string") { + let next_out_utf8 = strings.utf8border(strm.output, strm.next_out); + let tail = strm.next_out - next_out_utf8; + let utf8str = strings.buf2string(strm.output, next_out_utf8); + strm.next_out = tail; + strm.avail_out = chunkSize - tail; + if (tail) + strm.output.set(strm.output.subarray(next_out_utf8, next_out_utf8 + tail), 0); + this.onData(utf8str); + } else { + this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out)); + } + } + } + if (status === Z_OK && last_avail_out === 0) + continue; + if (status === Z_STREAM_END) { + status = inflate_1$2.inflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return true; + } + if (strm.avail_in === 0) + break; + } + return true; + }; + Inflate$1.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Inflate$1.prototype.onEnd = function(status) { + if (status === Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = common.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + Inflate_1$1 = Inflate$1; + inflate_2 = inflate$1; + inflateRaw_1$1 = inflateRaw$1; + ungzip$1 = inflate$1; + constants = constants$2; + inflate_1$1 = { + Inflate: Inflate_1$1, + inflate: inflate_2, + inflateRaw: inflateRaw_1$1, + ungzip: ungzip$1, + constants + }; + ({ Deflate, deflate, deflateRaw, gzip } = deflate_1$1); + ({ Inflate, inflate, inflateRaw, ungzip } = inflate_1$1); + inflate_1 = inflate; + } + }); + + // node_modules/geotiff/dist-module/compression/deflate.js + var deflate_exports = {}; + __export(deflate_exports, { + default: () => DeflateDecoder + }); + var DeflateDecoder; + var init_deflate = __esm({ + "node_modules/geotiff/dist-module/compression/deflate.js"() { + init_pako_esm(); + init_basedecoder(); + DeflateDecoder = class extends BaseDecoder { + decodeBlock(buffer) { + return inflate_1(new Uint8Array(buffer)).buffer; + } + }; + } + }); + + // node_modules/geotiff/dist-module/compression/packbits.js + var packbits_exports = {}; + __export(packbits_exports, { + default: () => PackbitsDecoder + }); + var PackbitsDecoder; + var init_packbits = __esm({ + "node_modules/geotiff/dist-module/compression/packbits.js"() { + init_basedecoder(); + PackbitsDecoder = class extends BaseDecoder { + decodeBlock(buffer) { + const dataView = new DataView(buffer); + const out = []; + for (let i3 = 0; i3 < buffer.byteLength; ++i3) { + let header = dataView.getInt8(i3); + if (header < 0) { + const next = dataView.getUint8(i3 + 1); + header = -header; + for (let j = 0; j <= header; ++j) { + out.push(next); + } + i3 += 1; + } else { + for (let j = 0; j <= header; ++j) { + out.push(dataView.getUint8(i3 + j + 1)); + } + i3 += header + 1; + } + } + return new Uint8Array(out).buffer; + } + }; + } + }); + + // node_modules/lerc/LercDecode.js + var require_LercDecode = __commonJS({ + "node_modules/lerc/LercDecode.js"(exports, module) { + (function() { + var LercDecode = function() { + var CntZImage = {}; + CntZImage.defaultNoDataValue = -34027999387901484e22; + CntZImage.decode = function(input, options) { + options = options || {}; + var skipMask = options.encodedMaskData || options.encodedMaskData === null; + var parsedData = parse2(input, options.inputOffset || 0, skipMask); + var noDataValue = options.noDataValue !== null ? options.noDataValue : CntZImage.defaultNoDataValue; + var uncompressedData = uncompressPixelValues( + parsedData, + options.pixelType || Float32Array, + options.encodedMaskData, + noDataValue, + options.returnMask + ); + var result = { + width: parsedData.width, + height: parsedData.height, + pixelData: uncompressedData.resultPixels, + minValue: uncompressedData.minValue, + maxValue: parsedData.pixels.maxValue, + noDataValue + }; + if (uncompressedData.resultMask) { + result.maskData = uncompressedData.resultMask; + } + if (options.returnEncodedMask && parsedData.mask) { + result.encodedMaskData = parsedData.mask.bitset ? parsedData.mask.bitset : null; + } + if (options.returnFileInfo) { + result.fileInfo = formatFileInfo(parsedData); + if (options.computeUsedBitDepths) { + result.fileInfo.bitDepths = computeUsedBitDepths(parsedData); + } + } + return result; + }; + var uncompressPixelValues = function(data, TypedArrayClass, maskBitset, noDataValue, storeDecodedMask) { + var blockIdx = 0; + var numX = data.pixels.numBlocksX; + var numY = data.pixels.numBlocksY; + var blockWidth = Math.floor(data.width / numX); + var blockHeight = Math.floor(data.height / numY); + var scale5 = 2 * data.maxZError; + var minValue = Number.MAX_VALUE, currentValue; + maskBitset = maskBitset || (data.mask ? data.mask.bitset : null); + var resultPixels, resultMask; + resultPixels = new TypedArrayClass(data.width * data.height); + if (storeDecodedMask && maskBitset) { + resultMask = new Uint8Array(data.width * data.height); + } + var blockDataBuffer = new Float32Array(blockWidth * blockHeight); + var xx, yy; + for (var y2 = 0; y2 <= numY; y2++) { + var thisBlockHeight = y2 !== numY ? blockHeight : data.height % numY; + if (thisBlockHeight === 0) { + continue; + } + for (var x2 = 0; x2 <= numX; x2++) { + var thisBlockWidth = x2 !== numX ? blockWidth : data.width % numX; + if (thisBlockWidth === 0) { + continue; + } + var outPtr = y2 * data.width * blockHeight + x2 * blockWidth; + var outStride = data.width - thisBlockWidth; + var block = data.pixels.blocks[blockIdx]; + var blockData, blockPtr, constValue; + if (block.encoding < 2) { + if (block.encoding === 0) { + blockData = block.rawData; + } else { + unstuff(block.stuffedData, block.bitsPerPixel, block.numValidPixels, block.offset, scale5, blockDataBuffer, data.pixels.maxValue); + blockData = blockDataBuffer; + } + blockPtr = 0; + } else if (block.encoding === 2) { + constValue = 0; + } else { + constValue = block.offset; + } + var maskByte; + if (maskBitset) { + for (yy = 0; yy < thisBlockHeight; yy++) { + if (outPtr & 7) { + maskByte = maskBitset[outPtr >> 3]; + maskByte <<= outPtr & 7; + } + for (xx = 0; xx < thisBlockWidth; xx++) { + if (!(outPtr & 7)) { + maskByte = maskBitset[outPtr >> 3]; + } + if (maskByte & 128) { + if (resultMask) { + resultMask[outPtr] = 1; + } + currentValue = block.encoding < 2 ? blockData[blockPtr++] : constValue; + minValue = minValue > currentValue ? currentValue : minValue; + resultPixels[outPtr++] = currentValue; + } else { + if (resultMask) { + resultMask[outPtr] = 0; + } + resultPixels[outPtr++] = noDataValue; + } + maskByte <<= 1; + } + outPtr += outStride; + } + } else { + if (block.encoding < 2) { + for (yy = 0; yy < thisBlockHeight; yy++) { + for (xx = 0; xx < thisBlockWidth; xx++) { + currentValue = blockData[blockPtr++]; + minValue = minValue > currentValue ? currentValue : minValue; + resultPixels[outPtr++] = currentValue; + } + outPtr += outStride; + } + } else { + minValue = minValue > constValue ? constValue : minValue; + for (yy = 0; yy < thisBlockHeight; yy++) { + for (xx = 0; xx < thisBlockWidth; xx++) { + resultPixels[outPtr++] = constValue; + } + outPtr += outStride; + } + } + } + if (block.encoding === 1 && blockPtr !== block.numValidPixels) { + throw "Block and Mask do not match"; + } + blockIdx++; + } + } + return { + resultPixels, + resultMask, + minValue + }; + }; + var formatFileInfo = function(data) { + return { + "fileIdentifierString": data.fileIdentifierString, + "fileVersion": data.fileVersion, + "imageType": data.imageType, + "height": data.height, + "width": data.width, + "maxZError": data.maxZError, + "eofOffset": data.eofOffset, + "mask": data.mask ? { + "numBlocksX": data.mask.numBlocksX, + "numBlocksY": data.mask.numBlocksY, + "numBytes": data.mask.numBytes, + "maxValue": data.mask.maxValue + } : null, + "pixels": { + "numBlocksX": data.pixels.numBlocksX, + "numBlocksY": data.pixels.numBlocksY, + "numBytes": data.pixels.numBytes, + "maxValue": data.pixels.maxValue, + "noDataValue": data.noDataValue + } + }; + }; + var computeUsedBitDepths = function(data) { + var numBlocks = data.pixels.numBlocksX * data.pixels.numBlocksY; + var bitDepths = {}; + for (var i3 = 0; i3 < numBlocks; i3++) { + var block = data.pixels.blocks[i3]; + if (block.encoding === 0) { + bitDepths.float32 = true; + } else if (block.encoding === 1) { + bitDepths[block.bitsPerPixel] = true; + } else { + bitDepths[0] = true; + } + } + return Object.keys(bitDepths); + }; + var parse2 = function(input, fp, skipMask) { + var data = {}; + var fileIdView = new Uint8Array(input, fp, 10); + data.fileIdentifierString = String.fromCharCode.apply(null, fileIdView); + if (data.fileIdentifierString.trim() !== "CntZImage") { + throw "Unexpected file identifier string: " + data.fileIdentifierString; + } + fp += 10; + var view = new DataView(input, fp, 24); + data.fileVersion = view.getInt32(0, true); + data.imageType = view.getInt32(4, true); + data.height = view.getUint32(8, true); + data.width = view.getUint32(12, true); + data.maxZError = view.getFloat64(16, true); + fp += 24; + if (!skipMask) { + view = new DataView(input, fp, 16); + data.mask = {}; + data.mask.numBlocksY = view.getUint32(0, true); + data.mask.numBlocksX = view.getUint32(4, true); + data.mask.numBytes = view.getUint32(8, true); + data.mask.maxValue = view.getFloat32(12, true); + fp += 16; + if (data.mask.numBytes > 0) { + var bitset = new Uint8Array(Math.ceil(data.width * data.height / 8)); + view = new DataView(input, fp, data.mask.numBytes); + var cnt = view.getInt16(0, true); + var ip = 2, op = 0; + do { + if (cnt > 0) { + while (cnt--) { + bitset[op++] = view.getUint8(ip++); + } + } else { + var val = view.getUint8(ip++); + cnt = -cnt; + while (cnt--) { + bitset[op++] = val; + } + } + cnt = view.getInt16(ip, true); + ip += 2; + } while (ip < data.mask.numBytes); + if (cnt !== -32768 || op < bitset.length) { + throw "Unexpected end of mask RLE encoding"; + } + data.mask.bitset = bitset; + fp += data.mask.numBytes; + } else if ((data.mask.numBytes | data.mask.numBlocksY | data.mask.maxValue) === 0) { + data.mask.bitset = new Uint8Array(Math.ceil(data.width * data.height / 8)); + } + } + view = new DataView(input, fp, 16); + data.pixels = {}; + data.pixels.numBlocksY = view.getUint32(0, true); + data.pixels.numBlocksX = view.getUint32(4, true); + data.pixels.numBytes = view.getUint32(8, true); + data.pixels.maxValue = view.getFloat32(12, true); + fp += 16; + var numBlocksX = data.pixels.numBlocksX; + var numBlocksY = data.pixels.numBlocksY; + var actualNumBlocksX = numBlocksX + (data.width % numBlocksX > 0 ? 1 : 0); + var actualNumBlocksY = numBlocksY + (data.height % numBlocksY > 0 ? 1 : 0); + data.pixels.blocks = new Array(actualNumBlocksX * actualNumBlocksY); + var blockI = 0; + for (var blockY = 0; blockY < actualNumBlocksY; blockY++) { + for (var blockX = 0; blockX < actualNumBlocksX; blockX++) { + var size = 0; + var bytesLeft = input.byteLength - fp; + view = new DataView(input, fp, Math.min(10, bytesLeft)); + var block = {}; + data.pixels.blocks[blockI++] = block; + var headerByte = view.getUint8(0); + size++; + block.encoding = headerByte & 63; + if (block.encoding > 3) { + throw "Invalid block encoding (" + block.encoding + ")"; + } + if (block.encoding === 2) { + fp++; + continue; + } + if (headerByte !== 0 && headerByte !== 2) { + headerByte >>= 6; + block.offsetType = headerByte; + if (headerByte === 2) { + block.offset = view.getInt8(1); + size++; + } else if (headerByte === 1) { + block.offset = view.getInt16(1, true); + size += 2; + } else if (headerByte === 0) { + block.offset = view.getFloat32(1, true); + size += 4; + } else { + throw "Invalid block offset type"; + } + if (block.encoding === 1) { + headerByte = view.getUint8(size); + size++; + block.bitsPerPixel = headerByte & 63; + headerByte >>= 6; + block.numValidPixelsType = headerByte; + if (headerByte === 2) { + block.numValidPixels = view.getUint8(size); + size++; + } else if (headerByte === 1) { + block.numValidPixels = view.getUint16(size, true); + size += 2; + } else if (headerByte === 0) { + block.numValidPixels = view.getUint32(size, true); + size += 4; + } else { + throw "Invalid valid pixel count type"; + } + } + } + fp += size; + if (block.encoding === 3) { + continue; + } + var arrayBuf, store8; + if (block.encoding === 0) { + var numPixels = (data.pixels.numBytes - 1) / 4; + if (numPixels !== Math.floor(numPixels)) { + throw "uncompressed block has invalid length"; + } + arrayBuf = new ArrayBuffer(numPixels * 4); + store8 = new Uint8Array(arrayBuf); + store8.set(new Uint8Array(input, fp, numPixels * 4)); + var rawData = new Float32Array(arrayBuf); + block.rawData = rawData; + fp += numPixels * 4; + } else if (block.encoding === 1) { + var dataBytes = Math.ceil(block.numValidPixels * block.bitsPerPixel / 8); + var dataWords = Math.ceil(dataBytes / 4); + arrayBuf = new ArrayBuffer(dataWords * 4); + store8 = new Uint8Array(arrayBuf); + store8.set(new Uint8Array(input, fp, dataBytes)); + block.stuffedData = new Uint32Array(arrayBuf); + fp += dataBytes; + } + } + } + data.eofOffset = fp; + return data; + }; + var unstuff = function(src, bitsPerPixel, numPixels, offset, scale5, dest, maxValue) { + var bitMask = (1 << bitsPerPixel) - 1; + var i3 = 0, o3; + var bitsLeft = 0; + var n2, buffer; + var nmax = Math.ceil((maxValue - offset) / scale5); + var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8); + src[src.length - 1] <<= 8 * numInvalidTailBytes; + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask; + bitsLeft -= bitsPerPixel; + } else { + var missingBits = bitsPerPixel - bitsLeft; + n2 = (buffer & bitMask) << missingBits & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 += buffer >>> bitsLeft; + } + dest[o3] = n2 < nmax ? offset + n2 * scale5 : maxValue; + } + return dest; + }; + return CntZImage; + }(); + var Lerc2Decode = function() { + "use strict"; + var BitStuffer = { + //methods ending with 2 are for the new byte order used by Lerc2.3 and above. + //originalUnstuff is used to unpack Huffman code table. code is duplicated to unstuffx for performance reasons. + unstuff: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale5, maxValue) { + var bitMask = (1 << bitsPerPixel) - 1; + var i3 = 0, o3; + var bitsLeft = 0; + var n2, buffer, missingBits, nmax; + var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8); + src[src.length - 1] <<= 8 * numInvalidTailBytes; + if (lutArr) { + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask; + bitsLeft -= bitsPerPixel; + } else { + missingBits = bitsPerPixel - bitsLeft; + n2 = (buffer & bitMask) << missingBits & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 += buffer >>> bitsLeft; + } + dest[o3] = lutArr[n2]; + } + } else { + nmax = Math.ceil((maxValue - offset) / scale5); + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask; + bitsLeft -= bitsPerPixel; + } else { + missingBits = bitsPerPixel - bitsLeft; + n2 = (buffer & bitMask) << missingBits & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 += buffer >>> bitsLeft; + } + dest[o3] = n2 < nmax ? offset + n2 * scale5 : maxValue; + } + } + }, + unstuffLUT: function(src, bitsPerPixel, numPixels, offset, scale5, maxValue) { + var bitMask = (1 << bitsPerPixel) - 1; + var i3 = 0, o3 = 0, missingBits = 0, bitsLeft = 0, n2 = 0; + var buffer; + var dest = []; + var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8); + src[src.length - 1] <<= 8 * numInvalidTailBytes; + var nmax = Math.ceil((maxValue - offset) / scale5); + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask; + bitsLeft -= bitsPerPixel; + } else { + missingBits = bitsPerPixel - bitsLeft; + n2 = (buffer & bitMask) << missingBits & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 += buffer >>> bitsLeft; + } + dest[o3] = n2 < nmax ? offset + n2 * scale5 : maxValue; + } + dest.unshift(offset); + return dest; + }, + unstuff2: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale5, maxValue) { + var bitMask = (1 << bitsPerPixel) - 1; + var i3 = 0, o3; + var bitsLeft = 0, bitPos = 0; + var n2, buffer, missingBits; + if (lutArr) { + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + bitPos = 0; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitPos & bitMask; + bitsLeft -= bitsPerPixel; + bitPos += bitsPerPixel; + } else { + missingBits = bitsPerPixel - bitsLeft; + n2 = buffer >>> bitPos & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits; + bitPos = missingBits; + } + dest[o3] = lutArr[n2]; + } + } else { + var nmax = Math.ceil((maxValue - offset) / scale5); + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + bitPos = 0; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitPos & bitMask; + bitsLeft -= bitsPerPixel; + bitPos += bitsPerPixel; + } else { + missingBits = bitsPerPixel - bitsLeft; + n2 = buffer >>> bitPos & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits; + bitPos = missingBits; + } + dest[o3] = n2 < nmax ? offset + n2 * scale5 : maxValue; + } + } + return dest; + }, + unstuffLUT2: function(src, bitsPerPixel, numPixels, offset, scale5, maxValue) { + var bitMask = (1 << bitsPerPixel) - 1; + var i3 = 0, o3 = 0, missingBits = 0, bitsLeft = 0, n2 = 0, bitPos = 0; + var buffer; + var dest = []; + var nmax = Math.ceil((maxValue - offset) / scale5); + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + bitPos = 0; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitPos & bitMask; + bitsLeft -= bitsPerPixel; + bitPos += bitsPerPixel; + } else { + missingBits = bitsPerPixel - bitsLeft; + n2 = buffer >>> bitPos & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits; + bitPos = missingBits; + } + dest[o3] = n2 < nmax ? offset + n2 * scale5 : maxValue; + } + dest.unshift(offset); + return dest; + }, + originalUnstuff: function(src, dest, bitsPerPixel, numPixels) { + var bitMask = (1 << bitsPerPixel) - 1; + var i3 = 0, o3; + var bitsLeft = 0; + var n2, buffer, missingBits; + var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8); + src[src.length - 1] <<= 8 * numInvalidTailBytes; + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitsLeft - bitsPerPixel & bitMask; + bitsLeft -= bitsPerPixel; + } else { + missingBits = bitsPerPixel - bitsLeft; + n2 = (buffer & bitMask) << missingBits & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 += buffer >>> bitsLeft; + } + dest[o3] = n2; + } + return dest; + }, + originalUnstuff2: function(src, dest, bitsPerPixel, numPixels) { + var bitMask = (1 << bitsPerPixel) - 1; + var i3 = 0, o3; + var bitsLeft = 0, bitPos = 0; + var n2, buffer, missingBits; + for (o3 = 0; o3 < numPixels; o3++) { + if (bitsLeft === 0) { + buffer = src[i3++]; + bitsLeft = 32; + bitPos = 0; + } + if (bitsLeft >= bitsPerPixel) { + n2 = buffer >>> bitPos & bitMask; + bitsLeft -= bitsPerPixel; + bitPos += bitsPerPixel; + } else { + missingBits = bitsPerPixel - bitsLeft; + n2 = buffer >>> bitPos & bitMask; + buffer = src[i3++]; + bitsLeft = 32 - missingBits; + n2 |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits; + bitPos = missingBits; + } + dest[o3] = n2; + } + return dest; + } + }; + var Lerc2Helpers = { + HUFFMAN_LUT_BITS_MAX: 12, + //use 2^12 lut, treat it like constant + computeChecksumFletcher32: function(input) { + var sum1 = 65535, sum2 = 65535; + var len2 = input.length; + var words = Math.floor(len2 / 2); + var i3 = 0; + while (words) { + var tlen = words >= 359 ? 359 : words; + words -= tlen; + do { + sum1 += input[i3++] << 8; + sum2 += sum1 += input[i3++]; + } while (--tlen); + sum1 = (sum1 & 65535) + (sum1 >>> 16); + sum2 = (sum2 & 65535) + (sum2 >>> 16); + } + if (len2 & 1) { + sum2 += sum1 += input[i3] << 8; + } + sum1 = (sum1 & 65535) + (sum1 >>> 16); + sum2 = (sum2 & 65535) + (sum2 >>> 16); + return (sum2 << 16 | sum1) >>> 0; + }, + readHeaderInfo: function(input, data) { + var ptr = data.ptr; + var fileIdView = new Uint8Array(input, ptr, 6); + var headerInfo = {}; + headerInfo.fileIdentifierString = String.fromCharCode.apply(null, fileIdView); + if (headerInfo.fileIdentifierString.lastIndexOf("Lerc2", 0) !== 0) { + throw "Unexpected file identifier string (expect Lerc2 ): " + headerInfo.fileIdentifierString; + } + ptr += 6; + var view = new DataView(input, ptr, 8); + var fileVersion = view.getInt32(0, true); + headerInfo.fileVersion = fileVersion; + ptr += 4; + if (fileVersion >= 3) { + headerInfo.checksum = view.getUint32(4, true); + ptr += 4; + } + view = new DataView(input, ptr, 12); + headerInfo.height = view.getUint32(0, true); + headerInfo.width = view.getUint32(4, true); + ptr += 8; + if (fileVersion >= 4) { + headerInfo.numDims = view.getUint32(8, true); + ptr += 4; + } else { + headerInfo.numDims = 1; + } + view = new DataView(input, ptr, 40); + headerInfo.numValidPixel = view.getUint32(0, true); + headerInfo.microBlockSize = view.getInt32(4, true); + headerInfo.blobSize = view.getInt32(8, true); + headerInfo.imageType = view.getInt32(12, true); + headerInfo.maxZError = view.getFloat64(16, true); + headerInfo.zMin = view.getFloat64(24, true); + headerInfo.zMax = view.getFloat64(32, true); + ptr += 40; + data.headerInfo = headerInfo; + data.ptr = ptr; + var checksum, keyLength; + if (fileVersion >= 3) { + keyLength = fileVersion >= 4 ? 52 : 48; + checksum = this.computeChecksumFletcher32(new Uint8Array(input, ptr - keyLength, headerInfo.blobSize - 14)); + if (checksum !== headerInfo.checksum) { + throw "Checksum failed."; + } + } + return true; + }, + checkMinMaxRanges: function(input, data) { + var headerInfo = data.headerInfo; + var OutPixelTypeArray = this.getDataTypeArray(headerInfo.imageType); + var rangeBytes = headerInfo.numDims * this.getDataTypeSize(headerInfo.imageType); + var minValues = this.readSubArray(input, data.ptr, OutPixelTypeArray, rangeBytes); + var maxValues = this.readSubArray(input, data.ptr + rangeBytes, OutPixelTypeArray, rangeBytes); + data.ptr += 2 * rangeBytes; + var i3, equal = true; + for (i3 = 0; i3 < headerInfo.numDims; i3++) { + if (minValues[i3] !== maxValues[i3]) { + equal = false; + break; + } + } + headerInfo.minValues = minValues; + headerInfo.maxValues = maxValues; + return equal; + }, + readSubArray: function(input, ptr, OutPixelTypeArray, numBytes) { + var rawData; + if (OutPixelTypeArray === Uint8Array) { + rawData = new Uint8Array(input, ptr, numBytes); + } else { + var arrayBuf = new ArrayBuffer(numBytes); + var store8 = new Uint8Array(arrayBuf); + store8.set(new Uint8Array(input, ptr, numBytes)); + rawData = new OutPixelTypeArray(arrayBuf); + } + return rawData; + }, + readMask: function(input, data) { + var ptr = data.ptr; + var headerInfo = data.headerInfo; + var numPixels = headerInfo.width * headerInfo.height; + var numValidPixel = headerInfo.numValidPixel; + var view = new DataView(input, ptr, 4); + var mask = {}; + mask.numBytes = view.getUint32(0, true); + ptr += 4; + if ((0 === numValidPixel || numPixels === numValidPixel) && 0 !== mask.numBytes) { + throw "invalid mask"; + } + var bitset, resultMask; + if (numValidPixel === 0) { + bitset = new Uint8Array(Math.ceil(numPixels / 8)); + mask.bitset = bitset; + resultMask = new Uint8Array(numPixels); + data.pixels.resultMask = resultMask; + ptr += mask.numBytes; + } else if (mask.numBytes > 0) { + bitset = new Uint8Array(Math.ceil(numPixels / 8)); + view = new DataView(input, ptr, mask.numBytes); + var cnt = view.getInt16(0, true); + var ip = 2, op = 0, val = 0; + do { + if (cnt > 0) { + while (cnt--) { + bitset[op++] = view.getUint8(ip++); + } + } else { + val = view.getUint8(ip++); + cnt = -cnt; + while (cnt--) { + bitset[op++] = val; + } + } + cnt = view.getInt16(ip, true); + ip += 2; + } while (ip < mask.numBytes); + if (cnt !== -32768 || op < bitset.length) { + throw "Unexpected end of mask RLE encoding"; + } + resultMask = new Uint8Array(numPixels); + var mb = 0, k = 0; + for (k = 0; k < numPixels; k++) { + if (k & 7) { + mb = bitset[k >> 3]; + mb <<= k & 7; + } else { + mb = bitset[k >> 3]; + } + if (mb & 128) { + resultMask[k] = 1; + } + } + data.pixels.resultMask = resultMask; + mask.bitset = bitset; + ptr += mask.numBytes; + } + data.ptr = ptr; + data.mask = mask; + return true; + }, + readDataOneSweep: function(input, data, OutPixelTypeArray, useBSQForOutputDim) { + var ptr = data.ptr; + var headerInfo = data.headerInfo; + var numDims = headerInfo.numDims; + var numPixels = headerInfo.width * headerInfo.height; + var imageType = headerInfo.imageType; + var numBytes = headerInfo.numValidPixel * Lerc2Helpers.getDataTypeSize(imageType) * numDims; + var rawData; + var mask = data.pixels.resultMask; + if (OutPixelTypeArray === Uint8Array) { + rawData = new Uint8Array(input, ptr, numBytes); + } else { + var arrayBuf = new ArrayBuffer(numBytes); + var store8 = new Uint8Array(arrayBuf); + store8.set(new Uint8Array(input, ptr, numBytes)); + rawData = new OutPixelTypeArray(arrayBuf); + } + if (rawData.length === numPixels * numDims) { + if (useBSQForOutputDim) { + data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(rawData, numPixels, numDims, OutPixelTypeArray, true); + } else { + data.pixels.resultPixels = rawData; + } + } else { + data.pixels.resultPixels = new OutPixelTypeArray(numPixels * numDims); + var z = 0, k = 0, i3 = 0, nStart = 0; + if (numDims > 1) { + if (useBSQForOutputDim) { + for (k = 0; k < numPixels; k++) { + if (mask[k]) { + nStart = k; + for (i3 = 0; i3 < numDims; i3++, nStart += numPixels) { + data.pixels.resultPixels[nStart] = rawData[z++]; + } + } + } + } else { + for (k = 0; k < numPixels; k++) { + if (mask[k]) { + nStart = k * numDims; + for (i3 = 0; i3 < numDims; i3++) { + data.pixels.resultPixels[nStart + i3] = rawData[z++]; + } + } + } + } + } else { + for (k = 0; k < numPixels; k++) { + if (mask[k]) { + data.pixels.resultPixels[k] = rawData[z++]; + } + } + } + } + ptr += numBytes; + data.ptr = ptr; + return true; + }, + readHuffmanTree: function(input, data) { + var BITS_MAX = this.HUFFMAN_LUT_BITS_MAX; + var view = new DataView(input, data.ptr, 16); + data.ptr += 16; + var version = view.getInt32(0, true); + if (version < 2) { + throw "unsupported Huffman version"; + } + var size = view.getInt32(4, true); + var i0 = view.getInt32(8, true); + var i1 = view.getInt32(12, true); + if (i0 >= i1) { + return false; + } + var blockDataBuffer = new Uint32Array(i1 - i0); + Lerc2Helpers.decodeBits(input, data, blockDataBuffer); + var codeTable = []; + var i3, j, k, len2; + for (i3 = i0; i3 < i1; i3++) { + j = i3 - (i3 < size ? 0 : size); + codeTable[j] = { first: blockDataBuffer[i3 - i0], second: null }; + } + var dataBytes = input.byteLength - data.ptr; + var dataWords = Math.ceil(dataBytes / 4); + var arrayBuf = new ArrayBuffer(dataWords * 4); + var store8 = new Uint8Array(arrayBuf); + store8.set(new Uint8Array(input, data.ptr, dataBytes)); + var stuffedData = new Uint32Array(arrayBuf); + var bitPos = 0, word, srcPtr = 0; + word = stuffedData[0]; + for (i3 = i0; i3 < i1; i3++) { + j = i3 - (i3 < size ? 0 : size); + len2 = codeTable[j].first; + if (len2 > 0) { + codeTable[j].second = word << bitPos >>> 32 - len2; + if (32 - bitPos >= len2) { + bitPos += len2; + if (bitPos === 32) { + bitPos = 0; + srcPtr++; + word = stuffedData[srcPtr]; + } + } else { + bitPos += len2 - 32; + srcPtr++; + word = stuffedData[srcPtr]; + codeTable[j].second |= word >>> 32 - bitPos; + } + } + } + var numBitsLUT = 0, numBitsLUTQick = 0; + var tree = new TreeNode(); + for (i3 = 0; i3 < codeTable.length; i3++) { + if (codeTable[i3] !== void 0) { + numBitsLUT = Math.max(numBitsLUT, codeTable[i3].first); + } + } + if (numBitsLUT >= BITS_MAX) { + numBitsLUTQick = BITS_MAX; + } else { + numBitsLUTQick = numBitsLUT; + } + var decodeLut = [], entry, code, numEntries, jj, currentBit, node; + for (i3 = i0; i3 < i1; i3++) { + j = i3 - (i3 < size ? 0 : size); + len2 = codeTable[j].first; + if (len2 > 0) { + entry = [len2, j]; + if (len2 <= numBitsLUTQick) { + code = codeTable[j].second << numBitsLUTQick - len2; + numEntries = 1 << numBitsLUTQick - len2; + for (k = 0; k < numEntries; k++) { + decodeLut[code | k] = entry; + } + } else { + code = codeTable[j].second; + node = tree; + for (jj = len2 - 1; jj >= 0; jj--) { + currentBit = code >>> jj & 1; + if (currentBit) { + if (!node.right) { + node.right = new TreeNode(); + } + node = node.right; + } else { + if (!node.left) { + node.left = new TreeNode(); + } + node = node.left; + } + if (jj === 0 && !node.val) { + node.val = entry[1]; + } + } + } + } + } + return { + decodeLut, + numBitsLUTQick, + numBitsLUT, + tree, + stuffedData, + srcPtr, + bitPos + }; + }, + readHuffman: function(input, data, OutPixelTypeArray, useBSQForOutputDim) { + var headerInfo = data.headerInfo; + var numDims = headerInfo.numDims; + var height = data.headerInfo.height; + var width = data.headerInfo.width; + var numPixels = width * height; + var huffmanInfo = this.readHuffmanTree(input, data); + var decodeLut = huffmanInfo.decodeLut; + var tree = huffmanInfo.tree; + var stuffedData = huffmanInfo.stuffedData; + var srcPtr = huffmanInfo.srcPtr; + var bitPos = huffmanInfo.bitPos; + var numBitsLUTQick = huffmanInfo.numBitsLUTQick; + var numBitsLUT = huffmanInfo.numBitsLUT; + var offset = data.headerInfo.imageType === 0 ? 128 : 0; + var node, val, delta, mask = data.pixels.resultMask, valTmp, valTmpQuick, currentBit; + var i3, j, k, ii; + var prevVal = 0; + if (bitPos > 0) { + srcPtr++; + bitPos = 0; + } + var word = stuffedData[srcPtr]; + var deltaEncode = data.encodeMode === 1; + var resultPixelsAllDim = new OutPixelTypeArray(numPixels * numDims); + var resultPixels = resultPixelsAllDim; + var iDim; + if (numDims < 2 || deltaEncode) { + for (iDim = 0; iDim < numDims; iDim++) { + if (numDims > 1) { + resultPixels = new OutPixelTypeArray(resultPixelsAllDim.buffer, numPixels * iDim, numPixels); + prevVal = 0; + } + if (data.headerInfo.numValidPixel === width * height) { + for (k = 0, i3 = 0; i3 < height; i3++) { + for (j = 0; j < width; j++, k++) { + val = 0; + valTmp = word << bitPos >>> 32 - numBitsLUTQick; + valTmpQuick = valTmp; + if (32 - bitPos < numBitsLUTQick) { + valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick; + valTmpQuick = valTmp; + } + if (decodeLut[valTmpQuick]) { + val = decodeLut[valTmpQuick][1]; + bitPos += decodeLut[valTmpQuick][0]; + } else { + valTmp = word << bitPos >>> 32 - numBitsLUT; + valTmpQuick = valTmp; + if (32 - bitPos < numBitsLUT) { + valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT; + valTmpQuick = valTmp; + } + node = tree; + for (ii = 0; ii < numBitsLUT; ii++) { + currentBit = valTmp >>> numBitsLUT - ii - 1 & 1; + node = currentBit ? node.right : node.left; + if (!(node.left || node.right)) { + val = node.val; + bitPos = bitPos + ii + 1; + break; + } + } + } + if (bitPos >= 32) { + bitPos -= 32; + srcPtr++; + word = stuffedData[srcPtr]; + } + delta = val - offset; + if (deltaEncode) { + if (j > 0) { + delta += prevVal; + } else if (i3 > 0) { + delta += resultPixels[k - width]; + } else { + delta += prevVal; + } + delta &= 255; + resultPixels[k] = delta; + prevVal = delta; + } else { + resultPixels[k] = delta; + } + } + } + } else { + for (k = 0, i3 = 0; i3 < height; i3++) { + for (j = 0; j < width; j++, k++) { + if (mask[k]) { + val = 0; + valTmp = word << bitPos >>> 32 - numBitsLUTQick; + valTmpQuick = valTmp; + if (32 - bitPos < numBitsLUTQick) { + valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick; + valTmpQuick = valTmp; + } + if (decodeLut[valTmpQuick]) { + val = decodeLut[valTmpQuick][1]; + bitPos += decodeLut[valTmpQuick][0]; + } else { + valTmp = word << bitPos >>> 32 - numBitsLUT; + valTmpQuick = valTmp; + if (32 - bitPos < numBitsLUT) { + valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT; + valTmpQuick = valTmp; + } + node = tree; + for (ii = 0; ii < numBitsLUT; ii++) { + currentBit = valTmp >>> numBitsLUT - ii - 1 & 1; + node = currentBit ? node.right : node.left; + if (!(node.left || node.right)) { + val = node.val; + bitPos = bitPos + ii + 1; + break; + } + } + } + if (bitPos >= 32) { + bitPos -= 32; + srcPtr++; + word = stuffedData[srcPtr]; + } + delta = val - offset; + if (deltaEncode) { + if (j > 0 && mask[k - 1]) { + delta += prevVal; + } else if (i3 > 0 && mask[k - width]) { + delta += resultPixels[k - width]; + } else { + delta += prevVal; + } + delta &= 255; + resultPixels[k] = delta; + prevVal = delta; + } else { + resultPixels[k] = delta; + } + } + } + } + } + } + } else { + for (k = 0, i3 = 0; i3 < height; i3++) { + for (j = 0; j < width; j++) { + k = i3 * width + j; + if (!mask || mask[k]) { + for (iDim = 0; iDim < numDims; iDim++, k += numPixels) { + val = 0; + valTmp = word << bitPos >>> 32 - numBitsLUTQick; + valTmpQuick = valTmp; + if (32 - bitPos < numBitsLUTQick) { + valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick; + valTmpQuick = valTmp; + } + if (decodeLut[valTmpQuick]) { + val = decodeLut[valTmpQuick][1]; + bitPos += decodeLut[valTmpQuick][0]; + } else { + valTmp = word << bitPos >>> 32 - numBitsLUT; + valTmpQuick = valTmp; + if (32 - bitPos < numBitsLUT) { + valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT; + valTmpQuick = valTmp; + } + node = tree; + for (ii = 0; ii < numBitsLUT; ii++) { + currentBit = valTmp >>> numBitsLUT - ii - 1 & 1; + node = currentBit ? node.right : node.left; + if (!(node.left || node.right)) { + val = node.val; + bitPos = bitPos + ii + 1; + break; + } + } + } + if (bitPos >= 32) { + bitPos -= 32; + srcPtr++; + word = stuffedData[srcPtr]; + } + delta = val - offset; + resultPixels[k] = delta; + } + } + } + } + } + data.ptr = data.ptr + (srcPtr + 1) * 4 + (bitPos > 0 ? 4 : 0); + data.pixels.resultPixels = resultPixelsAllDim; + if (numDims > 1 && !useBSQForOutputDim) { + data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(resultPixelsAllDim, numPixels, numDims, OutPixelTypeArray); + } + }, + decodeBits: function(input, data, blockDataBuffer, offset, iDim) { + { + var headerInfo = data.headerInfo; + var fileVersion = headerInfo.fileVersion; + var blockPtr = 0; + var viewByteLength = input.byteLength - data.ptr >= 5 ? 5 : input.byteLength - data.ptr; + var view = new DataView(input, data.ptr, viewByteLength); + var headerByte = view.getUint8(0); + blockPtr++; + var bits67 = headerByte >> 6; + var n2 = bits67 === 0 ? 4 : 3 - bits67; + var doLut = (headerByte & 32) > 0 ? true : false; + var numBits = headerByte & 31; + var numElements = 0; + if (n2 === 1) { + numElements = view.getUint8(blockPtr); + blockPtr++; + } else if (n2 === 2) { + numElements = view.getUint16(blockPtr, true); + blockPtr += 2; + } else if (n2 === 4) { + numElements = view.getUint32(blockPtr, true); + blockPtr += 4; + } else { + throw "Invalid valid pixel count type"; + } + var scale5 = 2 * headerInfo.maxZError; + var stuffedData, arrayBuf, store8, dataBytes, dataWords; + var lutArr, lutData, lutBytes, lutBitsPerElement, bitsPerPixel; + var zMax = headerInfo.numDims > 1 ? headerInfo.maxValues[iDim] : headerInfo.zMax; + if (doLut) { + data.counter.lut++; + lutBytes = view.getUint8(blockPtr); + lutBitsPerElement = numBits; + blockPtr++; + dataBytes = Math.ceil((lutBytes - 1) * numBits / 8); + dataWords = Math.ceil(dataBytes / 4); + arrayBuf = new ArrayBuffer(dataWords * 4); + store8 = new Uint8Array(arrayBuf); + data.ptr += blockPtr; + store8.set(new Uint8Array(input, data.ptr, dataBytes)); + lutData = new Uint32Array(arrayBuf); + data.ptr += dataBytes; + bitsPerPixel = 0; + while (lutBytes - 1 >>> bitsPerPixel) { + bitsPerPixel++; + } + dataBytes = Math.ceil(numElements * bitsPerPixel / 8); + dataWords = Math.ceil(dataBytes / 4); + arrayBuf = new ArrayBuffer(dataWords * 4); + store8 = new Uint8Array(arrayBuf); + store8.set(new Uint8Array(input, data.ptr, dataBytes)); + stuffedData = new Uint32Array(arrayBuf); + data.ptr += dataBytes; + if (fileVersion >= 3) { + lutArr = BitStuffer.unstuffLUT2(lutData, numBits, lutBytes - 1, offset, scale5, zMax); + } else { + lutArr = BitStuffer.unstuffLUT(lutData, numBits, lutBytes - 1, offset, scale5, zMax); + } + if (fileVersion >= 3) { + BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr); + } else { + BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr); + } + } else { + data.counter.bitstuffer++; + bitsPerPixel = numBits; + data.ptr += blockPtr; + if (bitsPerPixel > 0) { + dataBytes = Math.ceil(numElements * bitsPerPixel / 8); + dataWords = Math.ceil(dataBytes / 4); + arrayBuf = new ArrayBuffer(dataWords * 4); + store8 = new Uint8Array(arrayBuf); + store8.set(new Uint8Array(input, data.ptr, dataBytes)); + stuffedData = new Uint32Array(arrayBuf); + data.ptr += dataBytes; + if (fileVersion >= 3) { + if (offset == null) { + BitStuffer.originalUnstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements); + } else { + BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset, scale5, zMax); + } + } else { + if (offset == null) { + BitStuffer.originalUnstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements); + } else { + BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset, scale5, zMax); + } + } + } + } + } + }, + readTiles: function(input, data, OutPixelTypeArray, useBSQForOutputDim) { + var headerInfo = data.headerInfo; + var width = headerInfo.width; + var height = headerInfo.height; + var numPixels = width * height; + var microBlockSize = headerInfo.microBlockSize; + var imageType = headerInfo.imageType; + var dataTypeSize = Lerc2Helpers.getDataTypeSize(imageType); + var numBlocksX = Math.ceil(width / microBlockSize); + var numBlocksY = Math.ceil(height / microBlockSize); + data.pixels.numBlocksY = numBlocksY; + data.pixels.numBlocksX = numBlocksX; + data.pixels.ptr = 0; + var row = 0, col = 0, blockY = 0, blockX = 0, thisBlockHeight = 0, thisBlockWidth = 0, bytesLeft = 0, headerByte = 0, bits67 = 0, testCode = 0, outPtr = 0, outStride = 0, numBytes = 0, bytesleft = 0, z = 0, blockPtr = 0; + var view, block, arrayBuf, store8, rawData; + var blockEncoding; + var blockDataBuffer = new OutPixelTypeArray(microBlockSize * microBlockSize); + var lastBlockHeight = height % microBlockSize || microBlockSize; + var lastBlockWidth = width % microBlockSize || microBlockSize; + var offsetType, offset; + var numDims = headerInfo.numDims, iDim; + var mask = data.pixels.resultMask; + var resultPixels = data.pixels.resultPixels; + var fileVersion = headerInfo.fileVersion; + var fileVersionCheckNum = fileVersion >= 5 ? 14 : 15; + var isDiffEncoding; + var zMax = headerInfo.zMax; + var resultPixelsPrevDim; + for (blockY = 0; blockY < numBlocksY; blockY++) { + thisBlockHeight = blockY !== numBlocksY - 1 ? microBlockSize : lastBlockHeight; + for (blockX = 0; blockX < numBlocksX; blockX++) { + thisBlockWidth = blockX !== numBlocksX - 1 ? microBlockSize : lastBlockWidth; + outPtr = blockY * width * microBlockSize + blockX * microBlockSize; + outStride = width - thisBlockWidth; + for (iDim = 0; iDim < numDims; iDim++) { + if (numDims > 1) { + resultPixelsPrevDim = resultPixels; + outPtr = blockY * width * microBlockSize + blockX * microBlockSize; + resultPixels = new OutPixelTypeArray(data.pixels.resultPixels.buffer, numPixels * iDim * dataTypeSize, numPixels); + zMax = headerInfo.maxValues[iDim]; + } else { + resultPixelsPrevDim = null; + } + bytesLeft = input.byteLength - data.ptr; + view = new DataView(input, data.ptr, Math.min(10, bytesLeft)); + block = {}; + blockPtr = 0; + headerByte = view.getUint8(0); + blockPtr++; + isDiffEncoding = headerInfo.fileVersion >= 5 ? headerByte & 4 : 0; + bits67 = headerByte >> 6 & 255; + testCode = headerByte >> 2 & fileVersionCheckNum; + if (testCode !== (blockX * microBlockSize >> 3 & fileVersionCheckNum)) { + throw "integrity issue"; + } + if (isDiffEncoding && iDim === 0) { + throw "integrity issue"; + } + blockEncoding = headerByte & 3; + if (blockEncoding > 3) { + data.ptr += blockPtr; + throw "Invalid block encoding (" + blockEncoding + ")"; + } else if (blockEncoding === 2) { + if (isDiffEncoding) { + if (mask) { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + if (mask[outPtr]) { + resultPixels[outPtr] = resultPixelsPrevDim[outPtr]; + } + outPtr++; + } + } + } else { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + resultPixels[outPtr] = resultPixelsPrevDim[outPtr]; + outPtr++; + } + } + } + } + data.counter.constant++; + data.ptr += blockPtr; + continue; + } else if (blockEncoding === 0) { + if (isDiffEncoding) { + throw "integrity issue"; + } + data.counter.uncompressed++; + data.ptr += blockPtr; + numBytes = thisBlockHeight * thisBlockWidth * dataTypeSize; + bytesleft = input.byteLength - data.ptr; + numBytes = numBytes < bytesleft ? numBytes : bytesleft; + arrayBuf = new ArrayBuffer(numBytes % dataTypeSize === 0 ? numBytes : numBytes + dataTypeSize - numBytes % dataTypeSize); + store8 = new Uint8Array(arrayBuf); + store8.set(new Uint8Array(input, data.ptr, numBytes)); + rawData = new OutPixelTypeArray(arrayBuf); + z = 0; + if (mask) { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + if (mask[outPtr]) { + resultPixels[outPtr] = rawData[z++]; + } + outPtr++; + } + outPtr += outStride; + } + } else { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + resultPixels[outPtr++] = rawData[z++]; + } + outPtr += outStride; + } + } + data.ptr += z * dataTypeSize; + } else { + offsetType = Lerc2Helpers.getDataTypeUsed(isDiffEncoding && imageType < 6 ? 4 : imageType, bits67); + offset = Lerc2Helpers.getOnePixel(block, blockPtr, offsetType, view); + blockPtr += Lerc2Helpers.getDataTypeSize(offsetType); + if (blockEncoding === 3) { + data.ptr += blockPtr; + data.counter.constantoffset++; + if (mask) { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + if (mask[outPtr]) { + resultPixels[outPtr] = isDiffEncoding ? Math.min(zMax, resultPixelsPrevDim[outPtr] + offset) : offset; + } + outPtr++; + } + outPtr += outStride; + } + } else { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + resultPixels[outPtr] = isDiffEncoding ? Math.min(zMax, resultPixelsPrevDim[outPtr] + offset) : offset; + outPtr++; + } + outPtr += outStride; + } + } + } else { + data.ptr += blockPtr; + Lerc2Helpers.decodeBits(input, data, blockDataBuffer, offset, iDim); + blockPtr = 0; + if (isDiffEncoding) { + if (mask) { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + if (mask[outPtr]) { + resultPixels[outPtr] = blockDataBuffer[blockPtr++] + resultPixelsPrevDim[outPtr]; + } + outPtr++; + } + outPtr += outStride; + } + } else { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + resultPixels[outPtr] = blockDataBuffer[blockPtr++] + resultPixelsPrevDim[outPtr]; + outPtr++; + } + outPtr += outStride; + } + } + } else if (mask) { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + if (mask[outPtr]) { + resultPixels[outPtr] = blockDataBuffer[blockPtr++]; + } + outPtr++; + } + outPtr += outStride; + } + } else { + for (row = 0; row < thisBlockHeight; row++) { + for (col = 0; col < thisBlockWidth; col++) { + resultPixels[outPtr++] = blockDataBuffer[blockPtr++]; + } + outPtr += outStride; + } + } + } + } + } + } + } + if (numDims > 1 && !useBSQForOutputDim) { + data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(data.pixels.resultPixels, numPixels, numDims, OutPixelTypeArray); + } + }, + /***************** + * private methods (helper methods) + *****************/ + formatFileInfo: function(data) { + return { + "fileIdentifierString": data.headerInfo.fileIdentifierString, + "fileVersion": data.headerInfo.fileVersion, + "imageType": data.headerInfo.imageType, + "height": data.headerInfo.height, + "width": data.headerInfo.width, + "numValidPixel": data.headerInfo.numValidPixel, + "microBlockSize": data.headerInfo.microBlockSize, + "blobSize": data.headerInfo.blobSize, + "maxZError": data.headerInfo.maxZError, + "pixelType": Lerc2Helpers.getPixelType(data.headerInfo.imageType), + "eofOffset": data.eofOffset, + "mask": data.mask ? { + "numBytes": data.mask.numBytes + } : null, + "pixels": { + "numBlocksX": data.pixels.numBlocksX, + "numBlocksY": data.pixels.numBlocksY, + //"numBytes": data.pixels.numBytes, + "maxValue": data.headerInfo.zMax, + "minValue": data.headerInfo.zMin, + "noDataValue": data.noDataValue + } + }; + }, + constructConstantSurface: function(data, useBSQForOutputDim) { + var val = data.headerInfo.zMax; + var valMin = data.headerInfo.zMin; + var maxValues = data.headerInfo.maxValues; + var numDims = data.headerInfo.numDims; + var numPixels = data.headerInfo.height * data.headerInfo.width; + var i3 = 0, k = 0, nStart = 0; + var mask = data.pixels.resultMask; + var resultPixels = data.pixels.resultPixels; + if (mask) { + if (numDims > 1) { + if (useBSQForOutputDim) { + for (i3 = 0; i3 < numDims; i3++) { + nStart = i3 * numPixels; + val = maxValues[i3]; + for (k = 0; k < numPixels; k++) { + if (mask[k]) { + resultPixels[nStart + k] = val; + } + } + } + } else { + for (k = 0; k < numPixels; k++) { + if (mask[k]) { + nStart = k * numDims; + for (i3 = 0; i3 < numDims; i3++) { + resultPixels[nStart + numDims] = maxValues[i3]; + } + } + } + } + } else { + for (k = 0; k < numPixels; k++) { + if (mask[k]) { + resultPixels[k] = val; + } + } + } + } else { + if (numDims > 1 && valMin !== val) { + if (useBSQForOutputDim) { + for (i3 = 0; i3 < numDims; i3++) { + nStart = i3 * numPixels; + val = maxValues[i3]; + for (k = 0; k < numPixels; k++) { + resultPixels[nStart + k] = val; + } + } + } else { + for (k = 0; k < numPixels; k++) { + nStart = k * numDims; + for (i3 = 0; i3 < numDims; i3++) { + resultPixels[nStart + i3] = maxValues[i3]; + } + } + } + } else { + for (k = 0; k < numPixels * numDims; k++) { + resultPixels[k] = val; + } + } + } + return; + }, + getDataTypeArray: function(t2) { + var tp; + switch (t2) { + case 0: + tp = Int8Array; + break; + case 1: + tp = Uint8Array; + break; + case 2: + tp = Int16Array; + break; + case 3: + tp = Uint16Array; + break; + case 4: + tp = Int32Array; + break; + case 5: + tp = Uint32Array; + break; + case 6: + tp = Float32Array; + break; + case 7: + tp = Float64Array; + break; + default: + tp = Float32Array; + } + return tp; + }, + getPixelType: function(t2) { + var tp; + switch (t2) { + case 0: + tp = "S8"; + break; + case 1: + tp = "U8"; + break; + case 2: + tp = "S16"; + break; + case 3: + tp = "U16"; + break; + case 4: + tp = "S32"; + break; + case 5: + tp = "U32"; + break; + case 6: + tp = "F32"; + break; + case 7: + tp = "F64"; + break; + default: + tp = "F32"; + } + return tp; + }, + isValidPixelValue: function(t2, val) { + if (val == null) { + return false; + } + var isValid2; + switch (t2) { + case 0: + isValid2 = val >= -128 && val <= 127; + break; + case 1: + isValid2 = val >= 0 && val <= 255; + break; + case 2: + isValid2 = val >= -32768 && val <= 32767; + break; + case 3: + isValid2 = val >= 0 && val <= 65536; + break; + case 4: + isValid2 = val >= -2147483648 && val <= 2147483647; + break; + case 5: + isValid2 = val >= 0 && val <= 4294967296; + break; + case 6: + isValid2 = val >= -34027999387901484e22 && val <= 34027999387901484e22; + break; + case 7: + isValid2 = val >= -17976931348623157e292 && val <= 17976931348623157e292; + break; + default: + isValid2 = false; + } + return isValid2; + }, + getDataTypeSize: function(t2) { + var s = 0; + switch (t2) { + case 0: + case 1: + s = 1; + break; + case 2: + case 3: + s = 2; + break; + case 4: + case 5: + case 6: + s = 4; + break; + case 7: + s = 8; + break; + default: + s = t2; + } + return s; + }, + getDataTypeUsed: function(dt, tc) { + var t2 = dt; + switch (dt) { + case 2: + case 4: + t2 = dt - tc; + break; + case 3: + case 5: + t2 = dt - 2 * tc; + break; + case 6: + if (0 === tc) { + t2 = dt; + } else if (1 === tc) { + t2 = 2; + } else { + t2 = 1; + } + break; + case 7: + if (0 === tc) { + t2 = dt; + } else { + t2 = dt - 2 * tc + 1; + } + break; + default: + t2 = dt; + break; + } + return t2; + }, + getOnePixel: function(block, blockPtr, offsetType, view) { + var temp = 0; + switch (offsetType) { + case 0: + temp = view.getInt8(blockPtr); + break; + case 1: + temp = view.getUint8(blockPtr); + break; + case 2: + temp = view.getInt16(blockPtr, true); + break; + case 3: + temp = view.getUint16(blockPtr, true); + break; + case 4: + temp = view.getInt32(blockPtr, true); + break; + case 5: + temp = view.getUInt32(blockPtr, true); + break; + case 6: + temp = view.getFloat32(blockPtr, true); + break; + case 7: + temp = view.getFloat64(blockPtr, true); + break; + default: + throw "the decoder does not understand this pixel type"; + } + return temp; + }, + swapDimensionOrder: function(pixels, numPixels, numDims, OutPixelTypeArray, inputIsBIP) { + var i3 = 0, j = 0, iDim = 0, temp = 0, swap = pixels; + if (numDims > 1) { + swap = new OutPixelTypeArray(numPixels * numDims); + if (inputIsBIP) { + for (i3 = 0; i3 < numPixels; i3++) { + temp = i3; + for (iDim = 0; iDim < numDims; iDim++, temp += numPixels) { + swap[temp] = pixels[j++]; + } + } + } else { + for (i3 = 0; i3 < numPixels; i3++) { + temp = i3; + for (iDim = 0; iDim < numDims; iDim++, temp += numPixels) { + swap[j++] = pixels[temp]; + } + } + } + } + return swap; + } + }; + var TreeNode = function(val, left, right) { + this.val = val; + this.left = left; + this.right = right; + }; + var Lerc2Decode2 = { + /* + * ********removed options compared to LERC1. We can bring some of them back if needed. + * removed pixel type. LERC2 is typed and doesn't require user to give pixel type + * changed encodedMaskData to maskData. LERC2 's js version make it faster to use maskData directly. + * removed returnMask. mask is used by LERC2 internally and is cost free. In case of user input mask, it's returned as well and has neglible cost. + * removed nodatavalue. Because LERC2 pixels are typed, nodatavalue will sacrify a useful value for many types (8bit, 16bit) etc, + * user has to be knowledgable enough about raster and their data to avoid usability issues. so nodata value is simply removed now. + * We can add it back later if their's a clear requirement. + * removed encodedMask. This option was not implemented in LercDecode. It can be done after decoding (less efficient) + * removed computeUsedBitDepths. + * + * + * response changes compared to LERC1 + * 1. encodedMaskData is not available + * 2. noDataValue is optional (returns only if user's noDataValue is with in the valid data type range) + * 3. maskData is always available + */ + /***************** + * public properties + ******************/ + //HUFFMAN_LUT_BITS_MAX: 12, //use 2^12 lut, not configurable + /***************** + * public methods + *****************/ + /** + * Decode a LERC2 byte stream and return an object containing the pixel data and optional metadata. + * + * @param {ArrayBuffer} input The LERC input byte stream + * @param {object} [options] options Decoding options + * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid LERC file is expected at that position + * @param {boolean} [options.returnFileInfo] If true, the return value will have a fileInfo property that contains metadata obtained from the LERC headers and the decoding process + * @param {boolean} [options.returnPixelInterleavedDims] If true, returned dimensions are pixel-interleaved, a.k.a [p1_dim0, p1_dim1, p1_dimn, p2_dim0...], default is [p1_dim0, p2_dim0, ..., p1_dim1, p2_dim1...] + */ + decode: function(input, options) { + options = options || {}; + var noDataValue = options.noDataValue; + var i3 = 0, data = {}; + data.ptr = options.inputOffset || 0; + data.pixels = {}; + if (!Lerc2Helpers.readHeaderInfo(input, data)) { + return; + } + var headerInfo = data.headerInfo; + var fileVersion = headerInfo.fileVersion; + var OutPixelTypeArray = Lerc2Helpers.getDataTypeArray(headerInfo.imageType); + if (fileVersion > 5) { + throw "unsupported lerc version 2." + fileVersion; + } + Lerc2Helpers.readMask(input, data); + if (headerInfo.numValidPixel !== headerInfo.width * headerInfo.height && !data.pixels.resultMask) { + data.pixels.resultMask = options.maskData; + } + var numPixels = headerInfo.width * headerInfo.height; + data.pixels.resultPixels = new OutPixelTypeArray(numPixels * headerInfo.numDims); + data.counter = { + onesweep: 0, + uncompressed: 0, + lut: 0, + bitstuffer: 0, + constant: 0, + constantoffset: 0 + }; + var useBSQForOutputDim = !options.returnPixelInterleavedDims; + if (headerInfo.numValidPixel !== 0) { + if (headerInfo.zMax === headerInfo.zMin) { + Lerc2Helpers.constructConstantSurface(data, useBSQForOutputDim); + } else if (fileVersion >= 4 && Lerc2Helpers.checkMinMaxRanges(input, data)) { + Lerc2Helpers.constructConstantSurface(data, useBSQForOutputDim); + } else { + var view = new DataView(input, data.ptr, 2); + var bReadDataOneSweep = view.getUint8(0); + data.ptr++; + if (bReadDataOneSweep) { + Lerc2Helpers.readDataOneSweep(input, data, OutPixelTypeArray, useBSQForOutputDim); + } else { + if (fileVersion > 1 && headerInfo.imageType <= 1 && Math.abs(headerInfo.maxZError - 0.5) < 1e-5) { + var flagHuffman = view.getUint8(1); + data.ptr++; + data.encodeMode = flagHuffman; + if (flagHuffman > 2 || fileVersion < 4 && flagHuffman > 1) { + throw "Invalid Huffman flag " + flagHuffman; + } + if (flagHuffman) { + Lerc2Helpers.readHuffman(input, data, OutPixelTypeArray, useBSQForOutputDim); + } else { + Lerc2Helpers.readTiles(input, data, OutPixelTypeArray, useBSQForOutputDim); + } + } else { + Lerc2Helpers.readTiles(input, data, OutPixelTypeArray, useBSQForOutputDim); + } + } + } + } + data.eofOffset = data.ptr; + var diff; + if (options.inputOffset) { + diff = data.headerInfo.blobSize + options.inputOffset - data.ptr; + if (Math.abs(diff) >= 1) { + data.eofOffset = options.inputOffset + data.headerInfo.blobSize; + } + } else { + diff = data.headerInfo.blobSize - data.ptr; + if (Math.abs(diff) >= 1) { + data.eofOffset = data.headerInfo.blobSize; + } + } + var result = { + width: headerInfo.width, + height: headerInfo.height, + pixelData: data.pixels.resultPixels, + minValue: headerInfo.zMin, + maxValue: headerInfo.zMax, + validPixelCount: headerInfo.numValidPixel, + dimCount: headerInfo.numDims, + dimStats: { + minValues: headerInfo.minValues, + maxValues: headerInfo.maxValues + }, + maskData: data.pixels.resultMask + //noDataValue: noDataValue + }; + if (data.pixels.resultMask && Lerc2Helpers.isValidPixelValue(headerInfo.imageType, noDataValue)) { + var mask = data.pixels.resultMask; + for (i3 = 0; i3 < numPixels; i3++) { + if (!mask[i3]) { + result.pixelData[i3] = noDataValue; + } + } + result.noDataValue = noDataValue; + } + data.noDataValue = noDataValue; + if (options.returnFileInfo) { + result.fileInfo = Lerc2Helpers.formatFileInfo(data); + } + return result; + }, + getBandCount: function(input) { + var count2 = 0; + var i3 = 0; + var temp = {}; + temp.ptr = 0; + temp.pixels = {}; + while (i3 < input.byteLength - 58) { + Lerc2Helpers.readHeaderInfo(input, temp); + i3 += temp.headerInfo.blobSize; + count2++; + temp.ptr = i3; + } + return count2; + } + }; + return Lerc2Decode2; + }(); + var isPlatformLittleEndian = function() { + var a2 = new ArrayBuffer(4); + var b2 = new Uint8Array(a2); + var c2 = new Uint32Array(a2); + c2[0] = 1; + return b2[0] === 1; + }(); + var Lerc2 = { + /************wrapper**********************************************/ + /** + * A wrapper for decoding both LERC1 and LERC2 byte streams capable of handling multiband pixel blocks for various pixel types. + * + * @alias module:Lerc + * @param {ArrayBuffer} input The LERC input byte stream + * @param {object} [options] The decoding options below are optional. + * @param {number} [options.inputOffset] The number of bytes to skip in the input byte stream. A valid Lerc file is expected at that position. + * @param {string} [options.pixelType] (LERC1 only) Default value is F32. Valid pixel types for input are U8/S8/S16/U16/S32/U32/F32. + * @param {number} [options.noDataValue] (LERC1 only). It is recommended to use the returned mask instead of setting this value. + * @param {boolean} [options.returnPixelInterleavedDims] (nDim LERC2 only) If true, returned dimensions are pixel-interleaved, a.k.a [p1_dim0, p1_dim1, p1_dimn, p2_dim0...], default is [p1_dim0, p2_dim0, ..., p1_dim1, p2_dim1...] + * @returns {{width, height, pixels, pixelType, mask, statistics}} + * @property {number} width Width of decoded image. + * @property {number} height Height of decoded image. + * @property {array} pixels [band1, band2, …] Each band is a typed array of width*height. + * @property {string} pixelType The type of pixels represented in the output. + * @property {mask} mask Typed array with a size of width*height, or null if all pixels are valid. + * @property {array} statistics [statistics_band1, statistics_band2, …] Each element is a statistics object representing min and max values + **/ + decode: function(encodedData, options) { + if (!isPlatformLittleEndian) { + throw "Big endian system is not supported."; + } + options = options || {}; + var inputOffset = options.inputOffset || 0; + var fileIdView = new Uint8Array(encodedData, inputOffset, 10); + var fileIdentifierString = String.fromCharCode.apply(null, fileIdView); + var lerc, majorVersion; + if (fileIdentifierString.trim() === "CntZImage") { + lerc = LercDecode; + majorVersion = 1; + } else if (fileIdentifierString.substring(0, 5) === "Lerc2") { + lerc = Lerc2Decode; + majorVersion = 2; + } else { + throw "Unexpected file identifier string: " + fileIdentifierString; + } + var iPlane = 0, eof = encodedData.byteLength - 10, encodedMaskData, bandMasks = [], bandMask, maskData; + var decodedPixelBlock = { + width: 0, + height: 0, + pixels: [], + pixelType: options.pixelType, + mask: null, + statistics: [] + }; + var uniqueBandMaskCount = 0; + while (inputOffset < eof) { + var result = lerc.decode(encodedData, { + inputOffset, + //for both lerc1 and lerc2 + encodedMaskData, + //lerc1 only + maskData, + //lerc2 only + returnMask: iPlane === 0 ? true : false, + //lerc1 only + returnEncodedMask: iPlane === 0 ? true : false, + //lerc1 only + returnFileInfo: true, + //for both lerc1 and lerc2 + returnPixelInterleavedDims: options.returnPixelInterleavedDims, + //for ndim lerc2 only + pixelType: options.pixelType || null, + //lerc1 only + noDataValue: options.noDataValue || null + //lerc1 only + }); + inputOffset = result.fileInfo.eofOffset; + maskData = result.maskData; + if (iPlane === 0) { + encodedMaskData = result.encodedMaskData; + decodedPixelBlock.width = result.width; + decodedPixelBlock.height = result.height; + decodedPixelBlock.dimCount = result.dimCount || 1; + decodedPixelBlock.pixelType = result.pixelType || result.fileInfo.pixelType; + decodedPixelBlock.mask = maskData; + } + if (majorVersion > 1) { + if (maskData) { + bandMasks.push(maskData); + } + if (result.fileInfo.mask && result.fileInfo.mask.numBytes > 0) { + uniqueBandMaskCount++; + } + } + iPlane++; + decodedPixelBlock.pixels.push(result.pixelData); + decodedPixelBlock.statistics.push({ + minValue: result.minValue, + maxValue: result.maxValue, + noDataValue: result.noDataValue, + dimStats: result.dimStats + }); + } + var i3, j, numPixels; + if (majorVersion > 1 && uniqueBandMaskCount > 1) { + numPixels = decodedPixelBlock.width * decodedPixelBlock.height; + decodedPixelBlock.bandMasks = bandMasks; + maskData = new Uint8Array(numPixels); + maskData.set(bandMasks[0]); + for (i3 = 1; i3 < bandMasks.length; i3++) { + bandMask = bandMasks[i3]; + for (j = 0; j < numPixels; j++) { + maskData[j] = maskData[j] & bandMask[j]; + } + } + decodedPixelBlock.maskData = maskData; + } + return decodedPixelBlock; + } + }; + if (typeof define === "function" && define.amd) { + define([], function() { + return Lerc2; + }); + } else if (typeof module !== "undefined" && module.exports) { + module.exports = Lerc2; + } else { + this.Lerc = Lerc2; + } + })(); + } + }); + + // node_modules/zstddec/dist/zstddec.modern.js + var init, instance, heap, IMPORT_OBJECT, ZSTDDecoder, wasm; + var init_zstddec_modern = __esm({ + "node_modules/zstddec/dist/zstddec.modern.js"() { + IMPORT_OBJECT = { + env: { + emscripten_notify_memory_growth: function(index) { + heap = new Uint8Array(instance.exports.memory.buffer); + } + } + }; + ZSTDDecoder = class { + init() { + if (init) + return init; + if (typeof fetch !== "undefined") { + init = fetch("data:application/wasm;base64," + wasm).then((response) => response.arrayBuffer()).then((arrayBuffer2) => WebAssembly.instantiate(arrayBuffer2, IMPORT_OBJECT)).then(this._init); + } else { + init = WebAssembly.instantiate(Buffer.from(wasm, "base64"), IMPORT_OBJECT).then(this._init); + } + return init; + } + _init(result) { + instance = result.instance; + IMPORT_OBJECT.env.emscripten_notify_memory_growth(0); + } + decode(array, uncompressedSize = 0) { + if (!instance) + throw new Error(`ZSTDDecoder: Await .init() before decoding.`); + const compressedSize = array.byteLength; + const compressedPtr = instance.exports.malloc(compressedSize); + heap.set(array, compressedPtr); + uncompressedSize = uncompressedSize || Number(instance.exports.ZSTD_findDecompressedSize(compressedPtr, compressedSize)); + const uncompressedPtr = instance.exports.malloc(uncompressedSize); + const actualSize = instance.exports.ZSTD_decompress(uncompressedPtr, uncompressedSize, compressedPtr, compressedSize); + const dec = heap.slice(uncompressedPtr, uncompressedPtr + actualSize); + instance.exports.free(compressedPtr); + instance.exports.free(uncompressedPtr); + return dec; + } + }; + wasm = "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"; + } + }); + + // node_modules/geotiff/dist-module/compression/lerc.js + var lerc_exports = {}; + __export(lerc_exports, { + default: () => LercDecoder, + zstd: () => zstd + }); + var import_lerc, zstd, LercDecoder; + var init_lerc = __esm({ + "node_modules/geotiff/dist-module/compression/lerc.js"() { + init_pako_esm(); + import_lerc = __toESM(require_LercDecode(), 1); + init_zstddec_modern(); + init_basedecoder(); + init_globals(); + zstd = new ZSTDDecoder(); + LercDecoder = class extends BaseDecoder { + constructor(fileDirectory) { + super(); + this.planarConfiguration = typeof fileDirectory.PlanarConfiguration !== "undefined" ? fileDirectory.PlanarConfiguration : 1; + this.samplesPerPixel = typeof fileDirectory.SamplesPerPixel !== "undefined" ? fileDirectory.SamplesPerPixel : 1; + this.addCompression = fileDirectory.LercParameters[LercParameters.AddCompression]; + } + decodeBlock(buffer) { + switch (this.addCompression) { + case LercAddCompression.None: + break; + case LercAddCompression.Deflate: + buffer = inflate_1(new Uint8Array(buffer)).buffer; + break; + case LercAddCompression.Zstandard: + buffer = zstd.decode(new Uint8Array(buffer)).buffer; + break; + default: + throw new Error(`Unsupported LERC additional compression method identifier: ${this.addCompression}`); + } + const lercResult = import_lerc.default.decode(buffer, { returnPixelInterleavedDims: this.planarConfiguration === 1 }); + const lercData = lercResult.pixels[0]; + return lercData.buffer; + } + }; + } + }); + + // node_modules/geotiff/dist-module/compression/webimage.js + var webimage_exports = {}; + __export(webimage_exports, { + default: () => WebImageDecoder + }); + var WebImageDecoder; + var init_webimage = __esm({ + "node_modules/geotiff/dist-module/compression/webimage.js"() { + init_basedecoder(); + WebImageDecoder = class extends BaseDecoder { + constructor() { + super(); + if (typeof createImageBitmap === "undefined") { + throw new Error("Cannot decode WebImage as `createImageBitmap` is not available"); + } else if (typeof document === "undefined" && typeof OffscreenCanvas === "undefined") { + throw new Error("Cannot decode WebImage as neither `document` nor `OffscreenCanvas` is not available"); + } + } + async decode(fileDirectory, buffer) { + const blob = new Blob([buffer]); + const imageBitmap = await createImageBitmap(blob); + let canvas; + if (typeof document !== "undefined") { + canvas = document.createElement("canvas"); + canvas.width = imageBitmap.width; + canvas.height = imageBitmap.height; + } else { + canvas = new OffscreenCanvas(imageBitmap.width, imageBitmap.height); + } + const ctx = canvas.getContext("2d"); + ctx.drawImage(imageBitmap, 0, 0); + return ctx.getImageData(0, 0, imageBitmap.width, imageBitmap.height).data.buffer; + } + }; + } + }); + + // node_modules/papaparse/papaparse.min.js + var require_papaparse_min = __commonJS({ + "node_modules/papaparse/papaparse.min.js"(exports, module) { + !function(e2, t2) { + "function" == typeof define && define.amd ? define([], t2) : "object" == typeof module && "undefined" != typeof exports ? module.exports = t2() : e2.Papa = t2(); + }(exports, function s() { + "use strict"; + var f2 = "undefined" != typeof self ? self : "undefined" != typeof window ? window : void 0 !== f2 ? f2 : {}; + var n2 = !f2.document && !!f2.postMessage, o3 = f2.IS_PAPA_WORKER || false, a2 = {}, u2 = 0, b2 = { parse: function(e2, t2) { + var r3 = (t2 = t2 || {}).dynamicTyping || false; + J(r3) && (t2.dynamicTypingFunction = r3, r3 = {}); + if (t2.dynamicTyping = r3, t2.transform = !!J(t2.transform) && t2.transform, t2.worker && b2.WORKERS_SUPPORTED) { + var i3 = function() { + if (!b2.WORKERS_SUPPORTED) + return false; + var e3 = (r4 = f2.URL || f2.webkitURL || null, i4 = s.toString(), b2.BLOB_URL || (b2.BLOB_URL = r4.createObjectURL(new Blob(["var global = (function() { if (typeof self !== 'undefined') { return self; } if (typeof window !== 'undefined') { return window; } if (typeof global !== 'undefined') { return global; } return {}; })(); global.IS_PAPA_WORKER=true; ", "(", i4, ")();"], { type: "text/javascript" })))), t3 = new f2.Worker(e3); + var r4, i4; + return t3.onmessage = _2, t3.id = u2++, a2[t3.id] = t3; + }(); + return i3.userStep = t2.step, i3.userChunk = t2.chunk, i3.userComplete = t2.complete, i3.userError = t2.error, t2.step = J(t2.step), t2.chunk = J(t2.chunk), t2.complete = J(t2.complete), t2.error = J(t2.error), delete t2.worker, void i3.postMessage({ input: e2, config: t2, workerId: i3.id }); + } + var n3 = null; + b2.NODE_STREAM_INPUT, "string" == typeof e2 ? (e2 = function(e3) { + if (65279 === e3.charCodeAt(0)) + return e3.slice(1); + return e3; + }(e2), n3 = t2.download ? new l2(t2) : new p2(t2)) : true === e2.readable && J(e2.read) && J(e2.on) ? n3 = new g3(t2) : (f2.File && e2 instanceof File || e2 instanceof Object) && (n3 = new c2(t2)); + return n3.stream(e2); + }, unparse: function(e2, t2) { + var n3 = false, _3 = true, m2 = ",", y3 = "\r\n", s2 = '"', a3 = s2 + s2, r3 = false, i3 = null, o4 = false; + !function() { + if ("object" != typeof t2) + return; + "string" != typeof t2.delimiter || b2.BAD_DELIMITERS.filter(function(e3) { + return -1 !== t2.delimiter.indexOf(e3); + }).length || (m2 = t2.delimiter); + ("boolean" == typeof t2.quotes || "function" == typeof t2.quotes || Array.isArray(t2.quotes)) && (n3 = t2.quotes); + "boolean" != typeof t2.skipEmptyLines && "string" != typeof t2.skipEmptyLines || (r3 = t2.skipEmptyLines); + "string" == typeof t2.newline && (y3 = t2.newline); + "string" == typeof t2.quoteChar && (s2 = t2.quoteChar); + "boolean" == typeof t2.header && (_3 = t2.header); + if (Array.isArray(t2.columns)) { + if (0 === t2.columns.length) + throw new Error("Option columns is empty"); + i3 = t2.columns; + } + void 0 !== t2.escapeChar && (a3 = t2.escapeChar + s2); + ("boolean" == typeof t2.escapeFormulae || t2.escapeFormulae instanceof RegExp) && (o4 = t2.escapeFormulae instanceof RegExp ? t2.escapeFormulae : /^[=+\-@\t\r].*$/); + }(); + var u3 = new RegExp(Q2(s2), "g"); + "string" == typeof e2 && (e2 = JSON.parse(e2)); + if (Array.isArray(e2)) { + if (!e2.length || Array.isArray(e2[0])) + return h2(null, e2, r3); + if ("object" == typeof e2[0]) + return h2(i3 || Object.keys(e2[0]), e2, r3); + } else if ("object" == typeof e2) + return "string" == typeof e2.data && (e2.data = JSON.parse(e2.data)), Array.isArray(e2.data) && (e2.fields || (e2.fields = e2.meta && e2.meta.fields || i3), e2.fields || (e2.fields = Array.isArray(e2.data[0]) ? e2.fields : "object" == typeof e2.data[0] ? Object.keys(e2.data[0]) : []), Array.isArray(e2.data[0]) || "object" == typeof e2.data[0] || (e2.data = [e2.data])), h2(e2.fields || [], e2.data || [], r3); + throw new Error("Unable to serialize unrecognized input"); + function h2(e3, t3, r4) { + var i4 = ""; + "string" == typeof e3 && (e3 = JSON.parse(e3)), "string" == typeof t3 && (t3 = JSON.parse(t3)); + var n4 = Array.isArray(e3) && 0 < e3.length, s3 = !Array.isArray(t3[0]); + if (n4 && _3) { + for (var a4 = 0; a4 < e3.length; a4++) + 0 < a4 && (i4 += m2), i4 += v3(e3[a4], a4); + 0 < t3.length && (i4 += y3); + } + for (var o5 = 0; o5 < t3.length; o5++) { + var u4 = n4 ? e3.length : t3[o5].length, h3 = false, f3 = n4 ? 0 === Object.keys(t3[o5]).length : 0 === t3[o5].length; + if (r4 && !n4 && (h3 = "greedy" === r4 ? "" === t3[o5].join("").trim() : 1 === t3[o5].length && 0 === t3[o5][0].length), "greedy" === r4 && n4) { + for (var d3 = [], l3 = 0; l3 < u4; l3++) { + var c3 = s3 ? e3[l3] : l3; + d3.push(t3[o5][c3]); + } + h3 = "" === d3.join("").trim(); + } + if (!h3) { + for (var p3 = 0; p3 < u4; p3++) { + 0 < p3 && !f3 && (i4 += m2); + var g4 = n4 && s3 ? e3[p3] : p3; + i4 += v3(t3[o5][g4], p3); + } + o5 < t3.length - 1 && (!r4 || 0 < u4 && !f3) && (i4 += y3); + } + } + return i4; + } + function v3(e3, t3) { + if (null == e3) + return ""; + if (e3.constructor === Date) + return JSON.stringify(e3).slice(1, 25); + var r4 = false; + o4 && "string" == typeof e3 && o4.test(e3) && (e3 = "'" + e3, r4 = true); + var i4 = e3.toString().replace(u3, a3); + return (r4 = r4 || true === n3 || "function" == typeof n3 && n3(e3, t3) || Array.isArray(n3) && n3[t3] || function(e4, t4) { + for (var r5 = 0; r5 < t4.length; r5++) + if (-1 < e4.indexOf(t4[r5])) + return true; + return false; + }(i4, b2.BAD_DELIMITERS) || -1 < i4.indexOf(m2) || " " === i4.charAt(0) || " " === i4.charAt(i4.length - 1)) ? s2 + i4 + s2 : i4; + } + } }; + if (b2.RECORD_SEP = String.fromCharCode(30), b2.UNIT_SEP = String.fromCharCode(31), b2.BYTE_ORDER_MARK = "\uFEFF", b2.BAD_DELIMITERS = ["\r", "\n", '"', b2.BYTE_ORDER_MARK], b2.WORKERS_SUPPORTED = !n2 && !!f2.Worker, b2.NODE_STREAM_INPUT = 1, b2.LocalChunkSize = 10485760, b2.RemoteChunkSize = 5242880, b2.DefaultDelimiter = ",", b2.Parser = E3, b2.ParserHandle = r2, b2.NetworkStreamer = l2, b2.FileStreamer = c2, b2.StringStreamer = p2, b2.ReadableStreamStreamer = g3, f2.jQuery) { + var d2 = f2.jQuery; + d2.fn.parse = function(o4) { + var r3 = o4.config || {}, u3 = []; + return this.each(function(e3) { + if (!("INPUT" === d2(this).prop("tagName").toUpperCase() && "file" === d2(this).attr("type").toLowerCase() && f2.FileReader) || !this.files || 0 === this.files.length) + return true; + for (var t2 = 0; t2 < this.files.length; t2++) + u3.push({ file: this.files[t2], inputElem: this, instanceConfig: d2.extend({}, r3) }); + }), e2(), this; + function e2() { + if (0 !== u3.length) { + var e3, t2, r4, i3, n3 = u3[0]; + if (J(o4.before)) { + var s2 = o4.before(n3.file, n3.inputElem); + if ("object" == typeof s2) { + if ("abort" === s2.action) + return e3 = "AbortError", t2 = n3.file, r4 = n3.inputElem, i3 = s2.reason, void (J(o4.error) && o4.error({ name: e3 }, t2, r4, i3)); + if ("skip" === s2.action) + return void h2(); + "object" == typeof s2.config && (n3.instanceConfig = d2.extend(n3.instanceConfig, s2.config)); + } else if ("skip" === s2) + return void h2(); + } + var a3 = n3.instanceConfig.complete; + n3.instanceConfig.complete = function(e4) { + J(a3) && a3(e4, n3.file, n3.inputElem), h2(); + }, b2.parse(n3.file, n3.instanceConfig); + } else + J(o4.complete) && o4.complete(); + } + function h2() { + u3.splice(0, 1), e2(); + } + }; + } + function h(e2) { + this._handle = null, this._finished = false, this._completed = false, this._halted = false, this._input = null, this._baseIndex = 0, this._partialLine = "", this._rowCount = 0, this._start = 0, this._nextChunk = null, this.isFirstChunk = true, this._completeResults = { data: [], errors: [], meta: {} }, function(e3) { + var t2 = w3(e3); + t2.chunkSize = parseInt(t2.chunkSize), e3.step || e3.chunk || (t2.chunkSize = null); + this._handle = new r2(t2), (this._handle.streamer = this)._config = t2; + }.call(this, e2), this.parseChunk = function(e3, t2) { + if (this.isFirstChunk && J(this._config.beforeFirstChunk)) { + var r3 = this._config.beforeFirstChunk(e3); + void 0 !== r3 && (e3 = r3); + } + this.isFirstChunk = false, this._halted = false; + var i3 = this._partialLine + e3; + this._partialLine = ""; + var n3 = this._handle.parse(i3, this._baseIndex, !this._finished); + if (!this._handle.paused() && !this._handle.aborted()) { + var s2 = n3.meta.cursor; + this._finished || (this._partialLine = i3.substring(s2 - this._baseIndex), this._baseIndex = s2), n3 && n3.data && (this._rowCount += n3.data.length); + var a3 = this._finished || this._config.preview && this._rowCount >= this._config.preview; + if (o3) + f2.postMessage({ results: n3, workerId: b2.WORKER_ID, finished: a3 }); + else if (J(this._config.chunk) && !t2) { + if (this._config.chunk(n3, this._handle), this._handle.paused() || this._handle.aborted()) + return void (this._halted = true); + n3 = void 0, this._completeResults = void 0; + } + return this._config.step || this._config.chunk || (this._completeResults.data = this._completeResults.data.concat(n3.data), this._completeResults.errors = this._completeResults.errors.concat(n3.errors), this._completeResults.meta = n3.meta), this._completed || !a3 || !J(this._config.complete) || n3 && n3.meta.aborted || (this._config.complete(this._completeResults, this._input), this._completed = true), a3 || n3 && n3.meta.paused || this._nextChunk(), n3; + } + this._halted = true; + }, this._sendError = function(e3) { + J(this._config.error) ? this._config.error(e3) : o3 && this._config.error && f2.postMessage({ workerId: b2.WORKER_ID, error: e3, finished: false }); + }; + } + function l2(e2) { + var i3; + (e2 = e2 || {}).chunkSize || (e2.chunkSize = b2.RemoteChunkSize), h.call(this, e2), this._nextChunk = n2 ? function() { + this._readChunk(), this._chunkLoaded(); + } : function() { + this._readChunk(); + }, this.stream = function(e3) { + this._input = e3, this._nextChunk(); + }, this._readChunk = function() { + if (this._finished) + this._chunkLoaded(); + else { + if (i3 = new XMLHttpRequest(), this._config.withCredentials && (i3.withCredentials = this._config.withCredentials), n2 || (i3.onload = v2(this._chunkLoaded, this), i3.onerror = v2(this._chunkError, this)), i3.open(this._config.downloadRequestBody ? "POST" : "GET", this._input, !n2), this._config.downloadRequestHeaders) { + var e3 = this._config.downloadRequestHeaders; + for (var t2 in e3) + i3.setRequestHeader(t2, e3[t2]); + } + if (this._config.chunkSize) { + var r3 = this._start + this._config.chunkSize - 1; + i3.setRequestHeader("Range", "bytes=" + this._start + "-" + r3); + } + try { + i3.send(this._config.downloadRequestBody); + } catch (e4) { + this._chunkError(e4.message); + } + n2 && 0 === i3.status && this._chunkError(); + } + }, this._chunkLoaded = function() { + 4 === i3.readyState && (i3.status < 200 || 400 <= i3.status ? this._chunkError() : (this._start += this._config.chunkSize ? this._config.chunkSize : i3.responseText.length, this._finished = !this._config.chunkSize || this._start >= function(e3) { + var t2 = e3.getResponseHeader("Content-Range"); + if (null === t2) + return -1; + return parseInt(t2.substring(t2.lastIndexOf("/") + 1)); + }(i3), this.parseChunk(i3.responseText))); + }, this._chunkError = function(e3) { + var t2 = i3.statusText || e3; + this._sendError(new Error(t2)); + }; + } + function c2(e2) { + var i3, n3; + (e2 = e2 || {}).chunkSize || (e2.chunkSize = b2.LocalChunkSize), h.call(this, e2); + var s2 = "undefined" != typeof FileReader; + this.stream = function(e3) { + this._input = e3, n3 = e3.slice || e3.webkitSlice || e3.mozSlice, s2 ? ((i3 = new FileReader()).onload = v2(this._chunkLoaded, this), i3.onerror = v2(this._chunkError, this)) : i3 = new FileReaderSync(), this._nextChunk(); + }, this._nextChunk = function() { + this._finished || this._config.preview && !(this._rowCount < this._config.preview) || this._readChunk(); + }, this._readChunk = function() { + var e3 = this._input; + if (this._config.chunkSize) { + var t2 = Math.min(this._start + this._config.chunkSize, this._input.size); + e3 = n3.call(e3, this._start, t2); + } + var r3 = i3.readAsText(e3, this._config.encoding); + s2 || this._chunkLoaded({ target: { result: r3 } }); + }, this._chunkLoaded = function(e3) { + this._start += this._config.chunkSize, this._finished = !this._config.chunkSize || this._start >= this._input.size, this.parseChunk(e3.target.result); + }, this._chunkError = function() { + this._sendError(i3.error); + }; + } + function p2(e2) { + var r3; + h.call(this, e2 = e2 || {}), this.stream = function(e3) { + return r3 = e3, this._nextChunk(); + }, this._nextChunk = function() { + if (!this._finished) { + var e3, t2 = this._config.chunkSize; + return t2 ? (e3 = r3.substring(0, t2), r3 = r3.substring(t2)) : (e3 = r3, r3 = ""), this._finished = !r3, this.parseChunk(e3); + } + }; + } + function g3(e2) { + h.call(this, e2 = e2 || {}); + var t2 = [], r3 = true, i3 = false; + this.pause = function() { + h.prototype.pause.apply(this, arguments), this._input.pause(); + }, this.resume = function() { + h.prototype.resume.apply(this, arguments), this._input.resume(); + }, this.stream = function(e3) { + this._input = e3, this._input.on("data", this._streamData), this._input.on("end", this._streamEnd), this._input.on("error", this._streamError); + }, this._checkIsFinished = function() { + i3 && 1 === t2.length && (this._finished = true); + }, this._nextChunk = function() { + this._checkIsFinished(), t2.length ? this.parseChunk(t2.shift()) : r3 = true; + }, this._streamData = v2(function(e3) { + try { + t2.push("string" == typeof e3 ? e3 : e3.toString(this._config.encoding)), r3 && (r3 = false, this._checkIsFinished(), this.parseChunk(t2.shift())); + } catch (e4) { + this._streamError(e4); + } + }, this), this._streamError = v2(function(e3) { + this._streamCleanUp(), this._sendError(e3); + }, this), this._streamEnd = v2(function() { + this._streamCleanUp(), i3 = true, this._streamData(""); + }, this), this._streamCleanUp = v2(function() { + this._input.removeListener("data", this._streamData), this._input.removeListener("end", this._streamEnd), this._input.removeListener("error", this._streamError); + }, this); + } + function r2(m2) { + var a3, o4, u3, i3 = Math.pow(2, 53), n3 = -i3, s2 = /^\s*-?(\d+\.?|\.\d+|\d+\.\d+)([eE][-+]?\d+)?\s*$/, h2 = /^((\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)))$/, t2 = this, r3 = 0, f3 = 0, d3 = false, e2 = false, l3 = [], c3 = { data: [], errors: [], meta: {} }; + if (J(m2.step)) { + var p3 = m2.step; + m2.step = function(e3) { + if (c3 = e3, _3()) + g4(); + else { + if (g4(), 0 === c3.data.length) + return; + r3 += e3.data.length, m2.preview && r3 > m2.preview ? o4.abort() : (c3.data = c3.data[0], p3(c3, t2)); + } + }; + } + function y3(e3) { + return "greedy" === m2.skipEmptyLines ? "" === e3.join("").trim() : 1 === e3.length && 0 === e3[0].length; + } + function g4() { + return c3 && u3 && (k("Delimiter", "UndetectableDelimiter", "Unable to auto-detect delimiting character; defaulted to '" + b2.DefaultDelimiter + "'"), u3 = false), m2.skipEmptyLines && (c3.data = c3.data.filter(function(e3) { + return !y3(e3); + })), _3() && function() { + if (!c3) + return; + function e3(e4, t4) { + J(m2.transformHeader) && (e4 = m2.transformHeader(e4, t4)), l3.push(e4); + } + if (Array.isArray(c3.data[0])) { + for (var t3 = 0; _3() && t3 < c3.data.length; t3++) + c3.data[t3].forEach(e3); + c3.data.splice(0, 1); + } else + c3.data.forEach(e3); + }(), function() { + if (!c3 || !m2.header && !m2.dynamicTyping && !m2.transform) + return c3; + function e3(e4, t4) { + var r4, i4 = m2.header ? {} : []; + for (r4 = 0; r4 < e4.length; r4++) { + var n4 = r4, s3 = e4[r4]; + m2.header && (n4 = r4 >= l3.length ? "__parsed_extra" : l3[r4]), m2.transform && (s3 = m2.transform(s3, n4)), s3 = v3(n4, s3), "__parsed_extra" === n4 ? (i4[n4] = i4[n4] || [], i4[n4].push(s3)) : i4[n4] = s3; + } + return m2.header && (r4 > l3.length ? k("FieldMismatch", "TooManyFields", "Too many fields: expected " + l3.length + " fields but parsed " + r4, f3 + t4) : r4 < l3.length && k("FieldMismatch", "TooFewFields", "Too few fields: expected " + l3.length + " fields but parsed " + r4, f3 + t4)), i4; + } + var t3 = 1; + !c3.data.length || Array.isArray(c3.data[0]) ? (c3.data = c3.data.map(e3), t3 = c3.data.length) : c3.data = e3(c3.data, 0); + m2.header && c3.meta && (c3.meta.fields = l3); + return f3 += t3, c3; + }(); + } + function _3() { + return m2.header && 0 === l3.length; + } + function v3(e3, t3) { + return r4 = e3, m2.dynamicTypingFunction && void 0 === m2.dynamicTyping[r4] && (m2.dynamicTyping[r4] = m2.dynamicTypingFunction(r4)), true === (m2.dynamicTyping[r4] || m2.dynamicTyping) ? "true" === t3 || "TRUE" === t3 || "false" !== t3 && "FALSE" !== t3 && (function(e4) { + if (s2.test(e4)) { + var t4 = parseFloat(e4); + if (n3 < t4 && t4 < i3) + return true; + } + return false; + }(t3) ? parseFloat(t3) : h2.test(t3) ? new Date(t3) : "" === t3 ? null : t3) : t3; + var r4; + } + function k(e3, t3, r4, i4) { + var n4 = { type: e3, code: t3, message: r4 }; + void 0 !== i4 && (n4.row = i4), c3.errors.push(n4); + } + this.parse = function(e3, t3, r4) { + var i4 = m2.quoteChar || '"'; + if (m2.newline || (m2.newline = function(e4, t4) { + e4 = e4.substring(0, 1048576); + var r5 = new RegExp(Q2(t4) + "([^]*?)" + Q2(t4), "gm"), i5 = (e4 = e4.replace(r5, "")).split("\r"), n5 = e4.split("\n"), s4 = 1 < n5.length && n5[0].length < i5[0].length; + if (1 === i5.length || s4) + return "\n"; + for (var a4 = 0, o5 = 0; o5 < i5.length; o5++) + "\n" === i5[o5][0] && a4++; + return a4 >= i5.length / 2 ? "\r\n" : "\r"; + }(e3, i4)), u3 = false, m2.delimiter) + J(m2.delimiter) && (m2.delimiter = m2.delimiter(e3), c3.meta.delimiter = m2.delimiter); + else { + var n4 = function(e4, t4, r5, i5, n5) { + var s4, a4, o5, u4; + n5 = n5 || [",", " ", "|", ";", b2.RECORD_SEP, b2.UNIT_SEP]; + for (var h3 = 0; h3 < n5.length; h3++) { + var f4 = n5[h3], d4 = 0, l4 = 0, c4 = 0; + o5 = void 0; + for (var p4 = new E3({ comments: i5, delimiter: f4, newline: t4, preview: 10 }).parse(e4), g5 = 0; g5 < p4.data.length; g5++) + if (r5 && y3(p4.data[g5])) + c4++; + else { + var _4 = p4.data[g5].length; + l4 += _4, void 0 !== o5 ? 0 < _4 && (d4 += Math.abs(_4 - o5), o5 = _4) : o5 = _4; + } + 0 < p4.data.length && (l4 /= p4.data.length - c4), (void 0 === a4 || d4 <= a4) && (void 0 === u4 || u4 < l4) && 1.99 < l4 && (a4 = d4, s4 = f4, u4 = l4); + } + return { successful: !!(m2.delimiter = s4), bestDelimiter: s4 }; + }(e3, m2.newline, m2.skipEmptyLines, m2.comments, m2.delimitersToGuess); + n4.successful ? m2.delimiter = n4.bestDelimiter : (u3 = true, m2.delimiter = b2.DefaultDelimiter), c3.meta.delimiter = m2.delimiter; + } + var s3 = w3(m2); + return m2.preview && m2.header && s3.preview++, a3 = e3, o4 = new E3(s3), c3 = o4.parse(a3, t3, r4), g4(), d3 ? { meta: { paused: true } } : c3 || { meta: { paused: false } }; + }, this.paused = function() { + return d3; + }, this.pause = function() { + d3 = true, o4.abort(), a3 = J(m2.chunk) ? "" : a3.substring(o4.getCharIndex()); + }, this.resume = function() { + t2.streamer._halted ? (d3 = false, t2.streamer.parseChunk(a3, true)) : setTimeout(t2.resume, 3); + }, this.aborted = function() { + return e2; + }, this.abort = function() { + e2 = true, o4.abort(), c3.meta.aborted = true, J(m2.complete) && m2.complete(c3), a3 = ""; + }; + } + function Q2(e2) { + return e2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + } + function E3(j) { + var z, M = (j = j || {}).delimiter, P = j.newline, U = j.comments, q = j.step, N2 = j.preview, B2 = j.fastMode, K = z = void 0 === j.quoteChar || null === j.quoteChar ? '"' : j.quoteChar; + if (void 0 !== j.escapeChar && (K = j.escapeChar), ("string" != typeof M || -1 < b2.BAD_DELIMITERS.indexOf(M)) && (M = ","), U === M) + throw new Error("Comment character same as delimiter"); + true === U ? U = "#" : ("string" != typeof U || -1 < b2.BAD_DELIMITERS.indexOf(U)) && (U = false), "\n" !== P && "\r" !== P && "\r\n" !== P && (P = "\n"); + var W = 0, H = false; + this.parse = function(i3, t2, r3) { + if ("string" != typeof i3) + throw new Error("Input must be a string"); + var n3 = i3.length, e2 = M.length, s2 = P.length, a3 = U.length, o4 = J(q), u3 = [], h2 = [], f3 = [], d3 = W = 0; + if (!i3) + return L(); + if (j.header && !t2) { + var l3 = i3.split(P)[0].split(M), c3 = [], p3 = {}, g4 = false; + for (var _3 in l3) { + var m2 = l3[_3]; + J(j.transformHeader) && (m2 = j.transformHeader(m2, _3)); + var y3 = m2, v3 = p3[m2] || 0; + for (0 < v3 && (g4 = true, y3 = m2 + "_" + v3), p3[m2] = v3 + 1; c3.includes(y3); ) + y3 = y3 + "_" + v3; + c3.push(y3); + } + if (g4) { + var k = i3.split(P); + k[0] = c3.join(M), i3 = k.join(P); + } + } + if (B2 || false !== B2 && -1 === i3.indexOf(z)) { + for (var b3 = i3.split(P), E4 = 0; E4 < b3.length; E4++) { + if (f3 = b3[E4], W += f3.length, E4 !== b3.length - 1) + W += P.length; + else if (r3) + return L(); + if (!U || f3.substring(0, a3) !== U) { + if (o4) { + if (u3 = [], I2(f3.split(M)), F(), H) + return L(); + } else + I2(f3.split(M)); + if (N2 && N2 <= E4) + return u3 = u3.slice(0, N2), L(true); + } + } + return L(); + } + for (var w4 = i3.indexOf(M, W), R = i3.indexOf(P, W), C2 = new RegExp(Q2(K) + Q2(z), "g"), S = i3.indexOf(z, W); ; ) + if (i3[W] !== z) + if (U && 0 === f3.length && i3.substring(W, W + a3) === U) { + if (-1 === R) + return L(); + W = R + s2, R = i3.indexOf(P, W), w4 = i3.indexOf(M, W); + } else if (-1 !== w4 && (w4 < R || -1 === R)) + f3.push(i3.substring(W, w4)), W = w4 + e2, w4 = i3.indexOf(M, W); + else { + if (-1 === R) + break; + if (f3.push(i3.substring(W, R)), D2(R + s2), o4 && (F(), H)) + return L(); + if (N2 && u3.length >= N2) + return L(true); + } + else + for (S = W, W++; ; ) { + if (-1 === (S = i3.indexOf(z, S + 1))) + return r3 || h2.push({ type: "Quotes", code: "MissingQuotes", message: "Quoted field unterminated", row: u3.length, index: W }), T(); + if (S === n3 - 1) + return T(i3.substring(W, S).replace(C2, z)); + if (z !== K || i3[S + 1] !== K) { + if (z === K || 0 === S || i3[S - 1] !== K) { + -1 !== w4 && w4 < S + 1 && (w4 = i3.indexOf(M, S + 1)), -1 !== R && R < S + 1 && (R = i3.indexOf(P, S + 1)); + var O2 = A2(-1 === R ? w4 : Math.min(w4, R)); + if (i3.substr(S + 1 + O2, e2) === M) { + f3.push(i3.substring(W, S).replace(C2, z)), i3[W = S + 1 + O2 + e2] !== z && (S = i3.indexOf(z, W)), w4 = i3.indexOf(M, W), R = i3.indexOf(P, W); + break; + } + var x2 = A2(R); + if (i3.substring(S + 1 + x2, S + 1 + x2 + s2) === P) { + if (f3.push(i3.substring(W, S).replace(C2, z)), D2(S + 1 + x2 + s2), w4 = i3.indexOf(M, W), S = i3.indexOf(z, W), o4 && (F(), H)) + return L(); + if (N2 && u3.length >= N2) + return L(true); + break; + } + h2.push({ type: "Quotes", code: "InvalidQuotes", message: "Trailing quote on quoted field is malformed", row: u3.length, index: W }), S++; + } + } else + S++; + } + return T(); + function I2(e3) { + u3.push(e3), d3 = W; + } + function A2(e3) { + var t3 = 0; + if (-1 !== e3) { + var r4 = i3.substring(S + 1, e3); + r4 && "" === r4.trim() && (t3 = r4.length); + } + return t3; + } + function T(e3) { + return r3 || (void 0 === e3 && (e3 = i3.substring(W)), f3.push(e3), W = n3, I2(f3), o4 && F()), L(); + } + function D2(e3) { + W = e3, I2(f3), f3 = [], R = i3.indexOf(P, W); + } + function L(e3) { + return { data: u3, errors: h2, meta: { delimiter: M, linebreak: P, aborted: H, truncated: !!e3, cursor: d3 + (t2 || 0) } }; + } + function F() { + q(L()), u3 = [], h2 = []; + } + }, this.abort = function() { + H = true; + }, this.getCharIndex = function() { + return W; + }; + } + function _2(e2) { + var t2 = e2.data, r3 = a2[t2.workerId], i3 = false; + if (t2.error) + r3.userError(t2.error, t2.file); + else if (t2.results && t2.results.data) { + var n3 = { abort: function() { + i3 = true, m(t2.workerId, { data: [], errors: [], meta: { aborted: true } }); + }, pause: y2, resume: y2 }; + if (J(r3.userStep)) { + for (var s2 = 0; s2 < t2.results.data.length && (r3.userStep({ data: t2.results.data[s2], errors: t2.results.errors, meta: t2.results.meta }, n3), !i3); s2++) + ; + delete t2.results; + } else + J(r3.userChunk) && (r3.userChunk(t2.results, n3, t2.file), delete t2.results); + } + t2.finished && !i3 && m(t2.workerId, t2.results); + } + function m(e2, t2) { + var r3 = a2[e2]; + J(r3.userComplete) && r3.userComplete(t2), r3.terminate(), delete a2[e2]; + } + function y2() { + throw new Error("Not implemented."); + } + function w3(e2) { + if ("object" != typeof e2 || null === e2) + return e2; + var t2 = Array.isArray(e2) ? [] : {}; + for (var r3 in e2) + t2[r3] = w3(e2[r3]); + return t2; + } + function v2(e2, t2) { + return function() { + e2.apply(t2, arguments); + }; + } + function J(e2) { + return "function" == typeof e2; + } + return o3 && (f2.onmessage = function(e2) { + var t2 = e2.data; + void 0 === b2.WORKER_ID && t2 && (b2.WORKER_ID = t2.workerId); + if ("string" == typeof t2.input) + f2.postMessage({ workerId: b2.WORKER_ID, results: b2.parse(t2.input, t2.config), finished: true }); + else if (f2.File && t2.input instanceof File || t2.input instanceof Object) { + var r3 = b2.parse(t2.input, t2.config); + r3 && f2.postMessage({ workerId: b2.WORKER_ID, results: r3, finished: true }); + } + }), (l2.prototype = Object.create(h.prototype)).constructor = l2, (c2.prototype = Object.create(h.prototype)).constructor = c2, (p2.prototype = Object.create(p2.prototype)).constructor = p2, (g3.prototype = Object.create(h.prototype)).constructor = g3, b2; + }); + } + }); + + // node_modules/@babel/runtime/helpers/esm/typeof.js + function _typeof(o3) { + "@babel/helpers - typeof"; + return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o4) { + return typeof o4; + } : function(o4) { + return o4 && "function" == typeof Symbol && o4.constructor === Symbol && o4 !== Symbol.prototype ? "symbol" : typeof o4; + }, _typeof(o3); + } + + // node_modules/@babel/runtime/helpers/esm/toPrimitive.js + function toPrimitive(t2, r2) { + if ("object" != _typeof(t2) || !t2) + return t2; + var e2 = t2[Symbol.toPrimitive]; + if (void 0 !== e2) { + var i3 = e2.call(t2, r2 || "default"); + if ("object" != _typeof(i3)) + return i3; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return ("string" === r2 ? String : Number)(t2); + } + + // node_modules/@babel/runtime/helpers/esm/toPropertyKey.js + function toPropertyKey(t2) { + var i3 = toPrimitive(t2, "string"); + return "symbol" == _typeof(i3) ? i3 : String(i3); + } + + // node_modules/@babel/runtime/helpers/esm/defineProperty.js + function _defineProperty(obj, key, value) { + key = toPropertyKey(key); + if (key in obj) { + Object.defineProperty(obj, key, { + value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/env-utils/assert.js + function assert(condition, message) { + if (!condition) { + throw new Error(message || "loader assertion failed."); + } + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/env-utils/globals.js + var globals = { + self: typeof self !== "undefined" && self, + window: typeof window !== "undefined" && window, + global: typeof global !== "undefined" && global, + document: typeof document !== "undefined" && document + }; + var self_ = globals.self || globals.window || globals.global || {}; + var window_ = globals.window || globals.self || globals.global || {}; + var global_ = globals.global || globals.self || globals.window || {}; + var document_ = globals.document || {}; + var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser); + var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); + var nodeVersion = matches && parseFloat(matches[1]) || 0; + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/env-utils/version.js + var VERSION = true ? "3.4.14" : DEFAULT_VERSION; + if (false) { + console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."); + } + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/env-utils/assert.js + function assert2(condition, message) { + if (!condition) { + throw new Error(message || "loaders.gl assertion failed."); + } + } + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/env-utils/globals.js + var globals2 = { + self: typeof self !== "undefined" && self, + window: typeof window !== "undefined" && window, + global: typeof global !== "undefined" && global, + document: typeof document !== "undefined" && document + }; + var self_2 = globals2.self || globals2.window || globals2.global || {}; + var window_2 = globals2.window || globals2.self || globals2.global || {}; + var global_2 = globals2.global || globals2.self || globals2.window || {}; + var document_2 = globals2.document || {}; + var isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser; + var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined"; + var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version); + var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0; + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-job.js + var WorkerJob = class { + constructor(jobName, workerThread) { + _defineProperty(this, "name", void 0); + _defineProperty(this, "workerThread", void 0); + _defineProperty(this, "isRunning", true); + _defineProperty(this, "result", void 0); + _defineProperty(this, "_resolve", () => { + }); + _defineProperty(this, "_reject", () => { + }); + this.name = jobName; + this.workerThread = workerThread; + this.result = new Promise((resolve2, reject) => { + this._resolve = resolve2; + this._reject = reject; + }); + } + postMessage(type, payload) { + this.workerThread.postMessage({ + source: "loaders.gl", + type, + payload + }); + } + done(value) { + assert2(this.isRunning); + this.isRunning = false; + this._resolve(value); + } + error(error2) { + assert2(this.isRunning); + this.isRunning = false; + this._reject(error2); + } + }; + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/node/worker_threads-browser.js + var Worker2 = class { + terminate() { + } + }; + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-utils/get-loadable-worker-url.js + var workerURLCache = /* @__PURE__ */ new Map(); + function getLoadableWorkerURL(props) { + assert2(props.source && !props.url || !props.source && props.url); + let workerURL = workerURLCache.get(props.source || props.url); + if (!workerURL) { + if (props.url) { + workerURL = getLoadableWorkerURLFromURL(props.url); + workerURLCache.set(props.url, workerURL); + } + if (props.source) { + workerURL = getLoadableWorkerURLFromSource(props.source); + workerURLCache.set(props.source, workerURL); + } + } + assert2(workerURL); + return workerURL; + } + function getLoadableWorkerURLFromURL(url) { + if (!url.startsWith("http")) { + return url; + } + const workerSource = buildScriptSource(url); + return getLoadableWorkerURLFromSource(workerSource); + } + function getLoadableWorkerURLFromSource(workerSource) { + const blob = new Blob([workerSource], { + type: "application/javascript" + }); + return URL.createObjectURL(blob); + } + function buildScriptSource(workerUrl) { + return "try {\n importScripts('".concat(workerUrl, "');\n} catch (error) {\n console.error(error);\n throw error;\n}"); + } + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-utils/get-transfer-list.js + function getTransferList(object) { + let recursive = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true; + let transfers = arguments.length > 2 ? arguments[2] : void 0; + const transfersSet = transfers || /* @__PURE__ */ new Set(); + if (!object) { + } else if (isTransferable(object)) { + transfersSet.add(object); + } else if (isTransferable(object.buffer)) { + transfersSet.add(object.buffer); + } else if (ArrayBuffer.isView(object)) { + } else if (recursive && typeof object === "object") { + for (const key in object) { + getTransferList(object[key], recursive, transfersSet); + } + } + return transfers === void 0 ? Array.from(transfersSet) : []; + } + function isTransferable(object) { + if (!object) { + return false; + } + if (object instanceof ArrayBuffer) { + return true; + } + if (typeof MessagePort !== "undefined" && object instanceof MessagePort) { + return true; + } + if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) { + return true; + } + if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) { + return true; + } + return false; + } + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-thread.js + var NOOP = () => { + }; + var WorkerThread = class { + static isSupported() { + return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== "undefined" && !isBrowser2; + } + constructor(props) { + _defineProperty(this, "name", void 0); + _defineProperty(this, "source", void 0); + _defineProperty(this, "url", void 0); + _defineProperty(this, "terminated", false); + _defineProperty(this, "worker", void 0); + _defineProperty(this, "onMessage", void 0); + _defineProperty(this, "onError", void 0); + _defineProperty(this, "_loadableURL", ""); + const { + name, + source, + url + } = props; + assert2(source || url); + this.name = name; + this.source = source; + this.url = url; + this.onMessage = NOOP; + this.onError = (error2) => console.log(error2); + this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker(); + } + destroy() { + this.onMessage = NOOP; + this.onError = NOOP; + this.worker.terminate(); + this.terminated = true; + } + get isRunning() { + return Boolean(this.onMessage); + } + postMessage(data, transferList) { + transferList = transferList || getTransferList(data); + this.worker.postMessage(data, transferList); + } + _getErrorFromErrorEvent(event) { + let message = "Failed to load "; + message += "worker ".concat(this.name, " from ").concat(this.url, ". "); + if (event.message) { + message += "".concat(event.message, " in "); + } + if (event.lineno) { + message += ":".concat(event.lineno, ":").concat(event.colno); + } + return new Error(message); + } + _createBrowserWorker() { + this._loadableURL = getLoadableWorkerURL({ + source: this.source, + url: this.url + }); + const worker = new Worker(this._loadableURL, { + name: this.name + }); + worker.onmessage = (event) => { + if (!event.data) { + this.onError(new Error("No data received")); + } else { + this.onMessage(event.data); + } + }; + worker.onerror = (error2) => { + this.onError(this._getErrorFromErrorEvent(error2)); + this.terminated = true; + }; + worker.onmessageerror = (event) => console.error(event); + return worker; + } + _createNodeWorker() { + let worker; + if (this.url) { + const absolute = this.url.includes(":/") || this.url.startsWith("/"); + const url = absolute ? this.url : "./".concat(this.url); + worker = new Worker2(url, { + eval: false + }); + } else if (this.source) { + worker = new Worker2(this.source, { + eval: true + }); + } else { + throw new Error("no worker"); + } + worker.on("message", (data) => { + this.onMessage(data); + }); + worker.on("error", (error2) => { + this.onError(error2); + }); + worker.on("exit", (code) => { + }); + return worker; + } + }; + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-pool.js + var WorkerPool = class { + static isSupported() { + return WorkerThread.isSupported(); + } + constructor(props) { + _defineProperty(this, "name", "unnamed"); + _defineProperty(this, "source", void 0); + _defineProperty(this, "url", void 0); + _defineProperty(this, "maxConcurrency", 1); + _defineProperty(this, "maxMobileConcurrency", 1); + _defineProperty(this, "onDebug", () => { + }); + _defineProperty(this, "reuseWorkers", true); + _defineProperty(this, "props", {}); + _defineProperty(this, "jobQueue", []); + _defineProperty(this, "idleQueue", []); + _defineProperty(this, "count", 0); + _defineProperty(this, "isDestroyed", false); + this.source = props.source; + this.url = props.url; + this.setProps(props); + } + destroy() { + this.idleQueue.forEach((worker) => worker.destroy()); + this.isDestroyed = true; + } + setProps(props) { + this.props = { + ...this.props, + ...props + }; + if (props.name !== void 0) { + this.name = props.name; + } + if (props.maxConcurrency !== void 0) { + this.maxConcurrency = props.maxConcurrency; + } + if (props.maxMobileConcurrency !== void 0) { + this.maxMobileConcurrency = props.maxMobileConcurrency; + } + if (props.reuseWorkers !== void 0) { + this.reuseWorkers = props.reuseWorkers; + } + if (props.onDebug !== void 0) { + this.onDebug = props.onDebug; + } + } + async startJob(name) { + let onMessage2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : (job, type, data) => job.done(data); + let onError = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : (job, error2) => job.error(error2); + const startPromise = new Promise((onStart) => { + this.jobQueue.push({ + name, + onMessage: onMessage2, + onError, + onStart + }); + return this; + }); + this._startQueuedJob(); + return await startPromise; + } + async _startQueuedJob() { + if (!this.jobQueue.length) { + return; + } + const workerThread = this._getAvailableWorker(); + if (!workerThread) { + return; + } + const queuedJob = this.jobQueue.shift(); + if (queuedJob) { + this.onDebug({ + message: "Starting job", + name: queuedJob.name, + workerThread, + backlog: this.jobQueue.length + }); + const job = new WorkerJob(queuedJob.name, workerThread); + workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload); + workerThread.onError = (error2) => queuedJob.onError(job, error2); + queuedJob.onStart(job); + try { + await job.result; + } finally { + this.returnWorkerToQueue(workerThread); + } + } + } + returnWorkerToQueue(worker) { + const shouldDestroyWorker = this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency(); + if (shouldDestroyWorker) { + worker.destroy(); + this.count--; + } else { + this.idleQueue.push(worker); + } + if (!this.isDestroyed) { + this._startQueuedJob(); + } + } + _getAvailableWorker() { + if (this.idleQueue.length > 0) { + return this.idleQueue.shift() || null; + } + if (this.count < this._getMaxConcurrency()) { + this.count++; + const name = "".concat(this.name.toLowerCase(), " (#").concat(this.count, " of ").concat(this.maxConcurrency, ")"); + return new WorkerThread({ + name, + source: this.source, + url: this.url + }); + } + return null; + } + _getMaxConcurrency() { + return isMobile ? this.maxMobileConcurrency : this.maxConcurrency; + } + }; + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-farm/worker-farm.js + var DEFAULT_PROPS = { + maxConcurrency: 3, + maxMobileConcurrency: 1, + reuseWorkers: true, + onDebug: () => { + } + }; + var WorkerFarm = class _WorkerFarm { + static isSupported() { + return WorkerThread.isSupported(); + } + static getWorkerFarm() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({}); + _WorkerFarm._workerFarm.setProps(props); + return _WorkerFarm._workerFarm; + } + constructor(props) { + _defineProperty(this, "props", void 0); + _defineProperty(this, "workerPools", /* @__PURE__ */ new Map()); + this.props = { + ...DEFAULT_PROPS + }; + this.setProps(props); + this.workerPools = /* @__PURE__ */ new Map(); + } + destroy() { + for (const workerPool of this.workerPools.values()) { + workerPool.destroy(); + } + this.workerPools = /* @__PURE__ */ new Map(); + } + setProps(props) { + this.props = { + ...this.props, + ...props + }; + for (const workerPool of this.workerPools.values()) { + workerPool.setProps(this._getWorkerPoolProps()); + } + } + getWorkerPool(options) { + const { + name, + source, + url + } = options; + let workerPool = this.workerPools.get(name); + if (!workerPool) { + workerPool = new WorkerPool({ + name, + source, + url + }); + workerPool.setProps(this._getWorkerPoolProps()); + this.workerPools.set(name, workerPool); + } + return workerPool; + } + _getWorkerPoolProps() { + return { + maxConcurrency: this.props.maxConcurrency, + maxMobileConcurrency: this.props.maxMobileConcurrency, + reuseWorkers: this.props.reuseWorkers, + onDebug: this.props.onDebug + }; + } + }; + _defineProperty(WorkerFarm, "_workerFarm", void 0); + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-api/get-worker-url.js + var NPM_TAG = "latest"; + function getWorkerURL(worker) { + let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const workerOptions = options[worker.id] || {}; + const workerFile = "".concat(worker.id, "-worker.js"); + let url = workerOptions.workerUrl; + if (!url && worker.id === "compression") { + url = options.workerUrl; + } + if (options._workerType === "test") { + url = "modules/".concat(worker.module, "/dist/").concat(workerFile); + } + if (!url) { + let version = worker.version; + if (version === "latest") { + version = NPM_TAG; + } + const versionTag = version ? "@".concat(version) : ""; + url = "https://unpkg.com/@loaders.gl/".concat(worker.module).concat(versionTag, "/dist/").concat(workerFile); + } + assert2(url); + return url; + } + + // node_modules/@loaders.gl/worker-utils/dist/esm/lib/worker-api/validate-worker-version.js + function validateWorkerVersion(worker) { + let coreVersion = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : VERSION; + assert2(worker, "no worker provided"); + const workerVersion = worker.version; + if (!coreVersion || !workerVersion) { + return false; + } + return true; + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/worker-loader-utils/parse-with-worker.js + function canParseWithWorker(loader, options) { + if (!WorkerFarm.isSupported()) { + return false; + } + if (!isBrowser2 && !(options !== null && options !== void 0 && options._nodeWorkers)) { + return false; + } + return loader.worker && (options === null || options === void 0 ? void 0 : options.worker); + } + async function parseWithWorker(loader, data, options, context, parseOnMainThread) { + const name = loader.id; + const url = getWorkerURL(loader, options); + const workerFarm = WorkerFarm.getWorkerFarm(options); + const workerPool = workerFarm.getWorkerPool({ + name, + url + }); + options = JSON.parse(JSON.stringify(options)); + context = JSON.parse(JSON.stringify(context || {})); + const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread)); + job.postMessage("process", { + input: data, + options, + context + }); + const result = await job.result; + return await result.result; + } + async function onMessage(parseOnMainThread, job, type, payload) { + switch (type) { + case "done": + job.done(payload); + break; + case "error": + job.error(new Error(payload.error)); + break; + case "process": + const { + id, + input, + options + } = payload; + try { + const result = await parseOnMainThread(input, options); + job.postMessage("done", { + id, + result + }); + } catch (error2) { + const message = error2 instanceof Error ? error2.message : "unknown error"; + job.postMessage("error", { + id, + error: message + }); + } + break; + default: + console.warn("parse-with-worker unknown message ".concat(type)); + } + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/binary-utils/array-buffer-utils.js + function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) { + byteLength = byteLength || arrayBuffer1.byteLength; + if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) { + return false; + } + const array12 = new Uint8Array(arrayBuffer1); + const array2 = new Uint8Array(arrayBuffer2); + for (let i3 = 0; i3 < array12.length; ++i3) { + if (array12[i3] !== array2[i3]) { + return false; + } + } + return true; + } + function concatenateArrayBuffers() { + for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) { + sources[_key] = arguments[_key]; + } + const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2); + const byteLength = sourceArrays.reduce((length4, typedArray) => length4 + typedArray.byteLength, 0); + const result = new Uint8Array(byteLength); + let offset = 0; + for (const sourceArray of sourceArrays) { + result.set(sourceArray, offset); + offset += sourceArray.byteLength; + } + return result.buffer; + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/iterators/async-iteration.js + async function concatenateArrayBuffersAsync(asyncIterator) { + const arrayBuffers = []; + for await (const chunk of asyncIterator) { + arrayBuffers.push(chunk); + } + return concatenateArrayBuffers(...arrayBuffers); + } + + // node_modules/@loaders.gl/loader-utils/node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js + function getHiResTimestamp() { + let timestamp; + if (typeof window !== "undefined" && window.performance) { + timestamp = window.performance.now(); + } else if (typeof process !== "undefined" && process.hrtime) { + const timeParts = process.hrtime(); + timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; + } else { + timestamp = Date.now(); + } + return timestamp; + } + + // node_modules/@loaders.gl/loader-utils/node_modules/@probe.gl/stats/dist/lib/stat.js + var Stat = class { + constructor(name, type) { + this.name = void 0; + this.type = void 0; + this.sampleSize = 1; + this.time = 0; + this.count = 0; + this.samples = 0; + this.lastTiming = 0; + this.lastSampleTime = 0; + this.lastSampleCount = 0; + this._count = 0; + this._time = 0; + this._samples = 0; + this._startTime = 0; + this._timerPending = false; + this.name = name; + this.type = type; + this.reset(); + } + reset() { + this.time = 0; + this.count = 0; + this.samples = 0; + this.lastTiming = 0; + this.lastSampleTime = 0; + this.lastSampleCount = 0; + this._count = 0; + this._time = 0; + this._samples = 0; + this._startTime = 0; + this._timerPending = false; + return this; + } + setSampleSize(samples) { + this.sampleSize = samples; + return this; + } + incrementCount() { + this.addCount(1); + return this; + } + decrementCount() { + this.subtractCount(1); + return this; + } + addCount(value) { + this._count += value; + this._samples++; + this._checkSampling(); + return this; + } + subtractCount(value) { + this._count -= value; + this._samples++; + this._checkSampling(); + return this; + } + addTime(time) { + this._time += time; + this.lastTiming = time; + this._samples++; + this._checkSampling(); + return this; + } + timeStart() { + this._startTime = getHiResTimestamp(); + this._timerPending = true; + return this; + } + timeEnd() { + if (!this._timerPending) { + return this; + } + this.addTime(getHiResTimestamp() - this._startTime); + this._timerPending = false; + this._checkSampling(); + return this; + } + getSampleAverageCount() { + return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0; + } + getSampleAverageTime() { + return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0; + } + getSampleHz() { + return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0; + } + getAverageCount() { + return this.samples > 0 ? this.count / this.samples : 0; + } + getAverageTime() { + return this.samples > 0 ? this.time / this.samples : 0; + } + getHz() { + return this.time > 0 ? this.samples / (this.time / 1e3) : 0; + } + _checkSampling() { + if (this._samples === this.sampleSize) { + this.lastSampleTime = this._time; + this.lastSampleCount = this._count; + this.count += this._count; + this.time += this._time; + this.samples += this._samples; + this._time = 0; + this._count = 0; + this._samples = 0; + } + } + }; + + // node_modules/@loaders.gl/loader-utils/node_modules/@probe.gl/stats/dist/lib/stats.js + var Stats = class { + constructor(options) { + this.id = void 0; + this.stats = {}; + this.id = options.id; + this.stats = {}; + this._initializeStats(options.stats); + Object.seal(this); + } + get(name) { + let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count"; + return this._getOrCreate({ + name, + type + }); + } + get size() { + return Object.keys(this.stats).length; + } + reset() { + for (const stat of Object.values(this.stats)) { + stat.reset(); + } + return this; + } + forEach(fn) { + for (const stat of Object.values(this.stats)) { + fn(stat); + } + } + getTable() { + const table = {}; + this.forEach((stat) => { + table[stat.name] = { + time: stat.time || 0, + count: stat.count || 0, + average: stat.getAverageTime() || 0, + hz: stat.getHz() || 0 + }; + }); + return table; + } + _initializeStats() { + let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []; + stats.forEach((stat) => this._getOrCreate(stat)); + } + _getOrCreate(stat) { + const { + name, + type + } = stat; + let result = this.stats[name]; + if (!result) { + if (stat instanceof Stat) { + result = stat; + } else { + result = new Stat(name, type); + } + this.stats[name] = result; + } + return result; + } + }; + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/request-utils/request-scheduler.js + var STAT_QUEUED_REQUESTS = "Queued Requests"; + var STAT_ACTIVE_REQUESTS = "Active Requests"; + var STAT_CANCELLED_REQUESTS = "Cancelled Requests"; + var STAT_QUEUED_REQUESTS_EVER = "Queued Requests Ever"; + var STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever"; + var DEFAULT_PROPS2 = { + id: "request-scheduler", + throttleRequests: true, + maxRequests: 6 + }; + var RequestScheduler = class { + constructor() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + _defineProperty(this, "props", void 0); + _defineProperty(this, "stats", void 0); + _defineProperty(this, "activeRequestCount", 0); + _defineProperty(this, "requestQueue", []); + _defineProperty(this, "requestMap", /* @__PURE__ */ new Map()); + _defineProperty(this, "deferredUpdate", null); + this.props = { + ...DEFAULT_PROPS2, + ...props + }; + this.stats = new Stats({ + id: this.props.id + }); + this.stats.get(STAT_QUEUED_REQUESTS); + this.stats.get(STAT_ACTIVE_REQUESTS); + this.stats.get(STAT_CANCELLED_REQUESTS); + this.stats.get(STAT_QUEUED_REQUESTS_EVER); + this.stats.get(STAT_ACTIVE_REQUESTS_EVER); + } + scheduleRequest(handle) { + let getPriority = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : () => 0; + if (!this.props.throttleRequests) { + return Promise.resolve({ + done: () => { + } + }); + } + if (this.requestMap.has(handle)) { + return this.requestMap.get(handle); + } + const request = { + handle, + priority: 0, + getPriority + }; + const promise = new Promise((resolve2) => { + request.resolve = resolve2; + return request; + }); + this.requestQueue.push(request); + this.requestMap.set(handle, promise); + this._issueNewRequests(); + return promise; + } + _issueRequest(request) { + const { + handle, + resolve: resolve2 + } = request; + let isDone = false; + const done = () => { + if (!isDone) { + isDone = true; + this.requestMap.delete(handle); + this.activeRequestCount--; + this._issueNewRequests(); + } + }; + this.activeRequestCount++; + return resolve2 ? resolve2({ + done + }) : Promise.resolve({ + done + }); + } + _issueNewRequests() { + if (!this.deferredUpdate) { + this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0); + } + } + _issueNewRequestsAsync() { + this.deferredUpdate = null; + const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0); + if (freeSlots === 0) { + return; + } + this._updateAllRequests(); + for (let i3 = 0; i3 < freeSlots; ++i3) { + const request = this.requestQueue.shift(); + if (request) { + this._issueRequest(request); + } + } + } + _updateAllRequests() { + const requestQueue = this.requestQueue; + for (let i3 = 0; i3 < requestQueue.length; ++i3) { + const request = requestQueue[i3]; + if (!this._updateRequest(request)) { + requestQueue.splice(i3, 1); + this.requestMap.delete(request.handle); + i3--; + } + } + requestQueue.sort((a2, b2) => a2.priority - b2.priority); + } + _updateRequest(request) { + request.priority = request.getPriority(request.handle); + if (request.priority < 0) { + request.resolve(null); + return false; + } + return true; + } + }; + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/path-utils/file-aliases.js + var pathPrefix = ""; + var fileAliases = {}; + function resolvePath(filename2) { + for (const alias in fileAliases) { + if (filename2.startsWith(alias)) { + const replacement = fileAliases[alias]; + filename2 = filename2.replace(alias, replacement); + } + } + if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) { + filename2 = "".concat(pathPrefix).concat(filename2); + } + return filename2; + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/node/buffer.browser.js + function toArrayBuffer(buffer) { + return buffer; + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/binary-utils/memory-conversion-utils.js + function isBuffer(value) { + return value && typeof value === "object" && value.isBuffer; + } + function toArrayBuffer2(data) { + if (isBuffer(data)) { + return toArrayBuffer(data); + } + if (data instanceof ArrayBuffer) { + return data; + } + if (ArrayBuffer.isView(data)) { + if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) { + return data.buffer; + } + return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength); + } + if (typeof data === "string") { + const text = data; + const uint8Array = new TextEncoder().encode(text); + return uint8Array.buffer; + } + if (data && typeof data === "object" && data._toArrayBuffer) { + return data._toArrayBuffer(); + } + throw new Error("toArrayBuffer"); + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/path-utils/path.js + var path_exports = {}; + __export(path_exports, { + dirname: () => dirname, + filename: () => filename, + join: () => join, + resolve: () => resolve + }); + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/path-utils/get-cwd.js + function getCWD() { + var _window$location; + if (typeof process !== "undefined" && typeof process.cwd !== "undefined") { + return process.cwd(); + } + const pathname = (_window$location = window.location) === null || _window$location === void 0 ? void 0 : _window$location.pathname; + return (pathname === null || pathname === void 0 ? void 0 : pathname.slice(0, pathname.lastIndexOf("/") + 1)) || ""; + } + + // node_modules/@loaders.gl/loader-utils/dist/esm/lib/path-utils/path.js + function filename(url) { + const slashIndex = url ? url.lastIndexOf("/") : -1; + return slashIndex >= 0 ? url.substr(slashIndex + 1) : ""; + } + function dirname(url) { + const slashIndex = url ? url.lastIndexOf("/") : -1; + return slashIndex >= 0 ? url.substr(0, slashIndex) : ""; + } + function join() { + for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) { + parts[_key] = arguments[_key]; + } + const separator = "/"; + parts = parts.map((part, index) => { + if (index) { + part = part.replace(new RegExp("^".concat(separator)), ""); + } + if (index !== parts.length - 1) { + part = part.replace(new RegExp("".concat(separator, "$")), ""); + } + return part; + }); + return parts.join(separator); + } + function resolve() { + const paths = []; + for (let _i = 0; _i < arguments.length; _i++) { + paths[_i] = _i < 0 || arguments.length <= _i ? void 0 : arguments[_i]; + } + let resolvedPath = ""; + let resolvedAbsolute = false; + let cwd; + for (let i3 = paths.length - 1; i3 >= -1 && !resolvedAbsolute; i3--) { + let path; + if (i3 >= 0) { + path = paths[i3]; + } else { + if (cwd === void 0) { + cwd = getCWD(); + } + path = cwd; + } + if (path.length === 0) { + continue; + } + resolvedPath = "".concat(path, "/").concat(resolvedPath); + resolvedAbsolute = path.charCodeAt(0) === SLASH; + } + resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute); + if (resolvedAbsolute) { + return "/".concat(resolvedPath); + } else if (resolvedPath.length > 0) { + return resolvedPath; + } + return "."; + } + var SLASH = 47; + var DOT = 46; + function normalizeStringPosix(path, allowAboveRoot) { + let res = ""; + let lastSlash = -1; + let dots = 0; + let code; + let isAboveRoot = false; + for (let i3 = 0; i3 <= path.length; ++i3) { + if (i3 < path.length) { + code = path.charCodeAt(i3); + } else if (code === SLASH) { + break; + } else { + code = SLASH; + } + if (code === SLASH) { + if (lastSlash === i3 - 1 || dots === 1) { + } else if (lastSlash !== i3 - 1 && dots === 2) { + if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) { + if (res.length > 2) { + const start = res.length - 1; + let j = start; + for (; j >= 0; --j) { + if (res.charCodeAt(j) === SLASH) { + break; + } + } + if (j !== start) { + res = j === -1 ? "" : res.slice(0, j); + lastSlash = i3; + dots = 0; + isAboveRoot = false; + continue; + } + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSlash = i3; + dots = 0; + isAboveRoot = false; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) { + res += "/.."; + } else { + res = ".."; + } + isAboveRoot = true; + } + } else { + const slice = path.slice(lastSlash + 1, i3); + if (res.length > 0) { + res += "/".concat(slice); + } else { + res = slice; + } + isAboveRoot = false; + } + lastSlash = i3; + dots = 0; + } else if (code === DOT && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; + } + + // node_modules/@loaders.gl/core/dist/esm/javascript-utils/is-type.js + var isBoolean = (x2) => typeof x2 === "boolean"; + var isFunction = (x2) => typeof x2 === "function"; + var isObject = (x2) => x2 !== null && typeof x2 === "object"; + var isPureObject = (x2) => isObject(x2) && x2.constructor === {}.constructor; + var isIterable = (x2) => x2 && typeof x2[Symbol.iterator] === "function"; + var isAsyncIterable = (x2) => x2 && typeof x2[Symbol.asyncIterator] === "function"; + var isResponse = (x2) => typeof Response !== "undefined" && x2 instanceof Response || x2 && x2.arrayBuffer && x2.text && x2.json; + var isBlob = (x2) => typeof Blob !== "undefined" && x2 instanceof Blob; + var isBuffer2 = (x2) => x2 && typeof x2 === "object" && x2.isBuffer; + var isReadableDOMStream = (x2) => typeof ReadableStream !== "undefined" && x2 instanceof ReadableStream || isObject(x2) && isFunction(x2.tee) && isFunction(x2.cancel) && isFunction(x2.getReader); + var isReadableNodeStream = (x2) => isObject(x2) && isFunction(x2.read) && isFunction(x2.pipe) && isBoolean(x2.readable); + var isReadableStream = (x2) => isReadableDOMStream(x2) || isReadableNodeStream(x2); + + // node_modules/@loaders.gl/core/dist/esm/lib/utils/mime-type-utils.js var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/; var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/; function parseMIMEType(mimeString) { @@ -5454,18299 +13894,26306 @@ if (matches3) { return matches3[1]; } - return mimeString; - } - function parseMIMETypeFromURL(url) { - const matches3 = DATA_URL_PATTERN.exec(url); - if (matches3) { - return matches3[1]; + return mimeString; + } + function parseMIMETypeFromURL(url) { + const matches3 = DATA_URL_PATTERN.exec(url); + if (matches3) { + return matches3[1]; + } + return ""; + } + + // node_modules/@loaders.gl/core/dist/esm/lib/utils/url-utils.js + var QUERY_STRING_PATTERN = /\?.*/; + function extractQueryString(url) { + const matches3 = url.match(QUERY_STRING_PATTERN); + return matches3 && matches3[0]; + } + function stripQueryString(url) { + return url.replace(QUERY_STRING_PATTERN, ""); + } + + // node_modules/@loaders.gl/core/dist/esm/lib/utils/resource-utils.js + function getResourceUrl(resource) { + if (isResponse(resource)) { + const response = resource; + return response.url; + } + if (isBlob(resource)) { + const blob = resource; + return blob.name || ""; + } + if (typeof resource === "string") { + return resource; + } + return ""; + } + function getResourceMIMEType(resource) { + if (isResponse(resource)) { + const response = resource; + const contentTypeHeader = response.headers.get("content-type") || ""; + const noQueryUrl = stripQueryString(response.url); + return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl); + } + if (isBlob(resource)) { + const blob = resource; + return blob.type || ""; + } + if (typeof resource === "string") { + return parseMIMETypeFromURL(resource); + } + return ""; + } + function getResourceContentLength(resource) { + if (isResponse(resource)) { + const response = resource; + return response.headers["content-length"] || -1; + } + if (isBlob(resource)) { + const blob = resource; + return blob.size; + } + if (typeof resource === "string") { + return resource.length; + } + if (resource instanceof ArrayBuffer) { + return resource.byteLength; + } + if (ArrayBuffer.isView(resource)) { + return resource.byteLength; + } + return -1; + } + + // node_modules/@loaders.gl/core/dist/esm/lib/utils/response-utils.js + async function makeResponse(resource) { + if (isResponse(resource)) { + return resource; + } + const headers = {}; + const contentLength = getResourceContentLength(resource); + if (contentLength >= 0) { + headers["content-length"] = String(contentLength); + } + const url = getResourceUrl(resource); + const type = getResourceMIMEType(resource); + if (type) { + headers["content-type"] = type; + } + const initialDataUrl = await getInitialDataUrl(resource); + if (initialDataUrl) { + headers["x-first-bytes"] = initialDataUrl; + } + if (typeof resource === "string") { + resource = new TextEncoder().encode(resource); + } + const response = new Response(resource, { + headers + }); + Object.defineProperty(response, "url", { + value: url + }); + return response; + } + async function checkResponse(response) { + if (!response.ok) { + const message = await getResponseError(response); + throw new Error(message); + } + } + async function getResponseError(response) { + let message = "Failed to fetch resource ".concat(response.url, " (").concat(response.status, "): "); + try { + const contentType = response.headers.get("Content-Type"); + let text = response.statusText; + if (contentType.includes("application/json")) { + text += " ".concat(await response.text()); + } + message += text; + message = message.length > 60 ? "".concat(message.slice(0, 60), "...") : message; + } catch (error2) { + } + return message; + } + async function getInitialDataUrl(resource) { + const INITIAL_DATA_LENGTH = 5; + if (typeof resource === "string") { + return "data:,".concat(resource.slice(0, INITIAL_DATA_LENGTH)); + } + if (resource instanceof Blob) { + const blobSlice = resource.slice(0, 5); + return await new Promise((resolve2) => { + const reader = new FileReader(); + reader.onload = (event) => { + var _event$target; + return resolve2(event === null || event === void 0 ? void 0 : (_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.result); + }; + reader.readAsDataURL(blobSlice); + }); + } + if (resource instanceof ArrayBuffer) { + const slice = resource.slice(0, INITIAL_DATA_LENGTH); + const base64 = arrayBufferToBase64(slice); + return "data:base64,".concat(base64); + } + return null; + } + function arrayBufferToBase64(buffer) { + let binary = ""; + const bytes = new Uint8Array(buffer); + for (let i3 = 0; i3 < bytes.byteLength; i3++) { + binary += String.fromCharCode(bytes[i3]); + } + return btoa(binary); + } + + // node_modules/@loaders.gl/core/dist/esm/lib/fetch/fetch-file.js + async function fetchFile(url, options) { + if (typeof url === "string") { + url = resolvePath(url); + let fetchOptions = options; + if (options !== null && options !== void 0 && options.fetch && typeof (options === null || options === void 0 ? void 0 : options.fetch) !== "function") { + fetchOptions = options.fetch; + } + return await fetch(url, fetchOptions); + } + return await makeResponse(url); + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/env/dist/lib/is-electron.js + function isElectron(mockUserAgent) { + if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") { + return true; + } + if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) { + return true; + } + const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent; + const userAgent2 = mockUserAgent || realUserAgent; + if (userAgent2 && userAgent2.indexOf("Electron") >= 0) { + return true; + } + return false; + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/env/dist/lib/is-browser.js + function isBrowser3() { + const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser; + return !isNode || isElectron(); + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/env/dist/lib/globals.js + var self_3 = globalThis.self || globalThis.window || globalThis.global; + var window_3 = globalThis.window || globalThis.self || globalThis.global; + var document_3 = globalThis.document || {}; + var process_ = globalThis.process || {}; + var console_ = globalThis.console; + var navigator_ = globalThis.navigator || {}; + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/env/dist/utils/globals.js + var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source"; + var isBrowser4 = isBrowser3(); + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/local-storage.js + function getStorage(type) { + try { + const storage = window[type]; + const x2 = "__storage_test__"; + storage.setItem(x2, x2); + storage.removeItem(x2); + return storage; + } catch (e2) { + return null; + } + } + var LocalStorage = class { + constructor(id, defaultConfig) { + let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage"; + this.storage = void 0; + this.id = void 0; + this.config = void 0; + this.storage = getStorage(type); + this.id = id; + this.config = defaultConfig; + this._loadConfiguration(); + } + getConfiguration() { + return this.config; + } + setConfiguration(configuration) { + Object.assign(this.config, configuration); + if (this.storage) { + const serialized = JSON.stringify(this.config); + this.storage.setItem(this.id, serialized); + } + } + _loadConfiguration() { + let configuration = {}; + if (this.storage) { + const serializedConfiguration = this.storage.getItem(this.id); + configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {}; + } + Object.assign(this.config, configuration); + return this; + } + }; + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/formatters.js + function formatTime(ms) { + let formatted; + if (ms < 10) { + formatted = `${ms.toFixed(2)}ms`; + } else if (ms < 100) { + formatted = `${ms.toFixed(1)}ms`; + } else if (ms < 1e3) { + formatted = `${ms.toFixed(0)}ms`; + } else { + formatted = `${(ms / 1e3).toFixed(2)}s`; + } + return formatted; + } + function leftPad(string) { + let length4 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8; + const padLength = Math.max(length4 - string.length, 0); + return `${" ".repeat(padLength)}${string}`; + } + function formatImage(image, message, scale5) { + let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600; + const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29"); + if (image.width > maxWidth) { + scale5 = Math.min(scale5, maxWidth / image.width); + } + const width = image.width * scale5; + const height = image.height * scale5; + const style = ["font-size:1px;", `padding:${Math.floor(height / 2)}px ${Math.floor(width / 2)}px;`, `line-height:${height}px;`, `background:url(${imageUrl});`, `background-size:${width}px ${height}px;`, "color:transparent;"].join(""); + return [`${message} %c+`, style]; + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/color.js + var COLOR; + (function(COLOR3) { + COLOR3[COLOR3["BLACK"] = 30] = "BLACK"; + COLOR3[COLOR3["RED"] = 31] = "RED"; + COLOR3[COLOR3["GREEN"] = 32] = "GREEN"; + COLOR3[COLOR3["YELLOW"] = 33] = "YELLOW"; + COLOR3[COLOR3["BLUE"] = 34] = "BLUE"; + COLOR3[COLOR3["MAGENTA"] = 35] = "MAGENTA"; + COLOR3[COLOR3["CYAN"] = 36] = "CYAN"; + COLOR3[COLOR3["WHITE"] = 37] = "WHITE"; + COLOR3[COLOR3["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK"; + COLOR3[COLOR3["BRIGHT_RED"] = 91] = "BRIGHT_RED"; + COLOR3[COLOR3["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN"; + COLOR3[COLOR3["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW"; + COLOR3[COLOR3["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE"; + COLOR3[COLOR3["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA"; + COLOR3[COLOR3["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN"; + COLOR3[COLOR3["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE"; + })(COLOR || (COLOR = {})); + var BACKGROUND_INCREMENT = 10; + function getColor(color) { + if (typeof color !== "string") { + return color; + } + color = color.toUpperCase(); + return COLOR[color] || COLOR.WHITE; + } + function addColor(string, color, background) { + if (!isBrowser3 && typeof string === "string") { + if (color) { + const colorCode = getColor(color); + string = `\x1B[${colorCode}m${string}\x1B[39m`; + } + if (background) { + const colorCode = getColor(background); + string = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string}\x1B[49m`; + } + } + return string; + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/autobind.js + function autobind(obj) { + let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"]; + const proto = Object.getPrototypeOf(obj); + const propNames = Object.getOwnPropertyNames(proto); + const object = obj; + for (const key of propNames) { + const value = object[key]; + if (typeof value === "function") { + if (!predefined.find((name) => key === name)) { + object[key] = value.bind(obj); + } + } + } + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/assert.js + function assert3(condition, message) { + if (!condition) { + throw new Error(message || "Assertion failed"); + } + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js + function getHiResTimestamp2() { + let timestamp; + if (isBrowser3() && window_3.performance) { + var _window$performance, _window$performance$n; + timestamp = window_3 === null || window_3 === void 0 ? void 0 : (_window$performance = window_3.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance); + } else if ("hrtime" in process_) { + var _process$hrtime; + const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_); + timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; + } else { + timestamp = Date.now(); + } + return timestamp; + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/log.js + var originalConsole = { + debug: isBrowser3() ? console.debug || console.log : console.log, + log: console.log, + info: console.info, + warn: console.warn, + error: console.error + }; + var DEFAULT_LOG_CONFIGURATION = { + enabled: true, + level: 0 + }; + function noop() { + } + var cache = {}; + var ONCE = { + once: true + }; + var Log = class { + constructor() { + let { + id + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : { + id: "" + }; + this.id = void 0; + this.VERSION = VERSION2; + this._startTs = getHiResTimestamp2(); + this._deltaTs = getHiResTimestamp2(); + this._storage = void 0; + this.userData = {}; + this.LOG_THROTTLE_TIMEOUT = 0; + this.id = id; + this.userData = {}; + this._storage = new LocalStorage(`__probe-${this.id}__`, DEFAULT_LOG_CONFIGURATION); + this.timeStamp(`${this.id} started`); + autobind(this); + Object.seal(this); + } + set level(newLevel) { + this.setLevel(newLevel); + } + get level() { + return this.getLevel(); + } + isEnabled() { + return this._storage.config.enabled; + } + getLevel() { + return this._storage.config.level; + } + getTotal() { + return Number((getHiResTimestamp2() - this._startTs).toPrecision(10)); + } + getDelta() { + return Number((getHiResTimestamp2() - this._deltaTs).toPrecision(10)); + } + set priority(newPriority) { + this.level = newPriority; + } + get priority() { + return this.level; + } + getPriority() { + return this.level; + } + enable() { + let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; + this._storage.setConfiguration({ + enabled + }); + return this; + } + setLevel(level) { + this._storage.setConfiguration({ + level + }); + return this; + } + get(setting) { + return this._storage.config[setting]; + } + set(setting, value) { + this._storage.setConfiguration({ + [setting]: value + }); + } + settings() { + if (console.table) { + console.table(this._storage.config); + } else { + console.log(this._storage.config); + } + } + assert(condition, message) { + assert3(condition, message); + } + warn(message) { + return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE); + } + error(message) { + return this._getLogFunction(0, message, originalConsole.error, arguments); + } + deprecated(oldUsage, newUsage) { + return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`); + } + removed(oldUsage, newUsage) { + return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`); + } + probe(logLevel, message) { + return this._getLogFunction(logLevel, message, originalConsole.log, arguments, { + time: true, + once: true + }); + } + log(logLevel, message) { + return this._getLogFunction(logLevel, message, originalConsole.debug, arguments); + } + info(logLevel, message) { + return this._getLogFunction(logLevel, message, console.info, arguments); + } + once(logLevel, message) { + return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE); + } + table(logLevel, table, columns) { + if (table) { + return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], { + tag: getTableHeader(table) + }); + } + return noop; + } + image(_ref) { + let { + logLevel, + priority, + image, + message = "", + scale: scale5 = 1 + } = _ref; + if (!this._shouldLog(logLevel || priority)) { + return noop; + } + return isBrowser3() ? logImageInBrowser({ + image, + message, + scale: scale5 + }) : logImageInNode({ + image, + message, + scale: scale5 + }); + } + time(logLevel, message) { + return this._getLogFunction(logLevel, message, console.time ? console.time : console.info); + } + timeEnd(logLevel, message) { + return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info); + } + timeStamp(logLevel, message) { + return this._getLogFunction(logLevel, message, console.timeStamp || noop); + } + group(logLevel, message) { + let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : { + collapsed: false + }; + const options = normalizeArguments({ + logLevel, + message, + opts + }); + const { + collapsed + } = opts; + options.method = (collapsed ? console.groupCollapsed : console.group) || console.info; + return this._getLogFunction(options); + } + groupCollapsed(logLevel, message) { + let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + return this.group(logLevel, message, Object.assign({}, opts, { + collapsed: true + })); + } + groupEnd(logLevel) { + return this._getLogFunction(logLevel, "", console.groupEnd || noop); + } + withGroup(logLevel, message, func) { + this.group(logLevel, message)(); + try { + func(); + } finally { + this.groupEnd(logLevel)(); + } + } + trace() { + if (console.trace) { + console.trace(); + } + } + _shouldLog(logLevel) { + return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel); + } + _getLogFunction(logLevel, message, method, args, opts) { + if (this._shouldLog(logLevel)) { + opts = normalizeArguments({ + logLevel, + message, + args, + opts + }); + method = method || opts.method; + assert3(method); + opts.total = this.getTotal(); + opts.delta = this.getDelta(); + this._deltaTs = getHiResTimestamp2(); + const tag = opts.tag || opts.message; + if (opts.once && tag) { + if (!cache[tag]) { + cache[tag] = getHiResTimestamp2(); + } else { + return noop; + } + } + message = decorateMessage(this.id, opts.message, opts); + return method.bind(console, message, ...opts.args); + } + return noop; + } + }; + Log.VERSION = VERSION2; + function normalizeLogLevel(logLevel) { + if (!logLevel) { + return 0; + } + let resolvedLevel; + switch (typeof logLevel) { + case "number": + resolvedLevel = logLevel; + break; + case "object": + resolvedLevel = logLevel.logLevel || logLevel.priority || 0; + break; + default: + return 0; + } + assert3(Number.isFinite(resolvedLevel) && resolvedLevel >= 0); + return resolvedLevel; + } + function normalizeArguments(opts) { + const { + logLevel, + message + } = opts; + opts.logLevel = normalizeLogLevel(logLevel); + const args = opts.args ? Array.from(opts.args) : []; + while (args.length && args.shift() !== message) { + } + switch (typeof logLevel) { + case "string": + case "function": + if (message !== void 0) { + args.unshift(message); + } + opts.message = logLevel; + break; + case "object": + Object.assign(opts, logLevel); + break; + default: + } + if (typeof opts.message === "function") { + opts.message = opts.message(); + } + const messageType = typeof opts.message; + assert3(messageType === "string" || messageType === "object"); + return Object.assign(opts, { + args + }, opts.opts); + } + function decorateMessage(id, message, opts) { + if (typeof message === "string") { + const time = opts.time ? leftPad(formatTime(opts.total)) : ""; + message = opts.time ? `${id}: ${time} ${message}` : `${id}: ${message}`; + message = addColor(message, opts.color, opts.background); + } + return message; + } + function logImageInNode(_ref2) { + let { + image, + message = "", + scale: scale5 = 1 + } = _ref2; + console.warn("removed"); + return noop; + } + function logImageInBrowser(_ref3) { + let { + image, + message = "", + scale: scale5 = 1 + } = _ref3; + if (typeof image === "string") { + const img = new Image(); + img.onload = () => { + const args = formatImage(img, message, scale5); + console.log(...args); + }; + img.src = image; + return noop; + } + const element = image.nodeName || ""; + if (element.toLowerCase() === "img") { + console.log(...formatImage(image, message, scale5)); + return noop; + } + if (element.toLowerCase() === "canvas") { + const img = new Image(); + img.onload = () => console.log(...formatImage(img, message, scale5)); + img.src = image.toDataURL(); + return noop; + } + return noop; + } + function getTableHeader(table) { + for (const key in table) { + for (const title in table[key]) { + return title || "untitled"; + } + } + return "empty"; + } + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/init.js + globalThis.probe = {}; + + // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/index.js + var dist_default = new Log({ + id: "@probe.gl/log" + }); + + // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/loggers.js + var probeLog = new Log({ + id: "loaders.gl" + }); + var NullLog = class { + log() { + return () => { + }; + } + info() { + return () => { + }; + } + warn() { + return () => { + }; + } + error() { + return () => { + }; + } + }; + var ConsoleLog = class { + constructor() { + _defineProperty(this, "console", void 0); + this.console = console; + } + log() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return this.console.log.bind(this.console, ...args); + } + info() { + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + return this.console.info.bind(this.console, ...args); + } + warn() { + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + return this.console.warn.bind(this.console, ...args); + } + error() { + for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { + args[_key4] = arguments[_key4]; + } + return this.console.error.bind(this.console, ...args); + } + }; + + // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/option-defaults.js + var DEFAULT_LOADER_OPTIONS = { + fetch: null, + mimeType: void 0, + nothrow: false, + log: new ConsoleLog(), + CDN: "https://unpkg.com/@loaders.gl", + worker: true, + maxConcurrency: 3, + maxMobileConcurrency: 1, + reuseWorkers: isBrowser, + _nodeWorkers: false, + _workerType: "", + limit: 0, + _limitMB: 0, + batchSize: "auto", + batchDebounceMs: 0, + metadata: false, + transforms: [] + }; + var REMOVED_LOADER_OPTIONS = { + throws: "nothrow", + dataType: "(no longer used)", + uri: "baseUri", + method: "fetch.method", + headers: "fetch.headers", + body: "fetch.body", + mode: "fetch.mode", + credentials: "fetch.credentials", + cache: "fetch.cache", + redirect: "fetch.redirect", + referrer: "fetch.referrer", + referrerPolicy: "fetch.referrerPolicy", + integrity: "fetch.integrity", + keepalive: "fetch.keepalive", + signal: "fetch.signal" + }; + + // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/option-utils.js + function getGlobalLoaderState() { + globalThis.loaders = globalThis.loaders || {}; + const { + loaders + } = globalThis; + loaders._state = loaders._state || {}; + return loaders._state; + } + var getGlobalLoaderOptions = () => { + const state = getGlobalLoaderState(); + state.globalOptions = state.globalOptions || { + ...DEFAULT_LOADER_OPTIONS + }; + return state.globalOptions; + }; + function normalizeOptions(options, loader, loaders, url) { + loaders = loaders || []; + loaders = Array.isArray(loaders) ? loaders : [loaders]; + validateOptions(options, loaders); + return normalizeOptionsInternal(loader, options, url); + } + function validateOptions(options, loaders) { + validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders); + for (const loader of loaders) { + const idOptions = options && options[loader.id] || {}; + const loaderOptions = loader.options && loader.options[loader.id] || {}; + const deprecatedOptions = loader.deprecatedOptions && loader.deprecatedOptions[loader.id] || {}; + validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders); + } + } + function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) { + const loaderName = id || "Top level"; + const prefix = id ? "".concat(id, ".") : ""; + for (const key in options) { + const isSubOptions = !id && isObject(options[key]); + const isBaseUriOption = key === "baseUri" && !id; + const isWorkerUrlOption = key === "workerUrl" && id; + if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) { + if (key in deprecatedOptions) { + probeLog.warn("".concat(loaderName, " loader option '").concat(prefix).concat(key, "' no longer supported, use '").concat(deprecatedOptions[key], "'"))(); + } else if (!isSubOptions) { + const suggestion = findSimilarOption(key, loaders); + probeLog.warn("".concat(loaderName, " loader option '").concat(prefix).concat(key, "' not recognized. ").concat(suggestion))(); + } + } + } + } + function findSimilarOption(optionKey, loaders) { + const lowerCaseOptionKey = optionKey.toLowerCase(); + let bestSuggestion = ""; + for (const loader of loaders) { + for (const key in loader.options) { + if (optionKey === key) { + return "Did you mean '".concat(loader.id, ".").concat(key, "'?"); + } + const lowerCaseKey = key.toLowerCase(); + const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey); + if (isPartialMatch) { + bestSuggestion = bestSuggestion || "Did you mean '".concat(loader.id, ".").concat(key, "'?"); + } + } + } + return bestSuggestion; + } + function normalizeOptionsInternal(loader, options, url) { + const loaderDefaultOptions = loader.options || {}; + const mergedOptions = { + ...loaderDefaultOptions + }; + addUrlOptions(mergedOptions, url); + if (mergedOptions.log === null) { + mergedOptions.log = new NullLog(); + } + mergeNestedFields(mergedOptions, getGlobalLoaderOptions()); + mergeNestedFields(mergedOptions, options); + return mergedOptions; + } + function mergeNestedFields(mergedOptions, options) { + for (const key in options) { + if (key in options) { + const value = options[key]; + if (isPureObject(value) && isPureObject(mergedOptions[key])) { + mergedOptions[key] = { + ...mergedOptions[key], + ...options[key] + }; + } else { + mergedOptions[key] = options[key]; + } + } + } + } + function addUrlOptions(options, url) { + if (url && !("baseUri" in options)) { + options.baseUri = url; + } + } + + // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/normalize-loader.js + function isLoaderObject(loader) { + var _loader; + if (!loader) { + return false; + } + if (Array.isArray(loader)) { + loader = loader[0]; + } + const hasExtensions = Array.isArray((_loader = loader) === null || _loader === void 0 ? void 0 : _loader.extensions); + return hasExtensions; + } + function normalizeLoader(loader) { + var _loader2, _loader3; + assert(loader, "null loader"); + assert(isLoaderObject(loader), "invalid loader"); + let options; + if (Array.isArray(loader)) { + options = loader[1]; + loader = loader[0]; + loader = { + ...loader, + options: { + ...loader.options, + ...options + } + }; + } + if ((_loader2 = loader) !== null && _loader2 !== void 0 && _loader2.parseTextSync || (_loader3 = loader) !== null && _loader3 !== void 0 && _loader3.parseText) { + loader.text = true; + } + if (!loader.text) { + loader.binary = true; + } + return loader; + } + + // node_modules/@loaders.gl/core/dist/esm/lib/api/register-loaders.js + var getGlobalLoaderRegistry = () => { + const state = getGlobalLoaderState(); + state.loaderRegistry = state.loaderRegistry || []; + return state.loaderRegistry; + }; + function registerLoaders(loaders) { + const loaderRegistry = getGlobalLoaderRegistry(); + loaders = Array.isArray(loaders) ? loaders : [loaders]; + for (const loader of loaders) { + const normalizedLoader = normalizeLoader(loader); + if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) { + loaderRegistry.unshift(normalizedLoader); + } + } + } + function getRegisteredLoaders() { + return getGlobalLoaderRegistry(); + } + + // node_modules/@loaders.gl/core/dist/esm/lib/utils/log.js + var log = new Log({ + id: "loaders.gl" + }); + + // node_modules/@loaders.gl/core/dist/esm/lib/api/select-loader.js + var EXT_PATTERN = /\.([^.]+)$/; + async function selectLoader(data) { + let loaders = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : []; + let options = arguments.length > 2 ? arguments[2] : void 0; + let context = arguments.length > 3 ? arguments[3] : void 0; + if (!validHTTPResponse(data)) { + return null; + } + let loader = selectLoaderSync(data, loaders, { + ...options, + nothrow: true + }, context); + if (loader) { + return loader; + } + if (isBlob(data)) { + data = await data.slice(0, 10).arrayBuffer(); + loader = selectLoaderSync(data, loaders, options, context); + } + if (!loader && !(options !== null && options !== void 0 && options.nothrow)) { + throw new Error(getNoValidLoaderMessage(data)); + } + return loader; + } + function selectLoaderSync(data) { + let loaders = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : []; + let options = arguments.length > 2 ? arguments[2] : void 0; + let context = arguments.length > 3 ? arguments[3] : void 0; + if (!validHTTPResponse(data)) { + return null; + } + if (loaders && !Array.isArray(loaders)) { + return normalizeLoader(loaders); + } + let candidateLoaders = []; + if (loaders) { + candidateLoaders = candidateLoaders.concat(loaders); + } + if (!(options !== null && options !== void 0 && options.ignoreRegisteredLoaders)) { + candidateLoaders.push(...getRegisteredLoaders()); + } + normalizeLoaders(candidateLoaders); + const loader = selectLoaderInternal(data, candidateLoaders, options, context); + if (!loader && !(options !== null && options !== void 0 && options.nothrow)) { + throw new Error(getNoValidLoaderMessage(data)); + } + return loader; + } + function selectLoaderInternal(data, loaders, options, context) { + const url = getResourceUrl(data); + const type = getResourceMIMEType(data); + const testUrl = stripQueryString(url) || (context === null || context === void 0 ? void 0 : context.url); + let loader = null; + let reason = ""; + if (options !== null && options !== void 0 && options.mimeType) { + loader = findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.mimeType); + reason = "match forced by supplied MIME type ".concat(options === null || options === void 0 ? void 0 : options.mimeType); + } + loader = loader || findLoaderByUrl(loaders, testUrl); + reason = reason || (loader ? "matched url ".concat(testUrl) : ""); + loader = loader || findLoaderByMIMEType(loaders, type); + reason = reason || (loader ? "matched MIME type ".concat(type) : ""); + loader = loader || findLoaderByInitialBytes(loaders, data); + reason = reason || (loader ? "matched initial data ".concat(getFirstCharacters(data)) : ""); + loader = loader || findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.fallbackMimeType); + reason = reason || (loader ? "matched fallback MIME type ".concat(type) : ""); + if (reason) { + var _loader; + log.log(1, "selectLoader selected ".concat((_loader = loader) === null || _loader === void 0 ? void 0 : _loader.name, ": ").concat(reason, ".")); + } + return loader; + } + function validHTTPResponse(data) { + if (data instanceof Response) { + if (data.status === 204) { + return false; + } + } + return true; + } + function getNoValidLoaderMessage(data) { + const url = getResourceUrl(data); + const type = getResourceMIMEType(data); + let message = "No valid loader found ("; + message += url ? "".concat(path_exports.filename(url), ", ") : "no url provided, "; + message += "MIME type: ".concat(type ? '"'.concat(type, '"') : "not provided", ", "); + const firstCharacters = data ? getFirstCharacters(data) : ""; + message += firstCharacters ? ' first bytes: "'.concat(firstCharacters, '"') : "first bytes: not available"; + message += ")"; + return message; + } + function normalizeLoaders(loaders) { + for (const loader of loaders) { + normalizeLoader(loader); + } + } + function findLoaderByUrl(loaders, url) { + const match = url && EXT_PATTERN.exec(url); + const extension = match && match[1]; + return extension ? findLoaderByExtension(loaders, extension) : null; + } + function findLoaderByExtension(loaders, extension) { + extension = extension.toLowerCase(); + for (const loader of loaders) { + for (const loaderExtension of loader.extensions) { + if (loaderExtension.toLowerCase() === extension) { + return loader; + } + } + } + return null; + } + function findLoaderByMIMEType(loaders, mimeType) { + for (const loader of loaders) { + if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) { + return loader; + } + if (mimeType === "application/x.".concat(loader.id)) { + return loader; + } + } + return null; + } + function findLoaderByInitialBytes(loaders, data) { + if (!data) { + return null; + } + for (const loader of loaders) { + if (typeof data === "string") { + if (testDataAgainstText(data, loader)) { + return loader; + } + } else if (ArrayBuffer.isView(data)) { + if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) { + return loader; + } + } else if (data instanceof ArrayBuffer) { + const byteOffset = 0; + if (testDataAgainstBinary(data, byteOffset, loader)) { + return loader; + } + } + } + return null; + } + function testDataAgainstText(data, loader) { + if (loader.testText) { + return loader.testText(data); + } + const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests]; + return tests.some((test) => data.startsWith(test)); + } + function testDataAgainstBinary(data, byteOffset, loader) { + const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests]; + return tests.some((test) => testBinary(data, byteOffset, loader, test)); + } + function testBinary(data, byteOffset, loader, test) { + if (test instanceof ArrayBuffer) { + return compareArrayBuffers(test, data, test.byteLength); + } + switch (typeof test) { + case "function": + return test(data, loader); + case "string": + const magic = getMagicString(data, byteOffset, test.length); + return test === magic; + default: + return false; + } + } + function getFirstCharacters(data) { + let length4 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 5; + if (typeof data === "string") { + return data.slice(0, length4); + } else if (ArrayBuffer.isView(data)) { + return getMagicString(data.buffer, data.byteOffset, length4); + } else if (data instanceof ArrayBuffer) { + const byteOffset = 0; + return getMagicString(data, byteOffset, length4); + } + return ""; + } + function getMagicString(arrayBuffer2, byteOffset, length4) { + if (arrayBuffer2.byteLength < byteOffset + length4) { + return ""; + } + const dataView = new DataView(arrayBuffer2); + let magic = ""; + for (let i3 = 0; i3 < length4; i3++) { + magic += String.fromCharCode(dataView.getUint8(byteOffset + i3)); + } + return magic; + } + + // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-string-iterator.js + var DEFAULT_CHUNK_SIZE = 256 * 1024; + function* makeStringIterator(string, options) { + const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE; + let offset = 0; + const textEncoder = new TextEncoder(); + while (offset < string.length) { + const chunkLength = Math.min(string.length - offset, chunkSize); + const chunk = string.slice(offset, offset + chunkLength); + offset += chunkLength; + yield textEncoder.encode(chunk); + } + } + + // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-array-buffer-iterator.js + var DEFAULT_CHUNK_SIZE2 = 256 * 1024; + function makeArrayBufferIterator(arrayBuffer2) { + let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + return function* () { + const { + chunkSize = DEFAULT_CHUNK_SIZE2 + } = options; + let byteOffset = 0; + while (byteOffset < arrayBuffer2.byteLength) { + const chunkByteLength = Math.min(arrayBuffer2.byteLength - byteOffset, chunkSize); + const chunk = new ArrayBuffer(chunkByteLength); + const sourceArray = new Uint8Array(arrayBuffer2, byteOffset, chunkByteLength); + const chunkArray = new Uint8Array(chunk); + chunkArray.set(sourceArray); + byteOffset += chunkByteLength; + yield chunk; + } + }(); + } + + // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-blob-iterator.js + var DEFAULT_CHUNK_SIZE3 = 1024 * 1024; + async function* makeBlobIterator(blob, options) { + const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE3; + let offset = 0; + while (offset < blob.size) { + const end = offset + chunkSize; + const chunk = await blob.slice(offset, end).arrayBuffer(); + offset = end; + yield chunk; + } + } + + // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-stream-iterator.js + function makeStreamIterator(stream, options) { + return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options); + } + async function* makeBrowserStreamIterator(stream, options) { + const reader = stream.getReader(); + let nextBatchPromise; + try { + while (true) { + const currentBatchPromise = nextBatchPromise || reader.read(); + if (options !== null && options !== void 0 && options._streamReadAhead) { + nextBatchPromise = reader.read(); + } + const { + done, + value + } = await currentBatchPromise; + if (done) { + return; + } + yield toArrayBuffer2(value); + } + } catch (error2) { + reader.releaseLock(); + } + } + async function* makeNodeStreamIterator(stream, options) { + for await (const chunk of stream) { + yield toArrayBuffer2(chunk); + } + } + + // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-iterator.js + function makeIterator(data, options) { + if (typeof data === "string") { + return makeStringIterator(data, options); + } + if (data instanceof ArrayBuffer) { + return makeArrayBufferIterator(data, options); + } + if (isBlob(data)) { + return makeBlobIterator(data, options); + } + if (isReadableStream(data)) { + return makeStreamIterator(data, options); + } + if (isResponse(data)) { + const response = data; + return makeStreamIterator(response.body, options); + } + throw new Error("makeIterator"); + } + + // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/get-data.js + var ERR_DATA = "Cannot convert supplied data type"; + function getArrayBufferOrStringFromDataSync(data, loader, options) { + if (loader.text && typeof data === "string") { + return data; + } + if (isBuffer2(data)) { + data = data.buffer; + } + if (data instanceof ArrayBuffer) { + const arrayBuffer2 = data; + if (loader.text && !loader.binary) { + const textDecoder = new TextDecoder("utf8"); + return textDecoder.decode(arrayBuffer2); + } + return arrayBuffer2; + } + if (ArrayBuffer.isView(data)) { + if (loader.text && !loader.binary) { + const textDecoder = new TextDecoder("utf8"); + return textDecoder.decode(data); + } + let arrayBuffer2 = data.buffer; + const byteLength = data.byteLength || data.length; + if (data.byteOffset !== 0 || byteLength !== arrayBuffer2.byteLength) { + arrayBuffer2 = arrayBuffer2.slice(data.byteOffset, data.byteOffset + byteLength); + } + return arrayBuffer2; + } + throw new Error(ERR_DATA); + } + async function getArrayBufferOrStringFromData(data, loader, options) { + const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data); + if (typeof data === "string" || isArrayBuffer) { + return getArrayBufferOrStringFromDataSync(data, loader, options); + } + if (isBlob(data)) { + data = await makeResponse(data); + } + if (isResponse(data)) { + const response = data; + await checkResponse(response); + return loader.binary ? await response.arrayBuffer() : await response.text(); + } + if (isReadableStream(data)) { + data = makeIterator(data, options); + } + if (isIterable(data) || isAsyncIterable(data)) { + return concatenateArrayBuffersAsync(data); + } + throw new Error(ERR_DATA); + } + + // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/get-fetch-function.js + function getFetchFunction(options, context) { + const globalOptions = getGlobalLoaderOptions(); + const fetchOptions = options || globalOptions; + if (typeof fetchOptions.fetch === "function") { + return fetchOptions.fetch; + } + if (isObject(fetchOptions.fetch)) { + return (url) => fetchFile(url, fetchOptions); + } + if (context !== null && context !== void 0 && context.fetch) { + return context === null || context === void 0 ? void 0 : context.fetch; + } + return fetchFile; + } + + // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/loader-context.js + function getLoaderContext(context, options, parentContext) { + if (parentContext) { + return parentContext; + } + const newContext = { + fetch: getFetchFunction(options, context), + ...context + }; + if (newContext.url) { + const baseUrl = stripQueryString(newContext.url); + newContext.baseUrl = baseUrl; + newContext.queryString = extractQueryString(newContext.url); + newContext.filename = path_exports.filename(baseUrl); + newContext.baseUrl = path_exports.dirname(baseUrl); + } + if (!Array.isArray(newContext.loaders)) { + newContext.loaders = null; + } + return newContext; + } + function getLoadersFromContext(loaders, context) { + if (!context && loaders && !Array.isArray(loaders)) { + return loaders; + } + let candidateLoaders; + if (loaders) { + candidateLoaders = Array.isArray(loaders) ? loaders : [loaders]; + } + if (context && context.loaders) { + const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders]; + candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders; + } + return candidateLoaders && candidateLoaders.length ? candidateLoaders : null; + } + + // node_modules/@loaders.gl/core/dist/esm/lib/api/parse.js + async function parse(data, loaders, options, context) { + assert2(!context || typeof context === "object"); + if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) { + context = void 0; + options = loaders; + loaders = void 0; + } + data = await data; + options = options || {}; + const url = getResourceUrl(data); + const typedLoaders = loaders; + const candidateLoaders = getLoadersFromContext(typedLoaders, context); + const loader = await selectLoader(data, candidateLoaders, options); + if (!loader) { + return null; + } + options = normalizeOptions(options, loader, candidateLoaders, url); + context = getLoaderContext({ + url, + parse, + loaders: candidateLoaders + }, options, context || null); + return await parseWithLoader(loader, data, options, context); + } + async function parseWithLoader(loader, data, options, context) { + validateWorkerVersion(loader); + if (isResponse(data)) { + const response = data; + const { + ok, + redirected, + status, + statusText, + type, + url + } = response; + const headers = Object.fromEntries(response.headers.entries()); + context.response = { + headers, + ok, + redirected, + status, + statusText, + type, + url + }; + } + data = await getArrayBufferOrStringFromData(data, loader, options); + if (loader.parseTextSync && typeof data === "string") { + options.dataType = "text"; + return loader.parseTextSync(data, options, context, loader); + } + if (canParseWithWorker(loader, options)) { + return await parseWithWorker(loader, data, options, context, parse); + } + if (loader.parseText && typeof data === "string") { + return await loader.parseText(data, options, context, loader); + } + if (loader.parse) { + return await loader.parse(data, options, context, loader); + } + assert2(!loader.parseSync); + throw new Error("".concat(loader.id, " loader - no parser found and worker is disabled")); + } + + // node_modules/@loaders.gl/core/dist/esm/lib/api/load.js + async function load(url, loaders, options, context) { + if (!Array.isArray(loaders) && !isLoaderObject(loaders)) { + context = void 0; + options = loaders; + loaders = void 0; + } + const fetch2 = getFetchFunction(options); + let data = url; + if (typeof url === "string") { + data = await fetch2(url); + } + if (isBlob(url)) { + data = await fetch2(url); + } + return await parse(data, loaders, options); + } + + // node_modules/@loaders.gl/images/dist/esm/lib/utils/version.js + var VERSION3 = true ? "3.4.14" : "latest"; + + // node_modules/@loaders.gl/images/dist/esm/lib/category-api/image-type.js + var { + _parseImageNode + } = globalThis; + var IMAGE_SUPPORTED = typeof Image !== "undefined"; + var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined"; + var NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode); + var DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED; + function isImageTypeSupported(type) { + switch (type) { + case "auto": + return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED; + case "imagebitmap": + return IMAGE_BITMAP_SUPPORTED; + case "image": + return IMAGE_SUPPORTED; + case "data": + return DATA_SUPPORTED; + default: + throw new Error("@loaders.gl/images: image ".concat(type, " not supported in this environment")); + } + } + function getDefaultImageType() { + if (IMAGE_BITMAP_SUPPORTED) { + return "imagebitmap"; + } + if (IMAGE_SUPPORTED) { + return "image"; + } + if (DATA_SUPPORTED) { + return "data"; + } + throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js"); + } + + // node_modules/@loaders.gl/images/dist/esm/lib/category-api/parsed-image-api.js + function getImageType(image) { + const format = getImageTypeOrNull(image); + if (!format) { + throw new Error("Not an image"); + } + return format; + } + function getImageData(image) { + switch (getImageType(image)) { + case "data": + return image; + case "image": + case "imagebitmap": + const canvas = document.createElement("canvas"); + const context = canvas.getContext("2d"); + if (!context) { + throw new Error("getImageData"); + } + canvas.width = image.width; + canvas.height = image.height; + context.drawImage(image, 0, 0); + return context.getImageData(0, 0, image.width, image.height); + default: + throw new Error("getImageData"); + } + } + function getImageTypeOrNull(image) { + if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) { + return "imagebitmap"; + } + if (typeof Image !== "undefined" && image instanceof Image) { + return "image"; + } + if (image && typeof image === "object" && image.data && image.width && image.height) { + return "data"; + } + return null; + } + + // node_modules/@loaders.gl/images/dist/esm/lib/parsers/svg-utils.js + var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/; + var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/; + function isSVG(url) { + return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url)); + } + function getBlobOrSVGDataUrl(arrayBuffer2, url) { + if (isSVG(url)) { + const textDecoder = new TextDecoder(); + let xmlText = textDecoder.decode(arrayBuffer2); + try { + if (typeof unescape === "function" && typeof encodeURIComponent === "function") { + xmlText = unescape(encodeURIComponent(xmlText)); + } + } catch (error2) { + throw new Error(error2.message); + } + const src = "data:image/svg+xml;base64,".concat(btoa(xmlText)); + return src; + } + return getBlob(arrayBuffer2, url); + } + function getBlob(arrayBuffer2, url) { + if (isSVG(url)) { + throw new Error("SVG cannot be parsed directly to imagebitmap"); + } + return new Blob([new Uint8Array(arrayBuffer2)]); + } + + // node_modules/@loaders.gl/images/dist/esm/lib/parsers/parse-to-image.js + async function parseToImage(arrayBuffer2, options, url) { + const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer2, url); + const URL2 = self.URL || self.webkitURL; + const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl); + try { + return await loadToImage(objectUrl || blobOrDataUrl, options); + } finally { + if (objectUrl) { + URL2.revokeObjectURL(objectUrl); + } + } + } + async function loadToImage(url, options) { + const image = new Image(); + image.src = url; + if (options.image && options.image.decode && image.decode) { + await image.decode(); + return image; + } + return await new Promise((resolve2, reject) => { + try { + image.onload = () => resolve2(image); + image.onerror = (err3) => reject(new Error("Could not load image ".concat(url, ": ").concat(err3))); + } catch (error2) { + reject(error2); + } + }); + } + + // node_modules/@loaders.gl/images/dist/esm/lib/parsers/parse-to-image-bitmap.js + var EMPTY_OBJECT = {}; + var imagebitmapOptionsSupported = true; + async function parseToImageBitmap(arrayBuffer2, options, url) { + let blob; + if (isSVG(url)) { + const image = await parseToImage(arrayBuffer2, options, url); + blob = image; + } else { + blob = getBlob(arrayBuffer2, url); + } + const imagebitmapOptions = options && options.imagebitmap; + return await safeCreateImageBitmap(blob, imagebitmapOptions); + } + async function safeCreateImageBitmap(blob) { + let imagebitmapOptions = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null; + if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) { + imagebitmapOptions = null; + } + if (imagebitmapOptions) { + try { + return await createImageBitmap(blob, imagebitmapOptions); + } catch (error2) { + console.warn(error2); + imagebitmapOptionsSupported = false; + } + } + return await createImageBitmap(blob); + } + function isEmptyObject(object) { + for (const key in object || EMPTY_OBJECT) { + return false; + } + return true; + } + + // node_modules/@loaders.gl/images/dist/esm/lib/category-api/parse-isobmff-binary.js + function getISOBMFFMediaType(buffer) { + if (!checkString(buffer, "ftyp", 4)) { + return null; + } + if ((buffer[8] & 96) === 0) { + return null; + } + return decodeMajorBrand(buffer); + } + function decodeMajorBrand(buffer) { + const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim(); + switch (brandMajor) { + case "avif": + case "avis": + return { + extension: "avif", + mimeType: "image/avif" + }; + default: + return null; + } + } + function getUTF8String(array, start, end) { + return String.fromCharCode(...array.slice(start, end)); + } + function stringToBytes(string) { + return [...string].map((character) => character.charCodeAt(0)); + } + function checkString(buffer, header) { + let offset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0; + const headerBytes = stringToBytes(header); + for (let i3 = 0; i3 < headerBytes.length; ++i3) { + if (headerBytes[i3] !== buffer[i3 + offset]) { + return false; + } + } + return true; + } + + // node_modules/@loaders.gl/images/dist/esm/lib/category-api/binary-image-api.js + var BIG_ENDIAN = false; + var LITTLE_ENDIAN = true; + function getBinaryImageMetadata(binaryData) { + const dataView = toDataView(binaryData); + return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView); + } + function getISOBMFFMetadata(binaryData) { + const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData); + const mediaType = getISOBMFFMediaType(buffer); + if (!mediaType) { + return null; + } + return { + mimeType: mediaType.mimeType, + width: 0, + height: 0 + }; + } + function getPngMetadata(binaryData) { + const dataView = toDataView(binaryData); + const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511; + if (!isPng) { + return null; + } + return { + mimeType: "image/png", + width: dataView.getUint32(16, BIG_ENDIAN), + height: dataView.getUint32(20, BIG_ENDIAN) + }; + } + function getGifMetadata(binaryData) { + const dataView = toDataView(binaryData); + const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440; + if (!isGif) { + return null; + } + return { + mimeType: "image/gif", + width: dataView.getUint16(6, LITTLE_ENDIAN), + height: dataView.getUint16(8, LITTLE_ENDIAN) + }; + } + function getBmpMetadata(binaryData) { + const dataView = toDataView(binaryData); + const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength; + if (!isBmp) { + return null; + } + return { + mimeType: "image/bmp", + width: dataView.getUint32(18, LITTLE_ENDIAN), + height: dataView.getUint32(22, LITTLE_ENDIAN) + }; + } + function getJpegMetadata(binaryData) { + const dataView = toDataView(binaryData); + const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255; + if (!isJpeg) { + return null; + } + const { + tableMarkers, + sofMarkers + } = getJpegMarkers(); + let i3 = 2; + while (i3 + 9 < dataView.byteLength) { + const marker = dataView.getUint16(i3, BIG_ENDIAN); + if (sofMarkers.has(marker)) { + return { + mimeType: "image/jpeg", + height: dataView.getUint16(i3 + 5, BIG_ENDIAN), + width: dataView.getUint16(i3 + 7, BIG_ENDIAN) + }; + } + if (!tableMarkers.has(marker)) { + return null; + } + i3 += 2; + i3 += dataView.getUint16(i3, BIG_ENDIAN); + } + return null; + } + function getJpegMarkers() { + const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]); + for (let i3 = 65504; i3 < 65520; ++i3) { + tableMarkers.add(i3); + } + const sofMarkers = /* @__PURE__ */ new Set([65472, 65473, 65474, 65475, 65477, 65478, 65479, 65481, 65482, 65483, 65485, 65486, 65487, 65502]); + return { + tableMarkers, + sofMarkers + }; + } + function toDataView(data) { + if (data instanceof DataView) { + return data; + } + if (ArrayBuffer.isView(data)) { + return new DataView(data.buffer); + } + if (data instanceof ArrayBuffer) { + return new DataView(data); + } + throw new Error("toDataView"); + } + + // node_modules/@loaders.gl/images/dist/esm/lib/parsers/parse-to-node-image.js + async function parseToNodeImage(arrayBuffer2, options) { + const { + mimeType + } = getBinaryImageMetadata(arrayBuffer2) || {}; + const _parseImageNode2 = globalThis._parseImageNode; + assert(_parseImageNode2); + return await _parseImageNode2(arrayBuffer2, mimeType); + } + + // node_modules/@loaders.gl/images/dist/esm/lib/parsers/parse-image.js + async function parseImage(arrayBuffer2, options, context) { + options = options || {}; + const imageOptions = options.image || {}; + const imageType = imageOptions.type || "auto"; + const { + url + } = context || {}; + const loadType = getLoadableImageType(imageType); + let image; + switch (loadType) { + case "imagebitmap": + image = await parseToImageBitmap(arrayBuffer2, options, url); + break; + case "image": + image = await parseToImage(arrayBuffer2, options, url); + break; + case "data": + image = await parseToNodeImage(arrayBuffer2, options); + break; + default: + assert(false); + } + if (imageType === "data") { + image = getImageData(image); + } + return image; + } + function getLoadableImageType(type) { + switch (type) { + case "auto": + case "data": + return getDefaultImageType(); + default: + isImageTypeSupported(type); + return type; + } + } + + // node_modules/@loaders.gl/images/dist/esm/image-loader.js + var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"]; + var MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/bmp", "image/vnd.microsoft.icon", "image/svg+xml"]; + var DEFAULT_IMAGE_LOADER_OPTIONS = { + image: { + type: "auto", + decode: true + } + }; + var ImageLoader = { + id: "image", + module: "images", + name: "Images", + version: VERSION3, + mimeTypes: MIME_TYPES, + extensions: EXTENSIONS, + parse: parseImage, + tests: [(arrayBuffer2) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer2)))], + options: DEFAULT_IMAGE_LOADER_OPTIONS + }; + + // node_modules/@probe.gl/env/dist/esm/lib/is-electron.js + function isElectron2(mockUserAgent) { + if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") { + return true; + } + if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) { + return true; + } + const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent; + const userAgent2 = mockUserAgent || realUserAgent; + if (userAgent2 && userAgent2.indexOf("Electron") >= 0) { + return true; + } + return false; + } + + // node_modules/@probe.gl/env/dist/esm/lib/is-browser.js + function isBrowser5() { + const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser; + return !isNode || isElectron2(); + } + + // node_modules/@probe.gl/env/dist/esm/lib/globals.js + var globals3 = { + self: typeof self !== "undefined" && self, + window: typeof window !== "undefined" && window, + global: typeof global !== "undefined" && global, + document: typeof document !== "undefined" && document, + process: typeof process === "object" && process + }; + var self_4 = globals3.self || globals3.window || globals3.global; + var window_4 = globals3.window || globals3.self || globals3.global; + var document_4 = globals3.document || {}; + var process_2 = globals3.process || {}; + + // node_modules/@probe.gl/env/dist/esm/utils/globals.js + var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source"; + var isBrowser6 = isBrowser5(); + + // node_modules/@probe.gl/env/dist/esm/lib/get-browser.js + var window2 = globalThis; + function getBrowser(mockUserAgent) { + if (!mockUserAgent && !isBrowser5()) { + return "Node"; + } + if (isElectron2(mockUserAgent)) { + return "Electron"; + } + const navigator_2 = typeof navigator !== "undefined" ? navigator : {}; + const userAgent2 = mockUserAgent || navigator_2.userAgent || ""; + if (userAgent2.indexOf("Edge") > -1) { + return "Edge"; + } + const isMSIE = userAgent2.indexOf("MSIE ") !== -1; + const isTrident = userAgent2.indexOf("Trident/") !== -1; + if (isMSIE || isTrident) { + return "IE"; + } + if (window2.chrome) { + return "Chrome"; + } + if (window2.safari) { + return "Safari"; + } + if (window2.mozInnerScreenX) { + return "Firefox"; + } + return "Unknown"; + } + + // node_modules/@probe.gl/log/dist/esm/utils/local-storage.js + function getStorage2(type) { + try { + const storage = window[type]; + const x2 = "__storage_test__"; + storage.setItem(x2, x2); + storage.removeItem(x2); + return storage; + } catch (e2) { + return null; + } + } + var LocalStorage2 = class { + constructor(id, defaultConfig) { + let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage"; + _defineProperty(this, "storage", void 0); + _defineProperty(this, "id", void 0); + _defineProperty(this, "config", void 0); + this.storage = getStorage2(type); + this.id = id; + this.config = defaultConfig; + this._loadConfiguration(); + } + getConfiguration() { + return this.config; + } + setConfiguration(configuration) { + Object.assign(this.config, configuration); + if (this.storage) { + const serialized = JSON.stringify(this.config); + this.storage.setItem(this.id, serialized); + } + } + _loadConfiguration() { + let configuration = {}; + if (this.storage) { + const serializedConfiguration = this.storage.getItem(this.id); + configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {}; + } + Object.assign(this.config, configuration); + return this; + } + }; + + // node_modules/@probe.gl/log/dist/esm/utils/formatters.js + function formatTime2(ms) { + let formatted; + if (ms < 10) { + formatted = "".concat(ms.toFixed(2), "ms"); + } else if (ms < 100) { + formatted = "".concat(ms.toFixed(1), "ms"); + } else if (ms < 1e3) { + formatted = "".concat(ms.toFixed(0), "ms"); + } else { + formatted = "".concat((ms / 1e3).toFixed(2), "s"); + } + return formatted; + } + function leftPad2(string) { + let length4 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8; + const padLength = Math.max(length4 - string.length, 0); + return "".concat(" ".repeat(padLength)).concat(string); + } + function formatImage2(image, message, scale5) { + let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600; + const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29"); + if (image.width > maxWidth) { + scale5 = Math.min(scale5, maxWidth / image.width); + } + const width = image.width * scale5; + const height = image.height * scale5; + const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join(""); + return ["".concat(message, " %c+"), style]; + } + + // node_modules/@probe.gl/log/dist/esm/utils/color.js + var COLOR2; + (function(COLOR3) { + COLOR3[COLOR3["BLACK"] = 30] = "BLACK"; + COLOR3[COLOR3["RED"] = 31] = "RED"; + COLOR3[COLOR3["GREEN"] = 32] = "GREEN"; + COLOR3[COLOR3["YELLOW"] = 33] = "YELLOW"; + COLOR3[COLOR3["BLUE"] = 34] = "BLUE"; + COLOR3[COLOR3["MAGENTA"] = 35] = "MAGENTA"; + COLOR3[COLOR3["CYAN"] = 36] = "CYAN"; + COLOR3[COLOR3["WHITE"] = 37] = "WHITE"; + COLOR3[COLOR3["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK"; + COLOR3[COLOR3["BRIGHT_RED"] = 91] = "BRIGHT_RED"; + COLOR3[COLOR3["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN"; + COLOR3[COLOR3["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW"; + COLOR3[COLOR3["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE"; + COLOR3[COLOR3["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA"; + COLOR3[COLOR3["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN"; + COLOR3[COLOR3["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE"; + })(COLOR2 || (COLOR2 = {})); + function getColor2(color) { + return typeof color === "string" ? COLOR2[color.toUpperCase()] || COLOR2.WHITE : color; + } + function addColor2(string, color, background) { + if (!isBrowser5 && typeof string === "string") { + if (color) { + color = getColor2(color); + string = "\x1B[".concat(color, "m").concat(string, "\x1B[39m"); + } + if (background) { + color = getColor2(background); + string = "\x1B[".concat(background + 10, "m").concat(string, "\x1B[49m"); + } + } + return string; + } + + // node_modules/@probe.gl/log/dist/esm/utils/autobind.js + function autobind2(obj) { + let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"]; + const proto = Object.getPrototypeOf(obj); + const propNames = Object.getOwnPropertyNames(proto); + for (const key of propNames) { + if (typeof obj[key] === "function") { + if (!predefined.find((name) => key === name)) { + obj[key] = obj[key].bind(obj); + } + } + } + } + + // node_modules/@probe.gl/log/dist/esm/utils/assert.js + function assert4(condition, message) { + if (!condition) { + throw new Error(message || "Assertion failed"); + } + } + + // node_modules/@probe.gl/log/dist/esm/utils/hi-res-timestamp.js + function getHiResTimestamp3() { + let timestamp; + if (isBrowser5 && "performance" in window_4) { + var _window$performance, _window$performance$n; + timestamp = window_4 === null || window_4 === void 0 ? void 0 : (_window$performance = window_4.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance); + } else if ("hrtime" in process_2) { + var _process$hrtime; + const timeParts = process_2 === null || process_2 === void 0 ? void 0 : (_process$hrtime = process_2.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_2); + timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; + } else { + timestamp = Date.now(); + } + return timestamp; + } + + // node_modules/@probe.gl/log/dist/esm/log.js + var originalConsole2 = { + debug: isBrowser5 ? console.debug || console.log : console.log, + log: console.log, + info: console.info, + warn: console.warn, + error: console.error + }; + var DEFAULT_SETTINGS = { + enabled: true, + level: 0 + }; + function noop2() { + } + var cache2 = {}; + var ONCE2 = { + once: true + }; + var Log2 = class { + constructor() { + let { + id + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : { + id: "" + }; + _defineProperty(this, "id", void 0); + _defineProperty(this, "VERSION", VERSION4); + _defineProperty(this, "_startTs", getHiResTimestamp3()); + _defineProperty(this, "_deltaTs", getHiResTimestamp3()); + _defineProperty(this, "_storage", void 0); + _defineProperty(this, "userData", {}); + _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0); + this.id = id; + this.userData = {}; + this._storage = new LocalStorage2("__probe-".concat(this.id, "__"), DEFAULT_SETTINGS); + this.timeStamp("".concat(this.id, " started")); + autobind2(this); + Object.seal(this); + } + set level(newLevel) { + this.setLevel(newLevel); + } + get level() { + return this.getLevel(); + } + isEnabled() { + return this._storage.config.enabled; + } + getLevel() { + return this._storage.config.level; + } + getTotal() { + return Number((getHiResTimestamp3() - this._startTs).toPrecision(10)); + } + getDelta() { + return Number((getHiResTimestamp3() - this._deltaTs).toPrecision(10)); + } + set priority(newPriority) { + this.level = newPriority; + } + get priority() { + return this.level; + } + getPriority() { + return this.level; + } + enable() { + let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; + this._storage.setConfiguration({ + enabled + }); + return this; + } + setLevel(level) { + this._storage.setConfiguration({ + level + }); + return this; + } + get(setting) { + return this._storage.config[setting]; + } + set(setting, value) { + this._storage.setConfiguration({ + [setting]: value + }); + } + settings() { + if (console.table) { + console.table(this._storage.config); + } else { + console.log(this._storage.config); + } + } + assert(condition, message) { + assert4(condition, message); + } + warn(message) { + return this._getLogFunction(0, message, originalConsole2.warn, arguments, ONCE2); + } + error(message) { + return this._getLogFunction(0, message, originalConsole2.error, arguments); + } + deprecated(oldUsage, newUsage) { + return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead")); + } + removed(oldUsage, newUsage) { + return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead")); + } + probe(logLevel, message) { + return this._getLogFunction(logLevel, message, originalConsole2.log, arguments, { + time: true, + once: true + }); + } + log(logLevel, message) { + return this._getLogFunction(logLevel, message, originalConsole2.debug, arguments); + } + info(logLevel, message) { + return this._getLogFunction(logLevel, message, console.info, arguments); + } + once(logLevel, message) { + for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { + args[_key - 2] = arguments[_key]; + } + return this._getLogFunction(logLevel, message, originalConsole2.debug || originalConsole2.info, arguments, ONCE2); + } + table(logLevel, table, columns) { + if (table) { + return this._getLogFunction(logLevel, table, console.table || noop2, columns && [columns], { + tag: getTableHeader2(table) + }); + } + return noop2; + } + image(_ref) { + let { + logLevel, + priority, + image, + message = "", + scale: scale5 = 1 + } = _ref; + if (!this._shouldLog(logLevel || priority)) { + return noop2; + } + return isBrowser5 ? logImageInBrowser2({ + image, + message, + scale: scale5 + }) : logImageInNode2({ + image, + message, + scale: scale5 + }); + } + time(logLevel, message) { + return this._getLogFunction(logLevel, message, console.time ? console.time : console.info); + } + timeEnd(logLevel, message) { + return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info); + } + timeStamp(logLevel, message) { + return this._getLogFunction(logLevel, message, console.timeStamp || noop2); + } + group(logLevel, message) { + let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : { + collapsed: false + }; + const options = normalizeArguments2({ + logLevel, + message, + opts + }); + const { + collapsed + } = opts; + options.method = (collapsed ? console.groupCollapsed : console.group) || console.info; + return this._getLogFunction(options); + } + groupCollapsed(logLevel, message) { + let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + return this.group(logLevel, message, Object.assign({}, opts, { + collapsed: true + })); + } + groupEnd(logLevel) { + return this._getLogFunction(logLevel, "", console.groupEnd || noop2); + } + withGroup(logLevel, message, func) { + this.group(logLevel, message)(); + try { + func(); + } finally { + this.groupEnd(logLevel)(); + } + } + trace() { + if (console.trace) { + console.trace(); + } + } + _shouldLog(logLevel) { + return this.isEnabled() && this.getLevel() >= normalizeLogLevel2(logLevel); + } + _getLogFunction(logLevel, message, method, args, opts) { + if (this._shouldLog(logLevel)) { + opts = normalizeArguments2({ + logLevel, + message, + args, + opts + }); + method = method || opts.method; + assert4(method); + opts.total = this.getTotal(); + opts.delta = this.getDelta(); + this._deltaTs = getHiResTimestamp3(); + const tag = opts.tag || opts.message; + if (opts.once) { + if (!cache2[tag]) { + cache2[tag] = getHiResTimestamp3(); + } else { + return noop2; + } + } + message = decorateMessage2(this.id, opts.message, opts); + return method.bind(console, message, ...opts.args); + } + return noop2; + } + }; + _defineProperty(Log2, "VERSION", VERSION4); + function normalizeLogLevel2(logLevel) { + if (!logLevel) { + return 0; + } + let resolvedLevel; + switch (typeof logLevel) { + case "number": + resolvedLevel = logLevel; + break; + case "object": + resolvedLevel = logLevel.logLevel || logLevel.priority || 0; + break; + default: + return 0; + } + assert4(Number.isFinite(resolvedLevel) && resolvedLevel >= 0); + return resolvedLevel; + } + function normalizeArguments2(opts) { + const { + logLevel, + message + } = opts; + opts.logLevel = normalizeLogLevel2(logLevel); + const args = opts.args ? Array.from(opts.args) : []; + while (args.length && args.shift() !== message) { + } + switch (typeof logLevel) { + case "string": + case "function": + if (message !== void 0) { + args.unshift(message); + } + opts.message = logLevel; + break; + case "object": + Object.assign(opts, logLevel); + break; + default: + } + if (typeof opts.message === "function") { + opts.message = opts.message(); + } + const messageType = typeof opts.message; + assert4(messageType === "string" || messageType === "object"); + return Object.assign(opts, { + args + }, opts.opts); + } + function decorateMessage2(id, message, opts) { + if (typeof message === "string") { + const time = opts.time ? leftPad2(formatTime2(opts.total)) : ""; + message = opts.time ? "".concat(id, ": ").concat(time, " ").concat(message) : "".concat(id, ": ").concat(message); + message = addColor2(message, opts.color, opts.background); + } + return message; + } + function logImageInNode2(_ref2) { + let { + image, + message = "", + scale: scale5 = 1 + } = _ref2; + console.warn("removed"); + return noop2; + } + function logImageInBrowser2(_ref3) { + let { + image, + message = "", + scale: scale5 = 1 + } = _ref3; + if (typeof image === "string") { + const img = new Image(); + img.onload = () => { + const args = formatImage2(img, message, scale5); + console.log(...args); + }; + img.src = image; + return noop2; + } + const element = image.nodeName || ""; + if (element.toLowerCase() === "img") { + console.log(...formatImage2(image, message, scale5)); + return noop2; + } + if (element.toLowerCase() === "canvas") { + const img = new Image(); + img.onload = () => console.log(...formatImage2(img, message, scale5)); + img.src = image.toDataURL(); + return noop2; + } + return noop2; + } + function getTableHeader2(table) { + for (const key in table) { + for (const title in table[key]) { + return title || "untitled"; + } + } + return "empty"; + } + + // node_modules/@probe.gl/log/dist/esm/index.js + var esm_default = new Log2({ + id: "@probe.gl/log" + }); + + // node_modules/@deck.gl/core/dist/esm/utils/log.js + var log_default = new Log2({ + id: "deck" + }); + + // node_modules/@deck.gl/core/dist/esm/debug/loggers.js + var logState = { + attributeUpdateStart: -1, + attributeManagerUpdateStart: -1, + attributeUpdateMessages: [] + }; + var LOG_LEVEL_MAJOR_UPDATE = 1; + var LOG_LEVEL_MINOR_UPDATE = 2; + var LOG_LEVEL_UPDATE_DETAIL = 3; + var LOG_LEVEL_INFO = 4; + var LOG_LEVEL_DRAW = 2; + var getLoggers = (log4) => ({ + "layer.changeFlag": (layer, key, flags) => { + log4.log(LOG_LEVEL_UPDATE_DETAIL, "".concat(layer.id, " ").concat(key, ": "), flags[key])(); + }, + "layer.initialize": (layer) => { + log4.log(LOG_LEVEL_MAJOR_UPDATE, "Initializing ".concat(layer))(); + }, + "layer.update": (layer, needsUpdate) => { + if (needsUpdate) { + const flags = layer.getChangeFlags(); + log4.log(LOG_LEVEL_MINOR_UPDATE, "Updating ".concat(layer, " because: ").concat(Object.keys(flags).filter((key) => flags[key]).join(", ")))(); + } else { + log4.log(LOG_LEVEL_INFO, "".concat(layer, " does not need update"))(); + } + }, + "layer.matched": (layer, changed) => { + if (changed) { + log4.log(LOG_LEVEL_INFO, "Matched ".concat(layer, ", state transfered"))(); + } + }, + "layer.finalize": (layer) => { + log4.log(LOG_LEVEL_MAJOR_UPDATE, "Finalizing ".concat(layer))(); + }, + "compositeLayer.renderLayers": (layer, updated, subLayers) => { + if (updated) { + log4.log(LOG_LEVEL_MINOR_UPDATE, "Composite layer rendered new subLayers ".concat(layer), subLayers)(); + } else { + log4.log(LOG_LEVEL_INFO, "Composite layer reused subLayers ".concat(layer), subLayers)(); + } + }, + "layerManager.setLayers": (layerManager, updated, layers) => { + if (updated) { + log4.log(LOG_LEVEL_MINOR_UPDATE, "Updating ".concat(layers.length, " deck layers"))(); + } + }, + "layerManager.activateViewport": (layerManager, viewport) => { + log4.log(LOG_LEVEL_UPDATE_DETAIL, "Viewport changed", viewport)(); + }, + "attributeManager.invalidate": (attributeManager, trigger, attributeNames) => { + log4.log(LOG_LEVEL_MAJOR_UPDATE, attributeNames ? "invalidated attributes ".concat(attributeNames, " (").concat(trigger, ") for ").concat(attributeManager.id) : "invalidated all attributes for ".concat(attributeManager.id))(); + }, + "attributeManager.updateStart": (attributeManager) => { + logState.attributeUpdateMessages.length = 0; + logState.attributeManagerUpdateStart = Date.now(); + }, + "attributeManager.updateEnd": (attributeManager, numInstances) => { + const timeMs = Math.round(Date.now() - logState.attributeManagerUpdateStart); + log4.groupCollapsed(LOG_LEVEL_MINOR_UPDATE, "Updated attributes for ".concat(numInstances, " instances in ").concat(attributeManager.id, " in ").concat(timeMs, "ms"))(); + for (const updateMessage of logState.attributeUpdateMessages) { + log4.log(LOG_LEVEL_UPDATE_DETAIL, updateMessage)(); + } + log4.groupEnd(LOG_LEVEL_MINOR_UPDATE)(); + }, + "attribute.updateStart": (attribute) => { + logState.attributeUpdateStart = Date.now(); + }, + "attribute.allocate": (attribute, numInstances) => { + const message = "".concat(attribute.id, " allocated ").concat(numInstances); + logState.attributeUpdateMessages.push(message); + }, + "attribute.updateEnd": (attribute, numInstances) => { + const timeMs = Math.round(Date.now() - logState.attributeUpdateStart); + const message = "".concat(attribute.id, " updated ").concat(numInstances, " in ").concat(timeMs, "ms"); + logState.attributeUpdateMessages.push(message); + }, + "deckRenderer.renderLayers": (deckRenderer, renderStats, opts) => { + const { + pass, + redrawReason, + stats + } = opts; + for (const status of renderStats) { + const { + totalCount, + visibleCount, + compositeCount, + pickableCount + } = status; + const primitiveCount = totalCount - compositeCount; + const hiddenCount = primitiveCount - visibleCount; + log4.log(LOG_LEVEL_DRAW, "RENDER #".concat(deckRenderer.renderCount, " ").concat(visibleCount, " (of ").concat(totalCount, " layers) to ").concat(pass, " because ").concat(redrawReason, " (").concat(hiddenCount, " hidden, ").concat(compositeCount, " composite ").concat(pickableCount, " pickable)"))(); + if (stats) { + stats.get("Redraw Layers").add(visibleCount); + } + } + } + }); + + // node_modules/@deck.gl/core/dist/esm/debug/index.js + var loggers = {}; + if (true) { + loggers = getLoggers(log_default); + } + function register(handlers) { + loggers = handlers; + } + function debug(eventType, arg1, arg2, arg3) { + if (log_default.level > 0 && loggers[eventType]) { + loggers[eventType].call(null, arg1, arg2, arg3); + } + } + + // node_modules/@deck.gl/core/dist/esm/utils/json-loader.js + function isJSON(text) { + const firstChar = text[0]; + const lastChar = text[text.length - 1]; + return firstChar === "{" && lastChar === "}" || firstChar === "[" && lastChar === "]"; + } + var json_loader_default = { + id: "JSON", + name: "JSON", + module: "", + version: "", + options: {}, + extensions: ["json", "geojson"], + mimeTypes: ["application/json", "application/geo+json"], + testText: isJSON, + parseTextSync: JSON.parse + }; + + // node_modules/@deck.gl/core/dist/esm/lib/init.js + function checkVersion() { + const version = true ? "8.9.35" : globalThis.DECK_VERSION || "untranspiled source"; + const existingVersion = globalThis.deck && globalThis.deck.VERSION; + if (existingVersion && existingVersion !== version) { + throw new Error("deck.gl - multiple versions detected: ".concat(existingVersion, " vs ").concat(version)); + } + if (!existingVersion) { + log_default.log(1, "deck.gl ".concat(version))(); + globalThis.deck = { + ...globalThis.deck, + VERSION: version, + version, + log: log_default, + _registerLoggers: register + }; + registerLoaders([json_loader_default, [ImageLoader, { + imagebitmap: { + premultiplyAlpha: "none" + } + }]]); + } + return version; + } + var VERSION5 = checkVersion(); + + // node_modules/@deck.gl/core/dist/esm/lib/constants.js + var COORDINATE_SYSTEM = { + DEFAULT: -1, + LNGLAT: 1, + METER_OFFSETS: 2, + LNGLAT_OFFSETS: 3, + CARTESIAN: 0 + }; + Object.defineProperty(COORDINATE_SYSTEM, "IDENTITY", { + get: () => { + log_default.deprecated("COORDINATE_SYSTEM.IDENTITY", "COORDINATE_SYSTEM.CARTESIAN")(); + return 0; + } + }); + var PROJECTION_MODE = { + WEB_MERCATOR: 1, + GLOBE: 2, + WEB_MERCATOR_AUTO_OFFSET: 4, + IDENTITY: 0 + }; + var UNIT = { + common: 0, + meters: 1, + pixels: 2 + }; + var EVENTS = { + click: { + handler: "onClick" + }, + panstart: { + handler: "onDragStart" + }, + panmove: { + handler: "onDrag" + }, + panend: { + handler: "onDragEnd" + } + }; + + // node_modules/@luma.gl/gltools/dist/esm/utils/log.js + var log2 = new Log2({ + id: "luma.gl" + }); + + // node_modules/@luma.gl/gltools/dist/esm/utils/assert.js + function assert5(condition, message) { + if (!condition) { + throw new Error(message || "luma.gl: assertion failed."); + } + } + + // node_modules/@luma.gl/gltools/dist/esm/utils/webgl-checks.js + var ERR_CONTEXT = "Invalid WebGLRenderingContext"; + var ERR_WEBGL2 = "Requires WebGL2"; + function isWebGL(gl) { + if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) { + return true; + } + if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { + return true; + } + return Boolean(gl && Number.isFinite(gl._version)); + } + function isWebGL2(gl) { + if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { + return true; + } + return Boolean(gl && gl._version === 2); + } + function getWebGL2Context(gl) { + return isWebGL2(gl) ? gl : null; + } + function assertWebGLContext(gl) { + assert5(isWebGL(gl), ERR_CONTEXT); + return gl; + } + function assertWebGL2Context(gl) { + assert5(isWebGL2(gl), ERR_WEBGL2); + return gl; + } + + // node_modules/@luma.gl/gltools/dist/esm/polyfill/polyfill-vertex-array-object.js + var glErrorShadow = {}; + function error(msg) { + if (globalThis.console && globalThis.console.error) { + globalThis.console.error(msg); + } + } + function log3(msg) { + if (globalThis.console && globalThis.console.log) { + globalThis.console.log(msg); + } + } + function synthesizeGLError(err3, opt_msg) { + glErrorShadow[err3] = true; + if (opt_msg !== void 0) { + error(opt_msg); + } + } + function wrapGLError(gl) { + const f2 = gl.getError; + gl.getError = function getError() { + let err3; + do { + err3 = f2.apply(gl); + if (err3 !== 0) { + glErrorShadow[err3] = true; + } + } while (err3 !== 0); + for (err3 in glErrorShadow) { + if (glErrorShadow[err3]) { + delete glErrorShadow[err3]; + return parseInt(err3, 10); + } + } + return 0; + }; + } + var WebGLVertexArrayObjectOES = function WebGLVertexArrayObjectOES2(ext) { + const gl = ext.gl; + this.ext = ext; + this.isAlive = true; + this.hasBeenBound = false; + this.elementArrayBuffer = null; + this.attribs = new Array(ext.maxVertexAttribs); + for (let n2 = 0; n2 < this.attribs.length; n2++) { + const attrib = new WebGLVertexArrayObjectOES2.VertexAttrib(gl); + this.attribs[n2] = attrib; + } + this.maxAttrib = 0; + }; + WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) { + this.enabled = false; + this.buffer = null; + this.size = 4; + this.type = 5126; + this.normalized = false; + this.stride = 16; + this.offset = 0; + this.cached = ""; + this.recache(); + }; + WebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() { + this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(":"); + }; + var OESVertexArrayObject = function OESVertexArrayObject2(gl) { + const self2 = this; + this.gl = gl; + wrapGLError(gl); + const original = this.original = { + getParameter: gl.getParameter, + enableVertexAttribArray: gl.enableVertexAttribArray, + disableVertexAttribArray: gl.disableVertexAttribArray, + bindBuffer: gl.bindBuffer, + getVertexAttrib: gl.getVertexAttrib, + vertexAttribPointer: gl.vertexAttribPointer + }; + gl.getParameter = function getParameter(pname) { + if (pname === self2.VERTEX_ARRAY_BINDING_OES) { + if (self2.currentVertexArrayObject === self2.defaultVertexArrayObject) { + return null; + } + return self2.currentVertexArrayObject; + } + return original.getParameter.apply(this, arguments); + }; + gl.enableVertexAttribArray = function enableVertexAttribArray(index) { + const vao = self2.currentVertexArrayObject; + vao.maxAttrib = Math.max(vao.maxAttrib, index); + const attrib = vao.attribs[index]; + attrib.enabled = true; + return original.enableVertexAttribArray.apply(this, arguments); + }; + gl.disableVertexAttribArray = function disableVertexAttribArray(index) { + const vao = self2.currentVertexArrayObject; + vao.maxAttrib = Math.max(vao.maxAttrib, index); + const attrib = vao.attribs[index]; + attrib.enabled = false; + return original.disableVertexAttribArray.apply(this, arguments); + }; + gl.bindBuffer = function bindBuffer(target, buffer) { + switch (target) { + case 34962: + self2.currentArrayBuffer = buffer; + break; + case 34963: + self2.currentVertexArrayObject.elementArrayBuffer = buffer; + break; + default: + } + return original.bindBuffer.apply(this, arguments); + }; + gl.getVertexAttrib = function getVertexAttrib(index, pname) { + const vao = self2.currentVertexArrayObject; + const attrib = vao.attribs[index]; + switch (pname) { + case 34975: + return attrib.buffer; + case 34338: + return attrib.enabled; + case 34339: + return attrib.size; + case 34340: + return attrib.stride; + case 34341: + return attrib.type; + case 34922: + return attrib.normalized; + default: + return original.getVertexAttrib.apply(this, arguments); + } + }; + gl.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset) { + const vao = self2.currentVertexArrayObject; + vao.maxAttrib = Math.max(vao.maxAttrib, indx); + const attrib = vao.attribs[indx]; + attrib.buffer = self2.currentArrayBuffer; + attrib.size = size; + attrib.type = type; + attrib.normalized = normalized; + attrib.stride = stride; + attrib.offset = offset; + attrib.recache(); + return original.vertexAttribPointer.apply(this, arguments); + }; + if (gl.instrumentExtension) { + gl.instrumentExtension(this, "OES_vertex_array_object"); + } + if (gl.canvas) { + gl.canvas.addEventListener("webglcontextrestored", () => { + log3("OESVertexArrayObject emulation library context restored"); + self2.reset_(); + }, true); + } + this.reset_(); + }; + OESVertexArrayObject.prototype.VERTEX_ARRAY_BINDING_OES = 34229; + OESVertexArrayObject.prototype.reset_ = function reset_() { + const contextWasLost = this.vertexArrayObjects !== void 0; + if (contextWasLost) { + for (let ii = 0; ii < this.vertexArrayObjects.length; ++ii) { + this.vertexArrayObjects.isAlive = false; + } + } + const gl = this.gl; + this.maxVertexAttribs = gl.getParameter(34921); + this.defaultVertexArrayObject = new WebGLVertexArrayObjectOES(this); + this.currentVertexArrayObject = null; + this.currentArrayBuffer = null; + this.vertexArrayObjects = [this.defaultVertexArrayObject]; + this.bindVertexArrayOES(null); + }; + OESVertexArrayObject.prototype.createVertexArrayOES = function createVertexArrayOES() { + const arrayObject = new WebGLVertexArrayObjectOES(this); + this.vertexArrayObjects.push(arrayObject); + return arrayObject; + }; + OESVertexArrayObject.prototype.deleteVertexArrayOES = function deleteVertexArrayOES(arrayObject) { + arrayObject.isAlive = false; + this.vertexArrayObjects.splice(this.vertexArrayObjects.indexOf(arrayObject), 1); + if (this.currentVertexArrayObject === arrayObject) { + this.bindVertexArrayOES(null); + } + }; + OESVertexArrayObject.prototype.isVertexArrayOES = function isVertexArrayOES(arrayObject) { + if (arrayObject && arrayObject instanceof WebGLVertexArrayObjectOES) { + if (arrayObject.hasBeenBound && arrayObject.ext === this) { + return true; + } + } + return false; + }; + OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) { + const gl = this.gl; + if (arrayObject && !arrayObject.isAlive) { + synthesizeGLError(1282, "bindVertexArrayOES: attempt to bind deleted arrayObject"); + return; + } + const original = this.original; + const oldVAO = this.currentVertexArrayObject; + this.currentVertexArrayObject = arrayObject || this.defaultVertexArrayObject; + this.currentVertexArrayObject.hasBeenBound = true; + const newVAO = this.currentVertexArrayObject; + if (oldVAO === newVAO) { + return; + } + if (!oldVAO || newVAO.elementArrayBuffer !== oldVAO.elementArrayBuffer) { + original.bindBuffer.call(gl, 34963, newVAO.elementArrayBuffer); + } + let currentBinding = this.currentArrayBuffer; + const maxAttrib = Math.max(oldVAO ? oldVAO.maxAttrib : 0, newVAO.maxAttrib); + for (let n2 = 0; n2 <= maxAttrib; n2++) { + const attrib = newVAO.attribs[n2]; + const oldAttrib = oldVAO ? oldVAO.attribs[n2] : null; + if (!oldVAO || attrib.enabled !== oldAttrib.enabled) { + if (attrib.enabled) { + original.enableVertexAttribArray.call(gl, n2); + } else { + original.disableVertexAttribArray.call(gl, n2); + } + } + if (attrib.enabled) { + let bufferChanged = false; + if (!oldVAO || attrib.buffer !== oldAttrib.buffer) { + if (currentBinding !== attrib.buffer) { + original.bindBuffer.call(gl, 34962, attrib.buffer); + currentBinding = attrib.buffer; + } + bufferChanged = true; + } + if (bufferChanged || attrib.cached !== oldAttrib.cached) { + original.vertexAttribPointer.call(gl, n2, attrib.size, attrib.type, attrib.normalized, attrib.stride, attrib.offset); + } + } + } + if (this.currentArrayBuffer !== currentBinding) { + original.bindBuffer.call(gl, 34962, this.currentArrayBuffer); + } + }; + function polyfillVertexArrayObject(gl) { + if (typeof gl.createVertexArray === "function") { + return; + } + const original_getSupportedExtensions = gl.getSupportedExtensions; + gl.getSupportedExtensions = function getSupportedExtensions() { + const list = original_getSupportedExtensions.call(this) || []; + if (list.indexOf("OES_vertex_array_object") < 0) { + list.push("OES_vertex_array_object"); + } + return list; + }; + const original_getExtension = gl.getExtension; + gl.getExtension = function getExtension(name) { + const ext = original_getExtension.call(this, name); + if (ext) { + return ext; + } + if (name !== "OES_vertex_array_object") { + return null; + } + if (!gl.__OESVertexArrayObject) { + this.__OESVertexArrayObject = new OESVertexArrayObject(this); + } + return this.__OESVertexArrayObject; + }; + } + + // node_modules/@luma.gl/gltools/dist/esm/polyfill/get-parameter-polyfill.js + var OES_element_index = "OES_element_index"; + var WEBGL_draw_buffers = "WEBGL_draw_buffers"; + var EXT_disjoint_timer_query = "EXT_disjoint_timer_query"; + var EXT_disjoint_timer_query_webgl2 = "EXT_disjoint_timer_query_webgl2"; + var EXT_texture_filter_anisotropic = "EXT_texture_filter_anisotropic"; + var WEBGL_debug_renderer_info = "WEBGL_debug_renderer_info"; + var GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 35723; + var GL_DONT_CARE = 4352; + var GL_GPU_DISJOINT_EXT = 36795; + var GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047; + var GL_UNMASKED_VENDOR_WEBGL = 37445; + var GL_UNMASKED_RENDERER_WEBGL = 37446; + var getWebGL2ValueOrZero = (gl) => !isWebGL2(gl) ? 0 : void 0; + var WEBGL_PARAMETERS = { + [3074]: (gl) => !isWebGL2(gl) ? 36064 : void 0, + [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl) => !isWebGL2(gl) ? GL_DONT_CARE : void 0, + [35977]: getWebGL2ValueOrZero, + [32937]: getWebGL2ValueOrZero, + [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => { + const ext = isWebGL2(gl) ? gl.getExtension(EXT_disjoint_timer_query_webgl2) : gl.getExtension(EXT_disjoint_timer_query); + return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0; + }, + [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => { + const ext = gl.getExtension(WEBGL_debug_renderer_info); + return getParameter(ext && ext.UNMASKED_VENDOR_WEBGL || 7936); + }, + [GL_UNMASKED_RENDERER_WEBGL]: (gl, getParameter) => { + const ext = gl.getExtension(WEBGL_debug_renderer_info); + return getParameter(ext && ext.UNMASKED_RENDERER_WEBGL || 7937); + }, + [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => { + const ext = gl.luma.extensions[EXT_texture_filter_anisotropic]; + return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1; + }, + [32883]: getWebGL2ValueOrZero, + [35071]: getWebGL2ValueOrZero, + [37447]: getWebGL2ValueOrZero, + [36063]: (gl, getParameter) => { + if (!isWebGL2(gl)) { + const ext = gl.getExtension(WEBGL_draw_buffers); + return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0; + } + return void 0; + }, + [35379]: getWebGL2ValueOrZero, + [35374]: getWebGL2ValueOrZero, + [35377]: getWebGL2ValueOrZero, + [34852]: (gl) => { + if (!isWebGL2(gl)) { + const ext = gl.getExtension(WEBGL_draw_buffers); + return ext ? ext.MAX_DRAW_BUFFERS_WEBGL : 0; + } + return void 0; + }, + [36203]: (gl) => gl.getExtension(OES_element_index) ? 2147483647 : 65535, + [33001]: (gl) => gl.getExtension(OES_element_index) ? 16777216 : 65535, + [33e3]: (gl) => 16777216, + [37157]: getWebGL2ValueOrZero, + [35373]: getWebGL2ValueOrZero, + [35657]: getWebGL2ValueOrZero, + [36183]: getWebGL2ValueOrZero, + [37137]: getWebGL2ValueOrZero, + [34045]: getWebGL2ValueOrZero, + [35978]: getWebGL2ValueOrZero, + [35979]: getWebGL2ValueOrZero, + [35968]: getWebGL2ValueOrZero, + [35376]: getWebGL2ValueOrZero, + [35375]: getWebGL2ValueOrZero, + [35659]: getWebGL2ValueOrZero, + [37154]: getWebGL2ValueOrZero, + [35371]: getWebGL2ValueOrZero, + [35658]: getWebGL2ValueOrZero, + [35076]: getWebGL2ValueOrZero, + [35077]: getWebGL2ValueOrZero, + [35380]: getWebGL2ValueOrZero + }; + function getParameterPolyfill(gl, originalGetParameter, pname) { + const limit = WEBGL_PARAMETERS[pname]; + const value = typeof limit === "function" ? limit(gl, originalGetParameter, pname) : limit; + const result = value !== void 0 ? value : originalGetParameter(pname); + return result; + } + + // node_modules/@luma.gl/gltools/dist/esm/polyfill/polyfill-table.js + var OES_vertex_array_object = "OES_vertex_array_object"; + var ANGLE_instanced_arrays = "ANGLE_instanced_arrays"; + var WEBGL_draw_buffers2 = "WEBGL_draw_buffers"; + var EXT_disjoint_timer_query2 = "EXT_disjoint_timer_query"; + var EXT_texture_filter_anisotropic2 = "EXT_texture_filter_anisotropic"; + var ERR_VAO_NOT_SUPPORTED = "VertexArray requires WebGL2 or OES_vertex_array_object extension"; + function getExtensionData(gl, extension) { + return { + webgl2: isWebGL2(gl), + ext: gl.getExtension(extension) + }; + } + var WEBGL2_CONTEXT_POLYFILLS = { + [OES_vertex_array_object]: { + meta: { + suffix: "OES" + }, + createVertexArray: () => { + assert5(false, ERR_VAO_NOT_SUPPORTED); + }, + deleteVertexArray: () => { + }, + bindVertexArray: () => { + }, + isVertexArray: () => false + }, + [ANGLE_instanced_arrays]: { + meta: { + suffix: "ANGLE" + }, + vertexAttribDivisor(location, divisor) { + assert5(divisor === 0, "WebGL instanced rendering not supported"); + }, + drawElementsInstanced: () => { + }, + drawArraysInstanced: () => { + } + }, + [WEBGL_draw_buffers2]: { + meta: { + suffix: "WEBGL" + }, + drawBuffers: () => { + assert5(false); + } + }, + [EXT_disjoint_timer_query2]: { + meta: { + suffix: "EXT" + }, + createQuery: () => { + assert5(false); + }, + deleteQuery: () => { + assert5(false); + }, + beginQuery: () => { + assert5(false); + }, + endQuery: () => { + }, + getQuery(handle, pname) { + return this.getQueryObject(handle, pname); + }, + getQueryParameter(handle, pname) { + return this.getQueryObject(handle, pname); + }, + getQueryObject: () => { + } + } + }; + var WEBGL2_CONTEXT_OVERRIDES = { + readBuffer: (gl, originalFunc, attachment) => { + if (isWebGL2(gl)) { + originalFunc(attachment); + } else { + } + }, + getVertexAttrib: (gl, originalFunc, location, pname) => { + const { + webgl2, + ext + } = getExtensionData(gl, ANGLE_instanced_arrays); + let result; + switch (pname) { + case 35069: + result = !webgl2 ? false : void 0; + break; + case 35070: + result = !webgl2 && !ext ? 0 : void 0; + break; + default: + } + return result !== void 0 ? result : originalFunc(location, pname); + }, + getProgramParameter: (gl, originalFunc, program, pname) => { + if (!isWebGL2(gl)) { + switch (pname) { + case 35967: + return 35981; + case 35971: + return 0; + case 35382: + return 0; + default: + } + } + return originalFunc(program, pname); + }, + getInternalformatParameter: (gl, originalFunc, target, format, pname) => { + if (!isWebGL2(gl)) { + switch (pname) { + case 32937: + return new Int32Array([0]); + default: + } + } + return gl.getInternalformatParameter(target, format, pname); + }, + getTexParameter(gl, originalFunc, target, pname) { + switch (pname) { + case 34046: + const { + extensions + } = gl.luma; + const ext = extensions[EXT_texture_filter_anisotropic2]; + pname = ext && ext.TEXTURE_MAX_ANISOTROPY_EXT || 34046; + break; + default: + } + return originalFunc(target, pname); + }, + getParameter: getParameterPolyfill, + hint(gl, originalFunc, pname, value) { + return originalFunc(pname, value); + } + }; + + // node_modules/@luma.gl/gltools/dist/esm/polyfill/polyfill-context.js + function polyfillContext(gl) { + gl.luma = gl.luma || {}; + const { + luma + } = gl; + if (!luma.polyfilled) { + polyfillVertexArrayObject(gl); + initializeExtensions(gl); + installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS); + installOverrides(gl, { + target: luma, + target2: gl + }); + luma.polyfilled = true; + } + return gl; + } + globalThis.polyfillContext = polyfillContext; + function initializeExtensions(gl) { + gl.luma.extensions = {}; + const EXTENSIONS2 = gl.getSupportedExtensions() || []; + for (const extension of EXTENSIONS2) { + gl.luma[extension] = gl.getExtension(extension); + } + } + function installOverrides(gl, _ref) { + let { + target, + target2 + } = _ref; + Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach((key) => { + if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === "function") { + const originalFunc = gl[key] ? gl[key].bind(gl) : () => { + }; + const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl, originalFunc); + target[key] = polyfill; + target2[key] = polyfill; + } + }); + } + function installPolyfills(gl, polyfills) { + for (const extension of Object.getOwnPropertyNames(polyfills)) { + if (extension !== "overrides") { + polyfillExtension(gl, { + extension, + target: gl.luma, + target2: gl + }); + } + } + } + function polyfillExtension(gl, _ref2) { + let { + extension, + target, + target2 + } = _ref2; + const defaults = WEBGL2_CONTEXT_POLYFILLS[extension]; + assert5(defaults); + const { + meta = {} + } = defaults; + const { + suffix = "" + } = meta; + const ext = gl.getExtension(extension); + for (const key of Object.keys(defaults)) { + const extKey = "".concat(key).concat(suffix); + let polyfill = null; + if (key === "meta") { + } else if (typeof gl[key] === "function") { + } else if (ext && typeof ext[extKey] === "function") { + polyfill = function() { + return ext[extKey](...arguments); + }; + } else if (typeof defaults[key] === "function") { + polyfill = defaults[key].bind(target); + } + if (polyfill) { + target[key] = polyfill; + target2[key] = polyfill; + } + } + } + + // node_modules/@luma.gl/gltools/dist/esm/state-tracker/webgl-parameter-tables.js + var GL_PARAMETER_DEFAULTS = { + [3042]: false, + [32773]: new Float32Array([0, 0, 0, 0]), + [32777]: 32774, + [34877]: 32774, + [32969]: 1, + [32968]: 0, + [32971]: 1, + [32970]: 0, + [3106]: new Float32Array([0, 0, 0, 0]), + [3107]: [true, true, true, true], + [2884]: false, + [2885]: 1029, + [2929]: false, + [2931]: 1, + [2932]: 513, + [2928]: new Float32Array([0, 1]), + [2930]: true, + [3024]: true, + [36006]: null, + [2886]: 2305, + [33170]: 4352, + [2849]: 1, + [32823]: false, + [32824]: 0, + [10752]: 0, + [32938]: 1, + [32939]: false, + [3089]: false, + [3088]: new Int32Array([0, 0, 1024, 1024]), + [2960]: false, + [2961]: 0, + [2968]: 4294967295, + [36005]: 4294967295, + [2962]: 519, + [2967]: 0, + [2963]: 4294967295, + [34816]: 519, + [36003]: 0, + [36004]: 4294967295, + [2964]: 7680, + [2965]: 7680, + [2966]: 7680, + [34817]: 7680, + [34818]: 7680, + [34819]: 7680, + [2978]: [0, 0, 1024, 1024], + [3333]: 4, + [3317]: 4, + [37440]: false, + [37441]: false, + [37443]: 37444, + [35723]: 4352, + [36010]: null, + [35977]: false, + [3330]: 0, + [3332]: 0, + [3331]: 0, + [3314]: 0, + [32878]: 0, + [3316]: 0, + [3315]: 0, + [32877]: 0 + }; + var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key); + var hint = (gl, value, key) => gl.hint(key, value); + var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value); + var drawFramebuffer = (gl, value) => { + const target = isWebGL2(gl) ? 36009 : 36160; + return gl.bindFramebuffer(target, value); + }; + var readFramebuffer = (gl, value) => { + return gl.bindFramebuffer(36008, value); + }; + function isArray(array) { + return Array.isArray(array) || ArrayBuffer.isView(array); + } + var GL_PARAMETER_SETTERS = { + [3042]: enable, + [32773]: (gl, value) => gl.blendColor(...value), + [32777]: "blendEquation", + [34877]: "blendEquation", + [32969]: "blendFunc", + [32968]: "blendFunc", + [32971]: "blendFunc", + [32970]: "blendFunc", + [3106]: (gl, value) => gl.clearColor(...value), + [3107]: (gl, value) => gl.colorMask(...value), + [2884]: enable, + [2885]: (gl, value) => gl.cullFace(value), + [2929]: enable, + [2931]: (gl, value) => gl.clearDepth(value), + [2932]: (gl, value) => gl.depthFunc(value), + [2928]: (gl, value) => gl.depthRange(...value), + [2930]: (gl, value) => gl.depthMask(value), + [3024]: enable, + [35723]: hint, + [36006]: drawFramebuffer, + [2886]: (gl, value) => gl.frontFace(value), + [33170]: hint, + [2849]: (gl, value) => gl.lineWidth(value), + [32823]: enable, + [32824]: "polygonOffset", + [10752]: "polygonOffset", + [35977]: enable, + [32938]: "sampleCoverage", + [32939]: "sampleCoverage", + [3089]: enable, + [3088]: (gl, value) => gl.scissor(...value), + [2960]: enable, + [2961]: (gl, value) => gl.clearStencil(value), + [2968]: (gl, value) => gl.stencilMaskSeparate(1028, value), + [36005]: (gl, value) => gl.stencilMaskSeparate(1029, value), + [2962]: "stencilFuncFront", + [2967]: "stencilFuncFront", + [2963]: "stencilFuncFront", + [34816]: "stencilFuncBack", + [36003]: "stencilFuncBack", + [36004]: "stencilFuncBack", + [2964]: "stencilOpFront", + [2965]: "stencilOpFront", + [2966]: "stencilOpFront", + [34817]: "stencilOpBack", + [34818]: "stencilOpBack", + [34819]: "stencilOpBack", + [2978]: (gl, value) => gl.viewport(...value), + [3333]: pixelStorei, + [3317]: pixelStorei, + [37440]: pixelStorei, + [37441]: pixelStorei, + [37443]: pixelStorei, + [3330]: pixelStorei, + [3332]: pixelStorei, + [3331]: pixelStorei, + [36010]: readFramebuffer, + [3314]: pixelStorei, + [32878]: pixelStorei, + [3316]: pixelStorei, + [3315]: pixelStorei, + [32877]: pixelStorei, + framebuffer: (gl, framebuffer) => { + const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer; + return gl.bindFramebuffer(36160, handle); + }, + blend: (gl, value) => value ? gl.enable(3042) : gl.disable(3042), + blendColor: (gl, value) => gl.blendColor(...value), + blendEquation: (gl, args) => { + args = isArray(args) ? args : [args, args]; + gl.blendEquationSeparate(...args); + }, + blendFunc: (gl, args) => { + args = isArray(args) && args.length === 2 ? [...args, ...args] : args; + gl.blendFuncSeparate(...args); + }, + clearColor: (gl, value) => gl.clearColor(...value), + clearDepth: (gl, value) => gl.clearDepth(value), + clearStencil: (gl, value) => gl.clearStencil(value), + colorMask: (gl, value) => gl.colorMask(...value), + cull: (gl, value) => value ? gl.enable(2884) : gl.disable(2884), + cullFace: (gl, value) => gl.cullFace(value), + depthTest: (gl, value) => value ? gl.enable(2929) : gl.disable(2929), + depthFunc: (gl, value) => gl.depthFunc(value), + depthMask: (gl, value) => gl.depthMask(value), + depthRange: (gl, value) => gl.depthRange(...value), + dither: (gl, value) => value ? gl.enable(3024) : gl.disable(3024), + derivativeHint: (gl, value) => { + gl.hint(35723, value); + }, + frontFace: (gl, value) => gl.frontFace(value), + mipmapHint: (gl, value) => gl.hint(33170, value), + lineWidth: (gl, value) => gl.lineWidth(value), + polygonOffsetFill: (gl, value) => value ? gl.enable(32823) : gl.disable(32823), + polygonOffset: (gl, value) => gl.polygonOffset(...value), + sampleCoverage: (gl, value) => gl.sampleCoverage(...value), + scissorTest: (gl, value) => value ? gl.enable(3089) : gl.disable(3089), + scissor: (gl, value) => gl.scissor(...value), + stencilTest: (gl, value) => value ? gl.enable(2960) : gl.disable(2960), + stencilMask: (gl, value) => { + value = isArray(value) ? value : [value, value]; + const [mask, backMask] = value; + gl.stencilMaskSeparate(1028, mask); + gl.stencilMaskSeparate(1029, backMask); + }, + stencilFunc: (gl, args) => { + args = isArray(args) && args.length === 3 ? [...args, ...args] : args; + const [func, ref, mask, backFunc, backRef, backMask] = args; + gl.stencilFuncSeparate(1028, func, ref, mask); + gl.stencilFuncSeparate(1029, backFunc, backRef, backMask); + }, + stencilOp: (gl, args) => { + args = isArray(args) && args.length === 3 ? [...args, ...args] : args; + const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args; + gl.stencilOpSeparate(1028, sfail, dpfail, dppass); + gl.stencilOpSeparate(1029, backSfail, backDpfail, backDppass); + }, + viewport: (gl, value) => gl.viewport(...value) + }; + function getValue(glEnum, values, cache4) { + return values[glEnum] !== void 0 ? values[glEnum] : cache4[glEnum]; + } + var GL_COMPOSITE_PARAMETER_SETTERS = { + blendEquation: (gl, values, cache4) => gl.blendEquationSeparate(getValue(32777, values, cache4), getValue(34877, values, cache4)), + blendFunc: (gl, values, cache4) => gl.blendFuncSeparate(getValue(32969, values, cache4), getValue(32968, values, cache4), getValue(32971, values, cache4), getValue(32970, values, cache4)), + polygonOffset: (gl, values, cache4) => gl.polygonOffset(getValue(32824, values, cache4), getValue(10752, values, cache4)), + sampleCoverage: (gl, values, cache4) => gl.sampleCoverage(getValue(32938, values, cache4), getValue(32939, values, cache4)), + stencilFuncFront: (gl, values, cache4) => gl.stencilFuncSeparate(1028, getValue(2962, values, cache4), getValue(2967, values, cache4), getValue(2963, values, cache4)), + stencilFuncBack: (gl, values, cache4) => gl.stencilFuncSeparate(1029, getValue(34816, values, cache4), getValue(36003, values, cache4), getValue(36004, values, cache4)), + stencilOpFront: (gl, values, cache4) => gl.stencilOpSeparate(1028, getValue(2964, values, cache4), getValue(2965, values, cache4), getValue(2966, values, cache4)), + stencilOpBack: (gl, values, cache4) => gl.stencilOpSeparate(1029, getValue(34817, values, cache4), getValue(34818, values, cache4), getValue(34819, values, cache4)) + }; + var GL_HOOKED_SETTERS = { + enable: (update, capability) => update({ + [capability]: true + }), + disable: (update, capability) => update({ + [capability]: false + }), + pixelStorei: (update, pname, value) => update({ + [pname]: value + }), + hint: (update, pname, hint2) => update({ + [pname]: hint2 + }), + bindFramebuffer: (update, target, framebuffer) => { + switch (target) { + case 36160: + return update({ + [36006]: framebuffer, + [36010]: framebuffer + }); + case 36009: + return update({ + [36006]: framebuffer + }); + case 36008: + return update({ + [36010]: framebuffer + }); + default: + return null; + } + }, + blendColor: (update, r2, g3, b2, a2) => update({ + [32773]: new Float32Array([r2, g3, b2, a2]) + }), + blendEquation: (update, mode) => update({ + [32777]: mode, + [34877]: mode + }), + blendEquationSeparate: (update, modeRGB, modeAlpha) => update({ + [32777]: modeRGB, + [34877]: modeAlpha + }), + blendFunc: (update, src, dst) => update({ + [32969]: src, + [32968]: dst, + [32971]: src, + [32970]: dst + }), + blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({ + [32969]: srcRGB, + [32968]: dstRGB, + [32971]: srcAlpha, + [32970]: dstAlpha + }), + clearColor: (update, r2, g3, b2, a2) => update({ + [3106]: new Float32Array([r2, g3, b2, a2]) + }), + clearDepth: (update, depth) => update({ + [2931]: depth + }), + clearStencil: (update, s) => update({ + [2961]: s + }), + colorMask: (update, r2, g3, b2, a2) => update({ + [3107]: [r2, g3, b2, a2] + }), + cullFace: (update, mode) => update({ + [2885]: mode + }), + depthFunc: (update, func) => update({ + [2932]: func + }), + depthRange: (update, zNear, zFar) => update({ + [2928]: new Float32Array([zNear, zFar]) + }), + depthMask: (update, mask) => update({ + [2930]: mask + }), + frontFace: (update, face) => update({ + [2886]: face + }), + lineWidth: (update, width) => update({ + [2849]: width + }), + polygonOffset: (update, factor, units) => update({ + [32824]: factor, + [10752]: units + }), + sampleCoverage: (update, value, invert4) => update({ + [32938]: value, + [32939]: invert4 + }), + scissor: (update, x2, y2, width, height) => update({ + [3088]: new Int32Array([x2, y2, width, height]) + }), + stencilMask: (update, mask) => update({ + [2968]: mask, + [36005]: mask + }), + stencilMaskSeparate: (update, face, mask) => update({ + [face === 1028 ? 2968 : 36005]: mask + }), + stencilFunc: (update, func, ref, mask) => update({ + [2962]: func, + [2967]: ref, + [2963]: mask, + [34816]: func, + [36003]: ref, + [36004]: mask + }), + stencilFuncSeparate: (update, face, func, ref, mask) => update({ + [face === 1028 ? 2962 : 34816]: func, + [face === 1028 ? 2967 : 36003]: ref, + [face === 1028 ? 2963 : 36004]: mask + }), + stencilOp: (update, fail, zfail, zpass) => update({ + [2964]: fail, + [2965]: zfail, + [2966]: zpass, + [34817]: fail, + [34818]: zfail, + [34819]: zpass + }), + stencilOpSeparate: (update, face, fail, zfail, zpass) => update({ + [face === 1028 ? 2964 : 34817]: fail, + [face === 1028 ? 2965 : 34818]: zfail, + [face === 1028 ? 2966 : 34819]: zpass + }), + viewport: (update, x2, y2, width, height) => update({ + [2978]: [x2, y2, width, height] + }) + }; + var isEnabled = (gl, key) => gl.isEnabled(key); + var GL_PARAMETER_GETTERS = { + [3042]: isEnabled, + [2884]: isEnabled, + [2929]: isEnabled, + [3024]: isEnabled, + [32823]: isEnabled, + [32926]: isEnabled, + [32928]: isEnabled, + [3089]: isEnabled, + [2960]: isEnabled, + [35977]: isEnabled + }; + + // node_modules/@luma.gl/gltools/dist/esm/utils/utils.js + function isObjectEmpty(object) { + for (const key in object) { + return false; + } + return true; + } + function deepArrayEqual(x2, y2) { + if (x2 === y2) { + return true; + } + const isArrayX = Array.isArray(x2) || ArrayBuffer.isView(x2); + const isArrayY = Array.isArray(y2) || ArrayBuffer.isView(y2); + if (isArrayX && isArrayY && x2.length === y2.length) { + for (let i3 = 0; i3 < x2.length; ++i3) { + if (x2[i3] !== y2[i3]) { + return false; + } + } + return true; + } + return false; + } + + // node_modules/@luma.gl/gltools/dist/esm/state-tracker/track-context-state.js + function installGetterOverride(gl, functionName) { + const originalGetterFunc = gl[functionName].bind(gl); + gl[functionName] = function get() { + const pname = arguments.length <= 0 ? void 0 : arguments[0]; + if (!(pname in gl.state.cache)) { + return originalGetterFunc(...arguments); + } + return gl.state.enable ? gl.state.cache[pname] : originalGetterFunc(...arguments); + }; + Object.defineProperty(gl[functionName], "name", { + value: "".concat(functionName, "-from-cache"), + configurable: false + }); + } + function installSetterSpy(gl, functionName, setter) { + const originalSetterFunc = gl[functionName].bind(gl); + gl[functionName] = function set2() { + for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) { + params[_key] = arguments[_key]; + } + const { + valueChanged, + oldValue + } = setter(gl.state._updateCache, ...params); + if (valueChanged) { + originalSetterFunc(...params); + } + return oldValue; + }; + Object.defineProperty(gl[functionName], "name", { + value: "".concat(functionName, "-to-cache"), + configurable: false + }); + } + function installProgramSpy(gl) { + const originalUseProgram = gl.useProgram.bind(gl); + gl.useProgram = function useProgramLuma(handle) { + if (gl.state.program !== handle) { + originalUseProgram(handle); + gl.state.program = handle; + } + }; + } + var GLState = class { + constructor(gl) { + let { + copyState = false, + log: log4 = () => { + } + } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + this.gl = gl; + this.program = null; + this.stateStack = []; + this.enable = true; + this.cache = copyState ? getParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS); + this.log = log4; + this._updateCache = this._updateCache.bind(this); + Object.seal(this); + } + push() { + let values = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this.stateStack.push({}); + } + pop() { + assert5(this.stateStack.length > 0); + const oldValues = this.stateStack[this.stateStack.length - 1]; + setParameters(this.gl, oldValues); + this.stateStack.pop(); + } + _updateCache(values) { + let valueChanged = false; + let oldValue; + const oldValues = this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1]; + for (const key in values) { + assert5(key !== void 0); + const value = values[key]; + const cached = this.cache[key]; + if (!deepArrayEqual(value, cached)) { + valueChanged = true; + oldValue = cached; + if (oldValues && !(key in oldValues)) { + oldValues[key] = cached; + } + this.cache[key] = value; + } + } + return { + valueChanged, + oldValue + }; + } + }; + function trackContextState(gl) { + let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const { + enable: enable2 = true, + copyState + } = options; + assert5(copyState !== void 0); + if (!gl.state) { + const { + polyfillContext: polyfillContext2 + } = globalThis; + if (polyfillContext2) { + polyfillContext2(gl); + } + gl.state = new GLState(gl, { + copyState + }); + installProgramSpy(gl); + for (const key in GL_HOOKED_SETTERS) { + const setter = GL_HOOKED_SETTERS[key]; + installSetterSpy(gl, key, setter); + } + installGetterOverride(gl, "getParameter"); + installGetterOverride(gl, "isEnabled"); + } + gl.state.enable = enable2; + return gl; + } + function pushContextState(gl) { + if (!gl.state) { + trackContextState(gl, { + copyState: false + }); + } + gl.state.push(); + } + function popContextState(gl) { + assert5(gl.state); + gl.state.pop(); + } + + // node_modules/@luma.gl/gltools/dist/esm/state-tracker/unified-parameter-api.js + function setParameters(gl, values) { + assert5(isWebGL(gl), "setParameters requires a WebGL context"); + if (isObjectEmpty(values)) { + return; + } + const compositeSetters = {}; + for (const key in values) { + const glConstant = Number(key); + const setter = GL_PARAMETER_SETTERS[key]; + if (setter) { + if (typeof setter === "string") { + compositeSetters[setter] = true; + } else { + setter(gl, values[key], glConstant); + } + } + } + const cache4 = gl.state && gl.state.cache; + if (cache4) { + for (const key in compositeSetters) { + const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key]; + compositeSetter(gl, values, cache4); + } + } + } + function getParameters(gl, parameters) { + parameters = parameters || GL_PARAMETER_DEFAULTS; + if (typeof parameters === "number") { + const key = parameters; + const getter = GL_PARAMETER_GETTERS[key]; + return getter ? getter(gl, key) : gl.getParameter(key); + } + const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters); + const state = {}; + for (const key of parameterKeys) { + const getter = GL_PARAMETER_GETTERS[key]; + state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key)); + } + return state; + } + function resetParameters(gl) { + setParameters(gl, GL_PARAMETER_DEFAULTS); + } + function withParameters(gl, parameters, func) { + if (isObjectEmpty(parameters)) { + return func(gl); + } + const { + nocatch = true + } = parameters; + pushContextState(gl); + setParameters(gl, parameters); + let value; + if (nocatch) { + value = func(gl); + popContextState(gl); + } else { + try { + value = func(gl); + } finally { + popContextState(gl); + } + } + return value; + } + + // node_modules/@luma.gl/gltools/dist/esm/utils/device-pixels.js + function cssToDeviceRatio(gl) { + const { + luma + } = gl; + if (gl.canvas && luma) { + const cachedSize = luma.canvasSizeInfo; + const clientWidth = "clientWidth" in cachedSize ? cachedSize.clientWidth : gl.canvas.clientWidth; + return clientWidth ? gl.drawingBufferWidth / clientWidth : 1; + } + return 1; + } + function cssToDevicePixels(gl, cssPixel) { + let yInvert = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true; + const ratio = cssToDeviceRatio(gl); + const width = gl.drawingBufferWidth; + const height = gl.drawingBufferHeight; + return scalePixels(cssPixel, ratio, width, height, yInvert); + } + function getDevicePixelRatio(useDevicePixels) { + const windowRatio = typeof window === "undefined" ? 1 : window.devicePixelRatio || 1; + if (Number.isFinite(useDevicePixels)) { + return useDevicePixels <= 0 ? 1 : useDevicePixels; + } + return useDevicePixels ? windowRatio : 1; + } + function scalePixels(pixel, ratio, width, height, yInvert) { + const x2 = scaleX(pixel[0], ratio, width); + let y2 = scaleY(pixel[1], ratio, height, yInvert); + let t2 = scaleX(pixel[0] + 1, ratio, width); + const xHigh = t2 === width - 1 ? t2 : t2 - 1; + t2 = scaleY(pixel[1] + 1, ratio, height, yInvert); + let yHigh; + if (yInvert) { + t2 = t2 === 0 ? t2 : t2 + 1; + yHigh = y2; + y2 = t2; + } else { + yHigh = t2 === height - 1 ? t2 : t2 - 1; + } + return { + x: x2, + y: y2, + width: Math.max(xHigh - x2 + 1, 1), + height: Math.max(yHigh - y2 + 1, 1) + }; + } + function scaleX(x2, ratio, width) { + const r2 = Math.min(Math.round(x2 * ratio), width - 1); + return r2; + } + function scaleY(y2, ratio, height, yInvert) { + return yInvert ? Math.max(0, height - 1 - Math.round(y2 * ratio)) : Math.min(Math.round(y2 * ratio), height - 1); + } + + // node_modules/@luma.gl/gltools/dist/esm/context/context.js + var isBrowser7 = isBrowser5(); + var isPage = isBrowser7 && typeof document !== "undefined"; + var CONTEXT_DEFAULTS = { + webgl2: true, + webgl1: true, + throwOnError: true, + manageState: true, + canvas: null, + debug: false, + width: 800, + height: 600 + }; + function createGLContext() { + let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + assert5(isBrowser7, "createGLContext only available in the browser.\nCreate your own headless context or use 'createHeadlessContext' from @luma.gl/test-utils"); + options = Object.assign({}, CONTEXT_DEFAULTS, options); + const { + width, + height + } = options; + function onError(message) { + if (options.throwOnError) { + throw new Error(message); + } + console.error(message); + return null; + } + options.onError = onError; + let gl; + const { + canvas + } = options; + const targetCanvas = getCanvas({ + canvas, + width, + height, + onError + }); + gl = createBrowserContext(targetCanvas, options); + if (!gl) { + return null; + } + gl = instrumentGLContext(gl, options); + logInfo(gl); + return gl; + } + function instrumentGLContext(gl) { + let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + if (!gl || gl._instrumented) { + return gl; + } + gl._version = gl._version || getVersion(gl); + gl.luma = gl.luma || {}; + gl.luma.canvasSizeInfo = gl.luma.canvasSizeInfo || {}; + options = Object.assign({}, CONTEXT_DEFAULTS, options); + const { + manageState, + debug: debug2 + } = options; + if (manageState) { + trackContextState(gl, { + copyState: false, + log: function() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return log2.log(1, ...args)(); + } + }); + } + if (isBrowser7 && debug2) { + if (!globalThis.makeDebugContext) { + log2.warn('WebGL debug mode not activated. import "@luma.gl/debug" to enable.')(); + } else { + gl = globalThis.makeDebugContext(gl, options); + log2.level = Math.max(log2.level, 1); + } + } + gl._instrumented = true; + return gl; + } + function getContextDebugInfo(gl) { + const vendorMasked = gl.getParameter(7936); + const rendererMasked = gl.getParameter(7937); + const ext = gl.getExtension("WEBGL_debug_renderer_info"); + const vendorUnmasked = ext && gl.getParameter(ext.UNMASKED_VENDOR_WEBGL || 7936); + const rendererUnmasked = ext && gl.getParameter(ext.UNMASKED_RENDERER_WEBGL || 7937); + return { + vendor: vendorUnmasked || vendorMasked, + renderer: rendererUnmasked || rendererMasked, + vendorMasked, + rendererMasked, + version: gl.getParameter(7938), + shadingLanguageVersion: gl.getParameter(35724) + }; + } + function resizeGLContext(gl) { + let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + if (gl.canvas) { + const devicePixelRatio = getDevicePixelRatio(options.useDevicePixels); + setDevicePixelRatio(gl, devicePixelRatio, options); + return; + } + const ext = gl.getExtension("STACKGL_resize_drawingbuffer"); + if (ext && "width" in options && "height" in options) { + ext.resize(options.width, options.height); + } + } + function createBrowserContext(canvas, options) { + const { + onError + } = options; + let errorMessage = null; + const onCreateError = (error2) => errorMessage = error2.statusMessage || errorMessage; + canvas.addEventListener("webglcontextcreationerror", onCreateError, false); + const { + webgl1 = true, + webgl2 = true + } = options; + let gl = null; + if (webgl2) { + gl = gl || canvas.getContext("webgl2", options); + gl = gl || canvas.getContext("experimental-webgl2", options); + } + if (webgl1) { + gl = gl || canvas.getContext("webgl", options); + gl = gl || canvas.getContext("experimental-webgl", options); + } + canvas.removeEventListener("webglcontextcreationerror", onCreateError, false); + if (!gl) { + return onError("Failed to create ".concat(webgl2 && !webgl1 ? "WebGL2" : "WebGL", " context: ").concat(errorMessage || "Unknown error")); + } + if (options.onContextLost) { + canvas.addEventListener("webglcontextlost", options.onContextLost, false); + } + if (options.onContextRestored) { + canvas.addEventListener("webglcontextrestored", options.onContextRestored, false); + } + return gl; + } + function getCanvas(_ref) { + let { + canvas, + width = 800, + height = 600, + onError + } = _ref; + let targetCanvas; + if (typeof canvas === "string") { + const isPageLoaded = isPage && document.readyState === "complete"; + if (!isPageLoaded) { + onError("createGLContext called on canvas '".concat(canvas, "' before page was loaded")); + } + targetCanvas = document.getElementById(canvas); + } else if (canvas) { + targetCanvas = canvas; + } else { + targetCanvas = document.createElement("canvas"); + targetCanvas.id = "lumagl-canvas"; + targetCanvas.style.width = Number.isFinite(width) ? "".concat(width, "px") : "100%"; + targetCanvas.style.height = Number.isFinite(height) ? "".concat(height, "px") : "100%"; + document.body.insertBefore(targetCanvas, document.body.firstChild); + } + return targetCanvas; + } + function logInfo(gl) { + const webGL = isWebGL2(gl) ? "WebGL2" : "WebGL1"; + const info = getContextDebugInfo(gl); + const driver = info ? "(".concat(info.vendor, ",").concat(info.renderer, ")") : ""; + const debug2 = gl.debug ? " debug" : ""; + log2.info(1, "".concat(webGL).concat(debug2, " context ").concat(driver))(); + } + function getVersion(gl) { + if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { + return 2; + } + return 1; + } + function setDevicePixelRatio(gl, devicePixelRatio, options) { + let clientWidth = "width" in options ? options.width : gl.canvas.clientWidth; + let clientHeight = "height" in options ? options.height : gl.canvas.clientHeight; + if (!clientWidth || !clientHeight) { + log2.log(1, "Canvas clientWidth/clientHeight is 0")(); + devicePixelRatio = 1; + clientWidth = gl.canvas.width || 1; + clientHeight = gl.canvas.height || 1; + } + gl.luma = gl.luma || {}; + gl.luma.canvasSizeInfo = gl.luma.canvasSizeInfo || {}; + const cachedSize = gl.luma.canvasSizeInfo; + if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio) { + let clampedPixelRatio = devicePixelRatio; + const canvasWidth = Math.floor(clientWidth * clampedPixelRatio); + const canvasHeight = Math.floor(clientHeight * clampedPixelRatio); + gl.canvas.width = canvasWidth; + gl.canvas.height = canvasHeight; + if (gl.drawingBufferWidth !== canvasWidth || gl.drawingBufferHeight !== canvasHeight) { + log2.warn("Device pixel ratio clamped")(); + clampedPixelRatio = Math.min(gl.drawingBufferWidth / clientWidth, gl.drawingBufferHeight / clientHeight); + gl.canvas.width = Math.floor(clientWidth * clampedPixelRatio); + gl.canvas.height = Math.floor(clientHeight * clampedPixelRatio); + } + Object.assign(gl.luma.canvasSizeInfo, { + clientWidth, + clientHeight, + devicePixelRatio + }); + } + } + + // node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js + function getHiResTimestamp4() { + let timestamp; + if (typeof window !== "undefined" && window.performance) { + timestamp = window.performance.now(); + } else if (typeof process !== "undefined" && process.hrtime) { + const timeParts = process.hrtime(); + timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; + } else { + timestamp = Date.now(); + } + return timestamp; + } + + // node_modules/@probe.gl/stats/dist/esm/lib/stat.js + var Stat2 = class { + constructor(name, type) { + _defineProperty(this, "name", void 0); + _defineProperty(this, "type", void 0); + _defineProperty(this, "sampleSize", 1); + _defineProperty(this, "time", void 0); + _defineProperty(this, "count", void 0); + _defineProperty(this, "samples", void 0); + _defineProperty(this, "lastTiming", void 0); + _defineProperty(this, "lastSampleTime", void 0); + _defineProperty(this, "lastSampleCount", void 0); + _defineProperty(this, "_count", 0); + _defineProperty(this, "_time", 0); + _defineProperty(this, "_samples", 0); + _defineProperty(this, "_startTime", 0); + _defineProperty(this, "_timerPending", false); + this.name = name; + this.type = type; + this.reset(); + } + setSampleSize(samples) { + this.sampleSize = samples; + return this; + } + incrementCount() { + this.addCount(1); + return this; + } + decrementCount() { + this.subtractCount(1); + return this; + } + addCount(value) { + this._count += value; + this._samples++; + this._checkSampling(); + return this; + } + subtractCount(value) { + this._count -= value; + this._samples++; + this._checkSampling(); + return this; + } + addTime(time) { + this._time += time; + this.lastTiming = time; + this._samples++; + this._checkSampling(); + return this; + } + timeStart() { + this._startTime = getHiResTimestamp4(); + this._timerPending = true; + return this; + } + timeEnd() { + if (!this._timerPending) { + return this; + } + this.addTime(getHiResTimestamp4() - this._startTime); + this._timerPending = false; + this._checkSampling(); + return this; + } + getSampleAverageCount() { + return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0; + } + getSampleAverageTime() { + return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0; + } + getSampleHz() { + return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0; + } + getAverageCount() { + return this.samples > 0 ? this.count / this.samples : 0; + } + getAverageTime() { + return this.samples > 0 ? this.time / this.samples : 0; + } + getHz() { + return this.time > 0 ? this.samples / (this.time / 1e3) : 0; + } + reset() { + this.time = 0; + this.count = 0; + this.samples = 0; + this.lastTiming = 0; + this.lastSampleTime = 0; + this.lastSampleCount = 0; + this._count = 0; + this._time = 0; + this._samples = 0; + this._startTime = 0; + this._timerPending = false; + return this; + } + _checkSampling() { + if (this._samples === this.sampleSize) { + this.lastSampleTime = this._time; + this.lastSampleCount = this._count; + this.count += this._count; + this.time += this._time; + this.samples += this._samples; + this._time = 0; + this._count = 0; + this._samples = 0; + } + } + }; + + // node_modules/@probe.gl/stats/dist/esm/lib/stats.js + var Stats2 = class { + constructor(options) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "stats", {}); + this.id = options.id; + this.stats = {}; + this._initializeStats(options.stats); + Object.seal(this); + } + get(name) { + let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count"; + return this._getOrCreate({ + name, + type + }); + } + get size() { + return Object.keys(this.stats).length; + } + reset() { + for (const key in this.stats) { + this.stats[key].reset(); + } + return this; + } + forEach(fn) { + for (const key in this.stats) { + fn(this.stats[key]); + } + } + getTable() { + const table = {}; + this.forEach((stat) => { + table[stat.name] = { + time: stat.time || 0, + count: stat.count || 0, + average: stat.getAverageTime() || 0, + hz: stat.getHz() || 0 + }; + }); + return table; + } + _initializeStats() { + let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []; + stats.forEach((stat) => this._getOrCreate(stat)); + } + _getOrCreate(stat) { + if (!stat || !stat.name) { + return null; + } + const { + name, + type + } = stat; + if (!this.stats[name]) { + if (stat instanceof Stat2) { + this.stats[name] = stat; + } else { + this.stats[name] = new Stat2(name, type); + } + } + return this.stats[name]; + } + }; + + // node_modules/@luma.gl/webgl/dist/esm/init.js + var VERSION6 = true ? "8.5.21" : "untranspiled source"; + var STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering"; + var StatsManager = class { + constructor() { + this.stats = /* @__PURE__ */ new Map(); + } + get(name) { + if (!this.stats.has(name)) { + this.stats.set(name, new Stats2({ + id: name + })); + } + return this.stats.get(name); + } + }; + var lumaStats = new StatsManager(); + if (globalThis.luma && globalThis.luma.VERSION !== VERSION6) { + throw new Error("luma.gl - multiple VERSIONs detected: ".concat(globalThis.luma.VERSION, " vs ").concat(VERSION6)); + } + if (!globalThis.luma) { + if (isBrowser5()) { + log2.log(1, "luma.gl ".concat(VERSION6, " - ").concat(STARTUP_MESSAGE))(); + } + globalThis.luma = globalThis.luma || { + VERSION: VERSION6, + version: VERSION6, + log: log2, + stats: lumaStats, + globals: { + modules: {}, + nodeIO: {} + } + }; + } + var init_default = globalThis.luma; + + // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/request-animation-frame.js + function requestAnimationFrame2(callback) { + return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60); + } + function cancelAnimationFrame(timerId) { + return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId); + } + + // node_modules/@luma.gl/webgl/dist/esm/utils/assert.js + function assert6(condition, message) { + if (!condition) { + throw new Error(message || "luma.gl: assertion failed."); + } + } + + // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/constants-to-keys.js + function getKeyValue(gl, name) { + if (typeof name !== "string") { + return name; + } + const number = Number(name); + if (!isNaN(number)) { + return number; + } + name = name.replace(/^.*\./, ""); + const value = gl[name]; + assert6(value !== void 0, "Accessing undefined constant GL.".concat(name)); + return value; + } + function getKey(gl, value) { + value = Number(value); + for (const key in gl) { + if (gl[key] === value) { + return "GL.".concat(key); + } + } + return String(value); + } + + // node_modules/@luma.gl/webgl/dist/esm/utils/utils.js + var uidCounters = {}; + function uid() { + let id = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "id"; + uidCounters[id] = uidCounters[id] || 1; + const count2 = uidCounters[id]++; + return "".concat(id, "-").concat(count2); + } + function isPowerOfTwo(n2) { + assert6(typeof n2 === "number", "Input must be a number"); + return n2 && (n2 & n2 - 1) === 0; + } + function isObjectEmpty2(obj) { + let isEmpty = true; + for (const key in obj) { + isEmpty = false; + break; + } + return isEmpty; + } + + // node_modules/@luma.gl/webgl/dist/esm/utils/stub-methods.js + function stubRemovedMethods(instance2, className, version, methodNames) { + const upgradeMessage = "See luma.gl ".concat(version, " Upgrade Guide at https://luma.gl/docs/upgrade-guide"); + const prototype = Object.getPrototypeOf(instance2); + methodNames.forEach((methodName) => { + if (prototype.methodName) { + return; + } + prototype[methodName] = () => { + log2.removed("Calling removed method ".concat(className, ".").concat(methodName, ": "), upgradeMessage)(); + throw new Error(methodName); + }; + }); + } + + // node_modules/@luma.gl/webgl/dist/esm/classes/resource.js + var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods"; + var Resource = class { + get [Symbol.toStringTag]() { + return "Resource"; + } + constructor(gl) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + assertWebGLContext(gl); + const { + id, + userData = {} + } = opts; + this.gl = gl; + this.gl2 = gl; + this.id = id || uid(this[Symbol.toStringTag]); + this.userData = userData; + this._bound = false; + this._handle = opts.handle; + if (this._handle === void 0) { + this._handle = this._createHandle(); + } + this.byteLength = 0; + this._addStats(); + } + toString() { + return "".concat(this[Symbol.toStringTag] || this.constructor.name, "(").concat(this.id, ")"); + } + get handle() { + return this._handle; + } + delete() { + let { + deleteChildren = false + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const children = this._handle && this._deleteHandle(this._handle); + if (this._handle) { + this._removeStats(); + } + this._handle = null; + if (children && deleteChildren) { + children.filter(Boolean).forEach((child) => child.delete()); + } + return this; + } + bind() { + let funcOrHandle = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.handle; + if (typeof funcOrHandle !== "function") { + this._bindHandle(funcOrHandle); + return this; + } + let value; + if (!this._bound) { + this._bindHandle(this.handle); + this._bound = true; + value = funcOrHandle(); + this._bound = false; + this._bindHandle(null); + } else { + value = funcOrHandle(); + } + return value; + } + unbind() { + this.bind(null); + } + getParameter(pname) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + pname = getKeyValue(this.gl, pname); + assert6(pname); + const parameters = this.constructor.PARAMETERS || {}; + const parameter = parameters[pname]; + if (parameter) { + const isWebgl2 = isWebGL2(this.gl); + const parameterAvailable = (!("webgl2" in parameter) || isWebgl2) && (!("extension" in parameter) || this.gl.getExtension(parameter.extension)); + if (!parameterAvailable) { + const webgl1Default = parameter.webgl1; + const webgl2Default = "webgl2" in parameter ? parameter.webgl2 : parameter.webgl1; + const defaultValue = isWebgl2 ? webgl2Default : webgl1Default; + return defaultValue; + } + } + return this._getParameter(pname, opts); + } + getParameters() { + let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + parameters, + keys + } = options; + const PARAMETERS = this.constructor.PARAMETERS || {}; + const isWebgl2 = isWebGL2(this.gl); + const values = {}; + const parameterKeys = parameters || Object.keys(PARAMETERS); + for (const pname of parameterKeys) { + const parameter = PARAMETERS[pname]; + const parameterAvailable = parameter && (!("webgl2" in parameter) || isWebgl2) && (!("extension" in parameter) || this.gl.getExtension(parameter.extension)); + if (parameterAvailable) { + const key = keys ? getKey(this.gl, pname) : pname; + values[key] = this.getParameter(pname, options); + if (keys && parameter.type === "GLenum") { + values[key] = getKey(this.gl, values[key]); + } + } + } + return values; + } + setParameter(pname, value) { + pname = getKeyValue(this.gl, pname); + assert6(pname); + const parameters = this.constructor.PARAMETERS || {}; + const parameter = parameters[pname]; + if (parameter) { + const isWebgl2 = isWebGL2(this.gl); + const parameterAvailable = (!("webgl2" in parameter) || isWebgl2) && (!("extension" in parameter) || this.gl.getExtension(parameter.extension)); + if (!parameterAvailable) { + throw new Error("Parameter not available on this platform"); + } + if (parameter.type === "GLenum") { + value = getKeyValue(value); + } + } + this._setParameter(pname, value); + return this; + } + setParameters(parameters) { + for (const pname in parameters) { + this.setParameter(pname, parameters[pname]); + } + return this; + } + stubRemovedMethods(className, version, methodNames) { + return stubRemovedMethods(this, className, version, methodNames); + } + initialize(opts) { + } + _createHandle() { + throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + } + _deleteHandle() { + throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + } + _bindHandle(handle) { + throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + } + _getOptsFromHandle() { + throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + } + _getParameter(pname, opts) { + throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + } + _setParameter(pname, value) { + throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + } + _context() { + this.gl.luma = this.gl.luma || {}; + return this.gl.luma; + } + _addStats() { + const name = this[Symbol.toStringTag]; + const stats = lumaStats.get("Resource Counts"); + stats.get("Resources Created").incrementCount(); + stats.get("".concat(name, "s Created")).incrementCount(); + stats.get("".concat(name, "s Active")).incrementCount(); + } + _removeStats() { + const name = this[Symbol.toStringTag]; + const stats = lumaStats.get("Resource Counts"); + stats.get("".concat(name, "s Active")).decrementCount(); + } + _trackAllocatedMemory(bytes) { + let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this[Symbol.toStringTag]; + this._trackAllocatedMemoryForContext(bytes, name); + this._trackAllocatedMemoryForContext(bytes, name, this.gl.canvas && this.gl.canvas.id); + this.byteLength = bytes; + } + _trackAllocatedMemoryForContext(bytes) { + let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this[Symbol.toStringTag]; + let id = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ""; + const stats = lumaStats.get("Memory Usage".concat(id)); + stats.get("GPU Memory").addCount(bytes); + stats.get("".concat(name, " Memory")).addCount(bytes); + } + _trackDeallocatedMemory() { + let name = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this[Symbol.toStringTag]; + this._trackDeallocatedMemoryForContext(name); + this._trackDeallocatedMemoryForContext(name, this.gl.canvas && this.gl.canvas.id); + this.byteLength = 0; + } + _trackDeallocatedMemoryForContext() { + let name = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this[Symbol.toStringTag]; + let id = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ""; + const stats = lumaStats.get("Memory Usage".concat(id)); + stats.get("GPU Memory").subtractCount(this.byteLength); + stats.get("".concat(name, " Memory")).subtractCount(this.byteLength); + } + }; + + // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/typed-array-utils.js + var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array"; + function getGLTypeFromTypedArray(arrayOrType) { + const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType; + switch (type) { + case Float32Array: + return 5126; + case Uint16Array: + return 5123; + case Uint32Array: + return 5125; + case Uint8Array: + return 5121; + case Uint8ClampedArray: + return 5121; + case Int8Array: + return 5120; + case Int16Array: + return 5122; + case Int32Array: + return 5124; + default: + throw new Error(ERR_TYPE_DEDUCTION); + } + } + function getTypedArrayFromGLType(glType) { + let { + clamped = true + } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + switch (glType) { + case 5126: + return Float32Array; + case 5123: + case 33635: + case 32819: + case 32820: + return Uint16Array; + case 5125: + return Uint32Array; + case 5121: + return clamped ? Uint8ClampedArray : Uint8Array; + case 5120: + return Int8Array; + case 5122: + return Int16Array; + case 5124: + return Int32Array; + default: + throw new Error("Failed to deduce typed array type from GL constant"); + } + } + function flipRows(_ref) { + let { + data, + width, + height, + bytesPerPixel = 4, + temp + } = _ref; + const bytesPerRow = width * bytesPerPixel; + temp = temp || new Uint8Array(bytesPerRow); + for (let y2 = 0; y2 < height / 2; ++y2) { + const topOffset = y2 * bytesPerRow; + const bottomOffset = (height - y2 - 1) * bytesPerRow; + temp.set(data.subarray(topOffset, topOffset + bytesPerRow)); + data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow); + data.set(temp, bottomOffset); + } + } + function scalePixels2(_ref2) { + let { + data, + width, + height + } = _ref2; + const newWidth = Math.round(width / 2); + const newHeight = Math.round(height / 2); + const newData = new Uint8Array(newWidth * newHeight * 4); + for (let y2 = 0; y2 < newHeight; y2++) { + for (let x2 = 0; x2 < newWidth; x2++) { + for (let c2 = 0; c2 < 4; c2++) { + newData[(y2 * newWidth + x2) * 4 + c2] = data[(y2 * 2 * width + x2 * 2) * 4 + c2]; + } + } + } + return { + data: newData, + width: newWidth, + height: newHeight + }; + } + + // node_modules/@luma.gl/webgl/dist/esm/utils/check-props.js + function checkProps(className, props, propChecks) { + const { + removedProps = {}, + deprecatedProps = {}, + replacedProps = {} + } = propChecks; + for (const propName in removedProps) { + if (propName in props) { + const replacementProp = removedProps[propName]; + const replacement = replacementProp ? "".concat(className, ".").concat(removedProps[propName]) : "N/A"; + log2.removed("".concat(className, ".").concat(propName), replacement)(); + } + } + for (const propName in deprecatedProps) { + if (propName in props) { + const replacementProp = deprecatedProps[propName]; + log2.deprecated("".concat(className, ".").concat(propName), "".concat(className, ".").concat(replacementProp))(); + } + } + let newProps = null; + for (const propName in replacedProps) { + if (propName in props) { + const replacementProp = replacedProps[propName]; + log2.deprecated("".concat(className, ".").concat(propName), "".concat(className, ".").concat(replacementProp))(); + newProps = newProps || Object.assign({}, props); + newProps[replacementProp] = props[propName]; + delete newProps[propName]; + } + } + return newProps || props; + } + + // node_modules/@luma.gl/webgl/dist/esm/classes/accessor.js + var DEFAULT_ACCESSOR_VALUES = { + offset: 0, + stride: 0, + type: 5126, + size: 1, + divisor: 0, + normalized: false, + integer: false + }; + var PROP_CHECKS = { + deprecatedProps: { + instanced: "divisor", + isInstanced: "divisor" + } + }; + var Accessor = class _Accessor { + static getBytesPerElement(accessor) { + const ArrayType = getTypedArrayFromGLType(accessor.type || 5126); + return ArrayType.BYTES_PER_ELEMENT; + } + static getBytesPerVertex(accessor) { + assert6(accessor.size); + const ArrayType = getTypedArrayFromGLType(accessor.type || 5126); + return ArrayType.BYTES_PER_ELEMENT * accessor.size; + } + static resolve() { + for (var _len = arguments.length, accessors = new Array(_len), _key = 0; _key < _len; _key++) { + accessors[_key] = arguments[_key]; + } + return new _Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]); + } + constructor() { + for (var _len2 = arguments.length, accessors = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + accessors[_key2] = arguments[_key2]; + } + accessors.forEach((accessor) => this._assign(accessor)); + Object.freeze(this); + } + toString() { + return JSON.stringify(this); + } + get BYTES_PER_ELEMENT() { + return _Accessor.getBytesPerElement(this); + } + get BYTES_PER_VERTEX() { + return _Accessor.getBytesPerVertex(this); + } + _assign() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + props = checkProps("Accessor", props, PROP_CHECKS); + if (props.type !== void 0) { + this.type = props.type; + if (props.type === 5124 || props.type === 5125) { + this.integer = true; + } + } + if (props.size !== void 0) { + this.size = props.size; + } + if (props.offset !== void 0) { + this.offset = props.offset; + } + if (props.stride !== void 0) { + this.stride = props.stride; + } + if (props.normalized !== void 0) { + this.normalized = props.normalized; + } + if (props.integer !== void 0) { + this.integer = props.integer; + } + if (props.divisor !== void 0) { + this.divisor = props.divisor; + } + if (props.buffer !== void 0) { + this.buffer = props.buffer; + } + if (props.index !== void 0) { + if (typeof props.index === "boolean") { + this.index = props.index ? 1 : 0; + } else { + this.index = props.index; + } + } + if (props.instanced !== void 0) { + this.divisor = props.instanced ? 1 : 0; + } + if (props.isInstanced !== void 0) { + this.divisor = props.isInstanced ? 1 : 0; + } + return this; + } + }; + + // node_modules/@luma.gl/webgl/dist/esm/classes/buffer.js + var DEBUG_DATA_LENGTH = 10; + var DEPRECATED_PROPS = { + offset: "accessor.offset", + stride: "accessor.stride", + type: "accessor.type", + size: "accessor.size", + divisor: "accessor.divisor", + normalized: "accessor.normalized", + integer: "accessor.integer", + instanced: "accessor.divisor", + isInstanced: "accessor.divisor" + }; + var PROP_CHECKS_INITIALIZE = { + removedProps: {}, + replacedProps: { + bytes: "byteLength" + }, + deprecatedProps: DEPRECATED_PROPS + }; + var PROP_CHECKS_SET_PROPS = { + removedProps: DEPRECATED_PROPS + }; + var Buffer2 = class extends Resource { + get [Symbol.toStringTag]() { + return "Buffer"; + } + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + super(gl, props); + this.stubRemovedMethods("Buffer", "v6.0", ["layout", "setLayout", "getIndexedParameter"]); + this.target = props.target || (this.gl.webgl2 ? 36662 : 34962); + this.initialize(props); + Object.seal(this); + } + getElementCount() { + let accessor = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.accessor; + return Math.round(this.byteLength / Accessor.getBytesPerElement(accessor)); + } + getVertexCount() { + let accessor = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.accessor; + return Math.round(this.byteLength / Accessor.getBytesPerVertex(accessor)); + } + initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (ArrayBuffer.isView(props)) { + props = { + data: props + }; + } + if (Number.isFinite(props)) { + props = { + byteLength: props + }; + } + props = checkProps("Buffer", props, PROP_CHECKS_INITIALIZE); + this.usage = props.usage || 35044; + this.debugData = null; + this.setAccessor(Object.assign({}, props, props.accessor)); + if (props.data) { + this._setData(props.data, props.offset, props.byteLength); + } else { + this._setByteLength(props.byteLength || 0); + } + return this; + } + setProps(props) { + props = checkProps("Buffer", props, PROP_CHECKS_SET_PROPS); + if ("accessor" in props) { + this.setAccessor(props.accessor); + } + return this; + } + setAccessor(accessor) { + accessor = Object.assign({}, accessor); + delete accessor.buffer; + this.accessor = new Accessor(accessor); + return this; + } + reallocate(byteLength) { + if (byteLength > this.byteLength) { + this._setByteLength(byteLength); + return true; + } + this.bytesUsed = byteLength; + return false; + } + setData(props) { + return this.initialize(props); + } + subData(props) { + if (ArrayBuffer.isView(props)) { + props = { + data: props + }; + } + const { + data, + offset = 0, + srcOffset = 0 + } = props; + const byteLength = props.byteLength || props.length; + assert6(data); + const target = this.gl.webgl2 ? 36663 : this.target; + this.gl.bindBuffer(target, this.handle); + if (srcOffset !== 0 || byteLength !== void 0) { + assertWebGL2Context(this.gl); + this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength); + } else { + this.gl.bufferSubData(target, offset, data); + } + this.gl.bindBuffer(target, null); + this.debugData = null; + this._inferType(data); + return this; + } + copyData(_ref) { + let { + sourceBuffer, + readOffset = 0, + writeOffset = 0, + size + } = _ref; + const { + gl + } = this; + assertWebGL2Context(gl); + gl.bindBuffer(36662, sourceBuffer.handle); + gl.bindBuffer(36663, this.handle); + gl.copyBufferSubData(36662, 36663, readOffset, writeOffset, size); + gl.bindBuffer(36662, null); + gl.bindBuffer(36663, null); + this.debugData = null; + return this; + } + getData() { + let { + dstData = null, + srcByteOffset = 0, + dstOffset = 0, + length: length4 = 0 + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + assertWebGL2Context(this.gl); + const ArrayType = getTypedArrayFromGLType(this.accessor.type || 5126, { + clamped: false + }); + const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset); + const dstElementOffset = dstOffset; + let dstAvailableElementCount; + let dstElementCount; + if (dstData) { + dstElementCount = dstData.length; + dstAvailableElementCount = dstElementCount - dstElementOffset; + } else { + dstAvailableElementCount = Math.min(sourceAvailableElementCount, length4 || sourceAvailableElementCount); + dstElementCount = dstElementOffset + dstAvailableElementCount; + } + const copyElementCount = Math.min(sourceAvailableElementCount, dstAvailableElementCount); + length4 = length4 || copyElementCount; + assert6(length4 <= copyElementCount); + dstData = dstData || new ArrayType(dstElementCount); + this.gl.bindBuffer(36662, this.handle); + this.gl.getBufferSubData(36662, srcByteOffset, dstData, dstOffset, length4); + this.gl.bindBuffer(36662, null); + return dstData; + } + bind() { + let { + target = this.target, + index = this.accessor && this.accessor.index, + offset = 0, + size + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (target === 35345 || target === 35982) { + if (size !== void 0) { + this.gl.bindBufferRange(target, index, this.handle, offset, size); + } else { + assert6(offset === 0); + this.gl.bindBufferBase(target, index, this.handle); + } + } else { + this.gl.bindBuffer(target, this.handle); + } + return this; + } + unbind() { + let { + target = this.target, + index = this.accessor && this.accessor.index + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const isIndexedBuffer = target === 35345 || target === 35982; + if (isIndexedBuffer) { + this.gl.bindBufferBase(target, index, null); + } else { + this.gl.bindBuffer(target, null); + } + return this; + } + getDebugData() { + if (!this.debugData) { + this.debugData = this.getData({ + length: Math.min(DEBUG_DATA_LENGTH, this.byteLength) + }); + return { + data: this.debugData, + changed: true + }; + } + return { + data: this.debugData, + changed: false + }; + } + invalidateDebugData() { + this.debugData = null; + } + _setData(data) { + let offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0; + let byteLength = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : data.byteLength + offset; + assert6(ArrayBuffer.isView(data)); + this._trackDeallocatedMemory(); + const target = this._getTarget(); + this.gl.bindBuffer(target, this.handle); + this.gl.bufferData(target, byteLength, this.usage); + this.gl.bufferSubData(target, offset, data); + this.gl.bindBuffer(target, null); + this.debugData = data.slice(0, DEBUG_DATA_LENGTH); + this.bytesUsed = byteLength; + this._trackAllocatedMemory(byteLength); + const type = getGLTypeFromTypedArray(data); + assert6(type); + this.setAccessor(new Accessor(this.accessor, { + type + })); + return this; + } + _setByteLength(byteLength) { + let usage = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.usage; + assert6(byteLength >= 0); + this._trackDeallocatedMemory(); + let data = byteLength; + if (byteLength === 0) { + data = new Float32Array(0); + } + const target = this._getTarget(); + this.gl.bindBuffer(target, this.handle); + this.gl.bufferData(target, data, usage); + this.gl.bindBuffer(target, null); + this.usage = usage; + this.debugData = null; + this.bytesUsed = byteLength; + this._trackAllocatedMemory(byteLength); + return this; + } + _getTarget() { + return this.gl.webgl2 ? 36663 : this.target; + } + _getAvailableElementCount(srcByteOffset) { + const ArrayType = getTypedArrayFromGLType(this.accessor.type || 5126, { + clamped: false + }); + const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT; + return this.getElementCount() - sourceElementOffset; + } + _inferType(data) { + if (!this.accessor.type) { + this.setAccessor(new Accessor(this.accessor, { + type: getGLTypeFromTypedArray(data) + })); + } + } + _createHandle() { + return this.gl.createBuffer(); + } + _deleteHandle() { + this.gl.deleteBuffer(this.handle); + this._trackDeallocatedMemory(); + } + _getParameter(pname) { + this.gl.bindBuffer(this.target, this.handle); + const value = this.gl.getBufferParameter(this.target, pname); + this.gl.bindBuffer(this.target, null); + return value; + } + get type() { + log2.deprecated("Buffer.type", "Buffer.accessor.type")(); + return this.accessor.type; + } + get bytes() { + log2.deprecated("Buffer.bytes", "Buffer.byteLength")(); + return this.byteLength; + } + setByteLength(byteLength) { + log2.deprecated("setByteLength", "reallocate")(); + return this.reallocate(byteLength); + } + updateAccessor(opts) { + log2.deprecated("updateAccessor(...)", "setAccessor(new Accessor(buffer.accessor, ...)")(); + this.accessor = new Accessor(this.accessor, opts); + return this; + } + }; + + // node_modules/@luma.gl/webgl/dist/esm/classes/texture-formats.js + var TEXTURE_FORMATS = { + [6407]: { + dataFormat: 6407, + types: [5121, 33635] + }, + [6408]: { + dataFormat: 6408, + types: [5121, 32819, 32820] + }, + [6406]: { + dataFormat: 6406, + types: [5121] + }, + [6409]: { + dataFormat: 6409, + types: [5121] + }, + [6410]: { + dataFormat: 6410, + types: [5121] + }, + [33326]: { + dataFormat: 6403, + types: [5126], + gl2: true + }, + [33328]: { + dataFormat: 33319, + types: [5126], + gl2: true + }, + [34837]: { + dataFormat: 6407, + types: [5126], + gl2: true + }, + [34836]: { + dataFormat: 6408, + types: [5126], + gl2: true + } + }; + var DATA_FORMAT_CHANNELS = { + [6403]: 1, + [36244]: 1, + [33319]: 2, + [33320]: 2, + [6407]: 3, + [36248]: 3, + [6408]: 4, + [36249]: 4, + [6402]: 1, + [34041]: 1, + [6406]: 1, + [6409]: 1, + [6410]: 2 + }; + var TYPE_SIZES = { + [5126]: 4, + [5125]: 4, + [5124]: 4, + [5123]: 2, + [5122]: 2, + [5131]: 2, + [5120]: 1, + [5121]: 1 + }; + function isFormatSupported(gl, format) { + const info = TEXTURE_FORMATS[format]; + if (!info) { + return false; + } + if (info.gl1 === void 0 && info.gl2 === void 0) { + return true; + } + const value = isWebGL2(gl) ? info.gl2 || info.gl1 : info.gl1; + return typeof value === "string" ? gl.getExtension(value) : value; + } + function isLinearFilteringSupported(gl, format) { + const info = TEXTURE_FORMATS[format]; + switch (info && info.types[0]) { + case 5126: + return gl.getExtension("OES_texture_float_linear"); + case 5131: + return gl.getExtension("OES_texture_half_float_linear"); + default: + return true; + } + } + + // node_modules/@luma.gl/webgl/dist/esm/classes/texture.js + var NPOT_MIN_FILTERS = [9729, 9728]; + var WebGLBuffer = globalThis.WebGLBuffer || function WebGLBuffer2() { + }; + var Texture = class extends Resource { + get [Symbol.toStringTag]() { + return "Texture"; + } + static isSupported(gl) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const { + format, + linearFiltering + } = opts; + let supported = true; + if (format) { + supported = supported && isFormatSupported(gl, format); + supported = supported && (!linearFiltering || isLinearFilteringSupported(gl, format)); + } + return supported; + } + constructor(gl, props) { + const { + id = uid("texture"), + handle, + target + } = props; + super(gl, { + id, + handle + }); + this.target = target; + this.textureUnit = void 0; + this.loaded = false; + this.width = void 0; + this.height = void 0; + this.depth = void 0; + this.format = void 0; + this.type = void 0; + this.dataFormat = void 0; + this.border = void 0; + this.textureUnit = void 0; + this.mipmaps = void 0; + } + toString() { + return "Texture(".concat(this.id, ",").concat(this.width, "x").concat(this.height, ")"); + } + initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + let data = props.data; + if (data instanceof Promise) { + data.then((resolvedImageData) => this.initialize(Object.assign({}, props, { + pixels: resolvedImageData, + data: resolvedImageData + }))); + return this; + } + const isVideo = typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement; + if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) { + this._video = null; + data.addEventListener("loadeddata", () => this.initialize(props)); + return this; + } + const { + pixels = null, + format = 6408, + border = 0, + recreate = false, + parameters = {}, + pixelStore = {}, + textureUnit = void 0 + } = props; + if (!data) { + data = pixels; + } + let { + width, + height, + dataFormat, + type, + compressed = false, + mipmaps = true + } = props; + const { + depth = 0 + } = props; + ({ + width, + height, + compressed, + dataFormat, + type + } = this._deduceParameters({ + format, + type, + dataFormat, + compressed, + data, + width, + height + })); + this.width = width; + this.height = height; + this.depth = depth; + this.format = format; + this.type = type; + this.dataFormat = dataFormat; + this.border = border; + this.textureUnit = textureUnit; + if (Number.isFinite(this.textureUnit)) { + this.gl.activeTexture(33984 + this.textureUnit); + this.gl.bindTexture(this.target, this.handle); + } + if (mipmaps && this._isNPOT()) { + log2.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))(); + mipmaps = false; + this._updateForNPOT(parameters); + } + this.mipmaps = mipmaps; + this.setImageData({ + data, + width, + height, + depth, + format, + type, + dataFormat, + border, + mipmaps, + parameters: pixelStore, + compressed + }); + if (mipmaps) { + this.generateMipmap(); + } + this.setParameters(parameters); + if (recreate) { + this.data = data; + } + if (isVideo) { + this._video = { + video: data, + parameters, + lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1 + }; + } + return this; + } + update() { + if (this._video) { + const { + video, + parameters, + lastTime + } = this._video; + if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) { + return; + } + this.setSubImageData({ + data: video, + parameters + }); + if (this.mipmaps) { + this.generateMipmap(); + } + this._video.lastTime = video.currentTime; + } + } + resize(_ref) { + let { + height, + width, + mipmaps = false + } = _ref; + if (width !== this.width || height !== this.height) { + return this.initialize({ + width, + height, + format: this.format, + type: this.type, + dataFormat: this.dataFormat, + border: this.border, + mipmaps + }); + } + return this; + } + generateMipmap() { + let params = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (this._isNPOT()) { + log2.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))(); + return this; + } + this.mipmaps = true; + this.gl.bindTexture(this.target, this.handle); + withParameters(this.gl, params, () => { + this.gl.generateMipmap(this.target); + }); + this.gl.bindTexture(this.target, null); + return this; + } + setImageData(options) { + this._trackDeallocatedMemory("Texture"); + const { + target = this.target, + pixels = null, + level = 0, + format = this.format, + border = this.border, + offset = 0, + parameters = {} + } = options; + let { + data = null, + type = this.type, + width = this.width, + height = this.height, + dataFormat = this.dataFormat, + compressed = false + } = options; + if (!data) { + data = pixels; + } + ({ + type, + dataFormat, + compressed, + width, + height + } = this._deduceParameters({ + format, + type, + dataFormat, + compressed, + data, + width, + height + })); + const { + gl + } = this; + gl.bindTexture(this.target, this.handle); + let dataType = null; + ({ + data, + dataType + } = this._getDataType({ + data, + compressed + })); + let gl2; + let compressedTextureSize = 0; + withParameters(this.gl, parameters, () => { + switch (dataType) { + case "null": + gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data); + break; + case "typed-array": + gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data, offset); + break; + case "buffer": + gl2 = assertWebGL2Context(gl); + gl2.bindBuffer(35052, data.handle || data); + gl2.texImage2D(target, level, format, width, height, border, dataFormat, type, offset); + gl2.bindBuffer(35052, null); + break; + case "browser-object": + if (isWebGL2(gl)) { + gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data); + } else { + gl.texImage2D(target, level, format, dataFormat, type, data); + } + break; + case "compressed": + for (const [levelIndex, levelData] of data.entries()) { + gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, border, levelData.data); + compressedTextureSize += levelData.levelSize; + } + break; + default: + assert6(false, "Unknown image data type"); + } + }); + if (dataType === "compressed") { + this._trackAllocatedMemory(compressedTextureSize, "Texture"); + } else if (data && data.byteLength) { + this._trackAllocatedMemory(data.byteLength, "Texture"); + } else { + const channels2 = DATA_FORMAT_CHANNELS[this.dataFormat] || 4; + const channelSize = TYPE_SIZES[this.type] || 1; + this._trackAllocatedMemory(this.width * this.height * channels2 * channelSize, "Texture"); + } + this.loaded = true; + return this; + } + setSubImageData(_ref2) { + let { + target = this.target, + pixels = null, + data = null, + x: x2 = 0, + y: y2 = 0, + width = this.width, + height = this.height, + level = 0, + format = this.format, + type = this.type, + dataFormat = this.dataFormat, + compressed = false, + offset = 0, + border = this.border, + parameters = {} + } = _ref2; + ({ + type, + dataFormat, + compressed, + width, + height + } = this._deduceParameters({ + format, + type, + dataFormat, + compressed, + data, + width, + height + })); + assert6(this.depth === 0, "texSubImage not supported for 3D textures"); + if (!data) { + data = pixels; + } + if (data && data.data) { + const ndarray = data; + data = ndarray.data; + width = ndarray.shape[0]; + height = ndarray.shape[1]; + } + if (data instanceof Buffer2) { + data = data.handle; + } + this.gl.bindTexture(this.target, this.handle); + withParameters(this.gl, parameters, () => { + if (compressed) { + this.gl.compressedTexSubImage2D(target, level, x2, y2, width, height, format, data); + } else if (data === null) { + this.gl.texSubImage2D(target, level, x2, y2, width, height, dataFormat, type, null); + } else if (ArrayBuffer.isView(data)) { + this.gl.texSubImage2D(target, level, x2, y2, width, height, dataFormat, type, data, offset); + } else if (data instanceof WebGLBuffer) { + const gl2 = assertWebGL2Context(this.gl); + gl2.bindBuffer(35052, data); + gl2.texSubImage2D(target, level, x2, y2, width, height, dataFormat, type, offset); + gl2.bindBuffer(35052, null); + } else if (isWebGL2(this.gl)) { + const gl2 = assertWebGL2Context(this.gl); + gl2.texSubImage2D(target, level, x2, y2, width, height, dataFormat, type, data); + } else { + this.gl.texSubImage2D(target, level, x2, y2, dataFormat, type, data); + } + }); + this.gl.bindTexture(this.target, null); + } + copyFramebuffer() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + log2.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")(); + return null; + } + getActiveUnit() { + return this.gl.getParameter(34016) - 33984; + } + bind() { + let textureUnit = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.textureUnit; + const { + gl + } = this; + if (textureUnit !== void 0) { + this.textureUnit = textureUnit; + gl.activeTexture(33984 + textureUnit); + } + gl.bindTexture(this.target, this.handle); + return textureUnit; + } + unbind() { + let textureUnit = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.textureUnit; + const { + gl + } = this; + if (textureUnit !== void 0) { + this.textureUnit = textureUnit; + gl.activeTexture(33984 + textureUnit); + } + gl.bindTexture(this.target, null); + return textureUnit; + } + _getDataType(_ref3) { + let { + data, + compressed = false + } = _ref3; + if (compressed) { + return { + data, + dataType: "compressed" + }; + } + if (data === null) { + return { + data, + dataType: "null" + }; + } + if (ArrayBuffer.isView(data)) { + return { + data, + dataType: "typed-array" + }; + } + if (data instanceof Buffer2) { + return { + data: data.handle, + dataType: "buffer" + }; + } + if (data instanceof WebGLBuffer) { + return { + data, + dataType: "buffer" + }; + } + return { + data, + dataType: "browser-object" + }; + } + _deduceParameters(opts) { + const { + format, + data + } = opts; + let { + width, + height, + dataFormat, + type, + compressed + } = opts; + const textureFormat = TEXTURE_FORMATS[format]; + dataFormat = dataFormat || textureFormat && textureFormat.dataFormat; + type = type || textureFormat && textureFormat.types[0]; + compressed = compressed || textureFormat && textureFormat.compressed; + ({ + width, + height + } = this._deduceImageSize(data, width, height)); + return { + dataFormat, + type, + compressed, + width, + height, + format, + data + }; + } + _deduceImageSize(data, width, height) { + let size; + if (typeof ImageData !== "undefined" && data instanceof ImageData) { + size = { + width: data.width, + height: data.height + }; + } else if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) { + size = { + width: data.naturalWidth, + height: data.naturalHeight + }; + } else if (typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement) { + size = { + width: data.width, + height: data.height + }; + } else if (typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap) { + size = { + width: data.width, + height: data.height + }; + } else if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) { + size = { + width: data.videoWidth, + height: data.videoHeight + }; + } else if (!data) { + size = { + width: width >= 0 ? width : 1, + height: height >= 0 ? height : 1 + }; + } else { + size = { + width, + height + }; + } + assert6(size, "Could not deduced texture size"); + assert6(width === void 0 || size.width === width, "Deduced texture width does not match supplied width"); + assert6(height === void 0 || size.height === height, "Deduced texture height does not match supplied height"); + return size; + } + _createHandle() { + return this.gl.createTexture(); + } + _deleteHandle() { + this.gl.deleteTexture(this.handle); + this._trackDeallocatedMemory("Texture"); + } + _getParameter(pname) { + switch (pname) { + case 4096: + return this.width; + case 4097: + return this.height; + default: + this.gl.bindTexture(this.target, this.handle); + const value = this.gl.getTexParameter(this.target, pname); + this.gl.bindTexture(this.target, null); + return value; + } + } + _setParameter(pname, param) { + this.gl.bindTexture(this.target, this.handle); + param = this._getNPOTParam(pname, param); + switch (pname) { + case 33082: + case 33083: + this.gl.texParameterf(this.handle, pname, param); + break; + case 4096: + case 4097: + assert6(false); + break; + default: + this.gl.texParameteri(this.target, pname, param); + break; + } + this.gl.bindTexture(this.target, null); + return this; + } + _isNPOT() { + if (isWebGL2(this.gl)) { + return false; + } + if (!this.width || !this.height) { + return false; + } + return !isPowerOfTwo(this.width) || !isPowerOfTwo(this.height); + } + _updateForNPOT(parameters) { + if (parameters[this.gl.TEXTURE_MIN_FILTER] === void 0) { + parameters[this.gl.TEXTURE_MIN_FILTER] = this.gl.LINEAR; + } + if (parameters[this.gl.TEXTURE_WRAP_S] === void 0) { + parameters[this.gl.TEXTURE_WRAP_S] = this.gl.CLAMP_TO_EDGE; + } + if (parameters[this.gl.TEXTURE_WRAP_T] === void 0) { + parameters[this.gl.TEXTURE_WRAP_T] = this.gl.CLAMP_TO_EDGE; + } + } + _getNPOTParam(pname, param) { + if (this._isNPOT()) { + switch (pname) { + case 10241: + if (NPOT_MIN_FILTERS.indexOf(param) === -1) { + param = 9729; + } + break; + case 10242: + case 10243: + if (param !== 33071) { + param = 33071; + } + break; + default: + break; + } + } + return param; + } + }; + + // node_modules/@luma.gl/webgl/dist/esm/utils/load-file.js + var pathPrefix2 = ""; + function loadImage(url, opts) { + assert6(typeof url === "string"); + url = pathPrefix2 + url; + return new Promise((resolve2, reject) => { + try { + const image = new Image(); + image.onload = () => resolve2(image); + image.onerror = () => reject(new Error("Could not load image ".concat(url, "."))); + image.crossOrigin = opts && opts.crossOrigin || "anonymous"; + image.src = url; + } catch (error2) { + reject(error2); + } + }); + } + + // node_modules/@luma.gl/webgl/dist/esm/classes/texture-2d.js + var Texture2D = class extends Texture { + get [Symbol.toStringTag]() { + return "Texture2D"; + } + static isSupported(gl, opts) { + return Texture.isSupported(gl, opts); + } + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + assertWebGLContext(gl); + if (props instanceof Promise || typeof props === "string") { + props = { + data: props + }; + } + if (typeof props.data === "string") { + props = Object.assign({}, props, { + data: loadImage(props.data) + }); + } + super(gl, Object.assign({}, props, { + target: 3553 + })); + this.initialize(props); + Object.seal(this); + } + }; + + // node_modules/@luma.gl/webgl/dist/esm/classes/texture-cube.js + var FACES = [34069, 34070, 34071, 34072, 34073, 34074]; + var TextureCube = class extends Texture { + get [Symbol.toStringTag]() { + return "TextureCube"; + } + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + assertWebGLContext(gl); + super(gl, Object.assign({}, props, { + target: 34067 + })); + this.initialize(props); + Object.seal(this); + } + initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + mipmaps = true, + parameters = {} + } = props; + this.opts = props; + this.setCubeMapImageData(props).then(() => { + this.loaded = true; + if (mipmaps) { + this.generateMipmap(props); + } + this.setParameters(parameters); + }); + return this; + } + subImage(_ref) { + let { + face, + data, + x: x2 = 0, + y: y2 = 0, + mipmapLevel = 0 + } = _ref; + return this._subImage({ + target: face, + data, + x: x2, + y: y2, + mipmapLevel + }); + } + async setCubeMapImageData(_ref2) { + let { + width, + height, + pixels, + data, + border = 0, + format = 6408, + type = 5121 + } = _ref2; + const { + gl + } = this; + const imageDataMap = pixels || data; + const resolvedFaces = await Promise.all(FACES.map((face) => { + const facePixels = imageDataMap[face]; + return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]); + })); + this.bind(); + FACES.forEach((face, index) => { + if (resolvedFaces[index].length > 1 && this.opts.mipmaps !== false) { + log2.warn("".concat(this.id, " has mipmap and multiple LODs."))(); + } + resolvedFaces[index].forEach((image, lodLevel) => { + if (width && height) { + gl.texImage2D(face, lodLevel, format, width, height, border, format, type, image); + } else { + gl.texImage2D(face, lodLevel, format, format, type, image); + } + }); + }); + this.unbind(); + } + setImageDataForFace(options) { + const { + face, + width, + height, + pixels, + data, + border = 0, + format = 6408, + type = 5121 + } = options; + const { + gl + } = this; + const imageData = pixels || data; + this.bind(); + if (imageData instanceof Promise) { + imageData.then((resolvedImageData) => this.setImageDataForFace(Object.assign({}, options, { + face, + data: resolvedImageData, + pixels: resolvedImageData + }))); + } else if (this.width || this.height) { + gl.texImage2D(face, 0, format, width, height, border, format, type, imageData); + } else { + gl.texImage2D(face, 0, format, format, type, imageData); + } + return this; } - return ""; - } - - // node_modules/@loaders.gl/core/dist/esm/lib/utils/url-utils.js - var QUERY_STRING_PATTERN = /\?.*/; - function extractQueryString(url) { - const matches3 = url.match(QUERY_STRING_PATTERN); - return matches3 && matches3[0]; - } - function stripQueryString(url) { - return url.replace(QUERY_STRING_PATTERN, ""); - } + }; + TextureCube.FACES = FACES; - // node_modules/@loaders.gl/core/dist/esm/lib/utils/resource-utils.js - function getResourceUrl(resource) { - if (isResponse(resource)) { - const response = resource; - return response.url; + // node_modules/@luma.gl/webgl/dist/esm/classes/texture-3d.js + var Texture3D = class extends Texture { + get [Symbol.toStringTag]() { + return "Texture3D"; } - if (isBlob(resource)) { - const blob = resource; - return blob.name || ""; + static isSupported(gl) { + return isWebGL2(gl); } - if (typeof resource === "string") { - return resource; + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + assertWebGL2Context(gl); + props = Object.assign({ + depth: 1 + }, props, { + target: 32879, + unpackFlipY: false + }); + super(gl, props); + this.initialize(props); + Object.seal(this); } - return ""; - } - function getResourceMIMEType(resource) { - if (isResponse(resource)) { - const response = resource; - const contentTypeHeader = response.headers.get("content-type") || ""; - const noQueryUrl = stripQueryString(response.url); - return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl); + setImageData(_ref) { + let { + level = 0, + dataFormat = 6408, + width, + height, + depth = 1, + border = 0, + format, + type = 5121, + offset = 0, + data, + parameters = {} + } = _ref; + this._trackDeallocatedMemory("Texture"); + this.gl.bindTexture(this.target, this.handle); + withParameters(this.gl, parameters, () => { + if (ArrayBuffer.isView(data)) { + this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, border, format, type, data); + } + if (data instanceof Buffer2) { + this.gl.bindBuffer(35052, data.handle); + this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, border, format, type, offset); + } + }); + if (data && data.byteLength) { + this._trackAllocatedMemory(data.byteLength, "Texture"); + } else { + const channels2 = DATA_FORMAT_CHANNELS[this.dataFormat] || 4; + const channelSize = TYPE_SIZES[this.type] || 1; + this._trackAllocatedMemory(this.width * this.height * this.depth * channels2 * channelSize, "Texture"); + } + this.loaded = true; + return this; } - if (isBlob(resource)) { - const blob = resource; - return blob.type || ""; + }; + + // node_modules/@luma.gl/webgl/dist/esm/classes/renderbuffer-formats.js + var EXT_FLOAT_WEBGL2 = "EXT_color_buffer_float"; + var renderbuffer_formats_default = { + [33189]: { + bpp: 2 + }, + [33190]: { + gl2: true, + bpp: 3 + }, + [36012]: { + gl2: true, + bpp: 4 + }, + [36168]: { + bpp: 1 + }, + [34041]: { + bpp: 4 + }, + [35056]: { + gl2: true, + bpp: 4 + }, + [36013]: { + gl2: true, + bpp: 5 + }, + [32854]: { + bpp: 2 + }, + [36194]: { + bpp: 2 + }, + [32855]: { + bpp: 2 + }, + [33321]: { + gl2: true, + bpp: 1 + }, + [33330]: { + gl2: true, + bpp: 1 + }, + [33329]: { + gl2: true, + bpp: 1 + }, + [33332]: { + gl2: true, + bpp: 2 + }, + [33331]: { + gl2: true, + bpp: 2 + }, + [33334]: { + gl2: true, + bpp: 4 + }, + [33333]: { + gl2: true, + bpp: 4 + }, + [33323]: { + gl2: true, + bpp: 2 + }, + [33336]: { + gl2: true, + bpp: 2 + }, + [33335]: { + gl2: true, + bpp: 2 + }, + [33338]: { + gl2: true, + bpp: 4 + }, + [33337]: { + gl2: true, + bpp: 4 + }, + [33340]: { + gl2: true, + bpp: 8 + }, + [33339]: { + gl2: true, + bpp: 8 + }, + [32849]: { + gl2: true, + bpp: 3 + }, + [32856]: { + gl2: true, + bpp: 4 + }, + [32857]: { + gl2: true, + bpp: 4 + }, + [36220]: { + gl2: true, + bpp: 4 + }, + [36238]: { + gl2: true, + bpp: 4 + }, + [36975]: { + gl2: true, + bpp: 4 + }, + [36214]: { + gl2: true, + bpp: 8 + }, + [36232]: { + gl2: true, + bpp: 8 + }, + [36226]: { + gl2: true, + bpp: 16 + }, + [36208]: { + gl2: true, + bpp: 16 + }, + [33325]: { + gl2: EXT_FLOAT_WEBGL2, + bpp: 2 + }, + [33327]: { + gl2: EXT_FLOAT_WEBGL2, + bpp: 4 + }, + [34842]: { + gl2: EXT_FLOAT_WEBGL2, + bpp: 8 + }, + [33326]: { + gl2: EXT_FLOAT_WEBGL2, + bpp: 4 + }, + [33328]: { + gl2: EXT_FLOAT_WEBGL2, + bpp: 8 + }, + [34836]: { + gl2: EXT_FLOAT_WEBGL2, + bpp: 16 + }, + [35898]: { + gl2: EXT_FLOAT_WEBGL2, + bpp: 4 } - if (typeof resource === "string") { - return parseMIMETypeFromURL(resource); + }; + + // node_modules/@luma.gl/webgl/dist/esm/classes/renderbuffer.js + function isFormatSupported2(gl, format, formats) { + const info = formats[format]; + if (!info) { + return false; } - return ""; + const value = isWebGL2(gl) ? info.gl2 || info.gl1 : info.gl1; + if (typeof value === "string") { + return gl.getExtension(value); + } + return value; } - function getResourceContentLength(resource) { - if (isResponse(resource)) { - const response = resource; - return response.headers["content-length"] || -1; + var Renderbuffer = class extends Resource { + get [Symbol.toStringTag]() { + return "Renderbuffer"; } - if (isBlob(resource)) { - const blob = resource; - return blob.size; + static isSupported(gl) { + let { + format + } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : { + format: null + }; + return !format || isFormatSupported2(gl, format, renderbuffer_formats_default); } - if (typeof resource === "string") { - return resource.length; + static getSamplesForFormat(gl, _ref) { + let { + format + } = _ref; + return gl.getInternalformatParameter(36161, format, 32937); } - if (resource instanceof ArrayBuffer) { - return resource.byteLength; + constructor(gl) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + super(gl, opts); + this.initialize(opts); + Object.seal(this); } - if (ArrayBuffer.isView(resource)) { - return resource.byteLength; + initialize(_ref2) { + let { + format, + width = 1, + height = 1, + samples = 0 + } = _ref2; + assert6(format, "Needs format"); + this._trackDeallocatedMemory(); + this.gl.bindRenderbuffer(36161, this.handle); + if (samples !== 0 && isWebGL2(this.gl)) { + this.gl.renderbufferStorageMultisample(36161, samples, format, width, height); + } else { + this.gl.renderbufferStorage(36161, format, width, height); + } + this.format = format; + this.width = width; + this.height = height; + this.samples = samples; + this._trackAllocatedMemory(this.width * this.height * (this.samples || 1) * renderbuffer_formats_default[this.format].bpp); + return this; } - return -1; - } - - // node_modules/@loaders.gl/core/dist/esm/lib/utils/response-utils.js - async function makeResponse(resource) { - if (isResponse(resource)) { - return resource; + resize(_ref3) { + let { + width, + height + } = _ref3; + if (width !== this.width || height !== this.height) { + return this.initialize({ + width, + height, + format: this.format, + samples: this.samples + }); + } + return this; } - const headers = {}; - const contentLength = getResourceContentLength(resource); - if (contentLength >= 0) { - headers["content-length"] = String(contentLength); + _createHandle() { + return this.gl.createRenderbuffer(); } - const url = getResourceUrl(resource); - const type = getResourceMIMEType(resource); - if (type) { - headers["content-type"] = type; + _deleteHandle() { + this.gl.deleteRenderbuffer(this.handle); + this._trackDeallocatedMemory(); } - const initialDataUrl = await getInitialDataUrl(resource); - if (initialDataUrl) { - headers["x-first-bytes"] = initialDataUrl; + _bindHandle(handle) { + this.gl.bindRenderbuffer(36161, handle); } - if (typeof resource === "string") { - resource = new TextEncoder().encode(resource); + _syncHandle(handle) { + this.format = this.getParameter(36164); + this.width = this.getParameter(36162); + this.height = this.getParameter(36163); + this.samples = this.getParameter(36011); } - const response = new Response(resource, { - headers - }); - Object.defineProperty(response, "url", { - value: url - }); - return response; - } - async function checkResponse(response) { - if (!response.ok) { - const message = await getResponseError(response); - throw new Error(message); + _getParameter(pname) { + this.gl.bindRenderbuffer(36161, this.handle); + const value = this.gl.getRenderbufferParameter(36161, pname); + return value; } - } - async function getResponseError(response) { - let message = "Failed to fetch resource ".concat(response.url, " (").concat(response.status, "): "); - try { - const contentType = response.headers.get("Content-Type"); - let text = response.statusText; - if (contentType.includes("application/json")) { - text += " ".concat(await response.text()); - } - message += text; - message = message.length > 60 ? "".concat(message.slice(0, 60), "...") : message; - } catch (error2) { + }; + + // node_modules/@luma.gl/webgl/dist/esm/classes/clear.js + var GL_DEPTH_BUFFER_BIT = 256; + var GL_STENCIL_BUFFER_BIT = 1024; + var GL_COLOR_BUFFER_BIT = 16384; + var GL_COLOR = 6144; + var GL_DEPTH = 6145; + var GL_STENCIL = 6146; + var GL_DEPTH_STENCIL = 34041; + var ERR_ARGUMENTS = "clear: bad arguments"; + function clear(gl) { + let { + framebuffer = null, + color = null, + depth = null, + stencil = null + } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const parameters = {}; + if (framebuffer) { + parameters.framebuffer = framebuffer; } - return message; - } - async function getInitialDataUrl(resource) { - const INITIAL_DATA_LENGTH = 5; - if (typeof resource === "string") { - return "data:,".concat(resource.slice(0, INITIAL_DATA_LENGTH)); + let clearFlags = 0; + if (color) { + clearFlags |= GL_COLOR_BUFFER_BIT; + if (color !== true) { + parameters.clearColor = color; + } } - if (resource instanceof Blob) { - const blobSlice = resource.slice(0, 5); - return await new Promise((resolve2) => { - const reader = new FileReader(); - reader.onload = (event) => { - var _event$target; - return resolve2(event === null || event === void 0 ? void 0 : (_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.result); - }; - reader.readAsDataURL(blobSlice); - }); + if (depth) { + clearFlags |= GL_DEPTH_BUFFER_BIT; + if (depth !== true) { + parameters.clearDepth = depth; + } } - if (resource instanceof ArrayBuffer) { - const slice = resource.slice(0, INITIAL_DATA_LENGTH); - const base64 = arrayBufferToBase64(slice); - return "data:base64,".concat(base64); + if (stencil) { + clearFlags |= GL_STENCIL_BUFFER_BIT; + if (depth !== true) { + parameters.clearStencil = depth; + } } - return null; + assert6(clearFlags !== 0, ERR_ARGUMENTS); + withParameters(gl, parameters, () => { + gl.clear(clearFlags); + }); } - function arrayBufferToBase64(buffer) { - let binary = ""; - const bytes = new Uint8Array(buffer); - for (let i2 = 0; i2 < bytes.byteLength; i2++) { - binary += String.fromCharCode(bytes[i2]); - } - return btoa(binary); + function clearBuffer(gl) { + let { + framebuffer = null, + buffer = GL_COLOR, + drawBuffer = 0, + value = [0, 0, 0, 0] + } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + assertWebGL2Context(gl); + withParameters(gl, { + framebuffer + }, () => { + switch (buffer) { + case GL_COLOR: + switch (value.constructor) { + case Int32Array: + gl.clearBufferiv(buffer, drawBuffer, value); + break; + case Uint32Array: + gl.clearBufferuiv(buffer, drawBuffer, value); + break; + case Float32Array: + default: + gl.clearBufferfv(buffer, drawBuffer, value); + } + break; + case GL_DEPTH: + gl.clearBufferfv(GL_DEPTH, 0, [value]); + break; + case GL_STENCIL: + gl.clearBufferiv(GL_STENCIL, 0, [value]); + break; + case GL_DEPTH_STENCIL: + const [depth, stencil] = value; + gl.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil); + break; + default: + assert6(false, ERR_ARGUMENTS); + } + }); } - // node_modules/@loaders.gl/core/dist/esm/lib/fetch/fetch-file.js - async function fetchFile(url, options) { - if (typeof url === "string") { - url = resolvePath(url); - let fetchOptions = options; - if (options !== null && options !== void 0 && options.fetch && typeof (options === null || options === void 0 ? void 0 : options.fetch) !== "function") { - fetchOptions = options.fetch; - } - return await fetch(url, fetchOptions); + // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/format-utils.js + function glFormatToComponents(format) { + switch (format) { + case 6406: + case 33326: + case 6403: + return 1; + case 33328: + case 33319: + return 2; + case 6407: + case 34837: + return 3; + case 6408: + case 34836: + return 4; + default: + assert6(false); + return 0; } - return await makeResponse(url); } - // node_modules/@loaders.gl/core/node_modules/@probe.gl/env/dist/lib/is-electron.js - function isElectron(mockUserAgent) { - if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") { - return true; - } - if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) { - return true; + // node_modules/@luma.gl/webgl/dist/esm/classes/copy-and-blit.js + function readPixelsToArray(source) { + let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const { + sourceX = 0, + sourceY = 0, + sourceFormat = 6408 + } = options; + let { + sourceAttachment = 36064, + target = null, + sourceWidth, + sourceHeight, + sourceType + } = options; + const { + framebuffer, + deleteFramebuffer + } = getFramebuffer(source); + assert6(framebuffer); + const { + gl, + handle, + attachments + } = framebuffer; + sourceWidth = sourceWidth || framebuffer.width; + sourceHeight = sourceHeight || framebuffer.height; + if (sourceAttachment === 36064 && handle === null) { + sourceAttachment = 1028; } - const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent; - const userAgent2 = mockUserAgent || realUserAgent; - if (userAgent2 && userAgent2.indexOf("Electron") >= 0) { - return true; + assert6(attachments[sourceAttachment]); + sourceType = sourceType || attachments[sourceAttachment].type; + target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight); + sourceType = sourceType || getGLTypeFromTypedArray(target); + const prevHandle = gl.bindFramebuffer(36160, handle); + gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target); + gl.bindFramebuffer(36160, prevHandle || null); + if (deleteFramebuffer) { + framebuffer.delete(); } - return false; - } - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/env/dist/lib/is-browser.js - function isBrowser3() { - const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser; - return !isNode || isElectron(); + return target; } - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/env/dist/lib/globals.js - var self_3 = globalThis.self || globalThis.window || globalThis.global; - var window_3 = globalThis.window || globalThis.self || globalThis.global; - var document_3 = globalThis.document || {}; - var process_ = globalThis.process || {}; - var console_ = globalThis.console; - var navigator_ = globalThis.navigator || {}; - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/env/dist/utils/globals.js - var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source"; - var isBrowser4 = isBrowser3(); - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/local-storage.js - function getStorage(type) { - try { - const storage = window[type]; - const x2 = "__storage_test__"; - storage.setItem(x2, x2); - storage.removeItem(x2); - return storage; - } catch (e2) { - return null; + function copyToDataUrl(source) { + let { + sourceAttachment = 36064, + targetMaxHeight = Number.MAX_SAFE_INTEGER + } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + let data = readPixelsToArray(source, { + sourceAttachment + }); + let { + width, + height + } = source; + while (height > targetMaxHeight) { + ({ + data, + width, + height + } = scalePixels2({ + data, + width, + height + })); } + flipRows({ + data, + width, + height + }); + const canvas = document.createElement("canvas"); + canvas.width = width; + canvas.height = height; + const context = canvas.getContext("2d"); + const imageData = context.createImageData(width, height); + imageData.data.set(data); + context.putImageData(imageData, 0, 0); + return canvas.toDataURL(); } - var LocalStorage = class { - constructor(id, defaultConfig) { - let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage"; - this.storage = void 0; - this.id = void 0; - this.config = void 0; - this.storage = getStorage(type); - this.id = id; - this.config = defaultConfig; - this._loadConfiguration(); - } - getConfiguration() { - return this.config; - } - setConfiguration(configuration) { - Object.assign(this.config, configuration); - if (this.storage) { - const serialized = JSON.stringify(this.config); - this.storage.setItem(this.id, serialized); + function copyToTexture(source, target) { + let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + const { + sourceX = 0, + sourceY = 0, + targetMipmaplevel = 0, + targetInternalFormat = 6408 + } = options; + let { + targetX, + targetY, + targetZ, + width, + height + } = options; + const { + framebuffer, + deleteFramebuffer + } = getFramebuffer(source); + assert6(framebuffer); + const { + gl, + handle + } = framebuffer; + const isSubCopy = typeof targetX !== "undefined" || typeof targetY !== "undefined" || typeof targetZ !== "undefined"; + targetX = targetX || 0; + targetY = targetY || 0; + targetZ = targetZ || 0; + const prevHandle = gl.bindFramebuffer(36160, handle); + assert6(target); + let texture = null; + if (target instanceof Texture) { + texture = target; + width = Number.isFinite(width) ? width : texture.width; + height = Number.isFinite(height) ? height : texture.height; + texture.bind(0); + target = texture.target; + } + if (!isSubCopy) { + gl.copyTexImage2D(target, targetMipmaplevel, targetInternalFormat, sourceX, sourceY, width, height, 0); + } else { + switch (target) { + case 3553: + case 34067: + gl.copyTexSubImage2D(target, targetMipmaplevel, targetX, targetY, sourceX, sourceY, width, height); + break; + case 35866: + case 32879: + const gl2 = assertWebGL2Context(gl); + gl2.copyTexSubImage3D(target, targetMipmaplevel, targetX, targetY, targetZ, sourceX, sourceY, width, height); + break; + default: } } - _loadConfiguration() { - let configuration = {}; - if (this.storage) { - const serializedConfiguration = this.storage.getItem(this.id); - configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {}; - } - Object.assign(this.config, configuration); - return this; + if (texture) { + texture.unbind(); } - }; - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/formatters.js - function formatTime(ms) { - let formatted; - if (ms < 10) { - formatted = `${ms.toFixed(2)}ms`; - } else if (ms < 100) { - formatted = `${ms.toFixed(1)}ms`; - } else if (ms < 1e3) { - formatted = `${ms.toFixed(0)}ms`; - } else { - formatted = `${(ms / 1e3).toFixed(2)}s`; + gl.bindFramebuffer(36160, prevHandle || null); + if (deleteFramebuffer) { + framebuffer.delete(); } - return formatted; - } - function leftPad(string) { - let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8; - const padLength = Math.max(length - string.length, 0); - return `${" ".repeat(padLength)}${string}`; + return texture; } - function formatImage(image, message, scale3) { - let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600; - const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29"); - if (image.width > maxWidth) { - scale3 = Math.min(scale3, maxWidth / image.width); + function getFramebuffer(source) { + if (!(source instanceof Framebuffer)) { + return { + framebuffer: toFramebuffer(source), + deleteFramebuffer: true + }; } - const width = image.width * scale3; - const height = image.height * scale3; - const style = ["font-size:1px;", `padding:${Math.floor(height / 2)}px ${Math.floor(width / 2)}px;`, `line-height:${height}px;`, `background:url(${imageUrl});`, `background-size:${width}px ${height}px;`, "color:transparent;"].join(""); - return [`${message} %c+`, style]; + return { + framebuffer: source, + deleteFramebuffer: false + }; } - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/color.js - var COLOR; - (function(COLOR3) { - COLOR3[COLOR3["BLACK"] = 30] = "BLACK"; - COLOR3[COLOR3["RED"] = 31] = "RED"; - COLOR3[COLOR3["GREEN"] = 32] = "GREEN"; - COLOR3[COLOR3["YELLOW"] = 33] = "YELLOW"; - COLOR3[COLOR3["BLUE"] = 34] = "BLUE"; - COLOR3[COLOR3["MAGENTA"] = 35] = "MAGENTA"; - COLOR3[COLOR3["CYAN"] = 36] = "CYAN"; - COLOR3[COLOR3["WHITE"] = 37] = "WHITE"; - COLOR3[COLOR3["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK"; - COLOR3[COLOR3["BRIGHT_RED"] = 91] = "BRIGHT_RED"; - COLOR3[COLOR3["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN"; - COLOR3[COLOR3["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW"; - COLOR3[COLOR3["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE"; - COLOR3[COLOR3["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA"; - COLOR3[COLOR3["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN"; - COLOR3[COLOR3["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE"; - })(COLOR || (COLOR = {})); - var BACKGROUND_INCREMENT = 10; - function getColor(color) { - if (typeof color !== "string") { - return color; + function getPixelArray(pixelArray, type, format, width, height) { + if (pixelArray) { + return pixelArray; } - color = color.toUpperCase(); - return COLOR[color] || COLOR.WHITE; + type = type || 5121; + const ArrayType = getTypedArrayFromGLType(type, { + clamped: false + }); + const components = glFormatToComponents(format); + return new ArrayType(width * height * components); } - function addColor(string, color, background) { - if (!isBrowser3 && typeof string === "string") { - if (color) { - const colorCode = getColor(color); - string = `\x1B[${colorCode}m${string}\x1B[39m`; - } - if (background) { - const colorCode = getColor(background); - string = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string}\x1B[49m`; + + // node_modules/@luma.gl/webgl/dist/esm/features/webgl-features-table.js + var FEATURES = { + WEBGL2: "WEBGL2", + VERTEX_ARRAY_OBJECT: "VERTEX_ARRAY_OBJECT", + TIMER_QUERY: "TIMER_QUERY", + INSTANCED_RENDERING: "INSTANCED_RENDERING", + MULTIPLE_RENDER_TARGETS: "MULTIPLE_RENDER_TARGETS", + ELEMENT_INDEX_UINT32: "ELEMENT_INDEX_UINT32", + BLEND_EQUATION_MINMAX: "BLEND_EQUATION_MINMAX", + FLOAT_BLEND: "FLOAT_BLEND", + COLOR_ENCODING_SRGB: "COLOR_ENCODING_SRGB", + TEXTURE_DEPTH: "TEXTURE_DEPTH", + TEXTURE_FLOAT: "TEXTURE_FLOAT", + TEXTURE_HALF_FLOAT: "TEXTURE_HALF_FLOAT", + TEXTURE_FILTER_LINEAR_FLOAT: "TEXTURE_FILTER_LINEAR_FLOAT", + TEXTURE_FILTER_LINEAR_HALF_FLOAT: "TEXTURE_FILTER_LINEAR_HALF_FLOAT", + TEXTURE_FILTER_ANISOTROPIC: "TEXTURE_FILTER_ANISOTROPIC", + COLOR_ATTACHMENT_RGBA32F: "COLOR_ATTACHMENT_RGBA32F", + COLOR_ATTACHMENT_FLOAT: "COLOR_ATTACHMENT_FLOAT", + COLOR_ATTACHMENT_HALF_FLOAT: "COLOR_ATTACHMENT_HALF_FLOAT", + GLSL_FRAG_DATA: "GLSL_FRAG_DATA", + GLSL_FRAG_DEPTH: "GLSL_FRAG_DEPTH", + GLSL_DERIVATIVES: "GLSL_DERIVATIVES", + GLSL_TEXTURE_LOD: "GLSL_TEXTURE_LOD" + }; + function checkFloat32ColorAttachment(gl) { + const testTexture = new Texture2D(gl, { + format: 6408, + type: 5126, + dataFormat: 6408 + }); + const testFb = new Framebuffer(gl, { + id: "test-framebuffer", + check: false, + attachments: { + [36064]: testTexture } - } - return string; + }); + const status = testFb.getStatus(); + testTexture.delete(); + testFb.delete(); + return status === 36053; } + var webgl_features_table_default = { + [FEATURES.WEBGL2]: [false, true], + [FEATURES.VERTEX_ARRAY_OBJECT]: ["OES_vertex_array_object", true], + [FEATURES.TIMER_QUERY]: ["EXT_disjoint_timer_query", "EXT_disjoint_timer_query_webgl2"], + [FEATURES.INSTANCED_RENDERING]: ["ANGLE_instanced_arrays", true], + [FEATURES.MULTIPLE_RENDER_TARGETS]: ["WEBGL_draw_buffers", true], + [FEATURES.ELEMENT_INDEX_UINT32]: ["OES_element_index_uint", true], + [FEATURES.BLEND_EQUATION_MINMAX]: ["EXT_blend_minmax", true], + [FEATURES.FLOAT_BLEND]: ["EXT_float_blend"], + [FEATURES.COLOR_ENCODING_SRGB]: ["EXT_sRGB", true], + [FEATURES.TEXTURE_DEPTH]: ["WEBGL_depth_texture", true], + [FEATURES.TEXTURE_FLOAT]: ["OES_texture_float", true], + [FEATURES.TEXTURE_HALF_FLOAT]: ["OES_texture_half_float", true], + [FEATURES.TEXTURE_FILTER_LINEAR_FLOAT]: ["OES_texture_float_linear"], + [FEATURES.TEXTURE_FILTER_LINEAR_HALF_FLOAT]: ["OES_texture_half_float_linear"], + [FEATURES.TEXTURE_FILTER_ANISOTROPIC]: ["EXT_texture_filter_anisotropic"], + [FEATURES.COLOR_ATTACHMENT_RGBA32F]: [checkFloat32ColorAttachment, "EXT_color_buffer_float"], + [FEATURES.COLOR_ATTACHMENT_FLOAT]: [false, "EXT_color_buffer_float"], + [FEATURES.COLOR_ATTACHMENT_HALF_FLOAT]: ["EXT_color_buffer_half_float"], + [FEATURES.GLSL_FRAG_DATA]: ["WEBGL_draw_buffers", true], + [FEATURES.GLSL_FRAG_DEPTH]: ["EXT_frag_depth", true], + [FEATURES.GLSL_DERIVATIVES]: ["OES_standard_derivatives", true], + [FEATURES.GLSL_TEXTURE_LOD]: ["EXT_shader_texture_lod", true] + }; - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/autobind.js - function autobind(obj) { - let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"]; - const proto = Object.getPrototypeOf(obj); - const propNames = Object.getOwnPropertyNames(proto); - const object = obj; - for (const key of propNames) { - const value = object[key]; - if (typeof value === "function") { - if (!predefined.find((name) => key === name)) { - object[key] = value.bind(obj); - } + // node_modules/@luma.gl/webgl/dist/esm/features/features.js + var LOG_UNSUPPORTED_FEATURE = 2; + function hasFeature(gl, feature) { + return hasFeatures(gl, feature); + } + function hasFeatures(gl, features) { + features = Array.isArray(features) ? features : [features]; + return features.every((feature) => { + return isFeatureSupported(gl, feature); + }); + } + function getFeatures(gl) { + gl.luma = gl.luma || {}; + gl.luma.caps = gl.luma.caps || {}; + for (const cap in webgl_features_table_default) { + if (gl.luma.caps[cap] === void 0) { + gl.luma.caps[cap] = isFeatureSupported(gl, cap); } } + return gl.luma.caps; } - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/assert.js - function assert3(condition, message) { - if (!condition) { - throw new Error(message || "Assertion failed"); + function isFeatureSupported(gl, cap) { + gl.luma = gl.luma || {}; + gl.luma.caps = gl.luma.caps || {}; + if (gl.luma.caps[cap] === void 0) { + gl.luma.caps[cap] = queryFeature(gl, cap); + } + if (!gl.luma.caps[cap]) { + log2.log(LOG_UNSUPPORTED_FEATURE, "Feature: ".concat(cap, " not supported"))(); } + return gl.luma.caps[cap]; } - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js - function getHiResTimestamp() { - let timestamp; - if (isBrowser3() && window_3.performance) { - var _window$performance, _window$performance$n; - timestamp = window_3 === null || window_3 === void 0 ? void 0 : (_window$performance = window_3.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance); - } else if ("hrtime" in process_) { - var _process$hrtime; - const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_); - timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; + function queryFeature(gl, cap) { + const feature = webgl_features_table_default[cap]; + assert6(feature, cap); + let isSupported; + const featureDefinition = isWebGL2(gl) ? feature[1] || feature[0] : feature[0]; + if (typeof featureDefinition === "function") { + isSupported = featureDefinition(gl); + } else if (Array.isArray(featureDefinition)) { + isSupported = true; + for (const extension of featureDefinition) { + isSupported = isSupported && Boolean(gl.getExtension(extension)); + } + } else if (typeof featureDefinition === "string") { + isSupported = Boolean(gl.getExtension(featureDefinition)); + } else if (typeof featureDefinition === "boolean") { + isSupported = featureDefinition; } else { - timestamp = Date.now(); + assert6(false); } - return timestamp; + return isSupported; } - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/log.js - var originalConsole = { - debug: isBrowser3() ? console.debug || console.log : console.log, - log: console.log, - info: console.info, - warn: console.warn, - error: console.error - }; - var DEFAULT_LOG_CONFIGURATION = { - enabled: true, - level: 0 - }; - function noop() { - } - var cache = {}; - var ONCE = { - once: true - }; - var Log = class { - constructor() { - let { - id - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : { - id: "" - }; - this.id = void 0; - this.VERSION = VERSION2; - this._startTs = getHiResTimestamp(); - this._deltaTs = getHiResTimestamp(); - this._storage = void 0; - this.userData = {}; - this.LOG_THROTTLE_TIMEOUT = 0; - this.id = id; - this.userData = {}; - this._storage = new LocalStorage(`__probe-${this.id}__`, DEFAULT_LOG_CONFIGURATION); - this.timeStamp(`${this.id} started`); - autobind(this); - Object.seal(this); + // node_modules/@luma.gl/webgl/dist/esm/classes/framebuffer.js + var ERR_MULTIPLE_RENDERTARGETS = "Multiple render targets not supported"; + var Framebuffer = class _Framebuffer extends Resource { + get [Symbol.toStringTag]() { + return "Framebuffer"; } - set level(newLevel) { - this.setLevel(newLevel); + static isSupported(gl) { + let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const { + colorBufferFloat, + colorBufferHalfFloat + } = options; + let supported = true; + if (colorBufferFloat) { + supported = Boolean(gl.getExtension("EXT_color_buffer_float") || gl.getExtension("WEBGL_color_buffer_float") || gl.getExtension("OES_texture_float")); + } + if (colorBufferHalfFloat) { + supported = supported && Boolean(gl.getExtension("EXT_color_buffer_float") || gl.getExtension("EXT_color_buffer_half_float")); + } + return supported; } - get level() { - return this.getLevel(); + static getDefaultFramebuffer(gl) { + gl.luma = gl.luma || {}; + gl.luma.defaultFramebuffer = gl.luma.defaultFramebuffer || new _Framebuffer(gl, { + id: "default-framebuffer", + handle: null, + attachments: {} + }); + return gl.luma.defaultFramebuffer; } - isEnabled() { - return this._storage.config.enabled; + get MAX_COLOR_ATTACHMENTS() { + const gl2 = assertWebGL2Context(this.gl); + return gl2.getParameter(gl2.MAX_COLOR_ATTACHMENTS); } - getLevel() { - return this._storage.config.level; + get MAX_DRAW_BUFFERS() { + const gl2 = assertWebGL2Context(this.gl); + return gl2.getParameter(gl2.MAX_DRAW_BUFFERS); } - getTotal() { - return Number((getHiResTimestamp() - this._startTs).toPrecision(10)); + constructor(gl) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + super(gl, opts); + this.width = null; + this.height = null; + this.attachments = {}; + this.readBuffer = 36064; + this.drawBuffers = [36064]; + this.ownResources = []; + this.initialize(opts); + Object.seal(this); } - getDelta() { - return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10)); + get color() { + return this.attachments[36064] || null; } - set priority(newPriority) { - this.level = newPriority; + get texture() { + return this.attachments[36064] || null; } - get priority() { - return this.level; + get depth() { + return this.attachments[36096] || this.attachments[33306] || null; } - getPriority() { - return this.level; + get stencil() { + return this.attachments[36128] || this.attachments[33306] || null; } - enable() { - let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; - this._storage.setConfiguration({ - enabled + initialize(_ref) { + let { + width = 1, + height = 1, + attachments = null, + color = true, + depth = true, + stencil = false, + check = true, + readBuffer = void 0, + drawBuffers = void 0 + } = _ref; + assert6(width >= 0 && height >= 0, "Width and height need to be integers"); + this.width = width; + this.height = height; + if (attachments) { + for (const attachment in attachments) { + const target = attachments[attachment]; + const object = Array.isArray(target) ? target[0] : target; + object.resize({ + width, + height + }); + } + } else { + attachments = this._createDefaultAttachments(color, depth, stencil, width, height); + } + this.update({ + clearAttachments: true, + attachments, + readBuffer, + drawBuffers }); + if (attachments && check) { + this.checkStatus(); + } + } + delete() { + for (const resource of this.ownResources) { + resource.delete(); + } + super.delete(); return this; } - setLevel(level) { - this._storage.setConfiguration({ - level + update(_ref2) { + let { + attachments = {}, + readBuffer, + drawBuffers, + clearAttachments = false, + resizeAttachments = true + } = _ref2; + this.attach(attachments, { + clearAttachments, + resizeAttachments }); + const { + gl + } = this; + const prevHandle = gl.bindFramebuffer(36160, this.handle); + if (readBuffer) { + this._setReadBuffer(readBuffer); + } + if (drawBuffers) { + this._setDrawBuffers(drawBuffers); + } + gl.bindFramebuffer(36160, prevHandle || null); return this; } - get(setting) { - return this._storage.config[setting]; + resize() { + let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + let { + width, + height + } = options; + if (this.handle === null) { + assert6(width === void 0 && height === void 0); + this.width = this.gl.drawingBufferWidth; + this.height = this.gl.drawingBufferHeight; + return this; + } + if (width === void 0) { + width = this.gl.drawingBufferWidth; + } + if (height === void 0) { + height = this.gl.drawingBufferHeight; + } + if (width !== this.width && height !== this.height) { + log2.log(2, "Resizing framebuffer ".concat(this.id, " to ").concat(width, "x").concat(height))(); + } + for (const attachmentPoint in this.attachments) { + this.attachments[attachmentPoint].resize({ + width, + height + }); + } + this.width = width; + this.height = height; + return this; } - set(setting, value) { - this._storage.setConfiguration({ - [setting]: value + attach(attachments) { + let { + clearAttachments = false, + resizeAttachments = true + } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const newAttachments = {}; + if (clearAttachments) { + Object.keys(this.attachments).forEach((key) => { + newAttachments[key] = null; + }); + } + Object.assign(newAttachments, attachments); + const prevHandle = this.gl.bindFramebuffer(36160, this.handle); + for (const key in newAttachments) { + assert6(key !== void 0, "Misspelled framebuffer binding point?"); + const attachment = Number(key); + const descriptor = newAttachments[attachment]; + let object = descriptor; + if (!object) { + this._unattach(attachment); + } else if (object instanceof Renderbuffer) { + this._attachRenderbuffer({ + attachment, + renderbuffer: object + }); + } else if (Array.isArray(descriptor)) { + const [texture, layer = 0, level = 0] = descriptor; + object = texture; + this._attachTexture({ + attachment, + texture, + layer, + level + }); + } else { + this._attachTexture({ + attachment, + texture: object, + layer: 0, + level: 0 + }); + } + if (resizeAttachments && object) { + object.resize({ + width: this.width, + height: this.height + }); + } + } + this.gl.bindFramebuffer(36160, prevHandle || null); + Object.assign(this.attachments, attachments); + Object.keys(this.attachments).filter((key) => !this.attachments[key]).forEach((key) => { + delete this.attachments[key]; }); } - settings() { - if (console.table) { - console.table(this._storage.config); - } else { - console.log(this._storage.config); + checkStatus() { + const { + gl + } = this; + const status = this.getStatus(); + if (status !== 36053) { + throw new Error(_getFrameBufferStatus(status)); } + return this; } - assert(condition, message) { - assert3(condition, message); - } - warn(message) { - return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE); + getStatus() { + const { + gl + } = this; + const prevHandle = gl.bindFramebuffer(36160, this.handle); + const status = gl.checkFramebufferStatus(36160); + gl.bindFramebuffer(36160, prevHandle || null); + return status; } - error(message) { - return this._getLogFunction(0, message, originalConsole.error, arguments); + clear() { + let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + color, + depth, + stencil, + drawBuffers = [] + } = options; + const prevHandle = this.gl.bindFramebuffer(36160, this.handle); + if (color || depth || stencil) { + clear(this.gl, { + color, + depth, + stencil + }); + } + drawBuffers.forEach((value, drawBuffer) => { + clearBuffer(this.gl, { + drawBuffer, + value + }); + }); + this.gl.bindFramebuffer(36160, prevHandle || null); + return this; } - deprecated(oldUsage, newUsage) { - return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`); + readPixels() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + log2.error("Framebuffer.readPixels() is no logner supported, use readPixelsToArray(framebuffer)")(); + return null; } - removed(oldUsage, newUsage) { - return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`); + readPixelsToBuffer() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + log2.error("Framebuffer.readPixelsToBuffer()is no logner supported, use readPixelsToBuffer(framebuffer)")(); + return null; } - probe(logLevel, message) { - return this._getLogFunction(logLevel, message, originalConsole.log, arguments, { - time: true, - once: true - }); + copyToDataUrl() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + log2.error("Framebuffer.copyToDataUrl() is no logner supported, use copyToDataUrl(framebuffer)")(); + return null; } - log(logLevel, message) { - return this._getLogFunction(logLevel, message, originalConsole.debug, arguments); + copyToImage() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + log2.error("Framebuffer.copyToImage() is no logner supported, use copyToImage(framebuffer)")(); + return null; } - info(logLevel, message) { - return this._getLogFunction(logLevel, message, console.info, arguments); + copyToTexture() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + log2.error("Framebuffer.copyToTexture({...}) is no logner supported, use copyToTexture(source, target, opts})")(); + return null; } - once(logLevel, message) { - return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE); + blit() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + log2.error("Framebuffer.blit({...}) is no logner supported, use blit(source, target, opts)")(); + return null; } - table(logLevel, table, columns) { - if (table) { - return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], { - tag: getTableHeader(table) - }); + invalidate(_ref3) { + let { + attachments = [], + x: x2 = 0, + y: y2 = 0, + width, + height + } = _ref3; + const gl2 = assertWebGL2Context(this.gl); + const prevHandle = gl2.bindFramebuffer(36008, this.handle); + const invalidateAll = x2 === 0 && y2 === 0 && width === void 0 && height === void 0; + if (invalidateAll) { + gl2.invalidateFramebuffer(36008, attachments); + } else { + gl2.invalidateFramebuffer(36008, attachments, x2, y2, width, height); } - return noop; + gl2.bindFramebuffer(36008, prevHandle); + return this; } - image(_ref) { - let { - logLevel, - priority, - image, - message = "", - scale: scale3 = 1 - } = _ref; - if (!this._shouldLog(logLevel || priority)) { - return noop; + getAttachmentParameter(attachment, pname, keys) { + let value = this._getAttachmentParameterFallback(pname); + if (value === null) { + this.gl.bindFramebuffer(36160, this.handle); + value = this.gl.getFramebufferAttachmentParameter(36160, attachment, pname); + this.gl.bindFramebuffer(36160, null); } - return isBrowser3() ? logImageInBrowser({ - image, - message, - scale: scale3 - }) : logImageInNode({ - image, - message, - scale: scale3 - }); + if (keys && value > 1e3) { + value = getKey(this.gl, value); + } + return value; } - time(logLevel, message) { - return this._getLogFunction(logLevel, message, console.time ? console.time : console.info); + getAttachmentParameters() { + let attachment = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 36064; + let keys = arguments.length > 1 ? arguments[1] : void 0; + let parameters = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : this.constructor.ATTACHMENT_PARAMETERS || []; + const values = {}; + for (const pname of parameters) { + const key = keys ? getKey(this.gl, pname) : pname; + values[key] = this.getAttachmentParameter(attachment, pname, keys); + } + return values; } - timeEnd(logLevel, message) { - return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info); + getParameters() { + let keys = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; + const attachments = Object.keys(this.attachments); + const parameters = {}; + for (const attachmentName of attachments) { + const attachment = Number(attachmentName); + const key = keys ? getKey(this.gl, attachment) : attachment; + parameters[key] = this.getAttachmentParameters(attachment, keys); + } + return parameters; } - timeStamp(logLevel, message) { - return this._getLogFunction(logLevel, message, console.timeStamp || noop); + show() { + if (typeof window !== "undefined") { + window.open(copyToDataUrl(this), "luma-debug-texture"); + } + return this; } - group(logLevel, message) { - let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : { - collapsed: false - }; - const options = normalizeArguments({ + log() { + let logLevel = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0; + let message = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ""; + if (logLevel > log2.level || typeof window === "undefined") { + return this; + } + message = message || "Framebuffer ".concat(this.id); + const image = copyToDataUrl(this, { + targetMaxHeight: 100 + }); + log2.image({ logLevel, message, - opts - }); - const { - collapsed - } = opts; - options.method = (collapsed ? console.groupCollapsed : console.group) || console.info; - return this._getLogFunction(options); + image + }, message)(); + return this; } - groupCollapsed(logLevel, message) { - let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; - return this.group(logLevel, message, Object.assign({}, opts, { - collapsed: true - })); + bind() { + let { + target = 36160 + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this.gl.bindFramebuffer(target, this.handle); + return this; } - groupEnd(logLevel) { - return this._getLogFunction(logLevel, "", console.groupEnd || noop); + unbind() { + let { + target = 36160 + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this.gl.bindFramebuffer(target, null); + return this; } - withGroup(logLevel, message, func) { - this.group(logLevel, message)(); - try { - func(); - } finally { - this.groupEnd(logLevel)(); + _createDefaultAttachments(color, depth, stencil, width, height) { + let defaultAttachments = null; + if (color) { + defaultAttachments = defaultAttachments || {}; + defaultAttachments[36064] = new Texture2D(this.gl, { + id: "".concat(this.id, "-color0"), + pixels: null, + format: 6408, + type: 5121, + width, + height, + mipmaps: false, + parameters: { + [10241]: 9729, + [10240]: 9729, + [10242]: 33071, + [10243]: 33071 + } + }); + this.ownResources.push(defaultAttachments[36064]); + } + if (depth && stencil) { + defaultAttachments = defaultAttachments || {}; + defaultAttachments[33306] = new Renderbuffer(this.gl, { + id: "".concat(this.id, "-depth-stencil"), + format: 35056, + width, + height: 111 + }); + this.ownResources.push(defaultAttachments[33306]); + } else if (depth) { + defaultAttachments = defaultAttachments || {}; + defaultAttachments[36096] = new Renderbuffer(this.gl, { + id: "".concat(this.id, "-depth"), + format: 33189, + width, + height + }); + this.ownResources.push(defaultAttachments[36096]); + } else if (stencil) { + assert6(false); + } + return defaultAttachments; + } + _unattach(attachment) { + const oldAttachment = this.attachments[attachment]; + if (!oldAttachment) { + return; + } + if (oldAttachment instanceof Renderbuffer) { + this.gl.framebufferRenderbuffer(36160, attachment, 36161, null); + } else { + this.gl.framebufferTexture2D(36160, attachment, 3553, null, 0); + } + delete this.attachments[attachment]; + } + _attachRenderbuffer(_ref4) { + let { + attachment = 36064, + renderbuffer + } = _ref4; + const { + gl + } = this; + gl.framebufferRenderbuffer(36160, attachment, 36161, renderbuffer.handle); + this.attachments[attachment] = renderbuffer; + } + _attachTexture(_ref5) { + let { + attachment = 36064, + texture, + layer, + level + } = _ref5; + const { + gl + } = this; + gl.bindTexture(texture.target, texture.handle); + switch (texture.target) { + case 35866: + case 32879: + const gl2 = assertWebGL2Context(gl); + gl2.framebufferTextureLayer(36160, attachment, texture.target, level, layer); + break; + case 34067: + const face = mapIndexToCubeMapFace(layer); + gl.framebufferTexture2D(36160, attachment, face, texture.handle, level); + break; + case 3553: + gl.framebufferTexture2D(36160, attachment, 3553, texture.handle, level); + break; + default: + assert6(false, "Illegal texture type"); } + gl.bindTexture(texture.target, null); + this.attachments[attachment] = texture; } - trace() { - if (console.trace) { - console.trace(); + _setReadBuffer(readBuffer) { + const gl2 = getWebGL2Context(this.gl); + if (gl2) { + gl2.readBuffer(readBuffer); + } else { + assert6(readBuffer === 36064 || readBuffer === 1029, ERR_MULTIPLE_RENDERTARGETS); } + this.readBuffer = readBuffer; } - _shouldLog(logLevel) { - return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel); - } - _getLogFunction(logLevel, message, method, args, opts) { - if (this._shouldLog(logLevel)) { - opts = normalizeArguments({ - logLevel, - message, - args, - opts - }); - method = method || opts.method; - assert3(method); - opts.total = this.getTotal(); - opts.delta = this.getDelta(); - this._deltaTs = getHiResTimestamp(); - const tag = opts.tag || opts.message; - if (opts.once && tag) { - if (!cache[tag]) { - cache[tag] = getHiResTimestamp(); - } else { - return noop; - } + _setDrawBuffers(drawBuffers) { + const { + gl + } = this; + const gl2 = assertWebGL2Context(gl); + if (gl2) { + gl2.drawBuffers(drawBuffers); + } else { + const ext = gl.getExtension("WEBGL_draw_buffers"); + if (ext) { + ext.drawBuffersWEBGL(drawBuffers); + } else { + assert6(drawBuffers.length === 1 && (drawBuffers[0] === 36064 || drawBuffers[0] === 1029), ERR_MULTIPLE_RENDERTARGETS); } - message = decorateMessage(this.id, opts.message, opts); - return method.bind(console, message, ...opts.args); } - return noop; - } - }; - Log.VERSION = VERSION2; - function normalizeLogLevel(logLevel) { - if (!logLevel) { - return 0; - } - let resolvedLevel; - switch (typeof logLevel) { - case "number": - resolvedLevel = logLevel; - break; - case "object": - resolvedLevel = logLevel.logLevel || logLevel.priority || 0; - break; - default: - return 0; + this.drawBuffers = drawBuffers; } - assert3(Number.isFinite(resolvedLevel) && resolvedLevel >= 0); - return resolvedLevel; - } - function normalizeArguments(opts) { - const { - logLevel, - message - } = opts; - opts.logLevel = normalizeLogLevel(logLevel); - const args = opts.args ? Array.from(opts.args) : []; - while (args.length && args.shift() !== message) { + _getAttachmentParameterFallback(pname) { + const caps = getFeatures(this.gl); + switch (pname) { + case 36052: + return !caps.WEBGL2 ? 0 : null; + case 33298: + case 33299: + case 33300: + case 33301: + case 33302: + case 33303: + return !caps.WEBGL2 ? 8 : null; + case 33297: + return !caps.WEBGL2 ? 5125 : null; + case 33296: + return !caps.WEBGL2 && !caps.EXT_sRGB ? 9729 : null; + default: + return null; + } } - switch (typeof logLevel) { - case "string": - case "function": - if (message !== void 0) { - args.unshift(message); - } - opts.message = logLevel; - break; - case "object": - Object.assign(opts, logLevel); - break; - default: + _createHandle() { + return this.gl.createFramebuffer(); } - if (typeof opts.message === "function") { - opts.message = opts.message(); + _deleteHandle() { + this.gl.deleteFramebuffer(this.handle); } - const messageType = typeof opts.message; - assert3(messageType === "string" || messageType === "object"); - return Object.assign(opts, { - args - }, opts.opts); - } - function decorateMessage(id, message, opts) { - if (typeof message === "string") { - const time = opts.time ? leftPad(formatTime(opts.total)) : ""; - message = opts.time ? `${id}: ${time} ${message}` : `${id}: ${message}`; - message = addColor(message, opts.color, opts.background); + _bindHandle(handle) { + return this.gl.bindFramebuffer(36160, handle); } - return message; + }; + function mapIndexToCubeMapFace(layer) { + return layer < 34069 ? layer + 34069 : layer; } - function logImageInNode(_ref2) { - let { - image, - message = "", - scale: scale3 = 1 - } = _ref2; - console.warn("removed"); - return noop; + function _getFrameBufferStatus(status) { + const STATUS = Framebuffer.STATUS || {}; + return STATUS[status] || "Framebuffer error ".concat(status); } - function logImageInBrowser(_ref3) { - let { - image, - message = "", - scale: scale3 = 1 - } = _ref3; - if (typeof image === "string") { - const img = new Image(); - img.onload = () => { - const args = formatImage(img, message, scale3); - console.log(...args); - }; - img.src = image; - return noop; - } - const element = image.nodeName || ""; - if (element.toLowerCase() === "img") { - console.log(...formatImage(image, message, scale3)); - return noop; - } - if (element.toLowerCase() === "canvas") { - const img = new Image(); - img.onload = () => console.log(...formatImage(img, message, scale3)); - img.src = image.toDataURL(); - return noop; - } - return noop; + var FRAMEBUFFER_ATTACHMENT_PARAMETERS = [36049, 36048, 33296, 33298, 33299, 33300, 33301, 33302, 33303]; + Framebuffer.ATTACHMENT_PARAMETERS = FRAMEBUFFER_ATTACHMENT_PARAMETERS; + + // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/texture-utils.js + function cloneTextureFrom(refTexture, overrides) { + assert6(refTexture instanceof Texture2D || refTexture instanceof TextureCube || refTexture instanceof Texture3D); + const TextureType = refTexture.constructor; + const { + gl, + width, + height, + format, + type, + dataFormat, + border, + mipmaps + } = refTexture; + const textureOptions = Object.assign({ + width, + height, + format, + type, + dataFormat, + border, + mipmaps + }, overrides); + return new TextureType(gl, textureOptions); } - function getTableHeader(table) { - for (const key in table) { - for (const title in table[key]) { - return title || "untitled"; + function toFramebuffer(texture, opts) { + const { + gl, + width, + height, + id + } = texture; + const framebuffer = new Framebuffer(gl, Object.assign({}, opts, { + id: "framebuffer-for-".concat(id), + width, + height, + attachments: { + [36064]: texture } - } - return "empty"; + })); + return framebuffer; } - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/init.js - globalThis.probe = {}; - - // node_modules/@loaders.gl/core/node_modules/@probe.gl/log/dist/index.js - var dist_default = new Log({ - id: "@probe.gl/log" - }); + // node_modules/@luma.gl/webgl/dist/esm/glsl-utils/get-shader-name.js + function getShaderName(shader) { + let defaultName = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "unnamed"; + const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/; + const match = shader.match(SHADER_NAME_REGEXP); + return match ? match[1] : defaultName; + } - // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/loggers.js - var probeLog = new Log({ - id: "loaders.gl" - }); - var NullLog = class { - log() { - return () => { - }; - } - info() { - return () => { - }; - } - warn() { - return () => { - }; - } - error() { - return () => { - }; - } - }; - var ConsoleLog = class { - constructor() { - _defineProperty(this, "console", void 0); - this.console = console; + // node_modules/@luma.gl/webgl/dist/esm/glsl-utils/get-shader-type-name.js + var GL_FRAGMENT_SHADER = 35632; + var GL_VERTEX_SHADER = 35633; + function getShaderTypeName(type) { + switch (type) { + case GL_FRAGMENT_SHADER: + return "fragment"; + case GL_VERTEX_SHADER: + return "vertex"; + default: + return "unknown type"; } - log() { - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; + } + + // node_modules/@luma.gl/webgl/dist/esm/glsl-utils/format-glsl-error.js + function parseGLSLCompilerError(errLog, src, shaderType, shaderName) { + const errorStrings = errLog.split(/\r?\n/); + const errors = {}; + const warnings = {}; + const name = shaderName || getShaderName(src) || "(unnamed)"; + const shaderDescription = "".concat(getShaderTypeName(shaderType), " shader ").concat(name); + for (let i3 = 0; i3 < errorStrings.length; i3++) { + const errorString = errorStrings[i3]; + if (errorString.length <= 1) { + continue; } - return this.console.log.bind(this.console, ...args); - } - info() { - for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; + const segments = errorString.split(":"); + const type = segments[0]; + const line = parseInt(segments[2], 10); + if (isNaN(line)) { + throw new Error("GLSL compilation error in ".concat(shaderDescription, ": ").concat(errLog)); } - return this.console.info.bind(this.console, ...args); - } - warn() { - for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; + if (type !== "WARNING") { + errors[line] = errorString; + } else { + warnings[line] = errorString; } - return this.console.warn.bind(this.console, ...args); } - error() { - for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { - args[_key4] = arguments[_key4]; + const lines = addLineNumbers(src); + return { + shaderName: shaderDescription, + errors: formatErrors(errors, lines), + warnings: formatErrors(warnings, lines) + }; + } + function formatErrors(errors, lines) { + let message = ""; + for (let i3 = 0; i3 < lines.length; i3++) { + const line = lines[i3]; + if (!errors[i3 + 3] && !errors[i3 + 2] && !errors[i3 + 1]) { + continue; + } + message += "".concat(line, "\n"); + if (errors[i3 + 1]) { + const error2 = errors[i3 + 1]; + const segments = error2.split(":", 3); + const type = segments[0]; + const column = parseInt(segments[1], 10) || 0; + const err3 = error2.substring(segments.join(":").length + 1).trim(); + message += padLeft("^^^ ".concat(type, ": ").concat(err3, "\n\n"), column); } - return this.console.error.bind(this.console, ...args); } - }; - - // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/option-defaults.js - var DEFAULT_LOADER_OPTIONS = { - fetch: null, - mimeType: void 0, - nothrow: false, - log: new ConsoleLog(), - CDN: "https://unpkg.com/@loaders.gl", - worker: true, - maxConcurrency: 3, - maxMobileConcurrency: 1, - reuseWorkers: isBrowser, - _nodeWorkers: false, - _workerType: "", - limit: 0, - _limitMB: 0, - batchSize: "auto", - batchDebounceMs: 0, - metadata: false, - transforms: [] - }; - var REMOVED_LOADER_OPTIONS = { - throws: "nothrow", - dataType: "(no longer used)", - uri: "baseUri", - method: "fetch.method", - headers: "fetch.headers", - body: "fetch.body", - mode: "fetch.mode", - credentials: "fetch.credentials", - cache: "fetch.cache", - redirect: "fetch.redirect", - referrer: "fetch.referrer", - referrerPolicy: "fetch.referrerPolicy", - integrity: "fetch.integrity", - keepalive: "fetch.keepalive", - signal: "fetch.signal" - }; - - // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/option-utils.js - function getGlobalLoaderState() { - globalThis.loaders = globalThis.loaders || {}; - const { - loaders - } = globalThis; - loaders._state = loaders._state || {}; - return loaders._state; + return message; } - var getGlobalLoaderOptions = () => { - const state = getGlobalLoaderState(); - state.globalOptions = state.globalOptions || { - ...DEFAULT_LOADER_OPTIONS - }; - return state.globalOptions; - }; - function normalizeOptions(options, loader, loaders, url) { - loaders = loaders || []; - loaders = Array.isArray(loaders) ? loaders : [loaders]; - validateOptions(options, loaders); - return normalizeOptionsInternal(loader, options, url); + function addLineNumbers(string) { + let start = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1; + let delim = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ": "; + const lines = string.split(/\r?\n/); + const maxDigits = String(lines.length + start - 1).length; + return lines.map((line, i3) => { + const lineNumber = String(i3 + start); + const digits = lineNumber.length; + const prefix = padLeft(lineNumber, maxDigits - digits); + return prefix + delim + line; + }); } - function validateOptions(options, loaders) { - validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders); - for (const loader of loaders) { - const idOptions = options && options[loader.id] || {}; - const loaderOptions = loader.options && loader.options[loader.id] || {}; - const deprecatedOptions = loader.deprecatedOptions && loader.deprecatedOptions[loader.id] || {}; - validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders); + function padLeft(string, digits) { + let result = ""; + for (let i3 = 0; i3 < digits; ++i3) { + result += " "; } + return "".concat(result).concat(string); } - function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) { - const loaderName = id || "Top level"; - const prefix = id ? "".concat(id, ".") : ""; - for (const key in options) { - const isSubOptions = !id && isObject(options[key]); - const isBaseUriOption = key === "baseUri" && !id; - const isWorkerUrlOption = key === "workerUrl" && id; - if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) { - if (key in deprecatedOptions) { - probeLog.warn("".concat(loaderName, " loader option '").concat(prefix).concat(key, "' no longer supported, use '").concat(deprecatedOptions[key], "'"))(); - } else if (!isSubOptions) { - const suggestion = findSimilarOption(key, loaders); - probeLog.warn("".concat(loaderName, " loader option '").concat(prefix).concat(key, "' not recognized. ").concat(suggestion))(); - } + + // node_modules/@luma.gl/webgl/dist/esm/glsl-utils/get-shader-version.js + function getShaderVersion(source) { + let version = 100; + const words = source.match(/[^\s]+/g); + if (words.length >= 2 && words[0] === "#version") { + const v2 = parseInt(words[1], 10); + if (Number.isFinite(v2)) { + version = v2; } } + return version; } - function findSimilarOption(optionKey, loaders) { - const lowerCaseOptionKey = optionKey.toLowerCase(); - let bestSuggestion = ""; - for (const loader of loaders) { - for (const key in loader.options) { - if (optionKey === key) { - return "Did you mean '".concat(loader.id, ".").concat(key, "'?"); - } - const lowerCaseKey = key.toLowerCase(); - const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey); - if (isPartialMatch) { - bestSuggestion = bestSuggestion || "Did you mean '".concat(loader.id, ".").concat(key, "'?"); - } + + // node_modules/@luma.gl/webgl/dist/esm/classes/shader.js + var ERR_SOURCE = "Shader: GLSL source code must be a JavaScript string"; + var Shader = class _Shader extends Resource { + get [Symbol.toStringTag]() { + return "Shader"; + } + static getTypeName(shaderType) { + switch (shaderType) { + case 35633: + return "vertex-shader"; + case 35632: + return "fragment-shader"; + default: + assert6(false); + return "unknown"; } } - return bestSuggestion; - } - function normalizeOptionsInternal(loader, options, url) { - const loaderDefaultOptions = loader.options || {}; - const mergedOptions = { - ...loaderDefaultOptions - }; - addUrlOptions(mergedOptions, url); - if (mergedOptions.log === null) { - mergedOptions.log = new NullLog(); + constructor(gl, props) { + assertWebGLContext(gl); + assert6(typeof props.source === "string", ERR_SOURCE); + const id = getShaderName(props.source, null) || props.id || uid("unnamed ".concat(_Shader.getTypeName(props.shaderType))); + super(gl, { + id + }); + this.shaderType = props.shaderType; + this.source = props.source; + this.initialize(props); } - mergeNestedFields(mergedOptions, getGlobalLoaderOptions()); - mergeNestedFields(mergedOptions, options); - return mergedOptions; - } - function mergeNestedFields(mergedOptions, options) { - for (const key in options) { - if (key in options) { - const value = options[key]; - if (isPureObject(value) && isPureObject(mergedOptions[key])) { - mergedOptions[key] = { - ...mergedOptions[key], - ...options[key] - }; - } else { - mergedOptions[key] = options[key]; - } + initialize(_ref) { + let { + source + } = _ref; + const shaderName = getShaderName(source, null); + if (shaderName) { + this.id = uid(shaderName); } + this._compile(source); + } + getParameter(pname) { + return this.gl.getShaderParameter(this.handle, pname); + } + toString() { + return "".concat(_Shader.getTypeName(this.shaderType), ":").concat(this.id); + } + getName() { + return getShaderName(this.source) || "unnamed-shader"; } - } - function addUrlOptions(options, url) { - if (url && !("baseUri" in options)) { - options.baseUri = url; + getSource() { + return this.gl.getShaderSource(this.handle); } - } - - // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/normalize-loader.js - function isLoaderObject(loader) { - var _loader; - if (!loader) { - return false; + getTranslatedSource() { + const extension = this.gl.getExtension("WEBGL_debug_shaders"); + return extension ? extension.getTranslatedShaderSource(this.handle) : "No translated source available. WEBGL_debug_shaders not implemented"; } - if (Array.isArray(loader)) { - loader = loader[0]; + _compile() { + let source = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.source; + if (!source.startsWith("#version ")) { + source = "#version 100\n".concat(source); + } + this.source = source; + this.gl.shaderSource(this.handle, this.source); + this.gl.compileShader(this.handle); + const compileStatus = this.getParameter(35713); + if (!compileStatus) { + const infoLog = this.gl.getShaderInfoLog(this.handle); + const { + shaderName, + errors, + warnings + } = parseGLSLCompilerError(infoLog, this.source, this.shaderType, this.id); + log2.error("GLSL compilation errors in ".concat(shaderName, "\n").concat(errors))(); + log2.warn("GLSL compilation warnings in ".concat(shaderName, "\n").concat(warnings))(); + throw new Error("GLSL compilation errors in ".concat(shaderName)); + } } - const hasExtensions = Array.isArray((_loader = loader) === null || _loader === void 0 ? void 0 : _loader.extensions); - return hasExtensions; - } - function normalizeLoader(loader) { - var _loader2, _loader3; - assert(loader, "null loader"); - assert(isLoaderObject(loader), "invalid loader"); - let options; - if (Array.isArray(loader)) { - options = loader[1]; - loader = loader[0]; - loader = { - ...loader, - options: { - ...loader.options, - ...options - } + _deleteHandle() { + this.gl.deleteShader(this.handle); + } + _getOptsFromHandle() { + return { + type: this.getParameter(35663), + source: this.getSource() }; } - if ((_loader2 = loader) !== null && _loader2 !== void 0 && _loader2.parseTextSync || (_loader3 = loader) !== null && _loader3 !== void 0 && _loader3.parseText) { - loader.text = true; + }; + var VertexShader = class extends Shader { + get [Symbol.toStringTag]() { + return "VertexShader"; } - if (!loader.text) { - loader.binary = true; + constructor(gl, props) { + if (typeof props === "string") { + props = { + source: props + }; + } + super(gl, Object.assign({}, props, { + shaderType: 35633 + })); + } + _createHandle() { + return this.gl.createShader(35633); } - return loader; - } - - // node_modules/@loaders.gl/core/dist/esm/lib/api/register-loaders.js - var getGlobalLoaderRegistry = () => { - const state = getGlobalLoaderState(); - state.loaderRegistry = state.loaderRegistry || []; - return state.loaderRegistry; }; - function registerLoaders(loaders) { - const loaderRegistry = getGlobalLoaderRegistry(); - loaders = Array.isArray(loaders) ? loaders : [loaders]; - for (const loader of loaders) { - const normalizedLoader = normalizeLoader(loader); - if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) { - loaderRegistry.unshift(normalizedLoader); - } + var FragmentShader = class extends Shader { + get [Symbol.toStringTag]() { + return "FragmentShader"; } - } - function getRegisteredLoaders() { - return getGlobalLoaderRegistry(); - } - - // node_modules/@loaders.gl/core/dist/esm/lib/utils/log.js - var log = new Log({ - id: "loaders.gl" - }); - - // node_modules/@loaders.gl/core/dist/esm/lib/api/select-loader.js - var EXT_PATTERN = /\.([^.]+)$/; - async function selectLoader(data) { - let loaders = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : []; - let options = arguments.length > 2 ? arguments[2] : void 0; - let context = arguments.length > 3 ? arguments[3] : void 0; - if (!validHTTPResponse(data)) { - return null; + constructor(gl, props) { + if (typeof props === "string") { + props = { + source: props + }; + } + super(gl, Object.assign({}, props, { + shaderType: 35632 + })); } - let loader = selectLoaderSync(data, loaders, { - ...options, - nothrow: true - }, context); - if (loader) { - return loader; + _createHandle() { + return this.gl.createShader(35632); } - if (isBlob(data)) { - data = await data.slice(0, 10).arrayBuffer(); - loader = selectLoaderSync(data, loaders, options, context); + }; + + // node_modules/@luma.gl/webgl/dist/esm/classes/uniforms.js + var UNIFORM_SETTERS = { + [5126]: getArraySetter.bind(null, "uniform1fv", toFloatArray, 1, setVectorUniform), + [35664]: getArraySetter.bind(null, "uniform2fv", toFloatArray, 2, setVectorUniform), + [35665]: getArraySetter.bind(null, "uniform3fv", toFloatArray, 3, setVectorUniform), + [35666]: getArraySetter.bind(null, "uniform4fv", toFloatArray, 4, setVectorUniform), + [5124]: getArraySetter.bind(null, "uniform1iv", toIntArray, 1, setVectorUniform), + [35667]: getArraySetter.bind(null, "uniform2iv", toIntArray, 2, setVectorUniform), + [35668]: getArraySetter.bind(null, "uniform3iv", toIntArray, 3, setVectorUniform), + [35669]: getArraySetter.bind(null, "uniform4iv", toIntArray, 4, setVectorUniform), + [35670]: getArraySetter.bind(null, "uniform1iv", toIntArray, 1, setVectorUniform), + [35671]: getArraySetter.bind(null, "uniform2iv", toIntArray, 2, setVectorUniform), + [35672]: getArraySetter.bind(null, "uniform3iv", toIntArray, 3, setVectorUniform), + [35673]: getArraySetter.bind(null, "uniform4iv", toIntArray, 4, setVectorUniform), + [35674]: getArraySetter.bind(null, "uniformMatrix2fv", toFloatArray, 4, setMatrixUniform), + [35675]: getArraySetter.bind(null, "uniformMatrix3fv", toFloatArray, 9, setMatrixUniform), + [35676]: getArraySetter.bind(null, "uniformMatrix4fv", toFloatArray, 16, setMatrixUniform), + [35678]: getSamplerSetter, + [35680]: getSamplerSetter, + [5125]: getArraySetter.bind(null, "uniform1uiv", toUIntArray, 1, setVectorUniform), + [36294]: getArraySetter.bind(null, "uniform2uiv", toUIntArray, 2, setVectorUniform), + [36295]: getArraySetter.bind(null, "uniform3uiv", toUIntArray, 3, setVectorUniform), + [36296]: getArraySetter.bind(null, "uniform4uiv", toUIntArray, 4, setVectorUniform), + [35685]: getArraySetter.bind(null, "uniformMatrix2x3fv", toFloatArray, 6, setMatrixUniform), + [35686]: getArraySetter.bind(null, "uniformMatrix2x4fv", toFloatArray, 8, setMatrixUniform), + [35687]: getArraySetter.bind(null, "uniformMatrix3x2fv", toFloatArray, 6, setMatrixUniform), + [35688]: getArraySetter.bind(null, "uniformMatrix3x4fv", toFloatArray, 12, setMatrixUniform), + [35689]: getArraySetter.bind(null, "uniformMatrix4x2fv", toFloatArray, 8, setMatrixUniform), + [35690]: getArraySetter.bind(null, "uniformMatrix4x3fv", toFloatArray, 12, setMatrixUniform), + [35678]: getSamplerSetter, + [35680]: getSamplerSetter, + [35679]: getSamplerSetter, + [35682]: getSamplerSetter, + [36289]: getSamplerSetter, + [36292]: getSamplerSetter, + [36293]: getSamplerSetter, + [36298]: getSamplerSetter, + [36299]: getSamplerSetter, + [36300]: getSamplerSetter, + [36303]: getSamplerSetter, + [36306]: getSamplerSetter, + [36307]: getSamplerSetter, + [36308]: getSamplerSetter, + [36311]: getSamplerSetter + }; + var FLOAT_ARRAY = {}; + var INT_ARRAY = {}; + var UINT_ARRAY = {}; + var array1 = [0]; + function toTypedArray(value, uniformLength, Type, cache4) { + if (uniformLength === 1 && typeof value === "boolean") { + value = value ? 1 : 0; } - if (!loader && !(options !== null && options !== void 0 && options.nothrow)) { - throw new Error(getNoValidLoaderMessage(data)); + if (Number.isFinite(value)) { + array1[0] = value; + value = array1; } - return loader; - } - function selectLoaderSync(data) { - let loaders = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : []; - let options = arguments.length > 2 ? arguments[2] : void 0; - let context = arguments.length > 3 ? arguments[3] : void 0; - if (!validHTTPResponse(data)) { - return null; + const length4 = value.length; + if (length4 % uniformLength) { + log2.warn("Uniform size should be multiples of ".concat(uniformLength), value)(); } - if (loaders && !Array.isArray(loaders)) { - return normalizeLoader(loaders); + if (value instanceof Type) { + return value; } - let candidateLoaders = []; - if (loaders) { - candidateLoaders = candidateLoaders.concat(loaders); + let result = cache4[length4]; + if (!result) { + result = new Type(length4); + cache4[length4] = result; } - if (!(options !== null && options !== void 0 && options.ignoreRegisteredLoaders)) { - candidateLoaders.push(...getRegisteredLoaders()); + for (let i3 = 0; i3 < length4; i3++) { + result[i3] = value[i3]; } - normalizeLoaders(candidateLoaders); - const loader = selectLoaderInternal(data, candidateLoaders, options, context); - if (!loader && !(options !== null && options !== void 0 && options.nothrow)) { - throw new Error(getNoValidLoaderMessage(data)); + return result; + } + function toFloatArray(value, uniformLength) { + return toTypedArray(value, uniformLength, Float32Array, FLOAT_ARRAY); + } + function toIntArray(value, uniformLength) { + return toTypedArray(value, uniformLength, Int32Array, INT_ARRAY); + } + function toUIntArray(value, uniformLength) { + return toTypedArray(value, uniformLength, Uint32Array, UINT_ARRAY); + } + function getUniformSetter(gl, location, info) { + const setter = UNIFORM_SETTERS[info.type]; + if (!setter) { + throw new Error("Unknown GLSL uniform type ".concat(info.type)); } - return loader; + return setter().bind(null, gl, location); } - function selectLoaderInternal(data, loaders, options, context) { - const url = getResourceUrl(data); - const type = getResourceMIMEType(data); - const testUrl = stripQueryString(url) || (context === null || context === void 0 ? void 0 : context.url); - let loader = null; - let reason = ""; - if (options !== null && options !== void 0 && options.mimeType) { - loader = findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.mimeType); - reason = "match forced by supplied MIME type ".concat(options === null || options === void 0 ? void 0 : options.mimeType); + function parseUniformName(name) { + if (name[name.length - 1] !== "]") { + return { + name, + length: 1, + isArray: false + }; } - loader = loader || findLoaderByUrl(loaders, testUrl); - reason = reason || (loader ? "matched url ".concat(testUrl) : ""); - loader = loader || findLoaderByMIMEType(loaders, type); - reason = reason || (loader ? "matched MIME type ".concat(type) : ""); - loader = loader || findLoaderByInitialBytes(loaders, data); - reason = reason || (loader ? "matched initial data ".concat(getFirstCharacters(data)) : ""); - loader = loader || findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.fallbackMimeType); - reason = reason || (loader ? "matched fallback MIME type ".concat(type) : ""); - if (reason) { - var _loader; - log.log(1, "selectLoader selected ".concat((_loader = loader) === null || _loader === void 0 ? void 0 : _loader.name, ": ").concat(reason, ".")); + const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/; + const matches3 = name.match(UNIFORM_NAME_REGEXP); + if (!matches3 || matches3.length < 2) { + throw new Error("Failed to parse GLSL uniform name ".concat(name)); } - return loader; + return { + name: matches3[1], + length: matches3[2] || 1, + isArray: Boolean(matches3[2]) + }; } - function validHTTPResponse(data) { - if (data instanceof Response) { - if (data.status === 204) { - return false; + function checkUniformValues(uniforms, source, uniformMap) { + for (const uniformName in uniforms) { + const value = uniforms[uniformName]; + const shouldCheck = !uniformMap || Boolean(uniformMap[uniformName]); + if (shouldCheck && !checkUniformValue(value)) { + source = source ? "".concat(source, " ") : ""; + console.error("".concat(source, " Bad uniform ").concat(uniformName), value); + throw new Error("".concat(source, " Bad uniform ").concat(uniformName)); } } return true; } - function getNoValidLoaderMessage(data) { - const url = getResourceUrl(data); - const type = getResourceMIMEType(data); - let message = "No valid loader found ("; - message += url ? "".concat(path_exports.filename(url), ", ") : "no url provided, "; - message += "MIME type: ".concat(type ? '"'.concat(type, '"') : "not provided", ", "); - const firstCharacters = data ? getFirstCharacters(data) : ""; - message += firstCharacters ? ' first bytes: "'.concat(firstCharacters, '"') : "first bytes: not available"; - message += ")"; - return message; - } - function normalizeLoaders(loaders) { - for (const loader of loaders) { - normalizeLoader(loader); + function checkUniformValue(value) { + if (Array.isArray(value) || ArrayBuffer.isView(value)) { + return checkUniformArray(value); } - } - function findLoaderByUrl(loaders, url) { - const match = url && EXT_PATTERN.exec(url); - const extension = match && match[1]; - return extension ? findLoaderByExtension(loaders, extension) : null; - } - function findLoaderByExtension(loaders, extension) { - extension = extension.toLowerCase(); - for (const loader of loaders) { - for (const loaderExtension of loader.extensions) { - if (loaderExtension.toLowerCase() === extension) { - return loader; - } - } + if (isFinite(value)) { + return true; + } else if (value === true || value === false) { + return true; + } else if (value instanceof Texture) { + return true; + } else if (value instanceof Renderbuffer) { + return true; + } else if (value instanceof Framebuffer) { + return Boolean(value.texture); } - return null; + return false; } - function findLoaderByMIMEType(loaders, mimeType) { - for (const loader of loaders) { - if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) { - return loader; - } - if (mimeType === "application/x.".concat(loader.id)) { - return loader; + function copyUniform(uniforms, key, value) { + if (Array.isArray(value) || ArrayBuffer.isView(value)) { + if (uniforms[key]) { + const dest = uniforms[key]; + for (let i3 = 0, len2 = value.length; i3 < len2; ++i3) { + dest[i3] = value[i3]; + } + } else { + uniforms[key] = value.slice(); } + } else { + uniforms[key] = value; } - return null; } - function findLoaderByInitialBytes(loaders, data) { - if (!data) { - return null; + function checkUniformArray(value) { + if (value.length === 0) { + return false; } - for (const loader of loaders) { - if (typeof data === "string") { - if (testDataAgainstText(data, loader)) { - return loader; - } - } else if (ArrayBuffer.isView(data)) { - if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) { - return loader; - } - } else if (data instanceof ArrayBuffer) { - const byteOffset = 0; - if (testDataAgainstBinary(data, byteOffset, loader)) { - return loader; - } + const checkLength = Math.min(value.length, 16); + for (let i3 = 0; i3 < checkLength; ++i3) { + if (!Number.isFinite(value[i3])) { + return false; } } - return null; + return true; } - function testDataAgainstText(data, loader) { - if (loader.testText) { - return loader.testText(data); - } - const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests]; - return tests.some((test) => data.startsWith(test)); + function getSamplerSetter() { + let cache4 = null; + return (gl, location, value) => { + const update = cache4 !== value; + if (update) { + gl.uniform1i(location, value); + cache4 = value; + } + return update; + }; } - function testDataAgainstBinary(data, byteOffset, loader) { - const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests]; - return tests.some((test) => testBinary(data, byteOffset, loader, test)); + function getArraySetter(functionName, toArray, size, uniformSetter) { + let cache4 = null; + let cacheLength = null; + return (gl, location, value) => { + const arrayValue = toArray(value, size); + const length4 = arrayValue.length; + let update = false; + if (cache4 === null) { + cache4 = new Float32Array(length4); + cacheLength = length4; + update = true; + } else { + assert6(cacheLength === length4, "Uniform length cannot change."); + for (let i3 = 0; i3 < length4; ++i3) { + if (arrayValue[i3] !== cache4[i3]) { + update = true; + break; + } + } + } + if (update) { + uniformSetter(gl, functionName, location, arrayValue); + cache4.set(arrayValue); + } + return update; + }; } - function testBinary(data, byteOffset, loader, test) { - if (test instanceof ArrayBuffer) { - return compareArrayBuffers(test, data, test.byteLength); - } - switch (typeof test) { - case "function": - return test(data, loader); - case "string": - const magic = getMagicString(data, byteOffset, test.length); - return test === magic; - default: - return false; - } + function setVectorUniform(gl, functionName, location, value) { + gl[functionName](location, value); } - function getFirstCharacters(data) { - let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 5; - if (typeof data === "string") { - return data.slice(0, length); - } else if (ArrayBuffer.isView(data)) { - return getMagicString(data.buffer, data.byteOffset, length); - } else if (data instanceof ArrayBuffer) { - const byteOffset = 0; - return getMagicString(data, byteOffset, length); - } - return ""; + function setMatrixUniform(gl, functionName, location, value) { + gl[functionName](location, false, value); } - function getMagicString(arrayBuffer2, byteOffset, length) { - if (arrayBuffer2.byteLength < byteOffset + length) { - return ""; - } - const dataView = new DataView(arrayBuffer2); - let magic = ""; - for (let i2 = 0; i2 < length; i2++) { - magic += String.fromCharCode(dataView.getUint8(byteOffset + i2)); + + // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/attribute-utils.js + var GL_BYTE = 5120; + var GL_UNSIGNED_BYTE = 5121; + var GL_SHORT = 5122; + var GL_UNSIGNED_SHORT = 5123; + var GL_POINTS = 0; + var GL_LINES = 1; + var GL_LINE_LOOP = 2; + var GL_LINE_STRIP = 3; + var GL_TRIANGLES = 4; + var GL_TRIANGLE_STRIP = 5; + var GL_TRIANGLE_FAN = 6; + var GL_FLOAT = 5126; + var GL_FLOAT_VEC2 = 35664; + var GL_FLOAT_VEC3 = 35665; + var GL_FLOAT_VEC4 = 35666; + var GL_INT = 5124; + var GL_INT_VEC2 = 35667; + var GL_INT_VEC3 = 35668; + var GL_INT_VEC4 = 35669; + var GL_UNSIGNED_INT = 5125; + var GL_UNSIGNED_INT_VEC2 = 36294; + var GL_UNSIGNED_INT_VEC3 = 36295; + var GL_UNSIGNED_INT_VEC4 = 36296; + var GL_BOOL = 35670; + var GL_BOOL_VEC2 = 35671; + var GL_BOOL_VEC3 = 35672; + var GL_BOOL_VEC4 = 35673; + var GL_FLOAT_MAT2 = 35674; + var GL_FLOAT_MAT3 = 35675; + var GL_FLOAT_MAT4 = 35676; + var GL_FLOAT_MAT2x3 = 35685; + var GL_FLOAT_MAT2x4 = 35686; + var GL_FLOAT_MAT3x2 = 35687; + var GL_FLOAT_MAT3x4 = 35688; + var GL_FLOAT_MAT4x2 = 35689; + var GL_FLOAT_MAT4x3 = 35690; + var COMPOSITE_GL_TYPES = { + [GL_FLOAT]: [GL_FLOAT, 1, "float"], + [GL_FLOAT_VEC2]: [GL_FLOAT, 2, "vec2"], + [GL_FLOAT_VEC3]: [GL_FLOAT, 3, "vec3"], + [GL_FLOAT_VEC4]: [GL_FLOAT, 4, "vec4"], + [GL_INT]: [GL_INT, 1, "int"], + [GL_INT_VEC2]: [GL_INT, 2, "ivec2"], + [GL_INT_VEC3]: [GL_INT, 3, "ivec3"], + [GL_INT_VEC4]: [GL_INT, 4, "ivec4"], + [GL_UNSIGNED_INT]: [GL_UNSIGNED_INT, 1, "uint"], + [GL_UNSIGNED_INT_VEC2]: [GL_UNSIGNED_INT, 2, "uvec2"], + [GL_UNSIGNED_INT_VEC3]: [GL_UNSIGNED_INT, 3, "uvec3"], + [GL_UNSIGNED_INT_VEC4]: [GL_UNSIGNED_INT, 4, "uvec4"], + [GL_BOOL]: [GL_FLOAT, 1, "bool"], + [GL_BOOL_VEC2]: [GL_FLOAT, 2, "bvec2"], + [GL_BOOL_VEC3]: [GL_FLOAT, 3, "bvec3"], + [GL_BOOL_VEC4]: [GL_FLOAT, 4, "bvec4"], + [GL_FLOAT_MAT2]: [GL_FLOAT, 8, "mat2"], + [GL_FLOAT_MAT2x3]: [GL_FLOAT, 8, "mat2x3"], + [GL_FLOAT_MAT2x4]: [GL_FLOAT, 8, "mat2x4"], + [GL_FLOAT_MAT3]: [GL_FLOAT, 12, "mat3"], + [GL_FLOAT_MAT3x2]: [GL_FLOAT, 12, "mat3x2"], + [GL_FLOAT_MAT3x4]: [GL_FLOAT, 12, "mat3x4"], + [GL_FLOAT_MAT4]: [GL_FLOAT, 16, "mat4"], + [GL_FLOAT_MAT4x2]: [GL_FLOAT, 16, "mat4x2"], + [GL_FLOAT_MAT4x3]: [GL_FLOAT, 16, "mat4x3"] + }; + function getPrimitiveDrawMode(drawMode) { + switch (drawMode) { + case GL_POINTS: + return GL_POINTS; + case GL_LINES: + return GL_LINES; + case GL_LINE_STRIP: + return GL_LINES; + case GL_LINE_LOOP: + return GL_LINES; + case GL_TRIANGLES: + return GL_TRIANGLES; + case GL_TRIANGLE_STRIP: + return GL_TRIANGLES; + case GL_TRIANGLE_FAN: + return GL_TRIANGLES; + default: + assert6(false); + return 0; } - return magic; } - - // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-string-iterator.js - var DEFAULT_CHUNK_SIZE = 256 * 1024; - function* makeStringIterator(string, options) { - const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE; - let offset = 0; - const textEncoder = new TextEncoder(); - while (offset < string.length) { - const chunkLength = Math.min(string.length - offset, chunkSize); - const chunk = string.slice(offset, offset + chunkLength); - offset += chunkLength; - yield textEncoder.encode(chunk); + function decomposeCompositeGLType(compositeGLType) { + const typeAndSize = COMPOSITE_GL_TYPES[compositeGLType]; + if (!typeAndSize) { + return null; } + const [type, components] = typeAndSize; + return { + type, + components + }; } - - // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-array-buffer-iterator.js - var DEFAULT_CHUNK_SIZE2 = 256 * 1024; - function makeArrayBufferIterator(arrayBuffer2) { - let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - return function* () { - const { - chunkSize = DEFAULT_CHUNK_SIZE2 - } = options; - let byteOffset = 0; - while (byteOffset < arrayBuffer2.byteLength) { - const chunkByteLength = Math.min(arrayBuffer2.byteLength - byteOffset, chunkSize); - const chunk = new ArrayBuffer(chunkByteLength); - const sourceArray = new Uint8Array(arrayBuffer2, byteOffset, chunkByteLength); - const chunkArray = new Uint8Array(chunk); - chunkArray.set(sourceArray); - byteOffset += chunkByteLength; - yield chunk; - } - }(); - } - - // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-blob-iterator.js - var DEFAULT_CHUNK_SIZE3 = 1024 * 1024; - async function* makeBlobIterator(blob, options) { - const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE3; - let offset = 0; - while (offset < blob.size) { - const end = offset + chunkSize; - const chunk = await blob.slice(offset, end).arrayBuffer(); - offset = end; - yield chunk; + function getCompositeGLType(type, components) { + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + type = GL_FLOAT; + break; + default: } - } - - // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-stream-iterator.js - function makeStreamIterator(stream, options) { - return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options); - } - async function* makeBrowserStreamIterator(stream, options) { - const reader = stream.getReader(); - let nextBatchPromise; - try { - while (true) { - const currentBatchPromise = nextBatchPromise || reader.read(); - if (options !== null && options !== void 0 && options._streamReadAhead) { - nextBatchPromise = reader.read(); - } - const { - done, - value - } = await currentBatchPromise; - if (done) { - return; - } - yield toArrayBuffer2(value); + for (const glType in COMPOSITE_GL_TYPES) { + const [compType, compComponents, name] = COMPOSITE_GL_TYPES[glType]; + if (compType === type && compComponents === components) { + return { + glType, + name + }; } - } catch (error2) { - reader.releaseLock(); - } - } - async function* makeNodeStreamIterator(stream, options) { - for await (const chunk of stream) { - yield toArrayBuffer2(chunk); } + return null; } - // node_modules/@loaders.gl/core/dist/esm/iterators/make-iterator/make-iterator.js - function makeIterator(data, options) { - if (typeof data === "string") { - return makeStringIterator(data, options); + // node_modules/@luma.gl/webgl/dist/esm/classes/program-configuration.js + var ProgramConfiguration = class { + constructor(program) { + this.id = program.id; + this.attributeInfos = []; + this.attributeInfosByName = {}; + this.attributeInfosByLocation = []; + this.varyingInfos = []; + this.varyingInfosByName = {}; + Object.seal(this); + this._readAttributesFromProgram(program); + this._readVaryingsFromProgram(program); } - if (data instanceof ArrayBuffer) { - return makeArrayBufferIterator(data, options); + getAttributeInfo(locationOrName) { + const location = Number(locationOrName); + if (Number.isFinite(location)) { + return this.attributeInfosByLocation[location]; + } + return this.attributeInfosByName[locationOrName] || null; } - if (isBlob(data)) { - return makeBlobIterator(data, options); + getAttributeLocation(locationOrName) { + const attributeInfo = this.getAttributeInfo(locationOrName); + return attributeInfo ? attributeInfo.location : -1; } - if (isReadableStream(data)) { - return makeStreamIterator(data, options); + getAttributeAccessor(locationOrName) { + const attributeInfo = this.getAttributeInfo(locationOrName); + return attributeInfo ? attributeInfo.accessor : null; } - if (isResponse(data)) { - const response = data; - return makeStreamIterator(response.body, options); + getVaryingInfo(locationOrName) { + const location = Number(locationOrName); + if (Number.isFinite(location)) { + return this.varyingInfos[location]; + } + return this.varyingInfosByName[locationOrName] || null; } - throw new Error("makeIterator"); - } - - // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/get-data.js - var ERR_DATA = "Cannot convert supplied data type"; - function getArrayBufferOrStringFromDataSync(data, loader, options) { - if (loader.text && typeof data === "string") { - return data; + getVaryingIndex(locationOrName) { + const varying = this.getVaryingInfo(); + return varying ? varying.location : -1; } - if (isBuffer2(data)) { - data = data.buffer; + getVaryingAccessor(locationOrName) { + const varying = this.getVaryingInfo(); + return varying ? varying.accessor : null; } - if (data instanceof ArrayBuffer) { - const arrayBuffer2 = data; - if (loader.text && !loader.binary) { - const textDecoder = new TextDecoder("utf8"); - return textDecoder.decode(arrayBuffer2); + _readAttributesFromProgram(program) { + const { + gl + } = program; + const count2 = gl.getProgramParameter(program.handle, 35721); + for (let index = 0; index < count2; index++) { + const { + name, + type, + size + } = gl.getActiveAttrib(program.handle, index); + const location = gl.getAttribLocation(program.handle, name); + if (location >= 0) { + this._addAttribute(location, name, type, size); + } } - return arrayBuffer2; + this.attributeInfos.sort((a2, b2) => a2.location - b2.location); } - if (ArrayBuffer.isView(data)) { - if (loader.text && !loader.binary) { - const textDecoder = new TextDecoder("utf8"); - return textDecoder.decode(data); + _readVaryingsFromProgram(program) { + const { + gl + } = program; + if (!isWebGL2(gl)) { + return; } - let arrayBuffer2 = data.buffer; - const byteLength = data.byteLength || data.length; - if (data.byteOffset !== 0 || byteLength !== arrayBuffer2.byteLength) { - arrayBuffer2 = arrayBuffer2.slice(data.byteOffset, data.byteOffset + byteLength); + const count2 = gl.getProgramParameter(program.handle, 35971); + for (let location = 0; location < count2; location++) { + const { + name, + type, + size + } = gl.getTransformFeedbackVarying(program.handle, location); + this._addVarying(location, name, type, size); } - return arrayBuffer2; - } - throw new Error(ERR_DATA); - } - async function getArrayBufferOrStringFromData(data, loader, options) { - const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data); - if (typeof data === "string" || isArrayBuffer) { - return getArrayBufferOrStringFromDataSync(data, loader, options); - } - if (isBlob(data)) { - data = await makeResponse(data); - } - if (isResponse(data)) { - const response = data; - await checkResponse(response); - return loader.binary ? await response.arrayBuffer() : await response.text(); - } - if (isReadableStream(data)) { - data = makeIterator(data, options); - } - if (isIterable(data) || isAsyncIterable(data)) { - return concatenateArrayBuffersAsync(data); + this.varyingInfos.sort((a2, b2) => a2.location - b2.location); } - throw new Error(ERR_DATA); - } - - // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/get-fetch-function.js - function getFetchFunction(options, context) { - const globalOptions = getGlobalLoaderOptions(); - const fetchOptions = options || globalOptions; - if (typeof fetchOptions.fetch === "function") { - return fetchOptions.fetch; + _addAttribute(location, name, compositeType, size) { + const { + type, + components + } = decomposeCompositeGLType(compositeType); + const accessor = { + type, + size: size * components + }; + this._inferProperties(location, name, accessor); + const attributeInfo = { + location, + name, + accessor: new Accessor(accessor) + }; + this.attributeInfos.push(attributeInfo); + this.attributeInfosByLocation[location] = attributeInfo; + this.attributeInfosByName[attributeInfo.name] = attributeInfo; } - if (isObject(fetchOptions.fetch)) { - return (url) => fetchFile(url, fetchOptions); + _inferProperties(location, name, accessor) { + if (/instance/i.test(name)) { + accessor.divisor = 1; + } } - if (context !== null && context !== void 0 && context.fetch) { - return context === null || context === void 0 ? void 0 : context.fetch; + _addVarying(location, name, compositeType, size) { + const { + type, + components + } = decomposeCompositeGLType(compositeType); + const accessor = new Accessor({ + type, + size: size * components + }); + const varying = { + location, + name, + accessor + }; + this.varyingInfos.push(varying); + this.varyingInfosByName[varying.name] = varying; } - return fetchFile; - } + }; - // node_modules/@loaders.gl/core/dist/esm/lib/loader-utils/loader-context.js - function getLoaderContext(context, options, parentContext) { - if (parentContext) { - return parentContext; - } - const newContext = { - fetch: getFetchFunction(options, context), - ...context - }; - if (newContext.url) { - const baseUrl = stripQueryString(newContext.url); - newContext.baseUrl = baseUrl; - newContext.queryString = extractQueryString(newContext.url); - newContext.filename = path_exports.filename(baseUrl); - newContext.baseUrl = path_exports.dirname(baseUrl); - } - if (!Array.isArray(newContext.loaders)) { - newContext.loaders = null; + // node_modules/@luma.gl/webgl/dist/esm/classes/program.js + var LOG_PROGRAM_PERF_PRIORITY = 4; + var GL_SEPARATE_ATTRIBS = 35981; + var V6_DEPRECATED_METHODS = ["setVertexArray", "setAttributes", "setBuffers", "unsetBuffers", "use", "getUniformCount", "getUniformInfo", "getUniformLocation", "getUniformValue", "getVarying", "getFragDataLocation", "getAttachedShaders", "getAttributeCount", "getAttributeLocation", "getAttributeInfo"]; + var Program = class extends Resource { + get [Symbol.toStringTag]() { + return "Program"; } - return newContext; - } - function getLoadersFromContext(loaders, context) { - if (!context && loaders && !Array.isArray(loaders)) { - return loaders; + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + super(gl, props); + this.stubRemovedMethods("Program", "v6.0", V6_DEPRECATED_METHODS); + this._isCached = false; + this.initialize(props); + Object.seal(this); + this._setId(props.id); } - let candidateLoaders; - if (loaders) { - candidateLoaders = Array.isArray(loaders) ? loaders : [loaders]; + initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + hash, + vs: vs8, + fs: fs6, + varyings, + bufferMode = GL_SEPARATE_ATTRIBS + } = props; + this.hash = hash || ""; + this.vs = typeof vs8 === "string" ? new VertexShader(this.gl, { + id: "".concat(props.id, "-vs"), + source: vs8 + }) : vs8; + this.fs = typeof fs6 === "string" ? new FragmentShader(this.gl, { + id: "".concat(props.id, "-fs"), + source: fs6 + }) : fs6; + assert6(this.vs instanceof VertexShader); + assert6(this.fs instanceof FragmentShader); + this.uniforms = {}; + this._textureUniforms = {}; + if (varyings && varyings.length > 0) { + assertWebGL2Context(this.gl); + this.varyings = varyings; + this.gl2.transformFeedbackVaryings(this.handle, varyings, bufferMode); + } + this._compileAndLink(); + this._readUniformLocationsFromLinkedProgram(); + this.configuration = new ProgramConfiguration(this); + return this.setProps(props); } - if (context && context.loaders) { - const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders]; - candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders; + delete() { + let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (this._isCached) { + return this; + } + return super.delete(options); } - return candidateLoaders && candidateLoaders.length ? candidateLoaders : null; - } - - // node_modules/@loaders.gl/core/dist/esm/lib/api/parse.js - async function parse(data, loaders, options, context) { - assert2(!context || typeof context === "object"); - if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) { - context = void 0; - options = loaders; - loaders = void 0; + setProps(props) { + if ("uniforms" in props) { + this.setUniforms(props.uniforms); + } + return this; } - data = await data; - options = options || {}; - const url = getResourceUrl(data); - const typedLoaders = loaders; - const candidateLoaders = getLoadersFromContext(typedLoaders, context); - const loader = await selectLoader(data, candidateLoaders, options); - if (!loader) { - return null; + draw(_ref) { + let { + logPriority, + drawMode = 4, + vertexCount, + offset = 0, + start, + end, + isIndexed = false, + indexType = 5123, + instanceCount = 0, + isInstanced = instanceCount > 0, + vertexArray = null, + transformFeedback, + framebuffer, + parameters = {}, + uniforms, + samplers + } = _ref; + if (uniforms || samplers) { + log2.deprecated("Program.draw({uniforms})", "Program.setUniforms(uniforms)")(); + this.setUniforms(uniforms || {}); + } + if (log2.priority >= logPriority) { + const fb = framebuffer ? framebuffer.id : "default"; + const message = "mode=".concat(getKey(this.gl, drawMode), " verts=").concat(vertexCount, " ") + "instances=".concat(instanceCount, " indexType=").concat(getKey(this.gl, indexType), " ") + "isInstanced=".concat(isInstanced, " isIndexed=").concat(isIndexed, " ") + "Framebuffer=".concat(fb); + log2.log(logPriority, message)(); + } + assert6(vertexArray); + this.gl.useProgram(this.handle); + if (!this._areTexturesRenderable() || vertexCount === 0 || isInstanced && instanceCount === 0) { + return false; + } + vertexArray.bindForDraw(vertexCount, instanceCount, () => { + if (framebuffer !== void 0) { + parameters = Object.assign({}, parameters, { + framebuffer + }); + } + if (transformFeedback) { + const primitiveMode = getPrimitiveDrawMode(drawMode); + transformFeedback.begin(primitiveMode); + } + this._bindTextures(); + withParameters(this.gl, parameters, () => { + if (isIndexed && isInstanced) { + this.gl2.drawElementsInstanced(drawMode, vertexCount, indexType, offset, instanceCount); + } else if (isIndexed && isWebGL2(this.gl) && !isNaN(start) && !isNaN(end)) { + this.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset); + } else if (isIndexed) { + this.gl.drawElements(drawMode, vertexCount, indexType, offset); + } else if (isInstanced) { + this.gl2.drawArraysInstanced(drawMode, offset, vertexCount, instanceCount); + } else { + this.gl.drawArrays(drawMode, offset, vertexCount); + } + }); + if (transformFeedback) { + transformFeedback.end(); + } + }); + return true; } - options = normalizeOptions(options, loader, candidateLoaders, url); - context = getLoaderContext({ - url, - parse, - loaders: candidateLoaders - }, options, context || null); - return await parseWithLoader(loader, data, options, context); - } - async function parseWithLoader(loader, data, options, context) { - validateWorkerVersion(loader); - if (isResponse(data)) { - const response = data; - const { - ok, - redirected, - status, - statusText, - type, - url - } = response; - const headers = Object.fromEntries(response.headers.entries()); - context.response = { - headers, - ok, - redirected, - status, - statusText, - type, - url - }; + setUniforms() { + let uniforms = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (log2.priority >= 2) { + checkUniformValues(uniforms, this.id, this._uniformSetters); + } + this.gl.useProgram(this.handle); + for (const uniformName in uniforms) { + const uniform = uniforms[uniformName]; + const uniformSetter = this._uniformSetters[uniformName]; + if (uniformSetter) { + let value = uniform; + let textureUpdate = false; + if (value instanceof Framebuffer) { + value = value.texture; + } + if (value instanceof Texture) { + textureUpdate = this.uniforms[uniformName] !== uniform; + if (textureUpdate) { + if (uniformSetter.textureIndex === void 0) { + uniformSetter.textureIndex = this._textureIndexCounter++; + } + const texture = value; + const { + textureIndex + } = uniformSetter; + texture.bind(textureIndex); + value = textureIndex; + this._textureUniforms[uniformName] = texture; + } else { + value = uniformSetter.textureIndex; + } + } else if (this._textureUniforms[uniformName]) { + delete this._textureUniforms[uniformName]; + } + if (uniformSetter(value) || textureUpdate) { + copyUniform(this.uniforms, uniformName, uniform); + } + } + } + return this; } - data = await getArrayBufferOrStringFromData(data, loader, options); - if (loader.parseTextSync && typeof data === "string") { - options.dataType = "text"; - return loader.parseTextSync(data, options, context, loader); + _areTexturesRenderable() { + let texturesRenderable = true; + for (const uniformName in this._textureUniforms) { + const texture = this._textureUniforms[uniformName]; + texture.update(); + texturesRenderable = texturesRenderable && texture.loaded; + } + return texturesRenderable; } - if (canParseWithWorker(loader, options)) { - return await parseWithWorker(loader, data, options, context, parse); + _bindTextures() { + for (const uniformName in this._textureUniforms) { + const textureIndex = this._uniformSetters[uniformName].textureIndex; + this._textureUniforms[uniformName].bind(textureIndex); + } } - if (loader.parseText && typeof data === "string") { - return await loader.parseText(data, options, context, loader); + _createHandle() { + return this.gl.createProgram(); } - if (loader.parse) { - return await loader.parse(data, options, context, loader); + _deleteHandle() { + this.gl.deleteProgram(this.handle); } - assert2(!loader.parseSync); - throw new Error("".concat(loader.id, " loader - no parser found and worker is disabled")); - } - - // node_modules/@loaders.gl/core/dist/esm/lib/api/load.js - async function load(url, loaders, options, context) { - if (!Array.isArray(loaders) && !isLoaderObject(loaders)) { - context = void 0; - options = loaders; - loaders = void 0; + _getOptionsFromHandle(handle) { + const shaderHandles = this.gl.getAttachedShaders(handle); + const opts = {}; + for (const shaderHandle of shaderHandles) { + const type = this.gl.getShaderParameter(this.handle, 35663); + switch (type) { + case 35633: + opts.vs = new VertexShader({ + handle: shaderHandle + }); + break; + case 35632: + opts.fs = new FragmentShader({ + handle: shaderHandle + }); + break; + default: + } + } + return opts; } - const fetch2 = getFetchFunction(options); - let data = url; - if (typeof url === "string") { - data = await fetch2(url); + _getParameter(pname) { + return this.gl.getProgramParameter(this.handle, pname); } - if (isBlob(url)) { - data = await fetch2(url); + _setId(id) { + if (!id) { + const programName = this._getName(); + this.id = uid(programName); + } } - return await parse(data, loaders, options); - } - - // node_modules/@loaders.gl/images/dist/esm/lib/utils/version.js - var VERSION3 = true ? "3.4.14" : "latest"; - - // node_modules/@loaders.gl/images/dist/esm/lib/category-api/image-type.js - var { - _parseImageNode - } = globalThis; - var IMAGE_SUPPORTED = typeof Image !== "undefined"; - var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined"; - var NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode); - var DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED; - function isImageTypeSupported(type) { - switch (type) { - case "auto": - return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED; - case "imagebitmap": - return IMAGE_BITMAP_SUPPORTED; - case "image": - return IMAGE_SUPPORTED; - case "data": - return DATA_SUPPORTED; - default: - throw new Error("@loaders.gl/images: image ".concat(type, " not supported in this environment")); + _getName() { + let programName = this.vs.getName() || this.fs.getName(); + programName = programName.replace(/shader/i, ""); + programName = programName ? "".concat(programName, "-program") : "program"; + return programName; } - } - function getDefaultImageType() { - if (IMAGE_BITMAP_SUPPORTED) { - return "imagebitmap"; + _compileAndLink() { + const { + gl + } = this; + gl.attachShader(this.handle, this.vs.handle); + gl.attachShader(this.handle, this.fs.handle); + log2.time(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))(); + gl.linkProgram(this.handle); + log2.timeEnd(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))(); + if (gl.debug || log2.level > 0) { + const linked = gl.getProgramParameter(this.handle, 35714); + if (!linked) { + throw new Error("Error linking: ".concat(gl.getProgramInfoLog(this.handle))); + } + gl.validateProgram(this.handle); + const validated = gl.getProgramParameter(this.handle, 35715); + if (!validated) { + throw new Error("Error validating: ".concat(gl.getProgramInfoLog(this.handle))); + } + } } - if (IMAGE_SUPPORTED) { - return "image"; + _readUniformLocationsFromLinkedProgram() { + const { + gl + } = this; + this._uniformSetters = {}; + this._uniformCount = this._getParameter(35718); + for (let i3 = 0; i3 < this._uniformCount; i3++) { + const info = this.gl.getActiveUniform(this.handle, i3); + const { + name + } = parseUniformName(info.name); + let location = gl.getUniformLocation(this.handle, name); + this._uniformSetters[name] = getUniformSetter(gl, location, info); + if (info.size > 1) { + for (let l2 = 0; l2 < info.size; l2++) { + location = gl.getUniformLocation(this.handle, "".concat(name, "[").concat(l2, "]")); + this._uniformSetters["".concat(name, "[").concat(l2, "]")] = getUniformSetter(gl, location, info); + } + } + } + this._textureIndexCounter = 0; } - if (DATA_SUPPORTED) { - return "data"; + getActiveUniforms(uniformIndices, pname) { + return this.gl2.getActiveUniforms(this.handle, uniformIndices, pname); } - throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js"); - } + getUniformBlockIndex(blockName) { + return this.gl2.getUniformBlockIndex(this.handle, blockName); + } + getActiveUniformBlockParameter(blockIndex, pname) { + return this.gl2.getActiveUniformBlockParameter(this.handle, blockIndex, pname); + } + uniformBlockBinding(blockIndex, blockBinding) { + this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding); + } + }; - // node_modules/@loaders.gl/images/dist/esm/lib/category-api/parsed-image-api.js - function getImageType(image) { - const format = getImageTypeOrNull(image); - if (!format) { - throw new Error("Not an image"); + // node_modules/@luma.gl/webgl/dist/esm/classes/query.js + var GL_QUERY_RESULT = 34918; + var GL_QUERY_RESULT_AVAILABLE = 34919; + var GL_TIME_ELAPSED_EXT = 35007; + var GL_GPU_DISJOINT_EXT2 = 36795; + var GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 35976; + var GL_ANY_SAMPLES_PASSED = 35887; + var GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 36202; + var Query = class _Query extends Resource { + get [Symbol.toStringTag]() { + return "Query"; } - return format; - } - function getImageData(image) { - switch (getImageType(image)) { - case "data": - return image; - case "image": - case "imagebitmap": - const canvas = document.createElement("canvas"); - const context = canvas.getContext("2d"); - if (!context) { - throw new Error("getImageData"); + static isSupported(gl) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : []; + const webgl2 = isWebGL2(gl); + const hasTimerQuery = hasFeatures(gl, FEATURES.TIMER_QUERY); + let supported = webgl2 || hasTimerQuery; + for (const key of opts) { + switch (key) { + case "queries": + supported = supported && webgl2; + break; + case "timers": + supported = supported && hasTimerQuery; + break; + default: + assert6(false); } - canvas.width = image.width; - canvas.height = image.height; - context.drawImage(image, 0, 0); - return context.getImageData(0, 0, image.width, image.height); - default: - throw new Error("getImageData"); + } + return supported; } - } - function getImageTypeOrNull(image) { - if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) { - return "imagebitmap"; + constructor(gl) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + super(gl, opts); + this.target = null; + this._queryPending = false; + this._pollingPromise = null; + Object.seal(this); } - if (typeof Image !== "undefined" && image instanceof Image) { - return "image"; + beginTimeElapsedQuery() { + return this.begin(GL_TIME_ELAPSED_EXT); } - if (image && typeof image === "object" && image.data && image.width && image.height) { - return "data"; + beginOcclusionQuery() { + let { + conservative = false + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + return this.begin(conservative ? GL_ANY_SAMPLES_PASSED_CONSERVATIVE : GL_ANY_SAMPLES_PASSED); } - return null; - } - - // node_modules/@loaders.gl/images/dist/esm/lib/parsers/svg-utils.js - var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/; - var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/; - function isSVG(url) { - return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url)); - } - function getBlobOrSVGDataUrl(arrayBuffer2, url) { - if (isSVG(url)) { - const textDecoder = new TextDecoder(); - let xmlText = textDecoder.decode(arrayBuffer2); - try { - if (typeof unescape === "function" && typeof encodeURIComponent === "function") { - xmlText = unescape(encodeURIComponent(xmlText)); - } - } catch (error2) { - throw new Error(error2.message); + beginTransformFeedbackQuery() { + return this.begin(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); + } + begin(target) { + if (this._queryPending) { + return this; } - const src = "data:image/svg+xml;base64,".concat(btoa(xmlText)); - return src; + this.target = target; + this.gl2.beginQuery(this.target, this.handle); + return this; } - return getBlob(arrayBuffer2, url); - } - function getBlob(arrayBuffer2, url) { - if (isSVG(url)) { - throw new Error("SVG cannot be parsed directly to imagebitmap"); + end() { + if (this._queryPending) { + return this; + } + if (this.target) { + this.gl2.endQuery(this.target); + this.target = null; + this._queryPending = true; + } + return this; } - return new Blob([new Uint8Array(arrayBuffer2)]); - } - - // node_modules/@loaders.gl/images/dist/esm/lib/parsers/parse-to-image.js - async function parseToImage(arrayBuffer2, options, url) { - const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer2, url); - const URL2 = self.URL || self.webkitURL; - const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl); - try { - return await loadToImage(objectUrl || blobOrDataUrl, options); - } finally { - if (objectUrl) { - URL2.revokeObjectURL(objectUrl); + isResultAvailable() { + if (!this._queryPending) { + return false; + } + const resultAvailable = this.gl2.getQueryParameter(this.handle, GL_QUERY_RESULT_AVAILABLE); + if (resultAvailable) { + this._queryPending = false; } + return resultAvailable; } - } - async function loadToImage(url, options) { - const image = new Image(); - image.src = url; - if (options.image && options.image.decode && image.decode) { - await image.decode(); - return image; + isTimerDisjoint() { + return this.gl2.getParameter(GL_GPU_DISJOINT_EXT2); } - return await new Promise((resolve2, reject) => { - try { - image.onload = () => resolve2(image); - image.onerror = (err) => reject(new Error("Could not load image ".concat(url, ": ").concat(err))); - } catch (error2) { - reject(error2); - } - }); - } - - // node_modules/@loaders.gl/images/dist/esm/lib/parsers/parse-to-image-bitmap.js - var EMPTY_OBJECT = {}; - var imagebitmapOptionsSupported = true; - async function parseToImageBitmap(arrayBuffer2, options, url) { - let blob; - if (isSVG(url)) { - const image = await parseToImage(arrayBuffer2, options, url); - blob = image; - } else { - blob = getBlob(arrayBuffer2, url); + getResult() { + return this.gl2.getQueryParameter(this.handle, GL_QUERY_RESULT); } - const imagebitmapOptions = options && options.imagebitmap; - return await safeCreateImageBitmap(blob, imagebitmapOptions); - } - async function safeCreateImageBitmap(blob) { - let imagebitmapOptions = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null; - if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) { - imagebitmapOptions = null; + getTimerMilliseconds() { + return this.getResult() / 1e6; } - if (imagebitmapOptions) { - try { - return await createImageBitmap(blob, imagebitmapOptions); - } catch (error2) { - console.warn(error2); - imagebitmapOptionsSupported = false; + createPoll() { + let limit = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Number.POSITIVE_INFINITY; + if (this._pollingPromise) { + return this._pollingPromise; } + let counter2 = 0; + this._pollingPromise = new Promise((resolve2, reject) => { + const poll = () => { + if (this.isResultAvailable()) { + resolve2(this.getResult()); + this._pollingPromise = null; + } else if (counter2++ > limit) { + reject("Timed out"); + this._pollingPromise = null; + } else { + requestAnimationFrame(poll); + } + }; + requestAnimationFrame(poll); + }); + return this._pollingPromise; } - return await createImageBitmap(blob); - } - function isEmptyObject(object) { - for (const key in object || EMPTY_OBJECT) { - return false; + _createHandle() { + return _Query.isSupported(this.gl) ? this.gl2.createQuery() : null; } - return true; - } + _deleteHandle() { + this.gl2.deleteQuery(this.handle); + } + }; - // node_modules/@loaders.gl/images/dist/esm/lib/category-api/parse-isobmff-binary.js - function getISOBMFFMediaType(buffer) { - if (!checkString(buffer, "ftyp", 4)) { - return null; + // node_modules/@luma.gl/webgl/dist/esm/classes/transform-feedback.js + var TransformFeedback = class extends Resource { + get [Symbol.toStringTag]() { + return "TransformFeedback"; } - if ((buffer[8] & 96) === 0) { - return null; + static isSupported(gl) { + return isWebGL2(gl); } - return decodeMajorBrand(buffer); - } - function decodeMajorBrand(buffer) { - const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim(); - switch (brandMajor) { - case "avif": - case "avis": - return { - extension: "avif", - mimeType: "image/avif" - }; - default: - return null; + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + assertWebGL2Context(gl); + super(gl, props); + this.initialize(props); + this.stubRemovedMethods("TransformFeedback", "v6.0", ["pause", "resume"]); + Object.seal(this); } - } - function getUTF8String(array, start, end) { - return String.fromCharCode(...array.slice(start, end)); - } - function stringToBytes(string) { - return [...string].map((character) => character.charCodeAt(0)); - } - function checkString(buffer, header) { - let offset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0; - const headerBytes = stringToBytes(header); - for (let i2 = 0; i2 < headerBytes.length; ++i2) { - if (headerBytes[i2] !== buffer[i2 + offset]) { - return false; + initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this.buffers = {}; + this.unused = {}; + this.configuration = null; + this.bindOnUse = true; + if (!isObjectEmpty2(this.buffers)) { + this.bind(() => this._unbindBuffers()); } + this.setProps(props); + return this; } - return true; - } - - // node_modules/@loaders.gl/images/dist/esm/lib/category-api/binary-image-api.js - var BIG_ENDIAN = false; - var LITTLE_ENDIAN = true; - function getBinaryImageMetadata(binaryData) { - const dataView = toDataView(binaryData); - return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView); - } - function getISOBMFFMetadata(binaryData) { - const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData); - const mediaType = getISOBMFFMediaType(buffer); - if (!mediaType) { - return null; - } - return { - mimeType: mediaType.mimeType, - width: 0, - height: 0 - }; - } - function getPngMetadata(binaryData) { - const dataView = toDataView(binaryData); - const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511; - if (!isPng) { - return null; + setProps(props) { + if ("program" in props) { + this.configuration = props.program && props.program.configuration; + } + if ("configuration" in props) { + this.configuration = props.configuration; + } + if ("bindOnUse" in props) { + props = props.bindOnUse; + } + if ("buffers" in props) { + this.setBuffers(props.buffers); + } } - return { - mimeType: "image/png", - width: dataView.getUint32(16, BIG_ENDIAN), - height: dataView.getUint32(20, BIG_ENDIAN) - }; - } - function getGifMetadata(binaryData) { - const dataView = toDataView(binaryData); - const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440; - if (!isGif) { - return null; + setBuffers() { + let buffers = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this.bind(() => { + for (const bufferName in buffers) { + this.setBuffer(bufferName, buffers[bufferName]); + } + }); + return this; } - return { - mimeType: "image/gif", - width: dataView.getUint16(6, LITTLE_ENDIAN), - height: dataView.getUint16(8, LITTLE_ENDIAN) - }; - } - function getBmpMetadata(binaryData) { - const dataView = toDataView(binaryData); - const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength; - if (!isBmp) { - return null; + setBuffer(locationOrName, bufferOrParams) { + const location = this._getVaryingIndex(locationOrName); + const { + buffer, + byteSize, + byteOffset + } = this._getBufferParams(bufferOrParams); + if (location < 0) { + this.unused[locationOrName] = buffer; + log2.warn("".concat(this.id, " unused varying buffer ").concat(locationOrName))(); + return this; + } + this.buffers[location] = bufferOrParams; + if (!this.bindOnUse) { + this._bindBuffer(location, buffer, byteOffset, byteSize); + } + return this; } - return { - mimeType: "image/bmp", - width: dataView.getUint32(18, LITTLE_ENDIAN), - height: dataView.getUint32(22, LITTLE_ENDIAN) - }; - } - function getJpegMetadata(binaryData) { - const dataView = toDataView(binaryData); - const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255; - if (!isJpeg) { - return null; + begin() { + let primitiveMode = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0; + this.gl.bindTransformFeedback(36386, this.handle); + this._bindBuffers(); + this.gl.beginTransformFeedback(primitiveMode); + return this; } - const { - tableMarkers, - sofMarkers - } = getJpegMarkers(); - let i2 = 2; - while (i2 + 9 < dataView.byteLength) { - const marker = dataView.getUint16(i2, BIG_ENDIAN); - if (sofMarkers.has(marker)) { - return { - mimeType: "image/jpeg", - height: dataView.getUint16(i2 + 5, BIG_ENDIAN), - width: dataView.getUint16(i2 + 7, BIG_ENDIAN) - }; + end() { + this.gl.endTransformFeedback(); + this._unbindBuffers(); + this.gl.bindTransformFeedback(36386, null); + return this; + } + _getBufferParams(bufferOrParams) { + let byteOffset; + let byteSize; + let buffer; + if (bufferOrParams instanceof Buffer2 === false) { + buffer = bufferOrParams.buffer; + byteSize = bufferOrParams.byteSize; + byteOffset = bufferOrParams.byteOffset; + } else { + buffer = bufferOrParams; } - if (!tableMarkers.has(marker)) { - return null; + if (byteOffset !== void 0 || byteSize !== void 0) { + byteOffset = byteOffset || 0; + byteSize = byteSize || buffer.byteLength - byteOffset; } - i2 += 2; - i2 += dataView.getUint16(i2, BIG_ENDIAN); + return { + buffer, + byteOffset, + byteSize + }; } - return null; - } - function getJpegMarkers() { - const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]); - for (let i2 = 65504; i2 < 65520; ++i2) { - tableMarkers.add(i2); + _getVaryingInfo(locationOrName) { + return this.configuration && this.configuration.getVaryingInfo(locationOrName); } - const sofMarkers = /* @__PURE__ */ new Set([65472, 65473, 65474, 65475, 65477, 65478, 65479, 65481, 65482, 65483, 65485, 65486, 65487, 65502]); - return { - tableMarkers, - sofMarkers - }; - } - function toDataView(data) { - if (data instanceof DataView) { - return data; + _getVaryingIndex(locationOrName) { + if (this.configuration) { + return this.configuration.getVaryingInfo(locationOrName).location; + } + const location = Number(locationOrName); + return Number.isFinite(location) ? location : -1; } - if (ArrayBuffer.isView(data)) { - return new DataView(data.buffer); + _bindBuffers() { + if (this.bindOnUse) { + for (const bufferIndex in this.buffers) { + const { + buffer, + byteSize, + byteOffset + } = this._getBufferParams(this.buffers[bufferIndex]); + this._bindBuffer(bufferIndex, buffer, byteOffset, byteSize); + } + } } - if (data instanceof ArrayBuffer) { - return new DataView(data); + _unbindBuffers() { + if (this.bindOnUse) { + for (const bufferIndex in this.buffers) { + this._bindBuffer(bufferIndex, null); + } + } } - throw new Error("toDataView"); - } - - // node_modules/@loaders.gl/images/dist/esm/lib/parsers/parse-to-node-image.js - async function parseToNodeImage(arrayBuffer2, options) { - const { - mimeType - } = getBinaryImageMetadata(arrayBuffer2) || {}; - const _parseImageNode2 = globalThis._parseImageNode; - assert(_parseImageNode2); - return await _parseImageNode2(arrayBuffer2, mimeType); - } - - // node_modules/@loaders.gl/images/dist/esm/lib/parsers/parse-image.js - async function parseImage(arrayBuffer2, options, context) { - options = options || {}; - const imageOptions = options.image || {}; - const imageType = imageOptions.type || "auto"; - const { - url - } = context || {}; - const loadType = getLoadableImageType(imageType); - let image; - switch (loadType) { - case "imagebitmap": - image = await parseToImageBitmap(arrayBuffer2, options, url); - break; - case "image": - image = await parseToImage(arrayBuffer2, options, url); - break; - case "data": - image = await parseToNodeImage(arrayBuffer2, options); - break; - default: - assert(false); + _bindBuffer(index, buffer) { + let byteOffset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0; + let byteSize = arguments.length > 3 ? arguments[3] : void 0; + const handle = buffer && buffer.handle; + if (!handle || byteSize === void 0) { + this.gl.bindBufferBase(35982, index, handle); + } else { + this.gl.bindBufferRange(35982, index, handle, byteOffset, byteSize); + } + return this; } - if (imageType === "data") { - image = getImageData(image); + _createHandle() { + return this.gl.createTransformFeedback(); } - return image; - } - function getLoadableImageType(type) { - switch (type) { - case "auto": - case "data": - return getDefaultImageType(); - default: - isImageTypeSupported(type); - return type; + _deleteHandle() { + this.gl.deleteTransformFeedback(this.handle); } - } - - // node_modules/@loaders.gl/images/dist/esm/image-loader.js - var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"]; - var MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/bmp", "image/vnd.microsoft.icon", "image/svg+xml"]; - var DEFAULT_IMAGE_LOADER_OPTIONS = { - image: { - type: "auto", - decode: true + _bindHandle(handle) { + this.gl.bindTransformFeedback(36386, this.handle); } }; - var ImageLoader = { - id: "image", - module: "images", - name: "Images", - version: VERSION3, - mimeTypes: MIME_TYPES, - extensions: EXTENSIONS, - parse: parseImage, - tests: [(arrayBuffer2) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer2)))], - options: DEFAULT_IMAGE_LOADER_OPTIONS - }; - // node_modules/@probe.gl/env/dist/esm/lib/is-electron.js - function isElectron2(mockUserAgent) { - if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") { - return true; + // node_modules/@luma.gl/webgl/dist/esm/utils/array-utils-flat.js + var arrayBuffer = null; + function getScratchArrayBuffer(byteLength) { + if (!arrayBuffer || arrayBuffer.byteLength < byteLength) { + arrayBuffer = new ArrayBuffer(byteLength); } - if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) { - return true; + return arrayBuffer; + } + function getScratchArray(Type, length4) { + const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length4); + return new Type(scratchArrayBuffer, 0, length4); + } + function fillArray(_ref) { + let { + target, + source, + start = 0, + count: count2 = 1 + } = _ref; + const length4 = source.length; + const total = count2 * length4; + let copied = 0; + for (let i3 = start; copied < length4; copied++) { + target[i3++] = source[copied]; } - const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent; - const userAgent2 = mockUserAgent || realUserAgent; - if (userAgent2 && userAgent2.indexOf("Electron") >= 0) { - return true; + while (copied < total) { + if (copied < total - copied) { + target.copyWithin(start + copied, start, start + copied); + copied *= 2; + } else { + target.copyWithin(start + copied, start, start + total - copied); + copied = total; + } } - return false; - } - - // node_modules/@probe.gl/env/dist/esm/lib/is-browser.js - function isBrowser5() { - const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser; - return !isNode || isElectron2(); + return target; } - // node_modules/@probe.gl/env/dist/esm/lib/globals.js - var globals3 = { - self: typeof self !== "undefined" && self, - window: typeof window !== "undefined" && window, - global: typeof global !== "undefined" && global, - document: typeof document !== "undefined" && document, - process: typeof process === "object" && process - }; - var self_4 = globals3.self || globals3.window || globals3.global; - var window_4 = globals3.window || globals3.self || globals3.global; - var document_4 = globals3.document || {}; - var process_2 = globals3.process || {}; - - // node_modules/@probe.gl/env/dist/esm/utils/globals.js - var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source"; - var isBrowser6 = isBrowser5(); - - // node_modules/@probe.gl/env/dist/esm/lib/get-browser.js - var window2 = globalThis; - function getBrowser(mockUserAgent) { - if (!mockUserAgent && !isBrowser5()) { - return "Node"; + // node_modules/@luma.gl/webgl/dist/esm/classes/vertex-array-object.js + var ERR_ELEMENTS = "elements must be GL.ELEMENT_ARRAY_BUFFER"; + var VertexArrayObject = class _VertexArrayObject extends Resource { + get [Symbol.toStringTag]() { + return "VertexArrayObject"; } - if (isElectron2(mockUserAgent)) { - return "Electron"; + static isSupported(gl) { + let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + if (options.constantAttributeZero) { + return isWebGL2(gl) || getBrowser() === "Chrome"; + } + return true; } - const navigator_2 = typeof navigator !== "undefined" ? navigator : {}; - const userAgent2 = mockUserAgent || navigator_2.userAgent || ""; - if (userAgent2.indexOf("Edge") > -1) { - return "Edge"; + static getDefaultArray(gl) { + gl.luma = gl.luma || {}; + if (!gl.luma.defaultVertexArray) { + gl.luma.defaultVertexArray = new _VertexArrayObject(gl, { + handle: null, + isDefaultArray: true + }); + } + return gl.luma.defaultVertexArray; } - const isMSIE = userAgent2.indexOf("MSIE ") !== -1; - const isTrident = userAgent2.indexOf("Trident/") !== -1; - if (isMSIE || isTrident) { - return "IE"; + static getMaxAttributes(gl) { + _VertexArrayObject.MAX_ATTRIBUTES = _VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(34921); + return _VertexArrayObject.MAX_ATTRIBUTES; } - if (window2.chrome) { - return "Chrome"; + static setConstant(gl, location, array) { + switch (array.constructor) { + case Float32Array: + _VertexArrayObject._setConstantFloatArray(gl, location, array); + break; + case Int32Array: + _VertexArrayObject._setConstantIntArray(gl, location, array); + break; + case Uint32Array: + _VertexArrayObject._setConstantUintArray(gl, location, array); + break; + default: + assert6(false); + } } - if (window2.safari) { - return "Safari"; + constructor(gl) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const id = opts.id || opts.program && opts.program.id; + super(gl, Object.assign({}, opts, { + id + })); + this.buffer = null; + this.bufferValue = null; + this.isDefaultArray = opts.isDefaultArray || false; + this.gl2 = gl; + this.initialize(opts); + Object.seal(this); } - if (window2.mozInnerScreenX) { - return "Firefox"; + delete() { + super.delete(); + if (this.buffer) { + this.buffer.delete(); + } + return this; } - return "Unknown"; - } - - // node_modules/@probe.gl/log/dist/esm/utils/local-storage.js - function getStorage2(type) { - try { - const storage = window[type]; - const x2 = "__storage_test__"; - storage.setItem(x2, x2); - storage.removeItem(x2); - return storage; - } catch (e2) { - return null; + get MAX_ATTRIBUTES() { + return _VertexArrayObject.getMaxAttributes(this.gl); } - } - var LocalStorage2 = class { - constructor(id, defaultConfig) { - let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage"; - _defineProperty(this, "storage", void 0); - _defineProperty(this, "id", void 0); - _defineProperty(this, "config", void 0); - this.storage = getStorage2(type); - this.id = id; - this.config = defaultConfig; - this._loadConfiguration(); + initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + return this.setProps(props); } - getConfiguration() { - return this.config; + setProps(props) { + return this; } - setConfiguration(configuration) { - Object.assign(this.config, configuration); - if (this.storage) { - const serialized = JSON.stringify(this.config); - this.storage.setItem(this.id, serialized); + setElementBuffer() { + let elementBuffer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + assert6(!elementBuffer || elementBuffer.target === 34963, ERR_ELEMENTS); + this.bind(() => { + this.gl.bindBuffer(34963, elementBuffer ? elementBuffer.handle : null); + }); + return this; + } + setBuffer(location, buffer, accessor) { + if (buffer.target === 34963) { + return this.setElementBuffer(buffer, accessor); } + const { + size, + type, + stride, + offset, + normalized, + integer, + divisor + } = accessor; + const { + gl, + gl2 + } = this; + location = Number(location); + this.bind(() => { + gl.bindBuffer(34962, buffer.handle); + if (integer) { + assert6(isWebGL2(gl)); + gl2.vertexAttribIPointer(location, size, type, stride, offset); + } else { + gl.vertexAttribPointer(location, size, type, normalized, stride, offset); + } + gl.enableVertexAttribArray(location); + gl2.vertexAttribDivisor(location, divisor || 0); + }); + return this; } - _loadConfiguration() { - let configuration = {}; - if (this.storage) { - const serializedConfiguration = this.storage.getItem(this.id); - configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {}; + enable(location) { + let enable2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true; + const disablingAttributeZero = !enable2 && location === 0 && !_VertexArrayObject.isSupported(this.gl, { + constantAttributeZero: true + }); + if (!disablingAttributeZero) { + location = Number(location); + this.bind(() => enable2 ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location)); } - Object.assign(this.config, configuration); return this; } - }; - - // node_modules/@probe.gl/log/dist/esm/utils/formatters.js - function formatTime2(ms) { - let formatted; - if (ms < 10) { - formatted = "".concat(ms.toFixed(2), "ms"); - } else if (ms < 100) { - formatted = "".concat(ms.toFixed(1), "ms"); - } else if (ms < 1e3) { - formatted = "".concat(ms.toFixed(0), "ms"); - } else { - formatted = "".concat((ms / 1e3).toFixed(2), "s"); + getConstantBuffer(elementCount, value) { + const constantValue = this._normalizeConstantArrayValue(value); + const byteLength = constantValue.byteLength * elementCount; + const length4 = constantValue.length * elementCount; + let updateNeeded = !this.buffer; + this.buffer = this.buffer || new Buffer2(this.gl, byteLength); + updateNeeded = updateNeeded || this.buffer.reallocate(byteLength); + updateNeeded = updateNeeded || !this._compareConstantArrayValues(constantValue, this.bufferValue); + if (updateNeeded) { + const typedArray = getScratchArray(value.constructor, length4); + fillArray({ + target: typedArray, + source: constantValue, + start: 0, + count: length4 + }); + this.buffer.subData(typedArray); + this.bufferValue = value; + } + return this.buffer; } - return formatted; - } - function leftPad2(string) { - let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8; - const padLength = Math.max(length - string.length, 0); - return "".concat(" ".repeat(padLength)).concat(string); - } - function formatImage2(image, message, scale3) { - let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600; - const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29"); - if (image.width > maxWidth) { - scale3 = Math.min(scale3, maxWidth / image.width); + _normalizeConstantArrayValue(arrayValue) { + if (Array.isArray(arrayValue)) { + return new Float32Array(arrayValue); + } + return arrayValue; } - const width = image.width * scale3; - const height = image.height * scale3; - const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join(""); - return ["".concat(message, " %c+"), style]; - } - - // node_modules/@probe.gl/log/dist/esm/utils/color.js - var COLOR2; - (function(COLOR3) { - COLOR3[COLOR3["BLACK"] = 30] = "BLACK"; - COLOR3[COLOR3["RED"] = 31] = "RED"; - COLOR3[COLOR3["GREEN"] = 32] = "GREEN"; - COLOR3[COLOR3["YELLOW"] = 33] = "YELLOW"; - COLOR3[COLOR3["BLUE"] = 34] = "BLUE"; - COLOR3[COLOR3["MAGENTA"] = 35] = "MAGENTA"; - COLOR3[COLOR3["CYAN"] = 36] = "CYAN"; - COLOR3[COLOR3["WHITE"] = 37] = "WHITE"; - COLOR3[COLOR3["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK"; - COLOR3[COLOR3["BRIGHT_RED"] = 91] = "BRIGHT_RED"; - COLOR3[COLOR3["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN"; - COLOR3[COLOR3["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW"; - COLOR3[COLOR3["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE"; - COLOR3[COLOR3["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA"; - COLOR3[COLOR3["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN"; - COLOR3[COLOR3["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE"; - })(COLOR2 || (COLOR2 = {})); - function getColor2(color) { - return typeof color === "string" ? COLOR2[color.toUpperCase()] || COLOR2.WHITE : color; - } - function addColor2(string, color, background) { - if (!isBrowser5 && typeof string === "string") { - if (color) { - color = getColor2(color); - string = "\x1B[".concat(color, "m").concat(string, "\x1B[39m"); + _compareConstantArrayValues(v1, v2) { + if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) { + return false; } - if (background) { - color = getColor2(background); - string = "\x1B[".concat(background + 10, "m").concat(string, "\x1B[49m"); + for (let i3 = 0; i3 < v1.length; ++i3) { + if (v1[i3] !== v2[i3]) { + return false; + } + } + return true; + } + static _setConstantFloatArray(gl, location, array) { + switch (array.length) { + case 1: + gl.vertexAttrib1fv(location, array); + break; + case 2: + gl.vertexAttrib2fv(location, array); + break; + case 3: + gl.vertexAttrib3fv(location, array); + break; + case 4: + gl.vertexAttrib4fv(location, array); + break; + default: + assert6(false); + } + } + static _setConstantIntArray(gl, location, array) { + assert6(isWebGL2(gl)); + switch (array.length) { + case 1: + gl.vertexAttribI1iv(location, array); + break; + case 2: + gl.vertexAttribI2iv(location, array); + break; + case 3: + gl.vertexAttribI3iv(location, array); + break; + case 4: + gl.vertexAttribI4iv(location, array); + break; + default: + assert6(false); } } - return string; - } - - // node_modules/@probe.gl/log/dist/esm/utils/autobind.js - function autobind2(obj) { - let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"]; - const proto = Object.getPrototypeOf(obj); - const propNames = Object.getOwnPropertyNames(proto); - for (const key of propNames) { - if (typeof obj[key] === "function") { - if (!predefined.find((name) => key === name)) { - obj[key] = obj[key].bind(obj); - } + static _setConstantUintArray(gl, location, array) { + assert6(isWebGL2(gl)); + switch (array.length) { + case 1: + gl.vertexAttribI1uiv(location, array); + break; + case 2: + gl.vertexAttribI2uiv(location, array); + break; + case 3: + gl.vertexAttribI3uiv(location, array); + break; + case 4: + gl.vertexAttribI4uiv(location, array); + break; + default: + assert6(false); } } - } - - // node_modules/@probe.gl/log/dist/esm/utils/assert.js - function assert4(condition, message) { - if (!condition) { - throw new Error(message || "Assertion failed"); + _createHandle() { + const gl2 = this.gl; + return gl2.createVertexArray(); } - } - - // node_modules/@probe.gl/log/dist/esm/utils/hi-res-timestamp.js - function getHiResTimestamp2() { - let timestamp; - if (isBrowser5 && "performance" in window_4) { - var _window$performance, _window$performance$n; - timestamp = window_4 === null || window_4 === void 0 ? void 0 : (_window$performance = window_4.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance); - } else if ("hrtime" in process_2) { - var _process$hrtime; - const timeParts = process_2 === null || process_2 === void 0 ? void 0 : (_process$hrtime = process_2.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_2); - timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; - } else { - timestamp = Date.now(); + _deleteHandle(handle) { + this.gl2.deleteVertexArray(handle); + return [this.elements]; } - return timestamp; - } - - // node_modules/@probe.gl/log/dist/esm/log.js - var originalConsole2 = { - debug: isBrowser5 ? console.debug || console.log : console.log, - log: console.log, - info: console.info, - warn: console.warn, - error: console.error - }; - var DEFAULT_SETTINGS = { - enabled: true, - level: 0 - }; - function noop2() { - } - var cache2 = {}; - var ONCE2 = { - once: true - }; - var Log2 = class { - constructor() { + _bindHandle(handle) { + this.gl2.bindVertexArray(handle); + } + _getParameter(pname, _ref) { let { - id - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : { - id: "" - }; - _defineProperty(this, "id", void 0); - _defineProperty(this, "VERSION", VERSION4); - _defineProperty(this, "_startTs", getHiResTimestamp2()); - _defineProperty(this, "_deltaTs", getHiResTimestamp2()); - _defineProperty(this, "_storage", void 0); - _defineProperty(this, "userData", {}); - _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0); + location + } = _ref; + assert6(Number.isFinite(location)); + return this.bind(() => { + switch (pname) { + case 34373: + return this.gl.getVertexAttribOffset(location, pname); + default: + return this.gl.getVertexAttrib(location, pname); + } + }); + } + }; + + // node_modules/@luma.gl/webgl/dist/esm/classes/vertex-array.js + var ERR_ATTRIBUTE_TYPE = "VertexArray: attributes must be Buffers or constants (i.e. typed array)"; + var MULTI_LOCATION_ATTRIBUTE_REGEXP = /^(.+)__LOCATION_([0-9]+)$/; + var DEPRECATIONS_V6 = ["setBuffers", "setGeneric", "clearBindings", "setLocations", "setGenericValues", "setDivisor", "enable", "disable"]; + var VertexArray = class { + constructor(gl) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const id = opts.id || opts.program && opts.program.id; this.id = id; - this.userData = {}; - this._storage = new LocalStorage2("__probe-".concat(this.id, "__"), DEFAULT_SETTINGS); - this.timeStamp("".concat(this.id, " started")); - autobind2(this); + this.gl = gl; + this.configuration = null; + this.elements = null; + this.elementsAccessor = null; + this.values = null; + this.accessors = null; + this.unused = null; + this.drawParams = null; + this.buffer = null; + this.attributes = {}; + this.vertexArrayObject = new VertexArrayObject(gl); + stubRemovedMethods(this, "VertexArray", "v6.0", DEPRECATIONS_V6); + this.initialize(opts); Object.seal(this); } - set level(newLevel) { - this.setLevel(newLevel); + delete() { + if (this.buffer) { + this.buffer.delete(); + } + this.vertexArrayObject.delete(); } - get level() { - return this.getLevel(); + initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this.reset(); + this.configuration = null; + this.bindOnUse = false; + return this.setProps(props); } - isEnabled() { - return this._storage.config.enabled; + reset() { + this.elements = null; + this.elementsAccessor = null; + const { + MAX_ATTRIBUTES + } = this.vertexArrayObject; + this.values = new Array(MAX_ATTRIBUTES).fill(null); + this.accessors = new Array(MAX_ATTRIBUTES).fill(null); + this.unused = {}; + this.drawParams = null; + return this; } - getLevel() { - return this._storage.config.level; + setProps(props) { + if ("program" in props) { + this.configuration = props.program && props.program.configuration; + } + if ("configuration" in props) { + this.configuration = props.configuration; + } + if ("attributes" in props) { + this.setAttributes(props.attributes); + } + if ("elements" in props) { + this.setElementBuffer(props.elements); + } + if ("bindOnUse" in props) { + props = props.bindOnUse; + } + return this; } - getTotal() { - return Number((getHiResTimestamp2() - this._startTs).toPrecision(10)); + clearDrawParams() { + this.drawParams = null; } - getDelta() { - return Number((getHiResTimestamp2() - this._deltaTs).toPrecision(10)); + getDrawParams() { + this.drawParams = this.drawParams || this._updateDrawParams(); + return this.drawParams; } - set priority(newPriority) { - this.level = newPriority; + setAttributes(attributes) { + Object.assign(this.attributes, attributes); + this.vertexArrayObject.bind(() => { + for (const locationOrName in attributes) { + const value = attributes[locationOrName]; + this._setAttribute(locationOrName, value); + } + this.gl.bindBuffer(34962, null); + }); + return this; } - get priority() { - return this.level; + setElementBuffer() { + let elementBuffer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; + let accessor = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + this.elements = elementBuffer; + this.elementsAccessor = accessor; + this.clearDrawParams(); + this.vertexArrayObject.setElementBuffer(elementBuffer, accessor); + return this; } - getPriority() { - return this.level; + setBuffer(locationOrName, buffer) { + let appAccessor = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + if (buffer.target === 34963) { + return this.setElementBuffer(buffer, appAccessor); + } + const { + location, + accessor + } = this._resolveLocationAndAccessor(locationOrName, buffer, buffer.accessor, appAccessor); + if (location >= 0) { + this.values[location] = buffer; + this.accessors[location] = accessor; + this.clearDrawParams(); + this.vertexArrayObject.setBuffer(location, buffer, accessor); + } + return this; } - enable() { - let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; - this._storage.setConfiguration({ - enabled - }); + setConstant(locationOrName, arrayValue) { + let appAccessor = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + const { + location, + accessor + } = this._resolveLocationAndAccessor(locationOrName, arrayValue, Object.assign({ + size: arrayValue.length + }, appAccessor)); + if (location >= 0) { + arrayValue = this.vertexArrayObject._normalizeConstantArrayValue(arrayValue); + this.values[location] = arrayValue; + this.accessors[location] = accessor; + this.clearDrawParams(); + this.vertexArrayObject.enable(location, false); + } return this; } - setLevel(level) { - this._storage.setConfiguration({ - level + unbindBuffers() { + this.vertexArrayObject.bind(() => { + if (this.elements) { + this.vertexArrayObject.setElementBuffer(null); + } + this.buffer = this.buffer || new Buffer2(this.gl, { + accessor: { + size: 4 + } + }); + for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) { + if (this.values[location] instanceof Buffer2) { + this.gl.disableVertexAttribArray(location); + this.gl.bindBuffer(34962, this.buffer.handle); + this.gl.vertexAttribPointer(location, 1, 5126, false, 0, 0); + } + } }); return this; } - get(setting) { - return this._storage.config[setting]; + bindBuffers() { + this.vertexArrayObject.bind(() => { + if (this.elements) { + this.setElementBuffer(this.elements); + } + for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) { + const buffer = this.values[location]; + if (buffer instanceof Buffer2) { + this.setBuffer(location, buffer); + } + } + }); + return this; } - set(setting, value) { - this._storage.setConfiguration({ - [setting]: value + bindForDraw(vertexCount, instanceCount, func) { + let value; + this.vertexArrayObject.bind(() => { + this._setConstantAttributes(vertexCount, instanceCount); + value = func(); }); + return value; } - settings() { - if (console.table) { - console.table(this._storage.config); - } else { - console.log(this._storage.config); + _resolveLocationAndAccessor(locationOrName, value, valueAccessor, appAccessor) { + const INVALID_RESULT = { + location: -1, + accessor: null + }; + const { + location, + name + } = this._getAttributeIndex(locationOrName); + if (!Number.isFinite(location) || location < 0) { + this.unused[locationOrName] = value; + log2.once(3, () => "unused value ".concat(locationOrName, " in ").concat(this.id))(); + return INVALID_RESULT; } + const accessInfo = this._getAttributeInfo(name || location); + if (!accessInfo) { + return INVALID_RESULT; + } + const currentAccessor = this.accessors[location] || {}; + const accessor = Accessor.resolve(accessInfo.accessor, currentAccessor, valueAccessor, appAccessor); + const { + size, + type + } = accessor; + assert6(Number.isFinite(size) && Number.isFinite(type)); + return { + location, + accessor + }; } - assert(condition, message) { - assert4(condition, message); - } - warn(message) { - return this._getLogFunction(0, message, originalConsole2.warn, arguments, ONCE2); - } - error(message) { - return this._getLogFunction(0, message, originalConsole2.error, arguments); + _getAttributeInfo(attributeName) { + return this.configuration && this.configuration.getAttributeInfo(attributeName); } - deprecated(oldUsage, newUsage) { - return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead")); + _getAttributeIndex(locationOrName) { + const location = Number(locationOrName); + if (Number.isFinite(location)) { + return { + location + }; + } + const multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(locationOrName); + const name = multiLocation ? multiLocation[1] : locationOrName; + const locationOffset = multiLocation ? Number(multiLocation[2]) : 0; + if (this.configuration) { + return { + location: this.configuration.getAttributeLocation(name) + locationOffset, + name + }; + } + return { + location: -1 + }; } - removed(oldUsage, newUsage) { - return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead")); + _setAttribute(locationOrName, value) { + if (value instanceof Buffer2) { + this.setBuffer(locationOrName, value); + } else if (Array.isArray(value) && value.length && value[0] instanceof Buffer2) { + const buffer = value[0]; + const accessor = value[1]; + this.setBuffer(locationOrName, buffer, accessor); + } else if (ArrayBuffer.isView(value) || Array.isArray(value)) { + const constant = value; + this.setConstant(locationOrName, constant); + } else if (value.buffer instanceof Buffer2) { + const accessor = value; + this.setBuffer(locationOrName, accessor.buffer, accessor); + } else { + throw new Error(ERR_ATTRIBUTE_TYPE); + } } - probe(logLevel, message) { - return this._getLogFunction(logLevel, message, originalConsole2.log, arguments, { - time: true, - once: true - }); + _setConstantAttributes(vertexCount, instanceCount) { + const elementCount = Math.max(vertexCount | 0, instanceCount | 0); + let constant = this.values[0]; + if (ArrayBuffer.isView(constant)) { + this._setConstantAttributeZero(constant, elementCount); + } + for (let location = 1; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) { + constant = this.values[location]; + if (ArrayBuffer.isView(constant)) { + this._setConstantAttribute(location, constant); + } + } } - log(logLevel, message) { - return this._getLogFunction(logLevel, message, originalConsole2.debug, arguments); + _setConstantAttributeZero(constant, elementCount) { + if (VertexArrayObject.isSupported(this.gl, { + constantAttributeZero: true + })) { + this._setConstantAttribute(0, constant); + return; + } + const buffer = this.vertexArrayObject.getConstantBuffer(elementCount, constant); + this.vertexArrayObject.setBuffer(0, buffer, this.accessors[0]); } - info(logLevel, message) { - return this._getLogFunction(logLevel, message, console.info, arguments); + _setConstantAttribute(location, constant) { + VertexArrayObject.setConstant(this.gl, location, constant); } - once(logLevel, message) { - for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { - args[_key - 2] = arguments[_key]; + _updateDrawParams() { + const drawParams = { + isIndexed: false, + isInstanced: false, + indexCount: Infinity, + vertexCount: Infinity, + instanceCount: Infinity + }; + for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) { + this._updateDrawParamsForLocation(drawParams, location); } - return this._getLogFunction(logLevel, message, originalConsole2.debug || originalConsole2.info, arguments, ONCE2); - } - table(logLevel, table, columns) { - if (table) { - return this._getLogFunction(logLevel, table, console.table || noop2, columns && [columns], { - tag: getTableHeader2(table) - }); + if (this.elements) { + drawParams.elementCount = this.elements.getElementCount(this.elements.accessor); + drawParams.isIndexed = true; + drawParams.indexType = this.elementsAccessor.type || this.elements.accessor.type; + drawParams.indexOffset = this.elementsAccessor.offset || 0; } - return noop2; + if (drawParams.indexCount === Infinity) { + drawParams.indexCount = 0; + } + if (drawParams.vertexCount === Infinity) { + drawParams.vertexCount = 0; + } + if (drawParams.instanceCount === Infinity) { + drawParams.instanceCount = 0; + } + return drawParams; } - image(_ref) { - let { - logLevel, - priority, - image, - message = "", - scale: scale3 = 1 - } = _ref; - if (!this._shouldLog(logLevel || priority)) { - return noop2; + _updateDrawParamsForLocation(drawParams, location) { + const value = this.values[location]; + const accessor = this.accessors[location]; + if (!value) { + return; + } + const { + divisor + } = accessor; + const isInstanced = divisor > 0; + drawParams.isInstanced = drawParams.isInstanced || isInstanced; + if (value instanceof Buffer2) { + const buffer = value; + if (isInstanced) { + const instanceCount = buffer.getVertexCount(accessor); + drawParams.instanceCount = Math.min(drawParams.instanceCount, instanceCount); + } else { + const vertexCount = buffer.getVertexCount(accessor); + drawParams.vertexCount = Math.min(drawParams.vertexCount, vertexCount); + } } - return isBrowser5 ? logImageInBrowser2({ - image, - message, - scale: scale3 - }) : logImageInNode2({ - image, - message, - scale: scale3 - }); } - time(logLevel, message) { - return this._getLogFunction(logLevel, message, console.time ? console.time : console.info); + setElements() { + let elementBuffer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; + let accessor = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + log2.deprecated("setElements", "setElementBuffer")(); + return this.setElementBuffer(elementBuffer, accessor); + } + }; + + // node_modules/@luma.gl/webgl/dist/esm/utils/format-value.js + function formatArrayValue(v2, opts) { + const { + maxElts = 16, + size = 1 + } = opts; + let string = "["; + for (let i3 = 0; i3 < v2.length && i3 < maxElts; ++i3) { + if (i3 > 0) { + string += ",".concat(i3 % size === 0 ? " " : ""); + } + string += formatValue(v2[i3], opts); } - timeEnd(logLevel, message) { - return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info); + const terminator = v2.length > maxElts ? "..." : "]"; + return "".concat(string).concat(terminator); + } + function formatValue(v2) { + let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const EPSILON3 = 1e-16; + const { + isInteger = false + } = opts; + if (Array.isArray(v2) || ArrayBuffer.isView(v2)) { + return formatArrayValue(v2, opts); } - timeStamp(logLevel, message) { - return this._getLogFunction(logLevel, message, console.timeStamp || noop2); + if (!Number.isFinite(v2)) { + return String(v2); } - group(logLevel, message) { - let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : { - collapsed: false - }; - const options = normalizeArguments2({ - logLevel, - message, - opts - }); - const { - collapsed - } = opts; - options.method = (collapsed ? console.groupCollapsed : console.group) || console.info; - return this._getLogFunction(options); + if (Math.abs(v2) < EPSILON3) { + return isInteger ? "0" : "0."; } - groupCollapsed(logLevel, message) { - let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; - return this.group(logLevel, message, Object.assign({}, opts, { - collapsed: true - })); + if (isInteger) { + return v2.toFixed(0); } - groupEnd(logLevel) { - return this._getLogFunction(logLevel, "", console.groupEnd || noop2); + if (Math.abs(v2) > 100 && Math.abs(v2) < 1e4) { + return v2.toFixed(0); } - withGroup(logLevel, message, func) { - this.group(logLevel, message)(); - try { - func(); - } finally { - this.groupEnd(logLevel)(); + const string = v2.toPrecision(2); + const decimal = string.indexOf(".0"); + return decimal === string.length - 2 ? string.slice(0, -1) : string; + } + + // node_modules/@luma.gl/webgl/dist/esm/debug/debug-uniforms.js + function getDebugTableForUniforms(_ref) { + let { + header = "Uniforms", + program, + uniforms, + undefinedOnly = false + } = _ref; + assert6(program); + const SHADER_MODULE_UNIFORM_REGEXP = ".*_.*"; + const PROJECT_MODULE_UNIFORM_REGEXP = ".*Matrix"; + const uniformLocations = program._uniformSetters; + const table = {}; + const uniformNames = Object.keys(uniformLocations).sort(); + let count2 = 0; + for (const uniformName of uniformNames) { + if (!uniformName.match(SHADER_MODULE_UNIFORM_REGEXP) && !uniformName.match(PROJECT_MODULE_UNIFORM_REGEXP)) { + if (addUniformToTable({ + table, + header, + uniforms, + uniformName, + undefinedOnly + })) { + count2++; + } } } - trace() { - if (console.trace) { - console.trace(); + for (const uniformName of uniformNames) { + if (uniformName.match(PROJECT_MODULE_UNIFORM_REGEXP)) { + if (addUniformToTable({ + table, + header, + uniforms, + uniformName, + undefinedOnly + })) { + count2++; + } } } - _shouldLog(logLevel) { - return this.isEnabled() && this.getLevel() >= normalizeLogLevel2(logLevel); + for (const uniformName of uniformNames) { + if (!table[uniformName]) { + if (addUniformToTable({ + table, + header, + uniforms, + uniformName, + undefinedOnly + })) { + count2++; + } + } } - _getLogFunction(logLevel, message, method, args, opts) { - if (this._shouldLog(logLevel)) { - opts = normalizeArguments2({ - logLevel, - message, - args, - opts - }); - method = method || opts.method; - assert4(method); - opts.total = this.getTotal(); - opts.delta = this.getDelta(); - this._deltaTs = getHiResTimestamp2(); - const tag = opts.tag || opts.message; - if (opts.once) { - if (!cache2[tag]) { - cache2[tag] = getHiResTimestamp2(); - } else { - return noop2; - } + let unusedCount = 0; + const unusedTable = {}; + if (!undefinedOnly) { + for (const uniformName in uniforms) { + const uniform = uniforms[uniformName]; + if (!table[uniformName]) { + unusedCount++; + unusedTable[uniformName] = { + Type: "NOT USED: ".concat(uniform), + [header]: formatValue(uniform) + }; } - message = decorateMessage2(this.id, opts.message, opts); - return method.bind(console, message, ...opts.args); } - return noop2; } - }; - _defineProperty(Log2, "VERSION", VERSION4); - function normalizeLogLevel2(logLevel) { - if (!logLevel) { - return 0; + return { + table, + count: count2, + unusedTable, + unusedCount + }; + } + function addUniformToTable(_ref2) { + let { + table, + header, + uniforms, + uniformName, + undefinedOnly + } = _ref2; + const value = uniforms[uniformName]; + const isDefined = isUniformDefined(value); + if (!undefinedOnly || !isDefined) { + table[uniformName] = { + [header]: isDefined ? formatValue(value) : "N/A", + "Uniform Type": isDefined ? value : "NOT PROVIDED" + }; + return true; } - let resolvedLevel; - switch (typeof logLevel) { - case "number": - resolvedLevel = logLevel; - break; - case "object": - resolvedLevel = logLevel.logLevel || logLevel.priority || 0; - break; - default: - return 0; + return false; + } + function isUniformDefined(value) { + return value !== void 0 && value !== null; + } + + // node_modules/@luma.gl/webgl/dist/esm/debug/debug-vertex-array.js + function getDebugTableForVertexArray(_ref) { + let { + vertexArray, + header = "Attributes" + } = _ref; + if (!vertexArray.configuration) { + return {}; } - assert4(Number.isFinite(resolvedLevel) && resolvedLevel >= 0); - return resolvedLevel; + const table = {}; + if (vertexArray.elements) { + table.ELEMENT_ARRAY_BUFFER = getDebugTableRow(vertexArray, vertexArray.elements, null, header); + } + const attributes = vertexArray.values; + for (const attributeLocation in attributes) { + const info = vertexArray._getAttributeInfo(attributeLocation); + if (info) { + let rowHeader = "".concat(attributeLocation, ": ").concat(info.name); + const accessor = vertexArray.accessors[info.location]; + if (accessor) { + rowHeader = "".concat(attributeLocation, ": ").concat(getGLSLDeclaration(info.name, accessor)); + } + table[rowHeader] = getDebugTableRow(vertexArray, attributes[attributeLocation], accessor, header); + } + } + return table; } - function normalizeArguments2(opts) { + function getDebugTableRow(vertexArray, attribute, accessor, header) { const { - logLevel, - message - } = opts; - opts.logLevel = normalizeLogLevel2(logLevel); - const args = opts.args ? Array.from(opts.args) : []; - while (args.length && args.shift() !== message) { + gl + } = vertexArray; + if (!attribute) { + return { + [header]: "null", + "Format ": "N/A" + }; } - switch (typeof logLevel) { - case "string": - case "function": - if (message !== void 0) { - args.unshift(message); - } - opts.message = logLevel; - break; - case "object": - Object.assign(opts, logLevel); - break; - default: + let type = "NOT PROVIDED"; + let size = 1; + let verts = 0; + let bytes = 0; + let isInteger; + let marker; + let value; + if (accessor) { + type = accessor.type; + size = accessor.size; + type = String(type).replace("Array", ""); + isInteger = type.indexOf("nt") !== -1; } - if (typeof opts.message === "function") { - opts.message = opts.message(); + if (attribute instanceof Buffer2) { + const buffer = attribute; + const { + data, + changed + } = buffer.getDebugData(); + marker = changed ? "*" : ""; + value = data; + bytes = buffer.byteLength; + verts = bytes / data.BYTES_PER_ELEMENT / size; + let format; + if (accessor) { + const instanced = accessor.divisor > 0; + format = "".concat(instanced ? "I " : "P ", " ").concat(verts, " (x").concat(size, "=").concat(bytes, " bytes ").concat(getKey(gl, type), ")"); + } else { + isInteger = true; + format = "".concat(bytes, " bytes"); + } + return { + [header]: "".concat(marker).concat(formatValue(value, { + size, + isInteger + })), + "Format ": format + }; } - const messageType = typeof opts.message; - assert4(messageType === "string" || messageType === "object"); - return Object.assign(opts, { - args - }, opts.opts); + value = attribute; + size = attribute.length; + type = String(attribute.constructor.name).replace("Array", ""); + isInteger = type.indexOf("nt") !== -1; + return { + [header]: "".concat(formatValue(value, { + size, + isInteger + }), " (constant)"), + "Format ": "".concat(size, "x").concat(type, " (constant)") + }; } - function decorateMessage2(id, message, opts) { - if (typeof message === "string") { - const time = opts.time ? leftPad2(formatTime2(opts.total)) : ""; - message = opts.time ? "".concat(id, ": ").concat(time, " ").concat(message) : "".concat(id, ": ").concat(message); - message = addColor2(message, opts.color, opts.background); + function getGLSLDeclaration(name, accessor) { + const { + type, + size + } = accessor; + const typeAndName = getCompositeGLType(type, size); + return typeAndName ? "".concat(name, " (").concat(typeAndName.name, ")") : name; + } + + // node_modules/@luma.gl/webgl/dist/esm/debug/debug-program-configuration.js + function getDebugTableForProgramConfiguration(config2) { + const table = {}; + const header = "Accessors for ".concat(config2.id); + for (const attributeInfo of config2.attributeInfos) { + if (attributeInfo) { + const glslDeclaration = getGLSLDeclaration2(attributeInfo); + table["in ".concat(glslDeclaration)] = { + [header]: JSON.stringify(attributeInfo.accessor) + }; + } } - return message; + for (const varyingInfo of config2.varyingInfos) { + if (varyingInfo) { + const glslDeclaration = getGLSLDeclaration2(varyingInfo); + table["out ".concat(glslDeclaration)] = { + [header]: JSON.stringify(varyingInfo.accessor) + }; + } + } + return table; } - function logImageInNode2(_ref2) { - let { - image, - message = "", - scale: scale3 = 1 - } = _ref2; - console.warn("removed"); - return noop2; + function getGLSLDeclaration2(attributeInfo) { + const { + type, + size + } = attributeInfo.accessor; + const typeAndName = getCompositeGLType(type, size); + if (typeAndName) { + return "".concat(typeAndName.name, " ").concat(attributeInfo.name); + } + return attributeInfo.name; } - function logImageInBrowser2(_ref3) { - let { - image, - message = "", - scale: scale3 = 1 - } = _ref3; - if (typeof image === "string") { - const img = new Image(); - img.onload = () => { - const args = formatImage2(img, message, scale3); - console.log(...args); + + // node_modules/@luma.gl/engine/dist/esm/lib/animation-loop.js + var isPage2 = isBrowser5() && typeof document !== "undefined"; + var statIdCounter = 0; + var AnimationLoop = class { + constructor() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + onCreateContext = (opts) => createGLContext(opts), + onAddHTML = null, + onInitialize = () => { + }, + onRender = () => { + }, + onFinalize = () => { + }, + onError, + gl = null, + glOptions = {}, + debug: debug2 = false, + createFramebuffer = false, + autoResizeViewport = true, + autoResizeDrawingBuffer = true, + stats = lumaStats.get("animation-loop-".concat(statIdCounter++)) + } = props; + let { + useDevicePixels = true + } = props; + if ("useDevicePixelRatio" in props) { + log2.deprecated("useDevicePixelRatio", "useDevicePixels")(); + useDevicePixels = props.useDevicePixelRatio; + } + this.props = { + onCreateContext, + onAddHTML, + onInitialize, + onRender, + onFinalize, + onError, + gl, + glOptions, + debug: debug2, + createFramebuffer }; - img.src = image; - return noop2; + this.gl = gl; + this.needsRedraw = null; + this.timeline = null; + this.stats = stats; + this.cpuTime = this.stats.get("CPU Time"); + this.gpuTime = this.stats.get("GPU Time"); + this.frameRate = this.stats.get("Frame Rate"); + this._initialized = false; + this._running = false; + this._animationFrameId = null; + this._nextFramePromise = null; + this._resolveNextFrame = null; + this._cpuStartTime = 0; + this.setProps({ + autoResizeViewport, + autoResizeDrawingBuffer, + useDevicePixels + }); + this.start = this.start.bind(this); + this.stop = this.stop.bind(this); + this._pageLoadPromise = null; + this._onMousemove = this._onMousemove.bind(this); + this._onMouseleave = this._onMouseleave.bind(this); } - const element = image.nodeName || ""; - if (element.toLowerCase() === "img") { - console.log(...formatImage2(image, message, scale3)); - return noop2; + delete() { + this.stop(); + this._setDisplay(null); } - if (element.toLowerCase() === "canvas") { - const img = new Image(); - img.onload = () => console.log(...formatImage2(img, message, scale3)); - img.src = image.toDataURL(); - return noop2; + setNeedsRedraw(reason) { + assert6(typeof reason === "string"); + this.needsRedraw = this.needsRedraw || reason; + return this; } - return noop2; - } - function getTableHeader2(table) { - for (const key in table) { - for (const title in table[key]) { - return title || "untitled"; + setProps(props) { + if ("autoResizeViewport" in props) { + this.autoResizeViewport = props.autoResizeViewport; } - } - return "empty"; - } - - // node_modules/@probe.gl/log/dist/esm/index.js - var esm_default = new Log2({ - id: "@probe.gl/log" - }); - - // node_modules/@deck.gl/core/dist/esm/utils/log.js - var log_default = new Log2({ - id: "deck" - }); - - // node_modules/@deck.gl/core/dist/esm/debug/loggers.js - var logState = { - attributeUpdateStart: -1, - attributeManagerUpdateStart: -1, - attributeUpdateMessages: [] - }; - var LOG_LEVEL_MAJOR_UPDATE = 1; - var LOG_LEVEL_MINOR_UPDATE = 2; - var LOG_LEVEL_UPDATE_DETAIL = 3; - var LOG_LEVEL_INFO = 4; - var LOG_LEVEL_DRAW = 2; - var getLoggers = (log4) => ({ - "layer.changeFlag": (layer, key, flags) => { - log4.log(LOG_LEVEL_UPDATE_DETAIL, "".concat(layer.id, " ").concat(key, ": "), flags[key])(); - }, - "layer.initialize": (layer) => { - log4.log(LOG_LEVEL_MAJOR_UPDATE, "Initializing ".concat(layer))(); - }, - "layer.update": (layer, needsUpdate) => { - if (needsUpdate) { - const flags = layer.getChangeFlags(); - log4.log(LOG_LEVEL_MINOR_UPDATE, "Updating ".concat(layer, " because: ").concat(Object.keys(flags).filter((key) => flags[key]).join(", ")))(); - } else { - log4.log(LOG_LEVEL_INFO, "".concat(layer, " does not need update"))(); + if ("autoResizeDrawingBuffer" in props) { + this.autoResizeDrawingBuffer = props.autoResizeDrawingBuffer; } - }, - "layer.matched": (layer, changed) => { - if (changed) { - log4.log(LOG_LEVEL_INFO, "Matched ".concat(layer, ", state transfered"))(); + if ("useDevicePixels" in props) { + this.useDevicePixels = props.useDevicePixels; } - }, - "layer.finalize": (layer) => { - log4.log(LOG_LEVEL_MAJOR_UPDATE, "Finalizing ".concat(layer))(); - }, - "compositeLayer.renderLayers": (layer, updated, subLayers) => { - if (updated) { - log4.log(LOG_LEVEL_MINOR_UPDATE, "Composite layer rendered new subLayers ".concat(layer), subLayers)(); - } else { - log4.log(LOG_LEVEL_INFO, "Composite layer reused subLayers ".concat(layer), subLayers)(); + return this; + } + start() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (this._running) { + return this; + } + this._running = true; + const startPromise = this._getPageLoadPromise().then(() => { + if (!this._running || this._initialized) { + return null; + } + this._createWebGLContext(opts); + this._createFramebuffer(); + this._startEventHandling(); + this._initializeCallbackData(); + this._updateCallbackData(); + this._resizeCanvasDrawingBuffer(); + this._resizeViewport(); + this._gpuTimeQuery = Query.isSupported(this.gl, ["timers"]) ? new Query(this.gl) : null; + this._initialized = true; + return this.onInitialize(this.animationProps); + }).then((appContext) => { + if (this._running) { + this._addCallbackData(appContext || {}); + if (appContext !== false) { + this._startLoop(); + } + } + }); + if (this.props.onError) { + startPromise.catch(this.props.onError); } - }, - "layerManager.setLayers": (layerManager, updated, layers) => { - if (updated) { - log4.log(LOG_LEVEL_MINOR_UPDATE, "Updating ".concat(layers.length, " deck layers"))(); + return this; + } + redraw() { + if (this.isContextLost()) { + return this; } - }, - "layerManager.activateViewport": (layerManager, viewport) => { - log4.log(LOG_LEVEL_UPDATE_DETAIL, "Viewport changed", viewport)(); - }, - "attributeManager.invalidate": (attributeManager, trigger, attributeNames) => { - log4.log(LOG_LEVEL_MAJOR_UPDATE, attributeNames ? "invalidated attributes ".concat(attributeNames, " (").concat(trigger, ") for ").concat(attributeManager.id) : "invalidated all attributes for ".concat(attributeManager.id))(); - }, - "attributeManager.updateStart": (attributeManager) => { - logState.attributeUpdateMessages.length = 0; - logState.attributeManagerUpdateStart = Date.now(); - }, - "attributeManager.updateEnd": (attributeManager, numInstances) => { - const timeMs = Math.round(Date.now() - logState.attributeManagerUpdateStart); - log4.groupCollapsed(LOG_LEVEL_MINOR_UPDATE, "Updated attributes for ".concat(numInstances, " instances in ").concat(attributeManager.id, " in ").concat(timeMs, "ms"))(); - for (const updateMessage of logState.attributeUpdateMessages) { - log4.log(LOG_LEVEL_UPDATE_DETAIL, updateMessage)(); + this._beginTimers(); + this._setupFrame(); + this._updateCallbackData(); + this._renderFrame(this.animationProps); + this._clearNeedsRedraw(); + if (this.offScreen && this.gl.commit) { + this.gl.commit(); } - log4.groupEnd(LOG_LEVEL_MINOR_UPDATE)(); - }, - "attribute.updateStart": (attribute) => { - logState.attributeUpdateStart = Date.now(); - }, - "attribute.allocate": (attribute, numInstances) => { - const message = "".concat(attribute.id, " allocated ").concat(numInstances); - logState.attributeUpdateMessages.push(message); - }, - "attribute.updateEnd": (attribute, numInstances) => { - const timeMs = Math.round(Date.now() - logState.attributeUpdateStart); - const message = "".concat(attribute.id, " updated ").concat(numInstances, " in ").concat(timeMs, "ms"); - logState.attributeUpdateMessages.push(message); - }, - "deckRenderer.renderLayers": (deckRenderer, renderStats, opts) => { - const { - pass, - redrawReason, - stats - } = opts; - for (const status of renderStats) { - const { - totalCount, - visibleCount, - compositeCount, - pickableCount - } = status; - const primitiveCount = totalCount - compositeCount; - const hiddenCount = primitiveCount - visibleCount; - log4.log(LOG_LEVEL_DRAW, "RENDER #".concat(deckRenderer.renderCount, " ").concat(visibleCount, " (of ").concat(totalCount, " layers) to ").concat(pass, " because ").concat(redrawReason, " (").concat(hiddenCount, " hidden, ").concat(compositeCount, " composite ").concat(pickableCount, " pickable)"))(); - if (stats) { - stats.get("Redraw Layers").add(visibleCount); - } + if (this._resolveNextFrame) { + this._resolveNextFrame(this); + this._nextFramePromise = null; + this._resolveNextFrame = null; } + this._endTimers(); + return this; } - }); - - // node_modules/@deck.gl/core/dist/esm/debug/index.js - var loggers = {}; - if (true) { - loggers = getLoggers(log_default); - } - function register(handlers) { - loggers = handlers; - } - function debug(eventType, arg1, arg2, arg3) { - if (log_default.level > 0 && loggers[eventType]) { - loggers[eventType].call(null, arg1, arg2, arg3); + stop() { + if (this._running) { + this._finalizeCallbackData(); + this._cancelAnimationFrame(this._animationFrameId); + this._nextFramePromise = null; + this._resolveNextFrame = null; + this._animationFrameId = null; + this._running = false; + } + return this; } - } - - // node_modules/@deck.gl/core/dist/esm/utils/json-loader.js - function isJSON(text) { - const firstChar = text[0]; - const lastChar = text[text.length - 1]; - return firstChar === "{" && lastChar === "}" || firstChar === "[" && lastChar === "]"; - } - var json_loader_default = { - id: "JSON", - name: "JSON", - module: "", - version: "", - options: {}, - extensions: ["json", "geojson"], - mimeTypes: ["application/json", "application/geo+json"], - testText: isJSON, - parseTextSync: JSON.parse - }; - - // node_modules/@deck.gl/core/dist/esm/lib/init.js - function checkVersion() { - const version = true ? "8.9.34" : globalThis.DECK_VERSION || "untranspiled source"; - const existingVersion = globalThis.deck && globalThis.deck.VERSION; - if (existingVersion && existingVersion !== version) { - throw new Error("deck.gl - multiple versions detected: ".concat(existingVersion, " vs ").concat(version)); + attachTimeline(timeline) { + this.timeline = timeline; + return this.timeline; } - if (!existingVersion) { - log_default.log(1, "deck.gl ".concat(version))(); - globalThis.deck = { - ...globalThis.deck, - VERSION: version, - version, - log: log_default, - _registerLoggers: register - }; - registerLoaders([json_loader_default, [ImageLoader, { - imagebitmap: { - premultiplyAlpha: "none" - } - }]]); + detachTimeline() { + this.timeline = null; } - return version; - } - var VERSION5 = checkVersion(); - - // node_modules/@deck.gl/core/dist/esm/lib/constants.js - var COORDINATE_SYSTEM = { - DEFAULT: -1, - LNGLAT: 1, - METER_OFFSETS: 2, - LNGLAT_OFFSETS: 3, - CARTESIAN: 0 - }; - Object.defineProperty(COORDINATE_SYSTEM, "IDENTITY", { - get: () => { - log_default.deprecated("COORDINATE_SYSTEM.IDENTITY", "COORDINATE_SYSTEM.CARTESIAN")(); - return 0; + waitForRender() { + this.setNeedsRedraw("waitForRender"); + if (!this._nextFramePromise) { + this._nextFramePromise = new Promise((resolve2) => { + this._resolveNextFrame = resolve2; + }); + } + return this._nextFramePromise; } - }); - var PROJECTION_MODE = { - WEB_MERCATOR: 1, - GLOBE: 2, - WEB_MERCATOR_AUTO_OFFSET: 4, - IDENTITY: 0 - }; - var UNIT = { - common: 0, - meters: 1, - pixels: 2 - }; - var EVENTS = { - click: { - handler: "onClick" - }, - panstart: { - handler: "onDragStart" - }, - panmove: { - handler: "onDrag" - }, - panend: { - handler: "onDragEnd" + async toDataURL() { + this.setNeedsRedraw("toDataURL"); + await this.waitForRender(); + return this.gl.canvas.toDataURL(); } - }; - - // node_modules/@luma.gl/gltools/dist/esm/utils/log.js - var log2 = new Log2({ - id: "luma.gl" - }); - - // node_modules/@luma.gl/gltools/dist/esm/utils/assert.js - function assert5(condition, message) { - if (!condition) { - throw new Error(message || "luma.gl: assertion failed."); + isContextLost() { + return this.gl.isContextLost(); } - } - - // node_modules/@luma.gl/gltools/dist/esm/utils/webgl-checks.js - var ERR_CONTEXT = "Invalid WebGLRenderingContext"; - var ERR_WEBGL2 = "Requires WebGL2"; - function isWebGL(gl) { - if (typeof WebGLRenderingContext !== "undefined" && gl instanceof WebGLRenderingContext) { - return true; + onCreateContext() { + return this.props.onCreateContext(...arguments); } - if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { - return true; + onInitialize() { + return this.props.onInitialize(...arguments); } - return Boolean(gl && Number.isFinite(gl._version)); - } - function isWebGL2(gl) { - if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { - return true; + onRender() { + return this.props.onRender(...arguments); } - return Boolean(gl && gl._version === 2); - } - function getWebGL2Context(gl) { - return isWebGL2(gl) ? gl : null; - } - function assertWebGLContext(gl) { - assert5(isWebGL(gl), ERR_CONTEXT); - return gl; - } - function assertWebGL2Context(gl) { - assert5(isWebGL2(gl), ERR_WEBGL2); - return gl; - } - - // node_modules/@luma.gl/gltools/dist/esm/polyfill/polyfill-vertex-array-object.js - var glErrorShadow = {}; - function error(msg) { - if (globalThis.console && globalThis.console.error) { - globalThis.console.error(msg); + onFinalize() { + return this.props.onFinalize(...arguments); } - } - function log3(msg) { - if (globalThis.console && globalThis.console.log) { - globalThis.console.log(msg); + getHTMLControlValue(id) { + let defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1; + const element = document.getElementById(id); + return element ? Number(element.value) : defaultValue; } - } - function synthesizeGLError(err, opt_msg) { - glErrorShadow[err] = true; - if (opt_msg !== void 0) { - error(opt_msg); + setViewParameters() { + log2.removed("AnimationLoop.setViewParameters", "AnimationLoop.setProps")(); + return this; } - } - function wrapGLError(gl) { - const f2 = gl.getError; - gl.getError = function getError() { - let err; - do { - err = f2.apply(gl); - if (err !== 0) { - glErrorShadow[err] = true; - } - } while (err !== 0); - for (err in glErrorShadow) { - if (glErrorShadow[err]) { - delete glErrorShadow[err]; - return parseInt(err, 10); + _startLoop() { + const renderFrame = () => { + if (!this._running) { + return; } + this.redraw(); + this._animationFrameId = this._requestAnimationFrame(renderFrame); + }; + this._cancelAnimationFrame(this._animationFrameId); + this._animationFrameId = this._requestAnimationFrame(renderFrame); + } + _getPageLoadPromise() { + if (!this._pageLoadPromise) { + this._pageLoadPromise = isPage2 ? new Promise((resolve2, reject) => { + if (isPage2 && document.readyState === "complete") { + resolve2(document); + return; + } + window.addEventListener("load", () => { + resolve2(document); + }); + }) : Promise.resolve({}); } - return 0; - }; - } - var WebGLVertexArrayObjectOES = function WebGLVertexArrayObjectOES2(ext) { - const gl = ext.gl; - this.ext = ext; - this.isAlive = true; - this.hasBeenBound = false; - this.elementArrayBuffer = null; - this.attribs = new Array(ext.maxVertexAttribs); - for (let n2 = 0; n2 < this.attribs.length; n2++) { - const attrib = new WebGLVertexArrayObjectOES2.VertexAttrib(gl); - this.attribs[n2] = attrib; + return this._pageLoadPromise; } - this.maxAttrib = 0; - }; - WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) { - this.enabled = false; - this.buffer = null; - this.size = 4; - this.type = 5126; - this.normalized = false; - this.stride = 16; - this.offset = 0; - this.cached = ""; - this.recache(); - }; - WebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() { - this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(":"); - }; - var OESVertexArrayObject = function OESVertexArrayObject2(gl) { - const self2 = this; - this.gl = gl; - wrapGLError(gl); - const original = this.original = { - getParameter: gl.getParameter, - enableVertexAttribArray: gl.enableVertexAttribArray, - disableVertexAttribArray: gl.disableVertexAttribArray, - bindBuffer: gl.bindBuffer, - getVertexAttrib: gl.getVertexAttrib, - vertexAttribPointer: gl.vertexAttribPointer - }; - gl.getParameter = function getParameter(pname) { - if (pname === self2.VERTEX_ARRAY_BINDING_OES) { - if (self2.currentVertexArrayObject === self2.defaultVertexArrayObject) { - return null; - } - return self2.currentVertexArrayObject; + _setDisplay(display) { + if (this.display) { + this.display.delete(); + this.display.animationLoop = null; } - return original.getParameter.apply(this, arguments); - }; - gl.enableVertexAttribArray = function enableVertexAttribArray(index) { - const vao = self2.currentVertexArrayObject; - vao.maxAttrib = Math.max(vao.maxAttrib, index); - const attrib = vao.attribs[index]; - attrib.enabled = true; - return original.enableVertexAttribArray.apply(this, arguments); - }; - gl.disableVertexAttribArray = function disableVertexAttribArray(index) { - const vao = self2.currentVertexArrayObject; - vao.maxAttrib = Math.max(vao.maxAttrib, index); - const attrib = vao.attribs[index]; - attrib.enabled = false; - return original.disableVertexAttribArray.apply(this, arguments); - }; - gl.bindBuffer = function bindBuffer(target, buffer) { - switch (target) { - case 34962: - self2.currentArrayBuffer = buffer; - break; - case 34963: - self2.currentVertexArrayObject.elementArrayBuffer = buffer; - break; - default: + if (display) { + display.animationLoop = this; } - return original.bindBuffer.apply(this, arguments); - }; - gl.getVertexAttrib = function getVertexAttrib(index, pname) { - const vao = self2.currentVertexArrayObject; - const attrib = vao.attribs[index]; - switch (pname) { - case 34975: - return attrib.buffer; - case 34338: - return attrib.enabled; - case 34339: - return attrib.size; - case 34340: - return attrib.stride; - case 34341: - return attrib.type; - case 34922: - return attrib.normalized; - default: - return original.getVertexAttrib.apply(this, arguments); + this.display = display; + } + _cancelAnimationFrame(animationFrameId) { + if (this.display && this.display.cancelAnimationFrame) { + return this.display.cancelAnimationFrame(animationFrameId); } - }; - gl.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset) { - const vao = self2.currentVertexArrayObject; - vao.maxAttrib = Math.max(vao.maxAttrib, indx); - const attrib = vao.attribs[indx]; - attrib.buffer = self2.currentArrayBuffer; - attrib.size = size; - attrib.type = type; - attrib.normalized = normalized; - attrib.stride = stride; - attrib.offset = offset; - attrib.recache(); - return original.vertexAttribPointer.apply(this, arguments); - }; - if (gl.instrumentExtension) { - gl.instrumentExtension(this, "OES_vertex_array_object"); + return cancelAnimationFrame(animationFrameId); } - if (gl.canvas) { - gl.canvas.addEventListener("webglcontextrestored", () => { - log3("OESVertexArrayObject emulation library context restored"); - self2.reset_(); - }, true); + _requestAnimationFrame(renderFrameCallback) { + if (this._running) { + if (this.display && this.display.requestAnimationFrame) { + return this.display.requestAnimationFrame(renderFrameCallback); + } + return requestAnimationFrame2(renderFrameCallback); + } + return void 0; } - this.reset_(); - }; - OESVertexArrayObject.prototype.VERTEX_ARRAY_BINDING_OES = 34229; - OESVertexArrayObject.prototype.reset_ = function reset_() { - const contextWasLost = this.vertexArrayObjects !== void 0; - if (contextWasLost) { - for (let ii = 0; ii < this.vertexArrayObjects.length; ++ii) { - this.vertexArrayObjects.isAlive = false; + _renderFrame() { + if (this.display) { + this.display._renderFrame(...arguments); + return; } + this.onRender(...arguments); } - const gl = this.gl; - this.maxVertexAttribs = gl.getParameter(34921); - this.defaultVertexArrayObject = new WebGLVertexArrayObjectOES(this); - this.currentVertexArrayObject = null; - this.currentArrayBuffer = null; - this.vertexArrayObjects = [this.defaultVertexArrayObject]; - this.bindVertexArrayOES(null); - }; - OESVertexArrayObject.prototype.createVertexArrayOES = function createVertexArrayOES() { - const arrayObject = new WebGLVertexArrayObjectOES(this); - this.vertexArrayObjects.push(arrayObject); - return arrayObject; - }; - OESVertexArrayObject.prototype.deleteVertexArrayOES = function deleteVertexArrayOES(arrayObject) { - arrayObject.isAlive = false; - this.vertexArrayObjects.splice(this.vertexArrayObjects.indexOf(arrayObject), 1); - if (this.currentVertexArrayObject === arrayObject) { - this.bindVertexArrayOES(null); + _clearNeedsRedraw() { + this.needsRedraw = null; } - }; - OESVertexArrayObject.prototype.isVertexArrayOES = function isVertexArrayOES(arrayObject) { - if (arrayObject && arrayObject instanceof WebGLVertexArrayObjectOES) { - if (arrayObject.hasBeenBound && arrayObject.ext === this) { - return true; + _setupFrame() { + this._resizeCanvasDrawingBuffer(); + this._resizeViewport(); + this._resizeFramebuffer(); + } + _initializeCallbackData() { + this.animationProps = { + gl: this.gl, + stop: this.stop, + canvas: this.gl.canvas, + framebuffer: this.framebuffer, + useDevicePixels: this.useDevicePixels, + needsRedraw: null, + startTime: Date.now(), + engineTime: 0, + tick: 0, + tock: 0, + time: 0, + _timeline: this.timeline, + _loop: this, + _animationLoop: this, + _mousePosition: null + }; + } + _updateCallbackData() { + const { + width, + height, + aspect + } = this._getSizeAndAspect(); + if (width !== this.animationProps.width || height !== this.animationProps.height) { + this.setNeedsRedraw("drawing buffer resized"); + } + if (aspect !== this.animationProps.aspect) { + this.setNeedsRedraw("drawing buffer aspect changed"); + } + this.animationProps.width = width; + this.animationProps.height = height; + this.animationProps.aspect = aspect; + this.animationProps.needsRedraw = this.needsRedraw; + this.animationProps.engineTime = Date.now() - this.animationProps.startTime; + if (this.timeline) { + this.timeline.update(this.animationProps.engineTime); } + this.animationProps.tick = Math.floor(this.animationProps.time / 1e3 * 60); + this.animationProps.tock++; + this.animationProps.time = this.timeline ? this.timeline.getTime() : this.animationProps.engineTime; + this.animationProps._offScreen = this.offScreen; } - return false; - }; - OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) { - const gl = this.gl; - if (arrayObject && !arrayObject.isAlive) { - synthesizeGLError(1282, "bindVertexArrayOES: attempt to bind deleted arrayObject"); - return; + _finalizeCallbackData() { + this.onFinalize(this.animationProps); } - const original = this.original; - const oldVAO = this.currentVertexArrayObject; - this.currentVertexArrayObject = arrayObject || this.defaultVertexArrayObject; - this.currentVertexArrayObject.hasBeenBound = true; - const newVAO = this.currentVertexArrayObject; - if (oldVAO === newVAO) { - return; + _addCallbackData(appContext) { + if (typeof appContext === "object" && appContext !== null) { + this.animationProps = Object.assign({}, this.animationProps, appContext); + } } - if (!oldVAO || newVAO.elementArrayBuffer !== oldVAO.elementArrayBuffer) { - original.bindBuffer.call(gl, 34963, newVAO.elementArrayBuffer); + _createWebGLContext(opts) { + this.offScreen = opts.canvas && typeof OffscreenCanvas !== "undefined" && opts.canvas instanceof OffscreenCanvas; + opts = Object.assign({}, opts, this.props.glOptions); + this.gl = this.props.gl ? instrumentGLContext(this.props.gl, opts) : this.onCreateContext(opts); + if (!isWebGL(this.gl)) { + throw new Error("AnimationLoop.onCreateContext - illegal context returned"); + } + resetParameters(this.gl); + this._createInfoDiv(); } - let currentBinding = this.currentArrayBuffer; - const maxAttrib = Math.max(oldVAO ? oldVAO.maxAttrib : 0, newVAO.maxAttrib); - for (let n2 = 0; n2 <= maxAttrib; n2++) { - const attrib = newVAO.attribs[n2]; - const oldAttrib = oldVAO ? oldVAO.attribs[n2] : null; - if (!oldVAO || attrib.enabled !== oldAttrib.enabled) { - if (attrib.enabled) { - original.enableVertexAttribArray.call(gl, n2); - } else { - original.disableVertexAttribArray.call(gl, n2); + _createInfoDiv() { + if (this.gl.canvas && this.props.onAddHTML) { + const wrapperDiv = document.createElement("div"); + document.body.appendChild(wrapperDiv); + wrapperDiv.style.position = "relative"; + const div = document.createElement("div"); + div.style.position = "absolute"; + div.style.left = "10px"; + div.style.bottom = "10px"; + div.style.width = "300px"; + div.style.background = "white"; + wrapperDiv.appendChild(this.gl.canvas); + wrapperDiv.appendChild(div); + const html = this.props.onAddHTML(div); + if (html) { + div.innerHTML = html; } } - if (attrib.enabled) { - let bufferChanged = false; - if (!oldVAO || attrib.buffer !== oldAttrib.buffer) { - if (currentBinding !== attrib.buffer) { - original.bindBuffer.call(gl, 34962, attrib.buffer); - currentBinding = attrib.buffer; - } - bufferChanged = true; - } - if (bufferChanged || attrib.cached !== oldAttrib.cached) { - original.vertexAttribPointer.call(gl, n2, attrib.size, attrib.type, attrib.normalized, attrib.stride, attrib.offset); - } + } + _getSizeAndAspect() { + const width = this.gl.drawingBufferWidth; + const height = this.gl.drawingBufferHeight; + let aspect = 1; + const { + canvas + } = this.gl; + if (canvas && canvas.clientHeight) { + aspect = canvas.clientWidth / canvas.clientHeight; + } else if (width > 0 && height > 0) { + aspect = width / height; } + return { + width, + height, + aspect + }; } - if (this.currentArrayBuffer !== currentBinding) { - original.bindBuffer.call(gl, 34962, this.currentArrayBuffer); + _resizeViewport() { + if (this.autoResizeViewport) { + this.gl.viewport(0, 0, this.gl.drawingBufferWidth, this.gl.drawingBufferHeight); + } } - }; - function polyfillVertexArrayObject(gl) { - if (typeof gl.createVertexArray === "function") { - return; + _resizeCanvasDrawingBuffer() { + if (this.autoResizeDrawingBuffer) { + resizeGLContext(this.gl, { + useDevicePixels: this.useDevicePixels + }); + } } - const original_getSupportedExtensions = gl.getSupportedExtensions; - gl.getSupportedExtensions = function getSupportedExtensions() { - const list = original_getSupportedExtensions.call(this) || []; - if (list.indexOf("OES_vertex_array_object") < 0) { - list.push("OES_vertex_array_object"); + _createFramebuffer() { + if (this.props.createFramebuffer) { + this.framebuffer = new Framebuffer(this.gl); } - return list; - }; - const original_getExtension = gl.getExtension; - gl.getExtension = function getExtension(name) { - const ext = original_getExtension.call(this, name); - if (ext) { - return ext; + } + _resizeFramebuffer() { + if (this.framebuffer) { + this.framebuffer.resize({ + width: this.gl.drawingBufferWidth, + height: this.gl.drawingBufferHeight + }); } - if (name !== "OES_vertex_array_object") { - return null; + } + _beginTimers() { + this.frameRate.timeEnd(); + this.frameRate.timeStart(); + if (this._gpuTimeQuery && this._gpuTimeQuery.isResultAvailable() && !this._gpuTimeQuery.isTimerDisjoint()) { + this.stats.get("GPU Time").addTime(this._gpuTimeQuery.getTimerMilliseconds()); } - if (!gl.__OESVertexArrayObject) { - this.__OESVertexArrayObject = new OESVertexArrayObject(this); + if (this._gpuTimeQuery) { + this._gpuTimeQuery.beginTimeElapsedQuery(); } - return this.__OESVertexArrayObject; - }; + this.cpuTime.timeStart(); + } + _endTimers() { + this.cpuTime.timeEnd(); + if (this._gpuTimeQuery) { + this._gpuTimeQuery.end(); + } + } + _startEventHandling() { + const { + canvas + } = this.gl; + if (canvas) { + canvas.addEventListener("mousemove", this._onMousemove); + canvas.addEventListener("mouseleave", this._onMouseleave); + } + } + _onMousemove(e2) { + this.animationProps._mousePosition = [e2.offsetX, e2.offsetY]; + } + _onMouseleave(e2) { + this.animationProps._mousePosition = null; + } + }; + + // node_modules/@luma.gl/shadertools/dist/esm/lib/constants.js + var VERTEX_SHADER = "vs"; + var FRAGMENT_SHADER = "fs"; + + // node_modules/@luma.gl/shadertools/dist/esm/utils/assert.js + function assert7(condition, message) { + if (!condition) { + throw new Error(message || "shadertools: assertion failed."); + } } - // node_modules/@luma.gl/gltools/dist/esm/polyfill/get-parameter-polyfill.js - var OES_element_index = "OES_element_index"; - var WEBGL_draw_buffers = "WEBGL_draw_buffers"; - var EXT_disjoint_timer_query = "EXT_disjoint_timer_query"; - var EXT_disjoint_timer_query_webgl2 = "EXT_disjoint_timer_query_webgl2"; - var EXT_texture_filter_anisotropic = "EXT_texture_filter_anisotropic"; - var WEBGL_debug_renderer_info = "WEBGL_debug_renderer_info"; - var GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 35723; - var GL_DONT_CARE = 4352; - var GL_GPU_DISJOINT_EXT = 36795; - var GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047; - var GL_UNMASKED_VENDOR_WEBGL = 37445; - var GL_UNMASKED_RENDERER_WEBGL = 37446; - var getWebGL2ValueOrZero = (gl) => !isWebGL2(gl) ? 0 : void 0; - var WEBGL_PARAMETERS = { - [3074]: (gl) => !isWebGL2(gl) ? 36064 : void 0, - [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl) => !isWebGL2(gl) ? GL_DONT_CARE : void 0, - [35977]: getWebGL2ValueOrZero, - [32937]: getWebGL2ValueOrZero, - [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => { - const ext = isWebGL2(gl) ? gl.getExtension(EXT_disjoint_timer_query_webgl2) : gl.getExtension(EXT_disjoint_timer_query); - return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0; - }, - [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => { - const ext = gl.getExtension(WEBGL_debug_renderer_info); - return getParameter(ext && ext.UNMASKED_VENDOR_WEBGL || 7936); - }, - [GL_UNMASKED_RENDERER_WEBGL]: (gl, getParameter) => { - const ext = gl.getExtension(WEBGL_debug_renderer_info); - return getParameter(ext && ext.UNMASKED_RENDERER_WEBGL || 7937); - }, - [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => { - const ext = gl.luma.extensions[EXT_texture_filter_anisotropic]; - return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1; - }, - [32883]: getWebGL2ValueOrZero, - [35071]: getWebGL2ValueOrZero, - [37447]: getWebGL2ValueOrZero, - [36063]: (gl, getParameter) => { - if (!isWebGL2(gl)) { - const ext = gl.getExtension(WEBGL_draw_buffers); - return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0; + // node_modules/@luma.gl/shadertools/dist/esm/lib/filters/prop-types.js + var TYPE_DEFINITIONS = { + number: { + validate(value, propType) { + return Number.isFinite(value) && (!("max" in propType) || value <= propType.max) && (!("min" in propType) || value >= propType.min); } - return void 0; }, - [35379]: getWebGL2ValueOrZero, - [35374]: getWebGL2ValueOrZero, - [35377]: getWebGL2ValueOrZero, - [34852]: (gl) => { - if (!isWebGL2(gl)) { - const ext = gl.getExtension(WEBGL_draw_buffers); - return ext ? ext.MAX_DRAW_BUFFERS_WEBGL : 0; + array: { + validate(value, propType) { + return Array.isArray(value) || ArrayBuffer.isView(value); } - return void 0; - }, - [36203]: (gl) => gl.getExtension(OES_element_index) ? 2147483647 : 65535, - [33001]: (gl) => gl.getExtension(OES_element_index) ? 16777216 : 65535, - [33e3]: (gl) => 16777216, - [37157]: getWebGL2ValueOrZero, - [35373]: getWebGL2ValueOrZero, - [35657]: getWebGL2ValueOrZero, - [36183]: getWebGL2ValueOrZero, - [37137]: getWebGL2ValueOrZero, - [34045]: getWebGL2ValueOrZero, - [35978]: getWebGL2ValueOrZero, - [35979]: getWebGL2ValueOrZero, - [35968]: getWebGL2ValueOrZero, - [35376]: getWebGL2ValueOrZero, - [35375]: getWebGL2ValueOrZero, - [35659]: getWebGL2ValueOrZero, - [37154]: getWebGL2ValueOrZero, - [35371]: getWebGL2ValueOrZero, - [35658]: getWebGL2ValueOrZero, - [35076]: getWebGL2ValueOrZero, - [35077]: getWebGL2ValueOrZero, - [35380]: getWebGL2ValueOrZero + } }; - function getParameterPolyfill(gl, originalGetParameter, pname) { - const limit = WEBGL_PARAMETERS[pname]; - const value = typeof limit === "function" ? limit(gl, originalGetParameter, pname) : limit; - const result = value !== void 0 ? value : originalGetParameter(pname); - return result; - } - - // node_modules/@luma.gl/gltools/dist/esm/polyfill/polyfill-table.js - var OES_vertex_array_object = "OES_vertex_array_object"; - var ANGLE_instanced_arrays = "ANGLE_instanced_arrays"; - var WEBGL_draw_buffers2 = "WEBGL_draw_buffers"; - var EXT_disjoint_timer_query2 = "EXT_disjoint_timer_query"; - var EXT_texture_filter_anisotropic2 = "EXT_texture_filter_anisotropic"; - var ERR_VAO_NOT_SUPPORTED = "VertexArray requires WebGL2 or OES_vertex_array_object extension"; - function getExtensionData(gl, extension) { - return { - webgl2: isWebGL2(gl), - ext: gl.getExtension(extension) - }; + function parsePropTypes(propDefs) { + const propTypes = {}; + for (const propName in propDefs) { + const propDef = propDefs[propName]; + const propType = parsePropType(propDef); + propTypes[propName] = propType; + } + return propTypes; } - var WEBGL2_CONTEXT_POLYFILLS = { - [OES_vertex_array_object]: { - meta: { - suffix: "OES" - }, - createVertexArray: () => { - assert5(false, ERR_VAO_NOT_SUPPORTED); - }, - deleteVertexArray: () => { - }, - bindVertexArray: () => { - }, - isVertexArray: () => false - }, - [ANGLE_instanced_arrays]: { - meta: { - suffix: "ANGLE" - }, - vertexAttribDivisor(location, divisor) { - assert5(divisor === 0, "WebGL instanced rendering not supported"); - }, - drawElementsInstanced: () => { - }, - drawArraysInstanced: () => { + function parsePropType(propDef) { + let type = getTypeOf(propDef); + if (type === "object") { + if (!propDef) { + return { + type: "object", + value: null + }; } - }, - [WEBGL_draw_buffers2]: { - meta: { - suffix: "WEBGL" - }, - drawBuffers: () => { - assert5(false); + if ("type" in propDef) { + return Object.assign({}, propDef, TYPE_DEFINITIONS[propDef.type]); } - }, - [EXT_disjoint_timer_query2]: { - meta: { - suffix: "EXT" - }, - createQuery: () => { - assert5(false); - }, - deleteQuery: () => { - assert5(false); - }, - beginQuery: () => { - assert5(false); - }, - endQuery: () => { - }, - getQuery(handle, pname) { - return this.getQueryObject(handle, pname); - }, - getQueryParameter(handle, pname) { - return this.getQueryObject(handle, pname); - }, - getQueryObject: () => { + if (!("value" in propDef)) { + return { + type: "object", + value: propDef + }; } + type = getTypeOf(propDef.value); + return Object.assign({ + type + }, propDef, TYPE_DEFINITIONS[type]); } - }; - var WEBGL2_CONTEXT_OVERRIDES = { - readBuffer: (gl, originalFunc, attachment) => { - if (isWebGL2(gl)) { - originalFunc(attachment); - } else { + return Object.assign({ + type, + value: propDef + }, TYPE_DEFINITIONS[type]); + } + function getTypeOf(value) { + if (Array.isArray(value) || ArrayBuffer.isView(value)) { + return "array"; + } + return typeof value; + } + + // node_modules/@luma.gl/shadertools/dist/esm/lib/shader-module.js + var VERTEX_SHADER2 = "vs"; + var FRAGMENT_SHADER2 = "fs"; + var ShaderModule = class { + constructor(_ref) { + let { + name, + vs: vs8, + fs: fs6, + dependencies = [], + uniforms, + getUniforms: getUniforms5, + deprecations = [], + defines: defines2 = {}, + inject = {}, + vertexShader, + fragmentShader + } = _ref; + assert7(typeof name === "string"); + this.name = name; + this.vs = vs8 || vertexShader; + this.fs = fs6 || fragmentShader; + this.getModuleUniforms = getUniforms5; + this.dependencies = dependencies; + this.deprecations = this._parseDeprecationDefinitions(deprecations); + this.defines = defines2; + this.injections = normalizeInjections(inject); + if (uniforms) { + this.uniforms = parsePropTypes(uniforms); } - }, - getVertexAttrib: (gl, originalFunc, location, pname) => { - const { - webgl2, - ext - } = getExtensionData(gl, ANGLE_instanced_arrays); - let result; - switch (pname) { - case 35069: - result = !webgl2 ? false : void 0; + } + getModuleSource(type) { + let moduleSource; + switch (type) { + case VERTEX_SHADER2: + moduleSource = this.vs || ""; break; - case 35070: - result = !webgl2 && !ext ? 0 : void 0; + case FRAGMENT_SHADER2: + moduleSource = this.fs || ""; break; default: + assert7(false); } - return result !== void 0 ? result : originalFunc(location, pname); - }, - getProgramParameter: (gl, originalFunc, program, pname) => { - if (!isWebGL2(gl)) { - switch (pname) { - case 35967: - return 35981; - case 35971: - return 0; - case 35382: - return 0; - default: - } + return "#define MODULE_".concat(this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_"), "\n").concat(moduleSource, "// END MODULE_").concat(this.name, "\n\n"); + } + getUniforms(opts, uniforms) { + if (this.getModuleUniforms) { + return this.getModuleUniforms(opts, uniforms); } - return originalFunc(program, pname); - }, - getInternalformatParameter: (gl, originalFunc, target, format, pname) => { - if (!isWebGL2(gl)) { - switch (pname) { - case 32937: - return new Int32Array([0]); + if (this.uniforms) { + return this._defaultGetUniforms(opts); + } + return {}; + } + getDefines() { + return this.defines; + } + checkDeprecations(shaderSource, log4) { + this.deprecations.forEach((def) => { + if (def.regex.test(shaderSource)) { + if (def.deprecated) { + log4.deprecated(def.old, def.new)(); + } else { + log4.removed(def.old, def.new)(); + } + } + }); + } + _parseDeprecationDefinitions(deprecations) { + deprecations.forEach((def) => { + switch (def.type) { + case "function": + def.regex = new RegExp("\\b".concat(def.old, "\\(")); + break; default: + def.regex = new RegExp("".concat(def.type, " ").concat(def.old, ";")); + } + }); + return deprecations; + } + _defaultGetUniforms() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const uniforms = {}; + const propTypes = this.uniforms; + for (const key in propTypes) { + const propDef = propTypes[key]; + if (key in opts && !propDef.private) { + if (propDef.validate) { + assert7(propDef.validate(opts[key], propDef), "".concat(this.name, ": invalid ").concat(key)); + } + uniforms[key] = opts[key]; + } else { + uniforms[key] = propDef.value; } } - return gl.getInternalformatParameter(target, format, pname); - }, - getTexParameter(gl, originalFunc, target, pname) { - switch (pname) { - case 34046: - const { - extensions - } = gl.luma; - const ext = extensions[EXT_texture_filter_anisotropic2]; - pname = ext && ext.TEXTURE_MAX_ANISOTROPY_EXT || 34046; - break; - default: - } - return originalFunc(target, pname); - }, - getParameter: getParameterPolyfill, - hint(gl, originalFunc, pname, value) { - return originalFunc(pname, value); + return uniforms; } }; - - // node_modules/@luma.gl/gltools/dist/esm/polyfill/polyfill-context.js - function polyfillContext(gl) { - gl.luma = gl.luma || {}; - const { - luma - } = gl; - if (!luma.polyfilled) { - polyfillVertexArrayObject(gl); - initializeExtensions(gl); - installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS); - installOverrides(gl, { - target: luma, - target2: gl - }); - luma.polyfilled = true; + function normalizeInjections(injections) { + const result = { + vs: {}, + fs: {} + }; + for (const hook in injections) { + let injection = injections[hook]; + const stage = hook.slice(0, 2); + if (typeof injection === "string") { + injection = { + order: 0, + injection + }; + } + result[stage][hook] = injection; } - return gl; + return result; } - globalThis.polyfillContext = polyfillContext; - function initializeExtensions(gl) { - gl.luma.extensions = {}; - const EXTENSIONS2 = gl.getSupportedExtensions() || []; - for (const extension of EXTENSIONS2) { - gl.luma[extension] = gl.getExtension(extension); - } + + // node_modules/@luma.gl/shadertools/dist/esm/lib/resolve-modules.js + function resolveModules(modules) { + return getShaderDependencies(instantiateModules(modules)); } - function installOverrides(gl, _ref) { + function getShaderDependencies(modules) { + const moduleMap = {}; + const moduleDepth = {}; + getDependencyGraph({ + modules, + level: 0, + moduleMap, + moduleDepth + }); + return Object.keys(moduleDepth).sort((a2, b2) => moduleDepth[b2] - moduleDepth[a2]).map((name) => moduleMap[name]); + } + function getDependencyGraph(_ref) { let { - target, - target2 + modules, + level, + moduleMap, + moduleDepth } = _ref; - Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach((key) => { - if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === "function") { - const originalFunc = gl[key] ? gl[key].bind(gl) : () => { - }; - const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl, originalFunc); - target[key] = polyfill; - target2[key] = polyfill; + if (level >= 5) { + throw new Error("Possible loop in shader dependency graph"); + } + for (const module of modules) { + moduleMap[module.name] = module; + if (moduleDepth[module.name] === void 0 || moduleDepth[module.name] < level) { + moduleDepth[module.name] = level; } - }); - } - function installPolyfills(gl, polyfills) { - for (const extension of Object.getOwnPropertyNames(polyfills)) { - if (extension !== "overrides") { - polyfillExtension(gl, { - extension, - target: gl.luma, - target2: gl + } + for (const module of modules) { + if (module.dependencies) { + getDependencyGraph({ + modules: module.dependencies, + level: level + 1, + moduleMap, + moduleDepth }); } } } - function polyfillExtension(gl, _ref2) { - let { - extension, - target, - target2 - } = _ref2; - const defaults = WEBGL2_CONTEXT_POLYFILLS[extension]; - assert5(defaults); - const { - meta = {} - } = defaults; - const { - suffix = "" - } = meta; - const ext = gl.getExtension(extension); - for (const key of Object.keys(defaults)) { - const extKey = "".concat(key).concat(suffix); - let polyfill = null; - if (key === "meta") { - } else if (typeof gl[key] === "function") { - } else if (ext && typeof ext[extKey] === "function") { - polyfill = function() { - return ext[extKey](...arguments); - }; - } else if (typeof defaults[key] === "function") { - polyfill = defaults[key].bind(target); - } - if (polyfill) { - target[key] = polyfill; - target2[key] = polyfill; + function instantiateModules(modules, seen) { + return modules.map((module) => { + if (module instanceof ShaderModule) { + return module; } - } + assert7(typeof module !== "string", "Shader module use by name is deprecated. Import shader module '".concat(module, "' and use it directly.")); + assert7(module.name, "shader module has no name"); + module = new ShaderModule(module); + module.dependencies = instantiateModules(module.dependencies); + return module; + }); } - // node_modules/@luma.gl/gltools/dist/esm/state-tracker/webgl-parameter-tables.js - var GL_PARAMETER_DEFAULTS = { - [3042]: false, - [32773]: new Float32Array([0, 0, 0, 0]), - [32777]: 32774, - [34877]: 32774, - [32969]: 1, - [32968]: 0, - [32971]: 1, - [32970]: 0, - [3106]: new Float32Array([0, 0, 0, 0]), - [3107]: [true, true, true, true], - [2884]: false, - [2885]: 1029, - [2929]: false, - [2931]: 1, - [2932]: 513, - [2928]: new Float32Array([0, 1]), - [2930]: true, - [3024]: true, - [36006]: null, - [2886]: 2305, - [33170]: 4352, - [2849]: 1, - [32823]: false, - [32824]: 0, - [10752]: 0, - [32938]: 1, - [32939]: false, - [3089]: false, - [3088]: new Int32Array([0, 0, 1024, 1024]), - [2960]: false, - [2961]: 0, - [2968]: 4294967295, - [36005]: 4294967295, - [2962]: 519, - [2967]: 0, - [2963]: 4294967295, - [34816]: 519, - [36003]: 0, - [36004]: 4294967295, - [2964]: 7680, - [2965]: 7680, - [2966]: 7680, - [34817]: 7680, - [34818]: 7680, - [34819]: 7680, - [2978]: [0, 0, 1024, 1024], - [3333]: 4, - [3317]: 4, - [37440]: false, - [37441]: false, - [37443]: 37444, - [35723]: 4352, - [36010]: null, - [35977]: false, - [3330]: 0, - [3332]: 0, - [3331]: 0, - [3314]: 0, - [32878]: 0, - [3316]: 0, - [3315]: 0, - [32877]: 0 - }; - var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key); - var hint = (gl, value, key) => gl.hint(key, value); - var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value); - var drawFramebuffer = (gl, value) => { - const target = isWebGL2(gl) ? 36009 : 36160; - return gl.bindFramebuffer(target, value); - }; - var readFramebuffer = (gl, value) => { - return gl.bindFramebuffer(36008, value); - }; - function isArray(array) { - return Array.isArray(array) || ArrayBuffer.isView(array); - } - var GL_PARAMETER_SETTERS = { - [3042]: enable, - [32773]: (gl, value) => gl.blendColor(...value), - [32777]: "blendEquation", - [34877]: "blendEquation", - [32969]: "blendFunc", - [32968]: "blendFunc", - [32971]: "blendFunc", - [32970]: "blendFunc", - [3106]: (gl, value) => gl.clearColor(...value), - [3107]: (gl, value) => gl.colorMask(...value), - [2884]: enable, - [2885]: (gl, value) => gl.cullFace(value), - [2929]: enable, - [2931]: (gl, value) => gl.clearDepth(value), - [2932]: (gl, value) => gl.depthFunc(value), - [2928]: (gl, value) => gl.depthRange(...value), - [2930]: (gl, value) => gl.depthMask(value), - [3024]: enable, - [35723]: hint, - [36006]: drawFramebuffer, - [2886]: (gl, value) => gl.frontFace(value), - [33170]: hint, - [2849]: (gl, value) => gl.lineWidth(value), - [32823]: enable, - [32824]: "polygonOffset", - [10752]: "polygonOffset", - [35977]: enable, - [32938]: "sampleCoverage", - [32939]: "sampleCoverage", - [3089]: enable, - [3088]: (gl, value) => gl.scissor(...value), - [2960]: enable, - [2961]: (gl, value) => gl.clearStencil(value), - [2968]: (gl, value) => gl.stencilMaskSeparate(1028, value), - [36005]: (gl, value) => gl.stencilMaskSeparate(1029, value), - [2962]: "stencilFuncFront", - [2967]: "stencilFuncFront", - [2963]: "stencilFuncFront", - [34816]: "stencilFuncBack", - [36003]: "stencilFuncBack", - [36004]: "stencilFuncBack", - [2964]: "stencilOpFront", - [2965]: "stencilOpFront", - [2966]: "stencilOpFront", - [34817]: "stencilOpBack", - [34818]: "stencilOpBack", - [34819]: "stencilOpBack", - [2978]: (gl, value) => gl.viewport(...value), - [3333]: pixelStorei, - [3317]: pixelStorei, - [37440]: pixelStorei, - [37441]: pixelStorei, - [37443]: pixelStorei, - [3330]: pixelStorei, - [3332]: pixelStorei, - [3331]: pixelStorei, - [36010]: readFramebuffer, - [3314]: pixelStorei, - [32878]: pixelStorei, - [3316]: pixelStorei, - [3315]: pixelStorei, - [32877]: pixelStorei, - framebuffer: (gl, framebuffer) => { - const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer; - return gl.bindFramebuffer(36160, handle); - }, - blend: (gl, value) => value ? gl.enable(3042) : gl.disable(3042), - blendColor: (gl, value) => gl.blendColor(...value), - blendEquation: (gl, args) => { - args = isArray(args) ? args : [args, args]; - gl.blendEquationSeparate(...args); - }, - blendFunc: (gl, args) => { - args = isArray(args) && args.length === 2 ? [...args, ...args] : args; - gl.blendFuncSeparate(...args); - }, - clearColor: (gl, value) => gl.clearColor(...value), - clearDepth: (gl, value) => gl.clearDepth(value), - clearStencil: (gl, value) => gl.clearStencil(value), - colorMask: (gl, value) => gl.colorMask(...value), - cull: (gl, value) => value ? gl.enable(2884) : gl.disable(2884), - cullFace: (gl, value) => gl.cullFace(value), - depthTest: (gl, value) => value ? gl.enable(2929) : gl.disable(2929), - depthFunc: (gl, value) => gl.depthFunc(value), - depthMask: (gl, value) => gl.depthMask(value), - depthRange: (gl, value) => gl.depthRange(...value), - dither: (gl, value) => value ? gl.enable(3024) : gl.disable(3024), - derivativeHint: (gl, value) => { - gl.hint(35723, value); - }, - frontFace: (gl, value) => gl.frontFace(value), - mipmapHint: (gl, value) => gl.hint(33170, value), - lineWidth: (gl, value) => gl.lineWidth(value), - polygonOffsetFill: (gl, value) => value ? gl.enable(32823) : gl.disable(32823), - polygonOffset: (gl, value) => gl.polygonOffset(...value), - sampleCoverage: (gl, value) => gl.sampleCoverage(...value), - scissorTest: (gl, value) => value ? gl.enable(3089) : gl.disable(3089), - scissor: (gl, value) => gl.scissor(...value), - stencilTest: (gl, value) => value ? gl.enable(2960) : gl.disable(2960), - stencilMask: (gl, value) => { - value = isArray(value) ? value : [value, value]; - const [mask, backMask] = value; - gl.stencilMaskSeparate(1028, mask); - gl.stencilMaskSeparate(1029, backMask); - }, - stencilFunc: (gl, args) => { - args = isArray(args) && args.length === 3 ? [...args, ...args] : args; - const [func, ref, mask, backFunc, backRef, backMask] = args; - gl.stencilFuncSeparate(1028, func, ref, mask); - gl.stencilFuncSeparate(1029, backFunc, backRef, backMask); - }, - stencilOp: (gl, args) => { - args = isArray(args) && args.length === 3 ? [...args, ...args] : args; - const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args; - gl.stencilOpSeparate(1028, sfail, dpfail, dppass); - gl.stencilOpSeparate(1029, backSfail, backDpfail, backDppass); - }, - viewport: (gl, value) => gl.viewport(...value) - }; - function getValue(glEnum, values, cache3) { - return values[glEnum] !== void 0 ? values[glEnum] : cache3[glEnum]; + // node_modules/@luma.gl/shadertools/dist/esm/utils/is-old-ie.js + function isOldIE() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const navigator2 = typeof window !== "undefined" ? window.navigator || {} : {}; + const userAgent2 = opts.userAgent || navigator2.userAgent || ""; + const isMSIE = userAgent2.indexOf("MSIE ") !== -1; + const isTrident = userAgent2.indexOf("Trident/") !== -1; + return isMSIE || isTrident; } - var GL_COMPOSITE_PARAMETER_SETTERS = { - blendEquation: (gl, values, cache3) => gl.blendEquationSeparate(getValue(32777, values, cache3), getValue(34877, values, cache3)), - blendFunc: (gl, values, cache3) => gl.blendFuncSeparate(getValue(32969, values, cache3), getValue(32968, values, cache3), getValue(32971, values, cache3), getValue(32970, values, cache3)), - polygonOffset: (gl, values, cache3) => gl.polygonOffset(getValue(32824, values, cache3), getValue(10752, values, cache3)), - sampleCoverage: (gl, values, cache3) => gl.sampleCoverage(getValue(32938, values, cache3), getValue(32939, values, cache3)), - stencilFuncFront: (gl, values, cache3) => gl.stencilFuncSeparate(1028, getValue(2962, values, cache3), getValue(2967, values, cache3), getValue(2963, values, cache3)), - stencilFuncBack: (gl, values, cache3) => gl.stencilFuncSeparate(1029, getValue(34816, values, cache3), getValue(36003, values, cache3), getValue(36004, values, cache3)), - stencilOpFront: (gl, values, cache3) => gl.stencilOpSeparate(1028, getValue(2964, values, cache3), getValue(2965, values, cache3), getValue(2966, values, cache3)), - stencilOpBack: (gl, values, cache3) => gl.stencilOpSeparate(1029, getValue(34817, values, cache3), getValue(34818, values, cache3), getValue(34819, values, cache3)) - }; - var GL_HOOKED_SETTERS = { - enable: (update, capability) => update({ - [capability]: true - }), - disable: (update, capability) => update({ - [capability]: false - }), - pixelStorei: (update, pname, value) => update({ - [pname]: value - }), - hint: (update, pname, hint2) => update({ - [pname]: hint2 - }), - bindFramebuffer: (update, target, framebuffer) => { - switch (target) { - case 36160: - return update({ - [36006]: framebuffer, - [36010]: framebuffer - }); - case 36009: - return update({ - [36006]: framebuffer - }); - case 36008: - return update({ - [36010]: framebuffer - }); - default: - return null; - } - }, - blendColor: (update, r2, g2, b2, a2) => update({ - [32773]: new Float32Array([r2, g2, b2, a2]) - }), - blendEquation: (update, mode) => update({ - [32777]: mode, - [34877]: mode - }), - blendEquationSeparate: (update, modeRGB, modeAlpha) => update({ - [32777]: modeRGB, - [34877]: modeAlpha - }), - blendFunc: (update, src, dst) => update({ - [32969]: src, - [32968]: dst, - [32971]: src, - [32970]: dst - }), - blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({ - [32969]: srcRGB, - [32968]: dstRGB, - [32971]: srcAlpha, - [32970]: dstAlpha - }), - clearColor: (update, r2, g2, b2, a2) => update({ - [3106]: new Float32Array([r2, g2, b2, a2]) - }), - clearDepth: (update, depth) => update({ - [2931]: depth - }), - clearStencil: (update, s) => update({ - [2961]: s - }), - colorMask: (update, r2, g2, b2, a2) => update({ - [3107]: [r2, g2, b2, a2] - }), - cullFace: (update, mode) => update({ - [2885]: mode - }), - depthFunc: (update, func) => update({ - [2932]: func - }), - depthRange: (update, zNear, zFar) => update({ - [2928]: new Float32Array([zNear, zFar]) - }), - depthMask: (update, mask) => update({ - [2930]: mask - }), - frontFace: (update, face) => update({ - [2886]: face - }), - lineWidth: (update, width) => update({ - [2849]: width - }), - polygonOffset: (update, factor, units) => update({ - [32824]: factor, - [10752]: units - }), - sampleCoverage: (update, value, invert2) => update({ - [32938]: value, - [32939]: invert2 - }), - scissor: (update, x2, y2, width, height) => update({ - [3088]: new Int32Array([x2, y2, width, height]) - }), - stencilMask: (update, mask) => update({ - [2968]: mask, - [36005]: mask - }), - stencilMaskSeparate: (update, face, mask) => update({ - [face === 1028 ? 2968 : 36005]: mask - }), - stencilFunc: (update, func, ref, mask) => update({ - [2962]: func, - [2967]: ref, - [2963]: mask, - [34816]: func, - [36003]: ref, - [36004]: mask - }), - stencilFuncSeparate: (update, face, func, ref, mask) => update({ - [face === 1028 ? 2962 : 34816]: func, - [face === 1028 ? 2967 : 36003]: ref, - [face === 1028 ? 2963 : 36004]: mask - }), - stencilOp: (update, fail, zfail, zpass) => update({ - [2964]: fail, - [2965]: zfail, - [2966]: zpass, - [34817]: fail, - [34818]: zfail, - [34819]: zpass - }), - stencilOpSeparate: (update, face, fail, zfail, zpass) => update({ - [face === 1028 ? 2964 : 34817]: fail, - [face === 1028 ? 2965 : 34818]: zfail, - [face === 1028 ? 2966 : 34819]: zpass - }), - viewport: (update, x2, y2, width, height) => update({ - [2978]: [x2, y2, width, height] - }) - }; - var isEnabled = (gl, key) => gl.isEnabled(key); - var GL_PARAMETER_GETTERS = { - [3042]: isEnabled, - [2884]: isEnabled, - [2929]: isEnabled, - [3024]: isEnabled, - [32823]: isEnabled, - [32926]: isEnabled, - [32928]: isEnabled, - [3089]: isEnabled, - [2960]: isEnabled, - [35977]: isEnabled - }; - // node_modules/@luma.gl/gltools/dist/esm/utils/utils.js - function isObjectEmpty(object) { - for (const key in object) { - return false; + // node_modules/@luma.gl/shadertools/dist/esm/utils/webgl-info.js + var GL_VENDOR = 7936; + var GL_RENDERER = 7937; + var GL_VERSION = 7938; + var GL_SHADING_LANGUAGE_VERSION = 35724; + var WEBGL_FEATURES = { + GLSL_FRAG_DATA: ["WEBGL_draw_buffers", true], + GLSL_FRAG_DEPTH: ["EXT_frag_depth", true], + GLSL_DERIVATIVES: ["OES_standard_derivatives", true], + GLSL_TEXTURE_LOD: ["EXT_shader_texture_lod", true] + }; + var FEATURES2 = {}; + Object.keys(WEBGL_FEATURES).forEach((key) => { + FEATURES2[key] = key; + }); + function isWebGL22(gl) { + if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { + return true; } - return true; + return Boolean(gl && gl._version === 2); } - function deepArrayEqual(x2, y2) { - if (x2 === y2) { - return true; + function getContextInfo(gl) { + const info = gl.getExtension("WEBGL_debug_renderer_info"); + const vendor = gl.getParameter(info && info.UNMASKED_VENDOR_WEBGL || GL_VENDOR); + const renderer = gl.getParameter(info && info.UNMASKED_RENDERER_WEBGL || GL_RENDERER); + const gpuVendor = identifyGPUVendor(vendor, renderer); + const gpuInfo = { + gpuVendor, + vendor, + renderer, + version: gl.getParameter(GL_VERSION), + shadingLanguageVersion: gl.getParameter(GL_SHADING_LANGUAGE_VERSION) + }; + return gpuInfo; + } + function identifyGPUVendor(vendor, renderer) { + if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) { + return "NVIDIA"; } - const isArrayX = Array.isArray(x2) || ArrayBuffer.isView(x2); - const isArrayY = Array.isArray(y2) || ArrayBuffer.isView(y2); - if (isArrayX && isArrayY && x2.length === y2.length) { - for (let i2 = 0; i2 < x2.length; ++i2) { - if (x2[i2] !== y2[i2]) { - return false; - } - } + if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) { + return "INTEL"; + } + if (vendor.match(/AMD/i) || renderer.match(/AMD/i) || vendor.match(/ATI/i) || renderer.match(/ATI/i)) { + return "AMD"; + } + return "UNKNOWN GPU"; + } + var compiledGlslExtensions = {}; + function canCompileGLGSExtension(gl, cap) { + let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + const feature = WEBGL_FEATURES[cap]; + assert7(feature, cap); + if (!isOldIE(opts)) { return true; } - return false; + if (cap in compiledGlslExtensions) { + return compiledGlslExtensions[cap]; + } + const extensionName = feature[0]; + const behavior = opts.behavior || "enable"; + const source = "#extension GL_".concat(extensionName, " : ").concat(behavior, "\nvoid main(void) {}"); + const shader = gl.createShader(35633); + gl.shaderSource(shader, source); + gl.compileShader(shader); + const canCompile = gl.getShaderParameter(shader, 35713); + gl.deleteShader(shader); + compiledGlslExtensions[cap] = canCompile; + return canCompile; + } + function getFeature(gl, cap) { + const feature = WEBGL_FEATURES[cap]; + assert7(feature, cap); + const extensionName = isWebGL22(gl) ? feature[1] || feature[0] : feature[0]; + const value = typeof extensionName === "string" ? Boolean(gl.getExtension(extensionName)) : extensionName; + assert7(value === false || value === true); + return value; + } + function hasFeatures2(gl, features) { + features = Array.isArray(features) ? features : [features]; + return features.every((feature) => getFeature(gl, feature)); } - // node_modules/@luma.gl/gltools/dist/esm/state-tracker/track-context-state.js - function installGetterOverride(gl, functionName) { - const originalGetterFunc = gl[functionName].bind(gl); - gl[functionName] = function get() { - const pname = arguments.length <= 0 ? void 0 : arguments[0]; - if (!(pname in gl.state.cache)) { - return originalGetterFunc(...arguments); - } - return gl.state.enable ? gl.state.cache[pname] : originalGetterFunc(...arguments); - }; - Object.defineProperty(gl[functionName], "name", { - value: "".concat(functionName, "-from-cache"), - configurable: false - }); + // node_modules/@luma.gl/shadertools/dist/esm/lib/platform-defines.js + function getPlatformShaderDefines(gl) { + const debugInfo = getContextInfo(gl); + switch (debugInfo.gpuVendor.toLowerCase()) { + case "nvidia": + return "#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n"; + case "intel": + return "#define INTEL_GPU\n// Intel optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n"; + case "amd": + return "#define AMD_GPU\n"; + default: + return "#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n"; + } } - function installSetterSpy(gl, functionName, setter) { - const originalSetterFunc = gl[functionName].bind(gl); - gl[functionName] = function set() { - for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) { - params[_key] = arguments[_key]; + function getVersionDefines(gl, glslVersion, isFragment) { + let versionDefines = "#if (__VERSION__ > 120)\n\n# define FEATURE_GLSL_DERIVATIVES\n# define FEATURE_GLSL_DRAW_BUFFERS\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FEATURE_GLSL_TEXTURE_LOD\n\n// DEPRECATED FLAGS, remove in v9\n# define FRAG_DEPTH\n# define DERIVATIVES\n# define DRAW_BUFFERS\n# define TEXTURE_LOD\n\n#endif // __VERSION\n"; + if (hasFeatures2(gl, FEATURES2.GLSL_FRAG_DEPTH)) { + versionDefines += "\n// FRAG_DEPTH => gl_FragDepth is available\n#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FRAG_DEPTH\n# define gl_FragDepth gl_FragDepthEXT\n#endif\n"; + } + if (hasFeatures2(gl, FEATURES2.GLSL_DERIVATIVES) && canCompileGLGSExtension(gl, FEATURES2.GLSL_DERIVATIVES)) { + versionDefines += "\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n"; + } + if (hasFeatures2(gl, FEATURES2.GLSL_FRAG_DATA) && canCompileGLGSExtension(gl, FEATURES2.GLSL_FRAG_DATA, { + behavior: "require" + })) { + versionDefines += "\n// DRAW_BUFFERS => gl_FragData[] is available\n#ifdef GL_EXT_draw_buffers\n#extension GL_EXT_draw_buffers : require\n#define FEATURE_GLSL_DRAW_BUFFERS\n#define DRAW_BUFFERS\n#endif\n"; + } + if (hasFeatures2(gl, FEATURES2.GLSL_TEXTURE_LOD)) { + versionDefines += "// TEXTURE_LOD => texture2DLod etc are available\n#ifdef GL_EXT_shader_texture_lod\n#extension GL_EXT_shader_texture_lod : enable\n\n# define FEATURE_GLSL_TEXTURE_LOD\n# define TEXTURE_LOD\n\n#endif\n"; + } + return versionDefines; + } + + // node_modules/@luma.gl/shadertools/dist/esm/modules/module-injectors.js + var MODULE_INJECTORS_VS = "#ifdef MODULE_LOGDEPTH\n logdepth_adjustPosition(gl_Position);\n#endif\n"; + var MODULE_INJECTORS_FS = "#ifdef MODULE_MATERIAL\n gl_FragColor = material_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LIGHTING\n gl_FragColor = lighting_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_FOG\n gl_FragColor = fog_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_PICKING\n gl_FragColor = picking_filterHighlightColor(gl_FragColor);\n gl_FragColor = picking_filterPickingColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LOGDEPTH\n logdepth_setFragDepth();\n#endif\n"; + + // node_modules/@luma.gl/shadertools/dist/esm/lib/inject-shader.js + var MODULE_INJECTORS = { + [VERTEX_SHADER]: MODULE_INJECTORS_VS, + [FRAGMENT_SHADER]: MODULE_INJECTORS_FS + }; + var DECLARATION_INJECT_MARKER = "__LUMA_INJECT_DECLARATIONS__"; + var REGEX_START_OF_MAIN = /void\s+main\s*\([^)]*\)\s*\{\n?/; + var REGEX_END_OF_MAIN = /}\n?[^{}]*$/; + var fragments = []; + function injectShader(source, type, inject) { + let injectStandardStubs = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false; + const isVertex = type === VERTEX_SHADER; + for (const key in inject) { + const fragmentData = inject[key]; + fragmentData.sort((a2, b2) => a2.order - b2.order); + fragments.length = fragmentData.length; + for (let i3 = 0, len2 = fragmentData.length; i3 < len2; ++i3) { + fragments[i3] = fragmentData[i3].injection; } - const { - valueChanged, - oldValue - } = setter(gl.state._updateCache, ...params); - if (valueChanged) { - originalSetterFunc(...params); + const fragmentString = "".concat(fragments.join("\n"), "\n"); + switch (key) { + case "vs:#decl": + if (isVertex) { + source = source.replace(DECLARATION_INJECT_MARKER, fragmentString); + } + break; + case "vs:#main-start": + if (isVertex) { + source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString); + } + break; + case "vs:#main-end": + if (isVertex) { + source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match); + } + break; + case "fs:#decl": + if (!isVertex) { + source = source.replace(DECLARATION_INJECT_MARKER, fragmentString); + } + break; + case "fs:#main-start": + if (!isVertex) { + source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString); + } + break; + case "fs:#main-end": + if (!isVertex) { + source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match); + } + break; + default: + source = source.replace(key, (match) => match + fragmentString); } - return oldValue; - }; - Object.defineProperty(gl[functionName], "name", { - value: "".concat(functionName, "-to-cache"), - configurable: false - }); + } + source = source.replace(DECLARATION_INJECT_MARKER, ""); + if (injectStandardStubs) { + source = source.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[type]); + } + return source; } - function installProgramSpy(gl) { - const originalUseProgram = gl.useProgram.bind(gl); - gl.useProgram = function useProgramLuma(handle) { - if (gl.state.program !== handle) { - originalUseProgram(handle); - gl.state.program = handle; + function combineInjects(injects) { + const result = {}; + assert7(Array.isArray(injects) && injects.length > 1); + injects.forEach((inject) => { + for (const key in inject) { + result[key] = result[key] ? "".concat(result[key], "\n").concat(inject[key]) : inject[key]; } - }; + }); + return result; } - var GLState = class { - constructor(gl) { - let { - copyState = false, - log: log4 = () => { - } - } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - this.gl = gl; - this.program = null; - this.stateStack = []; - this.enable = true; - this.cache = copyState ? getParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS); - this.log = log4; - this._updateCache = this._updateCache.bind(this); - Object.seal(this); + + // node_modules/@luma.gl/shadertools/dist/esm/lib/transpile-shader.js + function testVariable(qualifier) { + return new RegExp("\\b".concat(qualifier, "[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)"), "g"); + } + var ES300_REPLACEMENTS = [[/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"], [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("], [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("]]; + var ES300_VERTEX_REPLACEMENTS = [...ES300_REPLACEMENTS, [testVariable("attribute"), "in $1"], [testVariable("varying"), "out $1"]]; + var ES300_FRAGMENT_REPLACEMENTS = [...ES300_REPLACEMENTS, [testVariable("varying"), "in $1"]]; + var ES100_REPLACEMENTS = [[/^#version[ \t]+300[ \t]+es/, "#version 100"], [/\btexture(2D|2DProj|Cube)Lod\(/g, "texture$1LodEXT("], [/\btexture\(/g, "texture2D("], [/\btextureLod\(/g, "texture2DLodEXT("]]; + var ES100_VERTEX_REPLACEMENTS = [...ES100_REPLACEMENTS, [testVariable("in"), "attribute $1"], [testVariable("out"), "varying $1"]]; + var ES100_FRAGMENT_REPLACEMENTS = [...ES100_REPLACEMENTS, [testVariable("in"), "varying $1"]]; + var ES100_FRAGMENT_OUTPUT_NAME = "gl_FragColor"; + var ES300_FRAGMENT_OUTPUT_REGEX = /\bout[ \t]+vec4[ \t]+(\w+)[ \t]*;\n?/; + var REGEX_START_OF_MAIN2 = /void\s+main\s*\([^)]*\)\s*\{\n?/; + function transpileShader(source, targetGLSLVersion, isVertex) { + switch (targetGLSLVersion) { + case 300: + return isVertex ? convertShader(source, ES300_VERTEX_REPLACEMENTS) : convertFragmentShaderTo300(source); + case 100: + return isVertex ? convertShader(source, ES100_VERTEX_REPLACEMENTS) : convertFragmentShaderTo100(source); + default: + throw new Error("unknown GLSL version ".concat(targetGLSLVersion)); } - push() { - let values = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this.stateStack.push({}); + } + function convertShader(source, replacements) { + for (const [pattern, replacement] of replacements) { + source = source.replace(pattern, replacement); } - pop() { - assert5(this.stateStack.length > 0); - const oldValues = this.stateStack[this.stateStack.length - 1]; - setParameters(this.gl, oldValues); - this.stateStack.pop(); + return source; + } + function convertFragmentShaderTo300(source) { + source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS); + const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX); + if (outputMatch) { + const outputName = outputMatch[1]; + source = source.replace(new RegExp("\\b".concat(ES100_FRAGMENT_OUTPUT_NAME, "\\b"), "g"), outputName); + } else { + const outputName = "fragmentColor"; + source = source.replace(REGEX_START_OF_MAIN2, (match) => "out vec4 ".concat(outputName, ";\n").concat(match)).replace(new RegExp("\\b".concat(ES100_FRAGMENT_OUTPUT_NAME, "\\b"), "g"), outputName); } - _updateCache(values) { - let valueChanged = false; - let oldValue; - const oldValues = this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1]; - for (const key in values) { - assert5(key !== void 0); - const value = values[key]; - const cached = this.cache[key]; - if (!deepArrayEqual(value, cached)) { - valueChanged = true; - oldValue = cached; - if (oldValues && !(key in oldValues)) { - oldValues[key] = cached; + return source; + } + function convertFragmentShaderTo100(source) { + source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS); + const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX); + if (outputMatch) { + const outputName = outputMatch[1]; + source = source.replace(ES300_FRAGMENT_OUTPUT_REGEX, "").replace(new RegExp("\\b".concat(outputName, "\\b"), "g"), ES100_FRAGMENT_OUTPUT_NAME); + } + return source; + } + + // node_modules/@luma.gl/shadertools/dist/esm/lib/assemble-shaders.js + var INJECT_SHADER_DECLARATIONS = "\n\n".concat(DECLARATION_INJECT_MARKER, "\n\n"); + var SHADER_TYPE = { + [VERTEX_SHADER]: "vertex", + [FRAGMENT_SHADER]: "fragment" + }; + var FRAGMENT_SHADER_PROLOGUE = "precision highp float;\n\n"; + function assembleShaders(gl, opts) { + const { + vs: vs8, + fs: fs6 + } = opts; + const modules = resolveModules(opts.modules || []); + return { + gl, + vs: assembleShader(gl, Object.assign({}, opts, { + source: vs8, + type: VERTEX_SHADER, + modules + })), + fs: assembleShader(gl, Object.assign({}, opts, { + source: fs6, + type: FRAGMENT_SHADER, + modules + })), + getUniforms: assembleGetUniforms(modules) + }; + } + function assembleShader(gl, _ref) { + let { + id, + source, + type, + modules, + defines: defines2 = {}, + hookFunctions = [], + inject = {}, + transpileToGLSL100 = false, + prologue = true, + log: log4 + } = _ref; + assert7(typeof source === "string", "shader source must be a string"); + const isVertex = type === VERTEX_SHADER; + const sourceLines = source.split("\n"); + let glslVersion = 100; + let versionLine = ""; + let coreSource = source; + if (sourceLines[0].indexOf("#version ") === 0) { + glslVersion = 300; + versionLine = sourceLines[0]; + coreSource = sourceLines.slice(1).join("\n"); + } else { + versionLine = "#version ".concat(glslVersion); + } + const allDefines = {}; + modules.forEach((module) => { + Object.assign(allDefines, module.getDefines()); + }); + Object.assign(allDefines, defines2); + let assembledSource = prologue ? "".concat(versionLine, "\n").concat(getShaderName2({ + id, + source, + type + }), "\n").concat(getShaderType({ + type + }), "\n").concat(getPlatformShaderDefines(gl), "\n").concat(getVersionDefines(gl, glslVersion, !isVertex), "\n").concat(getApplicationDefines(allDefines), "\n").concat(isVertex ? "" : FRAGMENT_SHADER_PROLOGUE, "\n") : "".concat(versionLine, "\n"); + const hookFunctionMap = normalizeHookFunctions(hookFunctions); + const hookInjections = {}; + const declInjections = {}; + const mainInjections = {}; + for (const key in inject) { + const injection = typeof inject[key] === "string" ? { + injection: inject[key], + order: 0 + } : inject[key]; + const match = key.match(/^(v|f)s:(#)?([\w-]+)$/); + if (match) { + const hash = match[2]; + const name = match[3]; + if (hash) { + if (name === "decl") { + declInjections[key] = [injection]; + } else { + mainInjections[key] = [injection]; } - this.cache[key] = value; + } else { + hookInjections[key] = [injection]; } + } else { + mainInjections[key] = [injection]; } - return { - valueChanged, - oldValue - }; } - }; - function trackContextState(gl) { - let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const { - enable: enable2 = true, - copyState - } = options; - assert5(copyState !== void 0); - if (!gl.state) { - const { - polyfillContext: polyfillContext2 - } = globalThis; - if (polyfillContext2) { - polyfillContext2(gl); + for (const module of modules) { + if (log4) { + module.checkDeprecations(coreSource, log4); } - gl.state = new GLState(gl, { - copyState - }); - installProgramSpy(gl); - for (const key in GL_HOOKED_SETTERS) { - const setter = GL_HOOKED_SETTERS[key]; - installSetterSpy(gl, key, setter); + const moduleSource = module.getModuleSource(type, glslVersion); + assembledSource += moduleSource; + const injections = module.injections[type]; + for (const key in injections) { + const match = key.match(/^(v|f)s:#([\w-]+)$/); + if (match) { + const name = match[2]; + const injectionType = name === "decl" ? declInjections : mainInjections; + injectionType[key] = injectionType[key] || []; + injectionType[key].push(injections[key]); + } else { + hookInjections[key] = hookInjections[key] || []; + hookInjections[key].push(injections[key]); + } } - installGetterOverride(gl, "getParameter"); - installGetterOverride(gl, "isEnabled"); } - gl.state.enable = enable2; - return gl; + assembledSource += INJECT_SHADER_DECLARATIONS; + assembledSource = injectShader(assembledSource, type, declInjections); + assembledSource += getHookFunctions(hookFunctionMap[type], hookInjections); + assembledSource += coreSource; + assembledSource = injectShader(assembledSource, type, mainInjections); + assembledSource = transpileShader(assembledSource, transpileToGLSL100 ? 100 : glslVersion, isVertex); + return assembledSource; } - function pushContextState(gl) { - if (!gl.state) { - trackContextState(gl, { - copyState: false - }); - } - gl.state.push(); + function assembleGetUniforms(modules) { + return function getUniforms5(opts) { + const uniforms = {}; + for (const module of modules) { + const moduleUniforms = module.getUniforms(opts, uniforms); + Object.assign(uniforms, moduleUniforms); + } + return uniforms; + }; } - function popContextState(gl) { - assert5(gl.state); - gl.state.pop(); + function getShaderType(_ref2) { + let { + type + } = _ref2; + return "\n#define SHADER_TYPE_".concat(SHADER_TYPE[type].toUpperCase(), "\n"); } - - // node_modules/@luma.gl/gltools/dist/esm/state-tracker/unified-parameter-api.js - function setParameters(gl, values) { - assert5(isWebGL(gl), "setParameters requires a WebGL context"); - if (isObjectEmpty(values)) { - return; + function getShaderName2(_ref3) { + let { + id, + source, + type + } = _ref3; + const injectShaderName = id && typeof id === "string" && source.indexOf("SHADER_NAME") === -1; + return injectShaderName ? "\n#define SHADER_NAME ".concat(id, "_").concat(SHADER_TYPE[type], "\n\n") : ""; + } + function getApplicationDefines() { + let defines2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + let count2 = 0; + let sourceText = ""; + for (const define2 in defines2) { + if (count2 === 0) { + sourceText += "\n// APPLICATION DEFINES\n"; + } + count2++; + const value = defines2[define2]; + if (value || Number.isFinite(value)) { + sourceText += "#define ".concat(define2.toUpperCase(), " ").concat(defines2[define2], "\n"); + } } - const compositeSetters = {}; - for (const key in values) { - const glConstant = Number(key); - const setter = GL_PARAMETER_SETTERS[key]; - if (setter) { - if (typeof setter === "string") { - compositeSetters[setter] = true; - } else { - setter(gl, values[key], glConstant); + if (count2 === 0) { + sourceText += "\n"; + } + return sourceText; + } + function getHookFunctions(hookFunctions, hookInjections) { + let result = ""; + for (const hookName in hookFunctions) { + const hookFunction = hookFunctions[hookName]; + result += "void ".concat(hookFunction.signature, " {\n"); + if (hookFunction.header) { + result += " ".concat(hookFunction.header); + } + if (hookInjections[hookName]) { + const injections = hookInjections[hookName]; + injections.sort((a2, b2) => a2.order - b2.order); + for (const injection of injections) { + result += " ".concat(injection.injection, "\n"); } } - } - const cache3 = gl.state && gl.state.cache; - if (cache3) { - for (const key in compositeSetters) { - const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key]; - compositeSetter(gl, values, cache3); + if (hookFunction.footer) { + result += " ".concat(hookFunction.footer); } + result += "}\n"; } + return result; } - function getParameters(gl, parameters) { - parameters = parameters || GL_PARAMETER_DEFAULTS; - if (typeof parameters === "number") { - const key = parameters; - const getter = GL_PARAMETER_GETTERS[key]; - return getter ? getter(gl, key) : gl.getParameter(key); - } - const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters); - const state = {}; - for (const key of parameterKeys) { - const getter = GL_PARAMETER_GETTERS[key]; - state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key)); - } - return state; - } - function resetParameters(gl) { - setParameters(gl, GL_PARAMETER_DEFAULTS); + function normalizeHookFunctions(hookFunctions) { + const result = { + vs: {}, + fs: {} + }; + hookFunctions.forEach((hook) => { + let opts; + if (typeof hook !== "string") { + opts = hook; + hook = opts.hook; + } else { + opts = {}; + } + hook = hook.trim(); + const [stage, signature] = hook.split(":"); + const name = hook.replace(/\(.+/, ""); + result[stage][name] = Object.assign(opts, { + signature + }); + }); + return result; } - function withParameters(gl, parameters, func) { - if (isObjectEmpty(parameters)) { - return func(gl); + + // node_modules/@luma.gl/shadertools/dist/esm/utils/shader-utils.js + var FS100 = "void main() {gl_FragColor = vec4(0);}"; + var FS_GLES = "out vec4 transform_output;\nvoid main() {\n transform_output = vec4(0);\n}"; + var FS300 = "#version 300 es\n".concat(FS_GLES); + function getQualifierDetails(line, qualifiers) { + qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers]; + const words = line.replace(/^\s+/, "").split(/\s+/); + const [qualifier, type, definition] = words; + if (!qualifiers.includes(qualifier) || !type || !definition) { + return null; } + const name = definition.split(";")[0]; + return { + qualifier, + type, + name + }; + } + function getPassthroughFS() { + let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; const { - nocatch = true - } = parameters; - pushContextState(gl); - setParameters(gl, parameters); - let value; - if (nocatch) { - value = func(gl); - popContextState(gl); - } else { - try { - value = func(gl); - } finally { - popContextState(gl); + version = 100, + input, + inputType, + output + } = options; + if (!input) { + if (version === 300) { + return FS300; + } else if (version > 300) { + return "#version ".concat(version, "\n").concat(FS_GLES); } + return FS100; } - return value; - } - - // node_modules/@luma.gl/gltools/dist/esm/utils/device-pixels.js - function cssToDeviceRatio(gl) { - const { - luma - } = gl; - if (gl.canvas && luma) { - const cachedSize = luma.canvasSizeInfo; - const clientWidth = "clientWidth" in cachedSize ? cachedSize.clientWidth : gl.canvas.clientWidth; - return clientWidth ? gl.drawingBufferWidth / clientWidth : 1; + const outputValue = convertToVec4(input, inputType); + if (version >= 300) { + return "#version ".concat(version, " ").concat(version === 300 ? "es" : "", "\nin ").concat(inputType, " ").concat(input, ";\nout vec4 ").concat(output, ";\nvoid main() {\n ").concat(output, " = ").concat(outputValue, ";\n}"); } - return 1; - } - function cssToDevicePixels(gl, cssPixel) { - let yInvert = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true; - const ratio = cssToDeviceRatio(gl); - const width = gl.drawingBufferWidth; - const height = gl.drawingBufferHeight; - return scalePixels(cssPixel, ratio, width, height, yInvert); + return "varying ".concat(inputType, " ").concat(input, ";\nvoid main() {\n gl_FragColor = ").concat(outputValue, ";\n}"); } - function getDevicePixelRatio(useDevicePixels) { - const windowRatio = typeof window === "undefined" ? 1 : window.devicePixelRatio || 1; - if (Number.isFinite(useDevicePixels)) { - return useDevicePixels <= 0 ? 1 : useDevicePixels; + function typeToChannelSuffix(type) { + switch (type) { + case "float": + return "x"; + case "vec2": + return "xy"; + case "vec3": + return "xyz"; + case "vec4": + return "xyzw"; + default: + assert7(false); + return null; } - return useDevicePixels ? windowRatio : 1; } - function scalePixels(pixel, ratio, width, height, yInvert) { - const x2 = scaleX(pixel[0], ratio, width); - let y2 = scaleY(pixel[1], ratio, height, yInvert); - let t2 = scaleX(pixel[0] + 1, ratio, width); - const xHigh = t2 === width - 1 ? t2 : t2 - 1; - t2 = scaleY(pixel[1] + 1, ratio, height, yInvert); - let yHigh; - if (yInvert) { - t2 = t2 === 0 ? t2 : t2 + 1; - yHigh = y2; - y2 = t2; - } else { - yHigh = t2 === height - 1 ? t2 : t2 - 1; + function typeToChannelCount(type) { + switch (type) { + case "float": + return 1; + case "vec2": + return 2; + case "vec3": + return 3; + case "vec4": + return 4; + default: + assert7(false); + return null; } - return { - x: x2, - y: y2, - width: Math.max(xHigh - x2 + 1, 1), - height: Math.max(yHigh - y2 + 1, 1) - }; } - function scaleX(x2, ratio, width) { - const r2 = Math.min(Math.round(x2 * ratio), width - 1); - return r2; + function convertToVec4(variable, type) { + switch (type) { + case "float": + return "vec4(".concat(variable, ", 0.0, 0.0, 1.0)"); + case "vec2": + return "vec4(".concat(variable, ", 0.0, 1.0)"); + case "vec3": + return "vec4(".concat(variable, ", 1.0)"); + case "vec4": + return variable; + default: + assert7(false); + return null; + } } - function scaleY(y2, ratio, height, yInvert) { - return yInvert ? Math.max(0, height - 1 - Math.round(y2 * ratio)) : Math.min(Math.round(y2 * ratio), height - 1); + + // node_modules/@luma.gl/shadertools/dist/esm/modules/fp32/fp32.js + var fp32shader = "#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\nconst float TWO_PI = 6.2831854820251465;\nconst float PI_2 = 1.5707963705062866;\nconst float PI_16 = 0.1963495463132858;\n\nconst float SIN_TABLE_0 = 0.19509032368659973;\nconst float SIN_TABLE_1 = 0.3826834261417389;\nconst float SIN_TABLE_2 = 0.5555702447891235;\nconst float SIN_TABLE_3 = 0.7071067690849304;\n\nconst float COS_TABLE_0 = 0.9807852506637573;\nconst float COS_TABLE_1 = 0.9238795042037964;\nconst float COS_TABLE_2 = 0.8314695954322815;\nconst float COS_TABLE_3 = 0.7071067690849304;\n\nconst float INVERSE_FACTORIAL_3 = 1.666666716337204e-01;\nconst float INVERSE_FACTORIAL_5 = 8.333333767950535e-03;\nconst float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04;\nconst float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06;\n\nfloat sin_taylor_fp32(float a) {\n float r, s, t, x;\n\n if (a == 0.0) {\n return 0.0;\n }\n\n x = -a * a;\n s = a;\n r = a;\n\n r = r * x;\n t = r * INVERSE_FACTORIAL_3;\n s = s + t;\n\n r = r * x;\n t = r * INVERSE_FACTORIAL_5;\n s = s + t;\n\n r = r * x;\n t = r * INVERSE_FACTORIAL_7;\n s = s + t;\n\n r = r * x;\n t = r * INVERSE_FACTORIAL_9;\n s = s + t;\n\n return s;\n}\n\nvoid sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {\n if (a == 0.0) {\n sin_t = 0.0;\n cos_t = 1.0;\n }\n sin_t = sin_taylor_fp32(a);\n cos_t = sqrt(1.0 - sin_t * sin_t);\n}\n\nfloat tan_taylor_fp32(float a) {\n float sin_a;\n float cos_a;\n\n if (a == 0.0) {\n return 0.0;\n }\n float z = floor(a / TWO_PI);\n float r = a - TWO_PI * z;\n\n float t;\n float q = floor(r / PI_2 + 0.5);\n int j = int(q);\n\n if (j < -2 || j > 2) {\n return 1.0 / 0.0;\n }\n\n t = r - PI_2 * q;\n\n q = floor(t / PI_16 + 0.5);\n int k = int(q);\n int abs_k = int(abs(float(k)));\n\n if (abs_k > 4) {\n return 1.0 / 0.0;\n } else {\n t = t - PI_16 * q;\n }\n\n float u = 0.0;\n float v = 0.0;\n\n float sin_t, cos_t;\n float s, c;\n sincos_taylor_fp32(t, sin_t, cos_t);\n\n if (k == 0) {\n s = sin_t;\n c = cos_t;\n } else {\n if (abs(float(abs_k) - 1.0) < 0.5) {\n u = COS_TABLE_0;\n v = SIN_TABLE_0;\n } else if (abs(float(abs_k) - 2.0) < 0.5) {\n u = COS_TABLE_1;\n v = SIN_TABLE_1;\n } else if (abs(float(abs_k) - 3.0) < 0.5) {\n u = COS_TABLE_2;\n v = SIN_TABLE_2;\n } else if (abs(float(abs_k) - 4.0) < 0.5) {\n u = COS_TABLE_3;\n v = SIN_TABLE_3;\n }\n if (k > 0) {\n s = u * sin_t + v * cos_t;\n c = u * cos_t - v * sin_t;\n } else {\n s = u * sin_t - v * cos_t;\n c = u * cos_t + v * sin_t;\n }\n }\n\n if (j == 0) {\n sin_a = s;\n cos_a = c;\n } else if (j == 1) {\n sin_a = c;\n cos_a = -s;\n } else if (j == -1) {\n sin_a = -c;\n cos_a = s;\n } else {\n sin_a = -s;\n cos_a = -c;\n }\n return sin_a / cos_a;\n}\n#endif\n\nfloat tan_fp32(float a) {\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n return tan_taylor_fp32(a);\n#else\n return tan(a);\n#endif\n}\n"; + var fp32 = { + name: "fp32", + vs: fp32shader, + fs: null + }; + + // node_modules/@math.gl/core/dist/esm/lib/assert.js + function assert8(condition, message) { + if (!condition) { + throw new Error("math.gl assertion ".concat(message)); + } } - // node_modules/@luma.gl/gltools/dist/esm/context/context.js - var isBrowser7 = isBrowser5(); - var isPage = isBrowser7 && typeof document !== "undefined"; - var CONTEXT_DEFAULTS = { - webgl2: true, - webgl1: true, - throwOnError: true, - manageState: true, - canvas: null, + // node_modules/@math.gl/core/dist/esm/lib/common.js + var RADIANS_TO_DEGREES = 1 / Math.PI * 180; + var DEGREES_TO_RADIANS = 1 / 180 * Math.PI; + var config = { + EPSILON: 1e-12, debug: false, - width: 800, - height: 600 + precision: 4, + printTypes: false, + printDegrees: false, + printRowMajor: true }; - function createGLContext() { - let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - assert5(isBrowser7, "createGLContext only available in the browser.\nCreate your own headless context or use 'createHeadlessContext' from @luma.gl/test-utils"); - options = Object.assign({}, CONTEXT_DEFAULTS, options); - const { - width, - height - } = options; - function onError(message) { - if (options.throwOnError) { - throw new Error(message); - } - console.error(message); - return null; - } - options.onError = onError; - let gl; - const { - canvas - } = options; - const targetCanvas = getCanvas({ - canvas, - width, - height, - onError - }); - gl = createBrowserContext(targetCanvas, options); - if (!gl) { - return null; + function formatValue2(value, { + precision = config.precision + } = {}) { + value = round(value); + return "".concat(parseFloat(value.toPrecision(precision))); + } + function isArray2(value) { + return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView); + } + function clamp(value, min, max) { + return map(value, (value2) => Math.max(min, Math.min(max, value2))); + } + function lerp(a2, b2, t2) { + if (isArray2(a2)) { + return a2.map((ai, i3) => lerp(ai, b2[i3], t2)); } - gl = instrumentGLContext(gl, options); - logInfo(gl); - return gl; + return t2 * b2 + (1 - t2) * a2; } - function instrumentGLContext(gl) { - let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - if (!gl || gl._instrumented) { - return gl; + function equals(a2, b2, epsilon) { + const oldEpsilon = config.EPSILON; + if (epsilon) { + config.EPSILON = epsilon; } - gl._version = gl._version || getVersion(gl); - gl.luma = gl.luma || {}; - gl.luma.canvasSizeInfo = gl.luma.canvasSizeInfo || {}; - options = Object.assign({}, CONTEXT_DEFAULTS, options); - const { - manageState, - debug: debug2 - } = options; - if (manageState) { - trackContextState(gl, { - copyState: false, - log: function() { - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; + try { + if (a2 === b2) { + return true; + } + if (isArray2(a2) && isArray2(b2)) { + if (a2.length !== b2.length) { + return false; + } + for (let i3 = 0; i3 < a2.length; ++i3) { + if (!equals(a2[i3], b2[i3])) { + return false; } - return log2.log(1, ...args)(); } - }); - } - if (isBrowser7 && debug2) { - if (!globalThis.makeDebugContext) { - log2.warn('WebGL debug mode not activated. import "@luma.gl/debug" to enable.')(); - } else { - gl = globalThis.makeDebugContext(gl, options); - log2.level = Math.max(log2.level, 1); + return true; + } + if (a2 && a2.equals) { + return a2.equals(b2); + } + if (b2 && b2.equals) { + return b2.equals(a2); } + if (typeof a2 === "number" && typeof b2 === "number") { + return Math.abs(a2 - b2) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)); + } + return false; + } finally { + config.EPSILON = oldEpsilon; } - gl._instrumented = true; - return gl; } - function getContextDebugInfo(gl) { - const vendorMasked = gl.getParameter(7936); - const rendererMasked = gl.getParameter(7937); - const ext = gl.getExtension("WEBGL_debug_renderer_info"); - const vendorUnmasked = ext && gl.getParameter(ext.UNMASKED_VENDOR_WEBGL || 7936); - const rendererUnmasked = ext && gl.getParameter(ext.UNMASKED_RENDERER_WEBGL || 7937); - return { - vendor: vendorUnmasked || vendorMasked, - renderer: rendererUnmasked || rendererMasked, - vendorMasked, - rendererMasked, - version: gl.getParameter(7938), - shadingLanguageVersion: gl.getParameter(35724) - }; + function round(value) { + return Math.round(value / config.EPSILON) * config.EPSILON; } - function resizeGLContext(gl) { - let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - if (gl.canvas) { - const devicePixelRatio = getDevicePixelRatio(options.useDevicePixels); - setDevicePixelRatio(gl, devicePixelRatio, options); - return; - } - const ext = gl.getExtension("STACKGL_resize_drawingbuffer"); - if (ext && "width" in options && "height" in options) { - ext.resize(options.width, options.height); + function duplicateArray(array) { + return array.clone ? array.clone() : new Array(array.length); + } + function map(value, func, result) { + if (isArray2(value)) { + const array = value; + result = result || duplicateArray(array); + for (let i3 = 0; i3 < result.length && i3 < array.length; ++i3) { + result[i3] = func(value[i3], i3, result); + } + return result; } + return func(value); } - function createBrowserContext(canvas, options) { - const { - onError - } = options; - let errorMessage = null; - const onCreateError = (error2) => errorMessage = error2.statusMessage || errorMessage; - canvas.addEventListener("webglcontextcreationerror", onCreateError, false); - const { - webgl1 = true, - webgl2 = true - } = options; - let gl = null; - if (webgl2) { - gl = gl || canvas.getContext("webgl2", options); - gl = gl || canvas.getContext("experimental-webgl2", options); + + // node_modules/@math.gl/core/dist/esm/classes/base/math-array.js + function _extendableBuiltin(cls) { + function ExtendableBuiltin() { + var instance2 = Reflect.construct(cls, Array.from(arguments)); + Object.setPrototypeOf(instance2, Object.getPrototypeOf(this)); + return instance2; } - if (webgl1) { - gl = gl || canvas.getContext("webgl", options); - gl = gl || canvas.getContext("experimental-webgl", options); + 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; } - canvas.removeEventListener("webglcontextcreationerror", onCreateError, false); - if (!gl) { - return onError("Failed to create ".concat(webgl2 && !webgl1 ? "WebGL2" : "WebGL", " context: ").concat(errorMessage || "Unknown error")); + return ExtendableBuiltin; + } + var MathArray = class extends _extendableBuiltin(Array) { + clone() { + return new this.constructor().copy(this); } - if (options.onContextLost) { - canvas.addEventListener("webglcontextlost", options.onContextLost, false); + fromArray(array, offset = 0) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] = array[i3 + offset]; + } + return this.check(); } - if (options.onContextRestored) { - canvas.addEventListener("webglcontextrestored", options.onContextRestored, false); + toArray(targetArray = [], offset = 0) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + targetArray[offset + i3] = this[i3]; + } + return targetArray; } - return gl; - } - function getCanvas(_ref) { - let { - canvas, - width = 800, - height = 600, - onError - } = _ref; - let targetCanvas; - if (typeof canvas === "string") { - const isPageLoaded = isPage && document.readyState === "complete"; - if (!isPageLoaded) { - onError("createGLContext called on canvas '".concat(canvas, "' before page was loaded")); + from(arrayOrObject) { + return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject); + } + to(arrayOrObject) { + if (arrayOrObject === this) { + return this; } - targetCanvas = document.getElementById(canvas); - } else if (canvas) { - targetCanvas = canvas; - } else { - targetCanvas = document.createElement("canvas"); - targetCanvas.id = "lumagl-canvas"; - targetCanvas.style.width = Number.isFinite(width) ? "".concat(width, "px") : "100%"; - targetCanvas.style.height = Number.isFinite(height) ? "".concat(height, "px") : "100%"; - document.body.insertBefore(targetCanvas, document.body.firstChild); + return isArray2(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject); } - return targetCanvas; - } - function logInfo(gl) { - const webGL = isWebGL2(gl) ? "WebGL2" : "WebGL1"; - const info = getContextDebugInfo(gl); - const driver = info ? "(".concat(info.vendor, ",").concat(info.renderer, ")") : ""; - const debug2 = gl.debug ? " debug" : ""; - log2.info(1, "".concat(webGL).concat(debug2, " context ").concat(driver))(); - } - function getVersion(gl) { - if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { - return 2; + toTarget(target) { + return target ? this.to(target) : this; } - return 1; - } - function setDevicePixelRatio(gl, devicePixelRatio, options) { - let clientWidth = "width" in options ? options.width : gl.canvas.clientWidth; - let clientHeight = "height" in options ? options.height : gl.canvas.clientHeight; - if (!clientWidth || !clientHeight) { - log2.log(1, "Canvas clientWidth/clientHeight is 0")(); - devicePixelRatio = 1; - clientWidth = gl.canvas.width || 1; - clientHeight = gl.canvas.height || 1; + toFloat32Array() { + return new Float32Array(this); } - gl.luma = gl.luma || {}; - gl.luma.canvasSizeInfo = gl.luma.canvasSizeInfo || {}; - const cachedSize = gl.luma.canvasSizeInfo; - if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio) { - let clampedPixelRatio = devicePixelRatio; - const canvasWidth = Math.floor(clientWidth * clampedPixelRatio); - const canvasHeight = Math.floor(clientHeight * clampedPixelRatio); - gl.canvas.width = canvasWidth; - gl.canvas.height = canvasHeight; - if (gl.drawingBufferWidth !== canvasWidth || gl.drawingBufferHeight !== canvasHeight) { - log2.warn("Device pixel ratio clamped")(); - clampedPixelRatio = Math.min(gl.drawingBufferWidth / clientWidth, gl.drawingBufferHeight / clientHeight); - gl.canvas.width = Math.floor(clientWidth * clampedPixelRatio); - gl.canvas.height = Math.floor(clientHeight * clampedPixelRatio); + toString() { + return this.formatString(config); + } + formatString(opts) { + let string = ""; + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + string += (i3 > 0 ? ", " : "") + formatValue2(this[i3], opts); } - Object.assign(gl.luma.canvasSizeInfo, { - clientWidth, - clientHeight, - devicePixelRatio - }); + return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]"); } - } - - // node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js - function getHiResTimestamp3() { - let timestamp; - if (typeof window !== "undefined" && window.performance) { - timestamp = window.performance.now(); - } else if (typeof process !== "undefined" && process.hrtime) { - const timeParts = process.hrtime(); - timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6; - } else { - timestamp = Date.now(); + equals(array) { + if (!array || this.length !== array.length) { + return false; + } + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + if (!equals(this[i3], array[i3])) { + return false; + } + } + return true; + } + exactEquals(array) { + if (!array || this.length !== array.length) { + return false; + } + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + if (this[i3] !== array[i3]) { + return false; + } + } + return true; } - return timestamp; - } - - // node_modules/@probe.gl/stats/dist/esm/lib/stat.js - var Stat = class { - constructor(name, type) { - _defineProperty(this, "name", void 0); - _defineProperty(this, "type", void 0); - _defineProperty(this, "sampleSize", 1); - _defineProperty(this, "time", void 0); - _defineProperty(this, "count", void 0); - _defineProperty(this, "samples", void 0); - _defineProperty(this, "lastTiming", void 0); - _defineProperty(this, "lastSampleTime", void 0); - _defineProperty(this, "lastSampleCount", void 0); - _defineProperty(this, "_count", 0); - _defineProperty(this, "_time", 0); - _defineProperty(this, "_samples", 0); - _defineProperty(this, "_startTime", 0); - _defineProperty(this, "_timerPending", false); - this.name = name; - this.type = type; - this.reset(); + negate() { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] = -this[i3]; + } + return this.check(); } - setSampleSize(samples) { - this.sampleSize = samples; - return this; + lerp(a2, b2, t2) { + if (t2 === void 0) { + return this.lerp(this, a2, b2); + } + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + const ai = a2[i3]; + this[i3] = ai + t2 * (b2[i3] - ai); + } + return this.check(); } - incrementCount() { - this.addCount(1); - return this; + min(vector) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] = Math.min(vector[i3], this[i3]); + } + return this.check(); } - decrementCount() { - this.subtractCount(1); - return this; + max(vector) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] = Math.max(vector[i3], this[i3]); + } + return this.check(); } - addCount(value) { - this._count += value; - this._samples++; - this._checkSampling(); - return this; + clamp(minVector, maxVector) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] = Math.min(Math.max(this[i3], minVector[i3]), maxVector[i3]); + } + return this.check(); } - subtractCount(value) { - this._count -= value; - this._samples++; - this._checkSampling(); - return this; + add(...vectors) { + for (const vector of vectors) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] += vector[i3]; + } + } + return this.check(); } - addTime(time) { - this._time += time; - this.lastTiming = time; - this._samples++; - this._checkSampling(); - return this; + subtract(...vectors) { + for (const vector of vectors) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] -= vector[i3]; + } + } + return this.check(); } - timeStart() { - this._startTime = getHiResTimestamp3(); - this._timerPending = true; - return this; + scale(scale5) { + if (typeof scale5 === "number") { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] *= scale5; + } + } else { + for (let i3 = 0; i3 < this.ELEMENTS && i3 < scale5.length; ++i3) { + this[i3] *= scale5[i3]; + } + } + return this.check(); } - timeEnd() { - if (!this._timerPending) { - return this; + multiplyByScalar(scalar) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] *= scalar; + } + return this.check(); + } + check() { + if (config.debug && !this.validate()) { + throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'")); } - this.addTime(getHiResTimestamp3() - this._startTime); - this._timerPending = false; - this._checkSampling(); return this; } - getSampleAverageCount() { - return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0; + validate() { + let valid = this.length === this.ELEMENTS; + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + valid = valid && Number.isFinite(this[i3]); + } + return valid; } - getSampleAverageTime() { - return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0; + sub(a2) { + return this.subtract(a2); } - getSampleHz() { - return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0; + setScalar(a2) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] = a2; + } + return this.check(); } - getAverageCount() { - return this.samples > 0 ? this.count / this.samples : 0; + addScalar(a2) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] += a2; + } + return this.check(); } - getAverageTime() { - return this.samples > 0 ? this.time / this.samples : 0; + subScalar(a2) { + return this.addScalar(-a2); } - getHz() { - return this.time > 0 ? this.samples / (this.time / 1e3) : 0; + multiplyScalar(scalar) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] *= scalar; + } + return this.check(); } - reset() { - this.time = 0; - this.count = 0; - this.samples = 0; - this.lastTiming = 0; - this.lastSampleTime = 0; - this.lastSampleCount = 0; - this._count = 0; - this._time = 0; - this._samples = 0; - this._startTime = 0; - this._timerPending = false; - return this; + divideScalar(a2) { + return this.multiplyByScalar(1 / a2); } - _checkSampling() { - if (this._samples === this.sampleSize) { - this.lastSampleTime = this._time; - this.lastSampleCount = this._count; - this.count += this._count; - this.time += this._time; - this.samples += this._samples; - this._time = 0; - this._count = 0; - this._samples = 0; + clampScalar(min, max) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] = Math.min(Math.max(this[i3], min), max); } + return this.check(); + } + get elements() { + return this; } }; - // node_modules/@probe.gl/stats/dist/esm/lib/stats.js - var Stats = class { - constructor(options) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "stats", {}); - this.id = options.id; - this.stats = {}; - this._initializeStats(options.stats); - Object.seal(this); + // node_modules/@math.gl/core/dist/esm/lib/validators.js + function validateVector(v2, length4) { + if (v2.length !== length4) { + return false; } - get(name) { - let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count"; - return this._getOrCreate({ - name, - type - }); + for (let i3 = 0; i3 < v2.length; ++i3) { + if (!Number.isFinite(v2[i3])) { + return false; + } } - get size() { - return Object.keys(this.stats).length; + return true; + } + function checkNumber(value) { + if (!Number.isFinite(value)) { + throw new Error("Invalid number ".concat(value)); } - reset() { - for (const key in this.stats) { - this.stats[key].reset(); + return value; + } + function checkVector(v2, length4, callerName = "") { + if (config.debug && !validateVector(v2, length4)) { + throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'")); + } + return v2; + } + + // node_modules/@math.gl/core/dist/esm/classes/base/vector.js + var Vector = class extends MathArray { + get x() { + return this[0]; + } + set x(value) { + this[0] = checkNumber(value); + } + get y() { + return this[1]; + } + set y(value) { + this[1] = checkNumber(value); + } + len() { + return Math.sqrt(this.lengthSquared()); + } + magnitude() { + return this.len(); + } + lengthSquared() { + let length4 = 0; + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + length4 += this[i3] * this[i3]; } - return this; + return length4; } - forEach(fn) { - for (const key in this.stats) { - fn(this.stats[key]); + magnitudeSquared() { + return this.lengthSquared(); + } + distance(mathArray) { + return Math.sqrt(this.distanceSquared(mathArray)); + } + distanceSquared(mathArray) { + let length4 = 0; + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + const dist = this[i3] - mathArray[i3]; + length4 += dist * dist; } + return checkNumber(length4); } - getTable() { - const table = {}; - this.forEach((stat) => { - table[stat.name] = { - time: stat.time || 0, - count: stat.count || 0, - average: stat.getAverageTime() || 0, - hz: stat.getHz() || 0 - }; - }); - return table; + dot(mathArray) { + let product = 0; + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + product += this[i3] * mathArray[i3]; + } + return checkNumber(product); } - _initializeStats() { - let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []; - stats.forEach((stat) => this._getOrCreate(stat)); + normalize() { + const length4 = this.magnitude(); + if (length4 !== 0) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] /= length4; + } + } + return this.check(); } - _getOrCreate(stat) { - if (!stat || !stat.name) { - return null; + multiply(...vectors) { + for (const vector of vectors) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] *= vector[i3]; + } } - const { - name, - type - } = stat; - if (!this.stats[name]) { - if (stat instanceof Stat) { - this.stats[name] = stat; - } else { - this.stats[name] = new Stat(name, type); + return this.check(); + } + divide(...vectors) { + for (const vector of vectors) { + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + this[i3] /= vector[i3]; } } - return this.stats[name]; + return this.check(); + } + lengthSq() { + return this.lengthSquared(); + } + distanceTo(vector) { + return this.distance(vector); + } + distanceToSquared(vector) { + return this.distanceSquared(vector); + } + getComponent(i3) { + assert8(i3 >= 0 && i3 < this.ELEMENTS, "index is out of range"); + return checkNumber(this[i3]); + } + setComponent(i3, value) { + assert8(i3 >= 0 && i3 < this.ELEMENTS, "index is out of range"); + this[i3] = value; + return this.check(); + } + addVectors(a2, b2) { + return this.copy(a2).add(b2); + } + subVectors(a2, b2) { + return this.copy(a2).subtract(b2); + } + multiplyVectors(a2, b2) { + return this.copy(a2).multiply(b2); + } + addScaledVector(a2, b2) { + return this.add(new this.constructor(a2).multiplyScalar(b2)); } }; - // node_modules/@luma.gl/webgl/dist/esm/init.js - var VERSION6 = true ? "8.5.21" : "untranspiled source"; - var STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering"; - var StatsManager = class { - constructor() { - this.stats = /* @__PURE__ */ new Map(); - } - get(name) { - if (!this.stats.has(name)) { - this.stats.set(name, new Stats({ - id: name - })); + // node_modules/gl-matrix/esm/common.js + var EPSILON = 1e-6; + var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array; + var degree = Math.PI / 180; + if (!Math.hypot) + Math.hypot = function() { + var y2 = 0, i3 = arguments.length; + while (i3--) { + y2 += arguments[i3] * arguments[i3]; } - return this.stats.get(name); + return Math.sqrt(y2); + }; + + // node_modules/gl-matrix/esm/vec2.js + function create() { + var out = new ARRAY_TYPE(2); + if (ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; } - }; - var lumaStats = new StatsManager(); - if (globalThis.luma && globalThis.luma.VERSION !== VERSION6) { - throw new Error("luma.gl - multiple VERSIONs detected: ".concat(globalThis.luma.VERSION, " vs ").concat(VERSION6)); + return out; } - if (!globalThis.luma) { - if (isBrowser5()) { - log2.log(1, "luma.gl ".concat(VERSION6, " - ").concat(STARTUP_MESSAGE))(); - } - globalThis.luma = globalThis.luma || { - VERSION: VERSION6, - version: VERSION6, - log: log2, - stats: lumaStats, - globals: { - modules: {}, - nodeIO: {} + function add(out, a2, b2) { + out[0] = a2[0] + b2[0]; + out[1] = a2[1] + b2[1]; + return out; + } + function negate(out, a2) { + out[0] = -a2[0]; + out[1] = -a2[1]; + return out; + } + function lerp2(out, a2, b2, t2) { + var ax = a2[0], ay = a2[1]; + out[0] = ax + t2 * (b2[0] - ax); + out[1] = ay + t2 * (b2[1] - ay); + return out; + } + function transformMat3(out, a2, m) { + var x2 = a2[0], y2 = a2[1]; + out[0] = m[0] * x2 + m[3] * y2 + m[6]; + out[1] = m[1] * x2 + m[4] * y2 + m[7]; + return out; + } + function transformMat4(out, a2, m) { + var x2 = a2[0]; + var y2 = a2[1]; + out[0] = m[0] * x2 + m[4] * y2 + m[12]; + out[1] = m[1] * x2 + m[5] * y2 + m[13]; + return out; + } + var forEach2 = function() { + var vec = create(); + return function(a2, stride, offset, count2, fn, arg) { + var i3, l2; + if (!stride) { + stride = 2; + } + if (!offset) { + offset = 0; + } + if (count2) { + l2 = Math.min(count2 * stride + offset, a2.length); + } else { + l2 = a2.length; + } + for (i3 = offset; i3 < l2; i3 += stride) { + vec[0] = a2[i3]; + vec[1] = a2[i3 + 1]; + fn(vec, vec, arg); + a2[i3] = vec[0]; + a2[i3 + 1] = vec[1]; } + return a2; }; - } - var init_default = globalThis.luma; + }(); - // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/request-animation-frame.js - function requestAnimationFrame2(callback) { - return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60); + // node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js + function vec2_transformMat4AsVector(out, a2, m) { + const x2 = a2[0]; + const y2 = a2[1]; + const w3 = m[3] * x2 + m[7] * y2 || 1; + out[0] = (m[0] * x2 + m[4] * y2) / w3; + out[1] = (m[1] * x2 + m[5] * y2) / w3; + return out; } - function cancelAnimationFrame(timerId) { - return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId); + function vec3_transformMat4AsVector(out, a2, m) { + const x2 = a2[0]; + const y2 = a2[1]; + const z = a2[2]; + const w3 = m[3] * x2 + m[7] * y2 + m[11] * z || 1; + out[0] = (m[0] * x2 + m[4] * y2 + m[8] * z) / w3; + out[1] = (m[1] * x2 + m[5] * y2 + m[9] * z) / w3; + out[2] = (m[2] * x2 + m[6] * y2 + m[10] * z) / w3; + return out; } - - // node_modules/@luma.gl/webgl/dist/esm/utils/assert.js - function assert6(condition, message) { - if (!condition) { - throw new Error(message || "luma.gl: assertion failed."); - } + function vec3_transformMat2(out, a2, m) { + const x2 = a2[0]; + const y2 = a2[1]; + out[0] = m[0] * x2 + m[2] * y2; + out[1] = m[1] * x2 + m[3] * y2; + out[2] = a2[2]; + return out; + } + function vec4_transformMat2(out, a2, m) { + const x2 = a2[0]; + const y2 = a2[1]; + out[0] = m[0] * x2 + m[2] * y2; + out[1] = m[1] * x2 + m[3] * y2; + out[2] = a2[2]; + out[3] = a2[3]; + return out; + } + function vec4_transformMat3(out, a2, m) { + const x2 = a2[0]; + const y2 = a2[1]; + const z = a2[2]; + out[0] = m[0] * x2 + m[3] * y2 + m[6] * z; + out[1] = m[1] * x2 + m[4] * y2 + m[7] * z; + out[2] = m[2] * x2 + m[5] * y2 + m[8] * z; + out[3] = a2[3]; + return out; } - // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/constants-to-keys.js - function getKeyValue(gl, name) { - if (typeof name !== "string") { - return name; - } - const number = Number(name); - if (!isNaN(number)) { - return number; + // node_modules/gl-matrix/esm/vec3.js + function create2() { + var out = new ARRAY_TYPE(3); + if (ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; } - name = name.replace(/^.*\./, ""); - const value = gl[name]; - assert6(value !== void 0, "Accessing undefined constant GL.".concat(name)); - return value; + return out; } - function getKey(gl, value) { - value = Number(value); - for (const key in gl) { - if (gl[key] === value) { - return "GL.".concat(key); - } - } - return String(value); + function length(a2) { + var x2 = a2[0]; + var y2 = a2[1]; + var z = a2[2]; + return Math.hypot(x2, y2, z); } - - // node_modules/@luma.gl/webgl/dist/esm/utils/utils.js - var uidCounters = {}; - function uid() { - let id = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "id"; - uidCounters[id] = uidCounters[id] || 1; - const count2 = uidCounters[id]++; - return "".concat(id, "-").concat(count2); + function fromValues(x2, y2, z) { + var out = new ARRAY_TYPE(3); + out[0] = x2; + out[1] = y2; + out[2] = z; + return out; + } + function subtract(out, a2, b2) { + out[0] = a2[0] - b2[0]; + out[1] = a2[1] - b2[1]; + out[2] = a2[2] - b2[2]; + return out; + } + function squaredLength(a2) { + var x2 = a2[0]; + var y2 = a2[1]; + var z = a2[2]; + return x2 * x2 + y2 * y2 + z * z; + } + function negate2(out, a2) { + out[0] = -a2[0]; + out[1] = -a2[1]; + out[2] = -a2[2]; + return out; + } + function normalize(out, a2) { + var x2 = a2[0]; + var y2 = a2[1]; + var z = a2[2]; + var len2 = x2 * x2 + y2 * y2 + z * z; + if (len2 > 0) { + len2 = 1 / Math.sqrt(len2); + } + out[0] = a2[0] * len2; + out[1] = a2[1] * len2; + out[2] = a2[2] * len2; + return out; + } + function dot(a2, b2) { + return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2]; + } + function cross(out, a2, b2) { + var ax = a2[0], ay = a2[1], az = a2[2]; + var bx = b2[0], by = b2[1], bz = b2[2]; + out[0] = ay * bz - az * by; + out[1] = az * bx - ax * bz; + out[2] = ax * by - ay * bx; + return out; + } + function lerp3(out, a2, b2, t2) { + var ax = a2[0]; + var ay = a2[1]; + var az = a2[2]; + out[0] = ax + t2 * (b2[0] - ax); + out[1] = ay + t2 * (b2[1] - ay); + out[2] = az + t2 * (b2[2] - az); + return out; + } + function transformMat42(out, a2, m) { + var x2 = a2[0], y2 = a2[1], z = a2[2]; + var w3 = m[3] * x2 + m[7] * y2 + m[11] * z + m[15]; + w3 = w3 || 1; + out[0] = (m[0] * x2 + m[4] * y2 + m[8] * z + m[12]) / w3; + out[1] = (m[1] * x2 + m[5] * y2 + m[9] * z + m[13]) / w3; + out[2] = (m[2] * x2 + m[6] * y2 + m[10] * z + m[14]) / w3; + return out; + } + function transformMat32(out, a2, m) { + var x2 = a2[0], y2 = a2[1], z = a2[2]; + out[0] = x2 * m[0] + y2 * m[3] + z * m[6]; + out[1] = x2 * m[1] + y2 * m[4] + z * m[7]; + out[2] = x2 * m[2] + y2 * m[5] + z * m[8]; + return out; + } + function transformQuat(out, a2, q) { + var qx = q[0], qy = q[1], qz = q[2], qw = q[3]; + var x2 = a2[0], y2 = a2[1], z = a2[2]; + var uvx = qy * z - qz * y2, uvy = qz * x2 - qx * z, uvz = qx * y2 - qy * x2; + var uuvx = qy * uvz - qz * uvy, uuvy = qz * uvx - qx * uvz, uuvz = qx * uvy - qy * uvx; + var w22 = qw * 2; + uvx *= w22; + uvy *= w22; + uvz *= w22; + uuvx *= 2; + uuvy *= 2; + uuvz *= 2; + out[0] = x2 + uvx + uuvx; + out[1] = y2 + uvy + uuvy; + out[2] = z + uvz + uuvz; + return out; } - function isPowerOfTwo(n2) { - assert6(typeof n2 === "number", "Input must be a number"); - return n2 && (n2 & n2 - 1) === 0; + function rotateX(out, a2, b2, rad) { + var p2 = [], r2 = []; + p2[0] = a2[0] - b2[0]; + p2[1] = a2[1] - b2[1]; + p2[2] = a2[2] - b2[2]; + r2[0] = p2[0]; + r2[1] = p2[1] * Math.cos(rad) - p2[2] * Math.sin(rad); + r2[2] = p2[1] * Math.sin(rad) + p2[2] * Math.cos(rad); + out[0] = r2[0] + b2[0]; + out[1] = r2[1] + b2[1]; + out[2] = r2[2] + b2[2]; + return out; } - function isObjectEmpty2(obj) { - let isEmpty = true; - for (const key in obj) { - isEmpty = false; - break; - } - return isEmpty; + function rotateY(out, a2, b2, rad) { + var p2 = [], r2 = []; + p2[0] = a2[0] - b2[0]; + p2[1] = a2[1] - b2[1]; + p2[2] = a2[2] - b2[2]; + r2[0] = p2[2] * Math.sin(rad) + p2[0] * Math.cos(rad); + r2[1] = p2[1]; + r2[2] = p2[2] * Math.cos(rad) - p2[0] * Math.sin(rad); + out[0] = r2[0] + b2[0]; + out[1] = r2[1] + b2[1]; + out[2] = r2[2] + b2[2]; + return out; } - - // node_modules/@luma.gl/webgl/dist/esm/utils/stub-methods.js - function stubRemovedMethods(instance, className, version, methodNames) { - const upgradeMessage = "See luma.gl ".concat(version, " Upgrade Guide at https://luma.gl/docs/upgrade-guide"); - const prototype = Object.getPrototypeOf(instance); - methodNames.forEach((methodName) => { - if (prototype.methodName) { - return; - } - prototype[methodName] = () => { - log2.removed("Calling removed method ".concat(className, ".").concat(methodName, ": "), upgradeMessage)(); - throw new Error(methodName); - }; - }); + function rotateZ(out, a2, b2, rad) { + var p2 = [], r2 = []; + p2[0] = a2[0] - b2[0]; + p2[1] = a2[1] - b2[1]; + p2[2] = a2[2] - b2[2]; + r2[0] = p2[0] * Math.cos(rad) - p2[1] * Math.sin(rad); + r2[1] = p2[0] * Math.sin(rad) + p2[1] * Math.cos(rad); + r2[2] = p2[2]; + out[0] = r2[0] + b2[0]; + out[1] = r2[1] + b2[1]; + out[2] = r2[2] + b2[2]; + return out; } - - // node_modules/@luma.gl/webgl/dist/esm/classes/resource.js - var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods"; - var Resource = class { - get [Symbol.toStringTag]() { - return "Resource"; - } - constructor(gl) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - assertWebGLContext(gl); - const { - id, - userData = {} - } = opts; - this.gl = gl; - this.gl2 = gl; - this.id = id || uid(this[Symbol.toStringTag]); - this.userData = userData; - this._bound = false; - this._handle = opts.handle; - if (this._handle === void 0) { - this._handle = this._createHandle(); + function angle(a2, b2) { + var ax = a2[0], ay = a2[1], az = a2[2], bx = b2[0], by = b2[1], bz = b2[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine = mag && dot(a2, b2) / mag; + return Math.acos(Math.min(Math.max(cosine, -1), 1)); + } + var sub = subtract; + var len = length; + var sqrLen = squaredLength; + var forEach3 = function() { + var vec = create2(); + return function(a2, stride, offset, count2, fn, arg) { + var i3, l2; + if (!stride) { + stride = 3; } - this.byteLength = 0; - this._addStats(); - } - toString() { - return "".concat(this[Symbol.toStringTag] || this.constructor.name, "(").concat(this.id, ")"); - } - get handle() { - return this._handle; - } - delete() { - let { - deleteChildren = false - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const children = this._handle && this._deleteHandle(this._handle); - if (this._handle) { - this._removeStats(); + if (!offset) { + offset = 0; } - this._handle = null; - if (children && deleteChildren) { - children.filter(Boolean).forEach((child) => child.delete()); + if (count2) { + l2 = Math.min(count2 * stride + offset, a2.length); + } else { + l2 = a2.length; } - return this; - } - bind() { - let funcOrHandle = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.handle; - if (typeof funcOrHandle !== "function") { - this._bindHandle(funcOrHandle); - return this; + for (i3 = offset; i3 < l2; i3 += stride) { + vec[0] = a2[i3]; + vec[1] = a2[i3 + 1]; + vec[2] = a2[i3 + 2]; + fn(vec, vec, arg); + a2[i3] = vec[0]; + a2[i3 + 1] = vec[1]; + a2[i3 + 2] = vec[2]; } - let value; - if (!this._bound) { - this._bindHandle(this.handle); - this._bound = true; - value = funcOrHandle(); - this._bound = false; - this._bindHandle(null); - } else { - value = funcOrHandle(); + return a2; + }; + }(); + + // node_modules/@math.gl/core/dist/esm/classes/vector3.js + var ORIGIN = [0, 0, 0]; + var ZERO; + var Vector3 = class _Vector3 extends Vector { + static get ZERO() { + if (!ZERO) { + ZERO = new _Vector3(0, 0, 0); + Object.freeze(ZERO); } - return value; - } - unbind() { - this.bind(null); + return ZERO; } - getParameter(pname) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - pname = getKeyValue(this.gl, pname); - assert6(pname); - const parameters = this.constructor.PARAMETERS || {}; - const parameter = parameters[pname]; - if (parameter) { - const isWebgl2 = isWebGL2(this.gl); - const parameterAvailable = (!("webgl2" in parameter) || isWebgl2) && (!("extension" in parameter) || this.gl.getExtension(parameter.extension)); - if (!parameterAvailable) { - const webgl1Default = parameter.webgl1; - const webgl2Default = "webgl2" in parameter ? parameter.webgl2 : parameter.webgl1; - const defaultValue = isWebgl2 ? webgl2Default : webgl1Default; - return defaultValue; + constructor(x2 = 0, y2 = 0, z = 0) { + super(-0, -0, -0); + if (arguments.length === 1 && isArray2(x2)) { + this.copy(x2); + } else { + if (config.debug) { + checkNumber(x2); + checkNumber(y2); + checkNumber(z); } + this[0] = x2; + this[1] = y2; + this[2] = z; } - return this._getParameter(pname, opts); } - getParameters() { - let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - parameters, - keys - } = options; - const PARAMETERS = this.constructor.PARAMETERS || {}; - const isWebgl2 = isWebGL2(this.gl); - const values = {}; - const parameterKeys = parameters || Object.keys(PARAMETERS); - for (const pname of parameterKeys) { - const parameter = PARAMETERS[pname]; - const parameterAvailable = parameter && (!("webgl2" in parameter) || isWebgl2) && (!("extension" in parameter) || this.gl.getExtension(parameter.extension)); - if (parameterAvailable) { - const key = keys ? getKey(this.gl, pname) : pname; - values[key] = this.getParameter(pname, options); - if (keys && parameter.type === "GLenum") { - values[key] = getKey(this.gl, values[key]); - } - } - } - return values; + set(x2, y2, z) { + this[0] = x2; + this[1] = y2; + this[2] = z; + return this.check(); } - setParameter(pname, value) { - pname = getKeyValue(this.gl, pname); - assert6(pname); - const parameters = this.constructor.PARAMETERS || {}; - const parameter = parameters[pname]; - if (parameter) { - const isWebgl2 = isWebGL2(this.gl); - const parameterAvailable = (!("webgl2" in parameter) || isWebgl2) && (!("extension" in parameter) || this.gl.getExtension(parameter.extension)); - if (!parameterAvailable) { - throw new Error("Parameter not available on this platform"); - } - if (parameter.type === "GLenum") { - value = getKeyValue(value); - } - } - this._setParameter(pname, value); - return this; + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + return this.check(); } - setParameters(parameters) { - for (const pname in parameters) { - this.setParameter(pname, parameters[pname]); + fromObject(object) { + if (config.debug) { + checkNumber(object.x); + checkNumber(object.y); + checkNumber(object.z); } - return this; + this[0] = object.x; + this[1] = object.y; + this[2] = object.z; + return this.check(); } - stubRemovedMethods(className, version, methodNames) { - return stubRemovedMethods(this, className, version, methodNames); + toObject(object) { + object.x = this[0]; + object.y = this[1]; + object.z = this[2]; + return object; } - initialize(opts) { + get ELEMENTS() { + return 3; } - _createHandle() { - throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + get z() { + return this[2]; } - _deleteHandle() { - throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + set z(value) { + this[2] = checkNumber(value); } - _bindHandle(handle) { - throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + angle(vector) { + return angle(this, vector); } - _getOptsFromHandle() { - throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + cross(vector) { + cross(this, this, vector); + return this.check(); } - _getParameter(pname, opts) { - throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + rotateX({ + radians: radians2, + origin = ORIGIN + }) { + rotateX(this, this, origin, radians2); + return this.check(); } - _setParameter(pname, value) { - throw new Error(ERR_RESOURCE_METHOD_UNDEFINED); + rotateY({ + radians: radians2, + origin = ORIGIN + }) { + rotateY(this, this, origin, radians2); + return this.check(); } - _context() { - this.gl.luma = this.gl.luma || {}; - return this.gl.luma; + rotateZ({ + radians: radians2, + origin = ORIGIN + }) { + rotateZ(this, this, origin, radians2); + return this.check(); } - _addStats() { - const name = this[Symbol.toStringTag]; - const stats = lumaStats.get("Resource Counts"); - stats.get("Resources Created").incrementCount(); - stats.get("".concat(name, "s Created")).incrementCount(); - stats.get("".concat(name, "s Active")).incrementCount(); + transform(matrix4) { + return this.transformAsPoint(matrix4); } - _removeStats() { - const name = this[Symbol.toStringTag]; - const stats = lumaStats.get("Resource Counts"); - stats.get("".concat(name, "s Active")).decrementCount(); + transformAsPoint(matrix4) { + transformMat42(this, this, matrix4); + return this.check(); } - _trackAllocatedMemory(bytes) { - let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this[Symbol.toStringTag]; - this._trackAllocatedMemoryForContext(bytes, name); - this._trackAllocatedMemoryForContext(bytes, name, this.gl.canvas && this.gl.canvas.id); - this.byteLength = bytes; + transformAsVector(matrix4) { + vec3_transformMat4AsVector(this, this, matrix4); + return this.check(); } - _trackAllocatedMemoryForContext(bytes) { - let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this[Symbol.toStringTag]; - let id = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ""; - const stats = lumaStats.get("Memory Usage".concat(id)); - stats.get("GPU Memory").addCount(bytes); - stats.get("".concat(name, " Memory")).addCount(bytes); + transformByMatrix3(matrix3) { + transformMat32(this, this, matrix3); + return this.check(); } - _trackDeallocatedMemory() { - let name = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this[Symbol.toStringTag]; - this._trackDeallocatedMemoryForContext(name); - this._trackDeallocatedMemoryForContext(name, this.gl.canvas && this.gl.canvas.id); - this.byteLength = 0; + transformByMatrix2(matrix2) { + vec3_transformMat2(this, this, matrix2); + return this.check(); } - _trackDeallocatedMemoryForContext() { - let name = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this[Symbol.toStringTag]; - let id = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ""; - const stats = lumaStats.get("Memory Usage".concat(id)); - stats.get("GPU Memory").subtractCount(this.byteLength); - stats.get("".concat(name, " Memory")).subtractCount(this.byteLength); + transformByQuaternion(quaternion) { + transformQuat(this, this, quaternion); + return this.check(); } }; - // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/typed-array-utils.js - var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array"; - function getGLTypeFromTypedArray(arrayOrType) { - const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType; - switch (type) { - case Float32Array: - return 5126; - case Uint16Array: - return 5123; - case Uint32Array: - return 5125; - case Uint8Array: - return 5121; - case Uint8ClampedArray: - return 5121; - case Int8Array: - return 5120; - case Int16Array: - return 5122; - case Int32Array: - return 5124; - default: - throw new Error(ERR_TYPE_DEDUCTION); - } - } - function getTypedArrayFromGLType(glType) { - let { - clamped = true - } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - switch (glType) { - case 5126: - return Float32Array; - case 5123: - case 33635: - case 32819: - case 32820: - return Uint16Array; - case 5125: - return Uint32Array; - case 5121: - return clamped ? Uint8ClampedArray : Uint8Array; - case 5120: - return Int8Array; - case 5122: - return Int16Array; - case 5124: - return Int32Array; - default: - throw new Error("Failed to deduce typed array type from GL constant"); - } - } - function flipRows(_ref) { - let { - data, - width, - height, - bytesPerPixel = 4, - temp - } = _ref; - const bytesPerRow = width * bytesPerPixel; - temp = temp || new Uint8Array(bytesPerRow); - for (let y2 = 0; y2 < height / 2; ++y2) { - const topOffset = y2 * bytesPerRow; - const bottomOffset = (height - y2 - 1) * bytesPerRow; - temp.set(data.subarray(topOffset, topOffset + bytesPerRow)); - data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow); - data.set(temp, bottomOffset); + // node_modules/@math.gl/core/dist/esm/classes/vector4.js + var ZERO2; + var Vector4 = class _Vector4 extends Vector { + static get ZERO() { + if (!ZERO2) { + ZERO2 = new _Vector4(0, 0, 0, 0); + Object.freeze(ZERO2); + } + return ZERO2; } - } - function scalePixels2(_ref2) { - let { - data, - width, - height - } = _ref2; - const newWidth = Math.round(width / 2); - const newHeight = Math.round(height / 2); - const newData = new Uint8Array(newWidth * newHeight * 4); - for (let y2 = 0; y2 < newHeight; y2++) { - for (let x2 = 0; x2 < newWidth; x2++) { - for (let c2 = 0; c2 < 4; c2++) { - newData[(y2 * newWidth + x2) * 4 + c2] = data[(y2 * 2 * width + x2 * 2) * 4 + c2]; + constructor(x2 = 0, y2 = 0, z = 0, w3 = 0) { + super(-0, -0, -0, -0); + if (isArray2(x2) && arguments.length === 1) { + this.copy(x2); + } else { + if (config.debug) { + checkNumber(x2); + checkNumber(y2); + checkNumber(z); + checkNumber(w3); } + this[0] = x2; + this[1] = y2; + this[2] = z; + this[3] = w3; } } - return { - data: newData, - width: newWidth, - height: newHeight - }; - } - - // node_modules/@luma.gl/webgl/dist/esm/utils/check-props.js - function checkProps(className, props, propChecks) { - const { - removedProps = {}, - deprecatedProps = {}, - replacedProps = {} - } = propChecks; - for (const propName in removedProps) { - if (propName in props) { - const replacementProp = removedProps[propName]; - const replacement = replacementProp ? "".concat(className, ".").concat(removedProps[propName]) : "N/A"; - log2.removed("".concat(className, ".").concat(propName), replacement)(); - } + set(x2, y2, z, w3) { + this[0] = x2; + this[1] = y2; + this[2] = z; + this[3] = w3; + return this.check(); } - for (const propName in deprecatedProps) { - if (propName in props) { - const replacementProp = deprecatedProps[propName]; - log2.deprecated("".concat(className, ".").concat(propName), "".concat(className, ".").concat(replacementProp))(); - } + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + this[3] = array[3]; + return this.check(); } - let newProps = null; - for (const propName in replacedProps) { - if (propName in props) { - const replacementProp = replacedProps[propName]; - log2.deprecated("".concat(className, ".").concat(propName), "".concat(className, ".").concat(replacementProp))(); - newProps = newProps || Object.assign({}, props); - newProps[replacementProp] = props[propName]; - delete newProps[propName]; + fromObject(object) { + if (config.debug) { + checkNumber(object.x); + checkNumber(object.y); + checkNumber(object.z); + checkNumber(object.w); } + this[0] = object.x; + this[1] = object.y; + this[2] = object.z; + this[3] = object.w; + return this; } - return newProps || props; - } - - // node_modules/@luma.gl/webgl/dist/esm/classes/accessor.js - var DEFAULT_ACCESSOR_VALUES = { - offset: 0, - stride: 0, - type: 5126, - size: 1, - divisor: 0, - normalized: false, - integer: false - }; - var PROP_CHECKS = { - deprecatedProps: { - instanced: "divisor", - isInstanced: "divisor" + toObject(object) { + object.x = this[0]; + object.y = this[1]; + object.z = this[2]; + object.w = this[3]; + return object; + } + get ELEMENTS() { + return 4; } - }; - var Accessor = class _Accessor { - static getBytesPerElement(accessor) { - const ArrayType = getTypedArrayFromGLType(accessor.type || 5126); - return ArrayType.BYTES_PER_ELEMENT; + get z() { + return this[2]; } - static getBytesPerVertex(accessor) { - assert6(accessor.size); - const ArrayType = getTypedArrayFromGLType(accessor.type || 5126); - return ArrayType.BYTES_PER_ELEMENT * accessor.size; + set z(value) { + this[2] = checkNumber(value); } - static resolve() { - for (var _len = arguments.length, accessors = new Array(_len), _key = 0; _key < _len; _key++) { - accessors[_key] = arguments[_key]; - } - return new _Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]); + get w() { + return this[3]; } - constructor() { - for (var _len2 = arguments.length, accessors = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - accessors[_key2] = arguments[_key2]; - } - accessors.forEach((accessor) => this._assign(accessor)); - Object.freeze(this); + set w(value) { + this[3] = checkNumber(value); } - toString() { - return JSON.stringify(this); + transform(matrix4) { + transformMat42(this, this, matrix4); + return this.check(); } - get BYTES_PER_ELEMENT() { - return _Accessor.getBytesPerElement(this); + transformByMatrix3(matrix3) { + vec4_transformMat3(this, this, matrix3); + return this.check(); } - get BYTES_PER_VERTEX() { - return _Accessor.getBytesPerVertex(this); + transformByMatrix2(matrix2) { + vec4_transformMat2(this, this, matrix2); + return this.check(); } - _assign() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - props = checkProps("Accessor", props, PROP_CHECKS); - if (props.type !== void 0) { - this.type = props.type; - if (props.type === 5124 || props.type === 5125) { - this.integer = true; + transformByQuaternion(quaternion) { + transformQuat(this, this, quaternion); + return this.check(); + } + applyMatrix4(m) { + m.transform(this, this); + return this; + } + }; + + // node_modules/@math.gl/core/dist/esm/classes/base/matrix.js + var Matrix = class extends MathArray { + toString() { + let string = "["; + if (config.printRowMajor) { + string += "row-major:"; + for (let row = 0; row < this.RANK; ++row) { + for (let col = 0; col < this.RANK; ++col) { + string += " ".concat(this[col * this.RANK + row]); + } } - } - if (props.size !== void 0) { - this.size = props.size; - } - if (props.offset !== void 0) { - this.offset = props.offset; - } - if (props.stride !== void 0) { - this.stride = props.stride; - } - if (props.normalized !== void 0) { - this.normalized = props.normalized; - } - if (props.integer !== void 0) { - this.integer = props.integer; - } - if (props.divisor !== void 0) { - this.divisor = props.divisor; - } - if (props.buffer !== void 0) { - this.buffer = props.buffer; - } - if (props.index !== void 0) { - if (typeof props.index === "boolean") { - this.index = props.index ? 1 : 0; - } else { - this.index = props.index; + } else { + string += "column-major:"; + for (let i3 = 0; i3 < this.ELEMENTS; ++i3) { + string += " ".concat(this[i3]); } } - if (props.instanced !== void 0) { - this.divisor = props.instanced ? 1 : 0; + string += "]"; + return string; + } + getElementIndex(row, col) { + return col * this.RANK + row; + } + getElement(row, col) { + return this[col * this.RANK + row]; + } + setElement(row, col, value) { + this[col * this.RANK + row] = checkNumber(value); + return this; + } + getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) { + const firstIndex = columnIndex * this.RANK; + for (let i3 = 0; i3 < this.RANK; ++i3) { + result[i3] = this[firstIndex + i3]; } - if (props.isInstanced !== void 0) { - this.divisor = props.isInstanced ? 1 : 0; + return result; + } + setColumn(columnIndex, columnVector) { + const firstIndex = columnIndex * this.RANK; + for (let i3 = 0; i3 < this.RANK; ++i3) { + this[firstIndex + i3] = columnVector[i3]; } return this; } }; - // node_modules/@luma.gl/webgl/dist/esm/classes/buffer.js - var DEBUG_DATA_LENGTH = 10; - var DEPRECATED_PROPS = { - offset: "accessor.offset", - stride: "accessor.stride", - type: "accessor.type", - size: "accessor.size", - divisor: "accessor.divisor", - normalized: "accessor.normalized", - integer: "accessor.integer", - instanced: "accessor.divisor", - isInstanced: "accessor.divisor" - }; - var PROP_CHECKS_INITIALIZE = { - removedProps: {}, - replacedProps: { - bytes: "byteLength" - }, - deprecatedProps: DEPRECATED_PROPS - }; - var PROP_CHECKS_SET_PROPS = { - removedProps: DEPRECATED_PROPS - }; - var Buffer2 = class extends Resource { - get [Symbol.toStringTag]() { - return "Buffer"; + // node_modules/gl-matrix/esm/mat3.js + function create3() { + var out = new ARRAY_TYPE(9); + if (ARRAY_TYPE != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[5] = 0; + out[6] = 0; + out[7] = 0; } - constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - super(gl, props); - this.stubRemovedMethods("Buffer", "v6.0", ["layout", "setLayout", "getIndexedParameter"]); - this.target = props.target || (this.gl.webgl2 ? 36662 : 34962); - this.initialize(props); - Object.seal(this); + out[0] = 1; + out[4] = 1; + out[8] = 1; + return out; + } + function transpose(out, a2) { + if (out === a2) { + var a01 = a2[1], a02 = a2[2], a12 = a2[5]; + out[1] = a2[3]; + out[2] = a2[6]; + out[3] = a01; + out[5] = a2[7]; + out[6] = a02; + out[7] = a12; + } else { + out[0] = a2[0]; + out[1] = a2[3]; + out[2] = a2[6]; + out[3] = a2[1]; + out[4] = a2[4]; + out[5] = a2[7]; + out[6] = a2[2]; + out[7] = a2[5]; + out[8] = a2[8]; } - getElementCount() { - let accessor = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.accessor; - return Math.round(this.byteLength / Accessor.getBytesPerElement(accessor)); + return out; + } + function invert(out, a2) { + var a00 = a2[0], a01 = a2[1], a02 = a2[2]; + var a10 = a2[3], a11 = a2[4], a12 = a2[5]; + var a20 = a2[6], a21 = a2[7], a22 = a2[8]; + var b01 = a22 * a11 - a12 * a21; + var b11 = -a22 * a10 + a12 * a20; + var b21 = a21 * a10 - a11 * a20; + var det = a00 * b01 + a01 * b11 + a02 * b21; + if (!det) { + return null; } - getVertexCount() { - let accessor = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.accessor; - return Math.round(this.byteLength / Accessor.getBytesPerVertex(accessor)); + det = 1 / det; + out[0] = b01 * det; + out[1] = (-a22 * a01 + a02 * a21) * det; + out[2] = (a12 * a01 - a02 * a11) * det; + out[3] = b11 * det; + out[4] = (a22 * a00 - a02 * a20) * det; + out[5] = (-a12 * a00 + a02 * a10) * det; + out[6] = b21 * det; + out[7] = (-a21 * a00 + a01 * a20) * det; + out[8] = (a11 * a00 - a01 * a10) * det; + return out; + } + function determinant(a2) { + var a00 = a2[0], a01 = a2[1], a02 = a2[2]; + var a10 = a2[3], a11 = a2[4], a12 = a2[5]; + var a20 = a2[6], a21 = a2[7], a22 = a2[8]; + return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20); + } + function multiply(out, a2, b2) { + var a00 = a2[0], a01 = a2[1], a02 = a2[2]; + var a10 = a2[3], a11 = a2[4], a12 = a2[5]; + var a20 = a2[6], a21 = a2[7], a22 = a2[8]; + var b00 = b2[0], b01 = b2[1], b02 = b2[2]; + var b10 = b2[3], b11 = b2[4], b12 = b2[5]; + var b20 = b2[6], b21 = b2[7], b22 = b2[8]; + out[0] = b00 * a00 + b01 * a10 + b02 * a20; + out[1] = b00 * a01 + b01 * a11 + b02 * a21; + out[2] = b00 * a02 + b01 * a12 + b02 * a22; + out[3] = b10 * a00 + b11 * a10 + b12 * a20; + out[4] = b10 * a01 + b11 * a11 + b12 * a21; + out[5] = b10 * a02 + b11 * a12 + b12 * a22; + out[6] = b20 * a00 + b21 * a10 + b22 * a20; + out[7] = b20 * a01 + b21 * a11 + b22 * a21; + out[8] = b20 * a02 + b21 * a12 + b22 * a22; + return out; + } + function translate(out, a2, v2) { + var a00 = a2[0], a01 = a2[1], a02 = a2[2], a10 = a2[3], a11 = a2[4], a12 = a2[5], a20 = a2[6], a21 = a2[7], a22 = a2[8], x2 = v2[0], y2 = v2[1]; + out[0] = a00; + out[1] = a01; + out[2] = a02; + out[3] = a10; + out[4] = a11; + out[5] = a12; + out[6] = x2 * a00 + y2 * a10 + a20; + out[7] = x2 * a01 + y2 * a11 + a21; + out[8] = x2 * a02 + y2 * a12 + a22; + return out; + } + function rotate(out, a2, rad) { + var a00 = a2[0], a01 = a2[1], a02 = a2[2], a10 = a2[3], a11 = a2[4], a12 = a2[5], a20 = a2[6], a21 = a2[7], a22 = a2[8], s = Math.sin(rad), c2 = Math.cos(rad); + out[0] = c2 * a00 + s * a10; + out[1] = c2 * a01 + s * a11; + out[2] = c2 * a02 + s * a12; + out[3] = c2 * a10 - s * a00; + out[4] = c2 * a11 - s * a01; + out[5] = c2 * a12 - s * a02; + out[6] = a20; + out[7] = a21; + out[8] = a22; + return out; + } + function scale(out, a2, v2) { + var x2 = v2[0], y2 = v2[1]; + out[0] = x2 * a2[0]; + out[1] = x2 * a2[1]; + out[2] = x2 * a2[2]; + out[3] = y2 * a2[3]; + out[4] = y2 * a2[4]; + out[5] = y2 * a2[5]; + out[6] = a2[6]; + out[7] = a2[7]; + out[8] = a2[8]; + return out; + } + function fromQuat(out, q) { + var x2 = q[0], y2 = q[1], z = q[2], w3 = q[3]; + var x22 = x2 + x2; + var y22 = y2 + y2; + var z2 = z + z; + var xx = x2 * x22; + var yx = y2 * x22; + var yy = y2 * y22; + var zx = z * x22; + var zy = z * y22; + var zz = z * z2; + var wx = w3 * x22; + var wy = w3 * y22; + var wz = w3 * z2; + out[0] = 1 - yy - zz; + out[3] = yx - wz; + out[6] = zx + wy; + out[1] = yx + wz; + out[4] = 1 - xx - zz; + out[7] = zy - wx; + out[2] = zx - wy; + out[5] = zy + wx; + out[8] = 1 - xx - yy; + return out; + } + + // node_modules/@math.gl/core/dist/esm/classes/matrix3.js + var INDICES; + (function(INDICES3) { + INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0"; + INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1"; + INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2"; + INDICES3[INDICES3["COL1ROW0"] = 3] = "COL1ROW0"; + INDICES3[INDICES3["COL1ROW1"] = 4] = "COL1ROW1"; + INDICES3[INDICES3["COL1ROW2"] = 5] = "COL1ROW2"; + INDICES3[INDICES3["COL2ROW0"] = 6] = "COL2ROW0"; + INDICES3[INDICES3["COL2ROW1"] = 7] = "COL2ROW1"; + INDICES3[INDICES3["COL2ROW2"] = 8] = "COL2ROW2"; + })(INDICES || (INDICES = {})); + var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]); + var Matrix3 = class extends Matrix { + static get IDENTITY() { + return getIdentityMatrix(); } - initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if (ArrayBuffer.isView(props)) { - props = { - data: props - }; - } - if (Number.isFinite(props)) { - props = { - byteLength: props - }; - } - props = checkProps("Buffer", props, PROP_CHECKS_INITIALIZE); - this.usage = props.usage || 35044; - this.debugData = null; - this.setAccessor(Object.assign({}, props, props.accessor)); - if (props.data) { - this._setData(props.data, props.offset, props.byteLength); + static get ZERO() { + return getZeroMatrix(); + } + get ELEMENTS() { + return 9; + } + get RANK() { + return 3; + } + get INDICES() { + return INDICES; + } + constructor(array, ...args) { + super(-0, -0, -0, -0, -0, -0, -0, -0, -0); + if (arguments.length === 1 && Array.isArray(array)) { + this.copy(array); + } else if (args.length > 0) { + this.copy([array, ...args]); } else { - this._setByteLength(props.byteLength || 0); + this.identity(); } - return this; } - setProps(props) { - props = checkProps("Buffer", props, PROP_CHECKS_SET_PROPS); - if ("accessor" in props) { - this.setAccessor(props.accessor); - } - return this; + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + this[3] = array[3]; + this[4] = array[4]; + this[5] = array[5]; + this[6] = array[6]; + this[7] = array[7]; + this[8] = array[8]; + return this.check(); } - setAccessor(accessor) { - accessor = Object.assign({}, accessor); - delete accessor.buffer; - this.accessor = new Accessor(accessor); - return this; + identity() { + return this.copy(IDENTITY_MATRIX); } - reallocate(byteLength) { - if (byteLength > this.byteLength) { - this._setByteLength(byteLength); - return true; - } - this.bytesUsed = byteLength; - return false; + fromObject(object) { + return this.check(); } - setData(props) { - return this.initialize(props); + fromQuaternion(q) { + fromQuat(this, q); + return this.check(); } - subData(props) { - if (ArrayBuffer.isView(props)) { - props = { - data: props - }; - } - const { - data, - offset = 0, - srcOffset = 0 - } = props; - const byteLength = props.byteLength || props.length; - assert6(data); - const target = this.gl.webgl2 ? 36663 : this.target; - this.gl.bindBuffer(target, this.handle); - if (srcOffset !== 0 || byteLength !== void 0) { - assertWebGL2Context(this.gl); - this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength); - } else { - this.gl.bufferSubData(target, offset, data); - } - this.gl.bindBuffer(target, null); - this.debugData = null; - this._inferType(data); - return this; + set(m00, m10, m20, m01, m11, m21, m02, m12, m22) { + this[0] = m00; + this[1] = m10; + this[2] = m20; + this[3] = m01; + this[4] = m11; + this[5] = m21; + this[6] = m02; + this[7] = m12; + this[8] = m22; + return this.check(); } - copyData(_ref) { - let { - sourceBuffer, - readOffset = 0, - writeOffset = 0, - size - } = _ref; - const { - gl - } = this; - assertWebGL2Context(gl); - gl.bindBuffer(36662, sourceBuffer.handle); - gl.bindBuffer(36663, this.handle); - gl.copyBufferSubData(36662, 36663, readOffset, writeOffset, size); - gl.bindBuffer(36662, null); - gl.bindBuffer(36663, null); - this.debugData = null; - return this; + setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) { + this[0] = m00; + this[1] = m10; + this[2] = m20; + this[3] = m01; + this[4] = m11; + this[5] = m21; + this[6] = m02; + this[7] = m12; + this[8] = m22; + return this.check(); } - getData() { - let { - dstData = null, - srcByteOffset = 0, - dstOffset = 0, - length = 0 - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - assertWebGL2Context(this.gl); - const ArrayType = getTypedArrayFromGLType(this.accessor.type || 5126, { - clamped: false - }); - const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset); - const dstElementOffset = dstOffset; - let dstAvailableElementCount; - let dstElementCount; - if (dstData) { - dstElementCount = dstData.length; - dstAvailableElementCount = dstElementCount - dstElementOffset; - } else { - dstAvailableElementCount = Math.min(sourceAvailableElementCount, length || sourceAvailableElementCount); - dstElementCount = dstElementOffset + dstAvailableElementCount; - } - const copyElementCount = Math.min(sourceAvailableElementCount, dstAvailableElementCount); - length = length || copyElementCount; - assert6(length <= copyElementCount); - dstData = dstData || new ArrayType(dstElementCount); - this.gl.bindBuffer(36662, this.handle); - this.gl.getBufferSubData(36662, srcByteOffset, dstData, dstOffset, length); - this.gl.bindBuffer(36662, null); - return dstData; + determinant() { + return determinant(this); } - bind() { - let { - target = this.target, - index = this.accessor && this.accessor.index, - offset = 0, - size - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if (target === 35345 || target === 35982) { - if (size !== void 0) { - this.gl.bindBufferRange(target, index, this.handle, offset, size); - } else { - assert6(offset === 0); - this.gl.bindBufferBase(target, index, this.handle); - } - } else { - this.gl.bindBuffer(target, this.handle); - } - return this; + transpose() { + transpose(this, this); + return this.check(); } - unbind() { - let { - target = this.target, - index = this.accessor && this.accessor.index - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const isIndexedBuffer = target === 35345 || target === 35982; - if (isIndexedBuffer) { - this.gl.bindBufferBase(target, index, null); + invert() { + invert(this, this); + return this.check(); + } + multiplyLeft(a2) { + multiply(this, a2, this); + return this.check(); + } + multiplyRight(a2) { + multiply(this, this, a2); + return this.check(); + } + rotate(radians2) { + rotate(this, this, radians2); + return this.check(); + } + scale(factor) { + if (Array.isArray(factor)) { + scale(this, this, factor); } else { - this.gl.bindBuffer(target, null); + scale(this, this, [factor, factor]); } - return this; + return this.check(); } - getDebugData() { - if (!this.debugData) { - this.debugData = this.getData({ - length: Math.min(DEBUG_DATA_LENGTH, this.byteLength) - }); - return { - data: this.debugData, - changed: true - }; + translate(vec) { + translate(this, this, vec); + return this.check(); + } + transform(vector, result) { + let out; + switch (vector.length) { + case 2: + out = transformMat3(result || [-0, -0], vector, this); + break; + case 3: + out = transformMat32(result || [-0, -0, -0], vector, this); + break; + case 4: + out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this); + break; + default: + throw new Error("Illegal vector"); } - return { - data: this.debugData, - changed: false - }; + checkVector(out, vector.length); + return out; } - invalidateDebugData() { - this.debugData = null; + transformVector(vector, result) { + return this.transform(vector, result); } - _setData(data) { - let offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0; - let byteLength = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : data.byteLength + offset; - assert6(ArrayBuffer.isView(data)); - this._trackDeallocatedMemory(); - const target = this._getTarget(); - this.gl.bindBuffer(target, this.handle); - this.gl.bufferData(target, byteLength, this.usage); - this.gl.bufferSubData(target, offset, data); - this.gl.bindBuffer(target, null); - this.debugData = data.slice(0, DEBUG_DATA_LENGTH); - this.bytesUsed = byteLength; - this._trackAllocatedMemory(byteLength); - const type = getGLTypeFromTypedArray(data); - assert6(type); - this.setAccessor(new Accessor(this.accessor, { - type - })); - return this; + transformVector2(vector, result) { + return this.transform(vector, result); } - _setByteLength(byteLength) { - let usage = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.usage; - assert6(byteLength >= 0); - this._trackDeallocatedMemory(); - let data = byteLength; - if (byteLength === 0) { - data = new Float32Array(0); - } - const target = this._getTarget(); - this.gl.bindBuffer(target, this.handle); - this.gl.bufferData(target, data, usage); - this.gl.bindBuffer(target, null); - this.usage = usage; - this.debugData = null; - this.bytesUsed = byteLength; - this._trackAllocatedMemory(byteLength); - return this; + transformVector3(vector, result) { + return this.transform(vector, result); } - _getTarget() { - return this.gl.webgl2 ? 36663 : this.target; + }; + var ZERO_MATRIX3; + var IDENTITY_MATRIX3; + function getZeroMatrix() { + if (!ZERO_MATRIX3) { + ZERO_MATRIX3 = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]); + Object.freeze(ZERO_MATRIX3); } - _getAvailableElementCount(srcByteOffset) { - const ArrayType = getTypedArrayFromGLType(this.accessor.type || 5126, { - clamped: false - }); - const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT; - return this.getElementCount() - sourceElementOffset; + return ZERO_MATRIX3; + } + function getIdentityMatrix() { + if (!IDENTITY_MATRIX3) { + IDENTITY_MATRIX3 = new Matrix3(); + Object.freeze(IDENTITY_MATRIX3); } - _inferType(data) { - if (!this.accessor.type) { - this.setAccessor(new Accessor(this.accessor, { - type: getGLTypeFromTypedArray(data) - })); - } + return IDENTITY_MATRIX3; + } + + // node_modules/gl-matrix/esm/mat4.js + function identity(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; + } + function transpose2(out, a2) { + if (out === a2) { + var a01 = a2[1], a02 = a2[2], a03 = a2[3]; + var a12 = a2[6], a13 = a2[7]; + var a23 = a2[11]; + out[1] = a2[4]; + out[2] = a2[8]; + out[3] = a2[12]; + out[4] = a01; + out[6] = a2[9]; + out[7] = a2[13]; + out[8] = a02; + out[9] = a12; + out[11] = a2[14]; + out[12] = a03; + out[13] = a13; + out[14] = a23; + } else { + out[0] = a2[0]; + out[1] = a2[4]; + out[2] = a2[8]; + out[3] = a2[12]; + out[4] = a2[1]; + out[5] = a2[5]; + out[6] = a2[9]; + out[7] = a2[13]; + out[8] = a2[2]; + out[9] = a2[6]; + out[10] = a2[10]; + out[11] = a2[14]; + out[12] = a2[3]; + out[13] = a2[7]; + out[14] = a2[11]; + out[15] = a2[15]; } - _createHandle() { - return this.gl.createBuffer(); + return out; + } + function invert2(out, a2) { + var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3]; + var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7]; + var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11]; + var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15]; + var b00 = a00 * a11 - a01 * a10; + var b01 = a00 * a12 - a02 * a10; + var b02 = a00 * a13 - a03 * a10; + var b03 = a01 * a12 - a02 * a11; + var b04 = a01 * a13 - a03 * a11; + var b05 = a02 * a13 - a03 * a12; + var b06 = a20 * a31 - a21 * a30; + var b07 = a20 * a32 - a22 * a30; + var b08 = a20 * a33 - a23 * a30; + var b09 = a21 * a32 - a22 * a31; + var b10 = a21 * a33 - a23 * a31; + var b11 = a22 * a33 - a23 * a32; + var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + if (!det) { + return null; } - _deleteHandle() { - this.gl.deleteBuffer(this.handle); - this._trackDeallocatedMemory(); + det = 1 / det; + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; + out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; + out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; + out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; + out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; + out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; + out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; + return out; + } + function determinant2(a2) { + var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3]; + var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7]; + var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11]; + var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15]; + var b00 = a00 * a11 - a01 * a10; + var b01 = a00 * a12 - a02 * a10; + var b02 = a00 * a13 - a03 * a10; + var b03 = a01 * a12 - a02 * a11; + var b04 = a01 * a13 - a03 * a11; + var b05 = a02 * a13 - a03 * a12; + var b06 = a20 * a31 - a21 * a30; + var b07 = a20 * a32 - a22 * a30; + var b08 = a20 * a33 - a23 * a30; + var b09 = a21 * a32 - a22 * a31; + var b10 = a21 * a33 - a23 * a31; + var b11 = a22 * a33 - a23 * a32; + return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + } + function multiply2(out, a2, b2) { + var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3]; + var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7]; + var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11]; + var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15]; + var b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3]; + out[0] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30; + out[1] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31; + out[2] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32; + out[3] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33; + b0 = b2[4]; + b1 = b2[5]; + b22 = b2[6]; + b3 = b2[7]; + out[4] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30; + out[5] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31; + out[6] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32; + out[7] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33; + b0 = b2[8]; + b1 = b2[9]; + b22 = b2[10]; + b3 = b2[11]; + out[8] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30; + out[9] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31; + out[10] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32; + out[11] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33; + b0 = b2[12]; + b1 = b2[13]; + b22 = b2[14]; + b3 = b2[15]; + out[12] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30; + out[13] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31; + out[14] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32; + out[15] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33; + return out; + } + function translate2(out, a2, v2) { + var x2 = v2[0], y2 = v2[1], z = v2[2]; + var a00, a01, a02, a03; + var a10, a11, a12, a13; + var a20, a21, a22, a23; + if (a2 === out) { + out[12] = a2[0] * x2 + a2[4] * y2 + a2[8] * z + a2[12]; + out[13] = a2[1] * x2 + a2[5] * y2 + a2[9] * z + a2[13]; + out[14] = a2[2] * x2 + a2[6] * y2 + a2[10] * z + a2[14]; + out[15] = a2[3] * x2 + a2[7] * y2 + a2[11] * z + a2[15]; + } else { + a00 = a2[0]; + a01 = a2[1]; + a02 = a2[2]; + a03 = a2[3]; + a10 = a2[4]; + a11 = a2[5]; + a12 = a2[6]; + a13 = a2[7]; + a20 = a2[8]; + a21 = a2[9]; + a22 = a2[10]; + a23 = a2[11]; + out[0] = a00; + out[1] = a01; + out[2] = a02; + out[3] = a03; + out[4] = a10; + out[5] = a11; + out[6] = a12; + out[7] = a13; + out[8] = a20; + out[9] = a21; + out[10] = a22; + out[11] = a23; + out[12] = a00 * x2 + a10 * y2 + a20 * z + a2[12]; + out[13] = a01 * x2 + a11 * y2 + a21 * z + a2[13]; + out[14] = a02 * x2 + a12 * y2 + a22 * z + a2[14]; + out[15] = a03 * x2 + a13 * y2 + a23 * z + a2[15]; } - _getParameter(pname) { - this.gl.bindBuffer(this.target, this.handle); - const value = this.gl.getBufferParameter(this.target, pname); - this.gl.bindBuffer(this.target, null); - return value; + return out; + } + function scale2(out, a2, v2) { + var x2 = v2[0], y2 = v2[1], z = v2[2]; + out[0] = a2[0] * x2; + out[1] = a2[1] * x2; + out[2] = a2[2] * x2; + out[3] = a2[3] * x2; + out[4] = a2[4] * y2; + out[5] = a2[5] * y2; + out[6] = a2[6] * y2; + out[7] = a2[7] * y2; + out[8] = a2[8] * z; + out[9] = a2[9] * z; + out[10] = a2[10] * z; + out[11] = a2[11] * z; + out[12] = a2[12]; + out[13] = a2[13]; + out[14] = a2[14]; + out[15] = a2[15]; + return out; + } + function rotate2(out, a2, rad, axis) { + var x2 = axis[0], y2 = axis[1], z = axis[2]; + var len2 = Math.hypot(x2, y2, z); + var s, c2, t2; + var a00, a01, a02, a03; + var a10, a11, a12, a13; + var a20, a21, a22, a23; + var b00, b01, b02; + var b10, b11, b12; + var b20, b21, b22; + if (len2 < EPSILON) { + return null; } - get type() { - log2.deprecated("Buffer.type", "Buffer.accessor.type")(); - return this.accessor.type; + len2 = 1 / len2; + x2 *= len2; + y2 *= len2; + z *= len2; + s = Math.sin(rad); + c2 = Math.cos(rad); + t2 = 1 - c2; + a00 = a2[0]; + a01 = a2[1]; + a02 = a2[2]; + a03 = a2[3]; + a10 = a2[4]; + a11 = a2[5]; + a12 = a2[6]; + a13 = a2[7]; + a20 = a2[8]; + a21 = a2[9]; + a22 = a2[10]; + a23 = a2[11]; + b00 = x2 * x2 * t2 + c2; + b01 = y2 * x2 * t2 + z * s; + b02 = z * x2 * t2 - y2 * s; + b10 = x2 * y2 * t2 - z * s; + b11 = y2 * y2 * t2 + c2; + b12 = z * y2 * t2 + x2 * s; + b20 = x2 * z * t2 + y2 * s; + b21 = y2 * z * t2 - x2 * s; + b22 = z * z * t2 + c2; + out[0] = a00 * b00 + a10 * b01 + a20 * b02; + out[1] = a01 * b00 + a11 * b01 + a21 * b02; + out[2] = a02 * b00 + a12 * b01 + a22 * b02; + out[3] = a03 * b00 + a13 * b01 + a23 * b02; + out[4] = a00 * b10 + a10 * b11 + a20 * b12; + out[5] = a01 * b10 + a11 * b11 + a21 * b12; + out[6] = a02 * b10 + a12 * b11 + a22 * b12; + out[7] = a03 * b10 + a13 * b11 + a23 * b12; + out[8] = a00 * b20 + a10 * b21 + a20 * b22; + out[9] = a01 * b20 + a11 * b21 + a21 * b22; + out[10] = a02 * b20 + a12 * b21 + a22 * b22; + out[11] = a03 * b20 + a13 * b21 + a23 * b22; + if (a2 !== out) { + out[12] = a2[12]; + out[13] = a2[13]; + out[14] = a2[14]; + out[15] = a2[15]; } - get bytes() { - log2.deprecated("Buffer.bytes", "Buffer.byteLength")(); - return this.byteLength; + return out; + } + function rotateX2(out, a2, rad) { + var s = Math.sin(rad); + var c2 = Math.cos(rad); + var a10 = a2[4]; + var a11 = a2[5]; + var a12 = a2[6]; + var a13 = a2[7]; + var a20 = a2[8]; + var a21 = a2[9]; + var a22 = a2[10]; + var a23 = a2[11]; + if (a2 !== out) { + out[0] = a2[0]; + out[1] = a2[1]; + out[2] = a2[2]; + out[3] = a2[3]; + out[12] = a2[12]; + out[13] = a2[13]; + out[14] = a2[14]; + out[15] = a2[15]; } - setByteLength(byteLength) { - log2.deprecated("setByteLength", "reallocate")(); - return this.reallocate(byteLength); + out[4] = a10 * c2 + a20 * s; + out[5] = a11 * c2 + a21 * s; + out[6] = a12 * c2 + a22 * s; + out[7] = a13 * c2 + a23 * s; + out[8] = a20 * c2 - a10 * s; + out[9] = a21 * c2 - a11 * s; + out[10] = a22 * c2 - a12 * s; + out[11] = a23 * c2 - a13 * s; + return out; + } + function rotateY2(out, a2, rad) { + var s = Math.sin(rad); + var c2 = Math.cos(rad); + var a00 = a2[0]; + var a01 = a2[1]; + var a02 = a2[2]; + var a03 = a2[3]; + var a20 = a2[8]; + var a21 = a2[9]; + var a22 = a2[10]; + var a23 = a2[11]; + if (a2 !== out) { + out[4] = a2[4]; + out[5] = a2[5]; + out[6] = a2[6]; + out[7] = a2[7]; + out[12] = a2[12]; + out[13] = a2[13]; + out[14] = a2[14]; + out[15] = a2[15]; } - updateAccessor(opts) { - log2.deprecated("updateAccessor(...)", "setAccessor(new Accessor(buffer.accessor, ...)")(); - this.accessor = new Accessor(this.accessor, opts); - return this; + out[0] = a00 * c2 - a20 * s; + out[1] = a01 * c2 - a21 * s; + out[2] = a02 * c2 - a22 * s; + out[3] = a03 * c2 - a23 * s; + out[8] = a00 * s + a20 * c2; + out[9] = a01 * s + a21 * c2; + out[10] = a02 * s + a22 * c2; + out[11] = a03 * s + a23 * c2; + return out; + } + function rotateZ2(out, a2, rad) { + var s = Math.sin(rad); + var c2 = Math.cos(rad); + var a00 = a2[0]; + var a01 = a2[1]; + var a02 = a2[2]; + var a03 = a2[3]; + var a10 = a2[4]; + var a11 = a2[5]; + var a12 = a2[6]; + var a13 = a2[7]; + if (a2 !== out) { + out[8] = a2[8]; + out[9] = a2[9]; + out[10] = a2[10]; + out[11] = a2[11]; + out[12] = a2[12]; + out[13] = a2[13]; + out[14] = a2[14]; + out[15] = a2[15]; } - }; - - // node_modules/@luma.gl/webgl/dist/esm/classes/texture-formats.js - var TEXTURE_FORMATS = { - [6407]: { - dataFormat: 6407, - types: [5121, 33635] - }, - [6408]: { - dataFormat: 6408, - types: [5121, 32819, 32820] - }, - [6406]: { - dataFormat: 6406, - types: [5121] - }, - [6409]: { - dataFormat: 6409, - types: [5121] - }, - [6410]: { - dataFormat: 6410, - types: [5121] - }, - [33326]: { - dataFormat: 6403, - types: [5126], - gl2: true - }, - [33328]: { - dataFormat: 33319, - types: [5126], - gl2: true - }, - [34837]: { - dataFormat: 6407, - types: [5126], - gl2: true - }, - [34836]: { - dataFormat: 6408, - types: [5126], - gl2: true + out[0] = a00 * c2 + a10 * s; + out[1] = a01 * c2 + a11 * s; + out[2] = a02 * c2 + a12 * s; + out[3] = a03 * c2 + a13 * s; + out[4] = a10 * c2 - a00 * s; + out[5] = a11 * c2 - a01 * s; + out[6] = a12 * c2 - a02 * s; + out[7] = a13 * c2 - a03 * s; + return out; + } + function getScaling(out, mat) { + var m11 = mat[0]; + var m12 = mat[1]; + var m13 = mat[2]; + var m21 = mat[4]; + var m22 = mat[5]; + var m23 = mat[6]; + var m31 = mat[8]; + var m32 = mat[9]; + var m33 = mat[10]; + out[0] = Math.hypot(m11, m12, m13); + out[1] = Math.hypot(m21, m22, m23); + out[2] = Math.hypot(m31, m32, m33); + return out; + } + function fromQuat2(out, q) { + var x2 = q[0], y2 = q[1], z = q[2], w3 = q[3]; + var x22 = x2 + x2; + var y22 = y2 + y2; + var z2 = z + z; + var xx = x2 * x22; + var yx = y2 * x22; + var yy = y2 * y22; + var zx = z * x22; + var zy = z * y22; + var zz = z * z2; + var wx = w3 * x22; + var wy = w3 * y22; + var wz = w3 * z2; + out[0] = 1 - yy - zz; + out[1] = yx + wz; + out[2] = zx - wy; + out[3] = 0; + out[4] = yx - wz; + out[5] = 1 - xx - zz; + out[6] = zy + wx; + out[7] = 0; + out[8] = zx + wy; + out[9] = zy - wx; + out[10] = 1 - xx - yy; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; + } + function frustum(out, left, right, bottom, top, near, far) { + var rl = 1 / (right - left); + var tb = 1 / (top - bottom); + var nf = 1 / (near - far); + out[0] = near * 2 * rl; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = near * 2 * tb; + out[6] = 0; + out[7] = 0; + out[8] = (right + left) * rl; + out[9] = (top + bottom) * tb; + out[10] = (far + near) * nf; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[14] = far * near * 2 * nf; + out[15] = 0; + return out; + } + function perspectiveNO(out, fovy, aspect, near, far) { + var f2 = 1 / Math.tan(fovy / 2), nf; + out[0] = f2 / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f2; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + nf = 1 / (near - far); + out[10] = (far + near) * nf; + out[14] = 2 * far * near * nf; + } else { + out[10] = -1; + out[14] = -2 * near; } - }; - var DATA_FORMAT_CHANNELS = { - [6403]: 1, - [36244]: 1, - [33319]: 2, - [33320]: 2, - [6407]: 3, - [36248]: 3, - [6408]: 4, - [36249]: 4, - [6402]: 1, - [34041]: 1, - [6406]: 1, - [6409]: 1, - [6410]: 2 - }; - var TYPE_SIZES = { - [5126]: 4, - [5125]: 4, - [5124]: 4, - [5123]: 2, - [5122]: 2, - [5131]: 2, - [5120]: 1, - [5121]: 1 - }; - function isFormatSupported(gl, format) { - const info = TEXTURE_FORMATS[format]; - if (!info) { - return false; + return out; + } + var perspective = perspectiveNO; + function orthoNO(out, left, right, bottom, top, near, far) { + var lr = 1 / (left - right); + var bt = 1 / (bottom - top); + var nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 2 * nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = (far + near) * nf; + out[15] = 1; + return out; + } + var ortho = orthoNO; + function lookAt(out, eye, center, up) { + var x0, x1, x2, y0, y1, y2, z0, z1, z2, len2; + var eyex = eye[0]; + var eyey = eye[1]; + var eyez = eye[2]; + var upx = up[0]; + var upy = up[1]; + var upz = up[2]; + var centerx = center[0]; + var centery = center[1]; + var centerz = center[2]; + if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) { + return identity(out); } - if (info.gl1 === void 0 && info.gl2 === void 0) { - return true; + z0 = eyex - centerx; + z1 = eyey - centery; + z2 = eyez - centerz; + len2 = 1 / Math.hypot(z0, z1, z2); + z0 *= len2; + z1 *= len2; + z2 *= len2; + x0 = upy * z2 - upz * z1; + x1 = upz * z0 - upx * z2; + x2 = upx * z1 - upy * z0; + len2 = Math.hypot(x0, x1, x2); + if (!len2) { + x0 = 0; + x1 = 0; + x2 = 0; + } else { + len2 = 1 / len2; + x0 *= len2; + x1 *= len2; + x2 *= len2; } - const value = isWebGL2(gl) ? info.gl2 || info.gl1 : info.gl1; - return typeof value === "string" ? gl.getExtension(value) : value; - } - function isLinearFilteringSupported(gl, format) { - const info = TEXTURE_FORMATS[format]; - switch (info && info.types[0]) { - case 5126: - return gl.getExtension("OES_texture_float_linear"); - case 5131: - return gl.getExtension("OES_texture_half_float_linear"); - default: - return true; + y0 = z1 * x2 - z2 * x1; + y1 = z2 * x0 - z0 * x2; + y2 = z0 * x1 - z1 * x0; + len2 = Math.hypot(y0, y1, y2); + if (!len2) { + y0 = 0; + y1 = 0; + y2 = 0; + } else { + len2 = 1 / len2; + y0 *= len2; + y1 *= len2; + y2 *= len2; } + out[0] = x0; + out[1] = y0; + out[2] = z0; + out[3] = 0; + out[4] = x1; + out[5] = y1; + out[6] = z1; + out[7] = 0; + out[8] = x2; + out[9] = y2; + out[10] = z2; + out[11] = 0; + out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); + out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); + out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); + out[15] = 1; + return out; } - // node_modules/@luma.gl/webgl/dist/esm/classes/texture.js - var NPOT_MIN_FILTERS = [9729, 9728]; - var WebGLBuffer = globalThis.WebGLBuffer || function WebGLBuffer2() { - }; - var Texture = class extends Resource { - get [Symbol.toStringTag]() { - return "Texture"; - } - static isSupported(gl) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const { - format, - linearFiltering - } = opts; - let supported = true; - if (format) { - supported = supported && isFormatSupported(gl, format); - supported = supported && (!linearFiltering || isLinearFilteringSupported(gl, format)); - } - return supported; - } - constructor(gl, props) { - const { - id = uid("texture"), - handle, - target - } = props; - super(gl, { - id, - handle - }); - this.target = target; - this.textureUnit = void 0; - this.loaded = false; - this.width = void 0; - this.height = void 0; - this.depth = void 0; - this.format = void 0; - this.type = void 0; - this.dataFormat = void 0; - this.border = void 0; - this.textureUnit = void 0; - this.mipmaps = void 0; - } - toString() { - return "Texture(".concat(this.id, ",").concat(this.width, "x").concat(this.height, ")"); + // node_modules/gl-matrix/esm/vec4.js + function create4() { + var out = new ARRAY_TYPE(4); + if (ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; } - initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - let data = props.data; - if (data instanceof Promise) { - data.then((resolvedImageData) => this.initialize(Object.assign({}, props, { - pixels: resolvedImageData, - data: resolvedImageData - }))); - return this; - } - const isVideo = typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement; - if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) { - this._video = null; - data.addEventListener("loadeddata", () => this.initialize(props)); - return this; - } - const { - pixels = null, - format = 6408, - border = 0, - recreate = false, - parameters = {}, - pixelStore = {}, - textureUnit = void 0 - } = props; - if (!data) { - data = pixels; - } - let { - width, - height, - dataFormat, - type, - compressed = false, - mipmaps = true - } = props; - const { - depth = 0 - } = props; - ({ - width, - height, - compressed, - dataFormat, - type - } = this._deduceParameters({ - format, - type, - dataFormat, - compressed, - data, - width, - height - })); - this.width = width; - this.height = height; - this.depth = depth; - this.format = format; - this.type = type; - this.dataFormat = dataFormat; - this.border = border; - this.textureUnit = textureUnit; - if (Number.isFinite(this.textureUnit)) { - this.gl.activeTexture(33984 + this.textureUnit); - this.gl.bindTexture(this.target, this.handle); - } - if (mipmaps && this._isNPOT()) { - log2.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))(); - mipmaps = false; - this._updateForNPOT(parameters); + return out; + } + function add2(out, a2, b2) { + out[0] = a2[0] + b2[0]; + out[1] = a2[1] + b2[1]; + out[2] = a2[2] + b2[2]; + out[3] = a2[3] + b2[3]; + return out; + } + function scale3(out, a2, b2) { + out[0] = a2[0] * b2; + out[1] = a2[1] * b2; + out[2] = a2[2] * b2; + out[3] = a2[3] * b2; + return out; + } + function length2(a2) { + var x2 = a2[0]; + var y2 = a2[1]; + var z = a2[2]; + var w3 = a2[3]; + return Math.hypot(x2, y2, z, w3); + } + function squaredLength2(a2) { + var x2 = a2[0]; + var y2 = a2[1]; + var z = a2[2]; + var w3 = a2[3]; + return x2 * x2 + y2 * y2 + z * z + w3 * w3; + } + function normalize2(out, a2) { + var x2 = a2[0]; + var y2 = a2[1]; + var z = a2[2]; + var w3 = a2[3]; + var len2 = x2 * x2 + y2 * y2 + z * z + w3 * w3; + if (len2 > 0) { + len2 = 1 / Math.sqrt(len2); + } + out[0] = x2 * len2; + out[1] = y2 * len2; + out[2] = z * len2; + out[3] = w3 * len2; + return out; + } + function dot2(a2, b2) { + return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2] + a2[3] * b2[3]; + } + function lerp4(out, a2, b2, t2) { + var ax = a2[0]; + var ay = a2[1]; + var az = a2[2]; + var aw = a2[3]; + out[0] = ax + t2 * (b2[0] - ax); + out[1] = ay + t2 * (b2[1] - ay); + out[2] = az + t2 * (b2[2] - az); + out[3] = aw + t2 * (b2[3] - aw); + return out; + } + function transformMat43(out, a2, m) { + var x2 = a2[0], y2 = a2[1], z = a2[2], w3 = a2[3]; + out[0] = m[0] * x2 + m[4] * y2 + m[8] * z + m[12] * w3; + out[1] = m[1] * x2 + m[5] * y2 + m[9] * z + m[13] * w3; + out[2] = m[2] * x2 + m[6] * y2 + m[10] * z + m[14] * w3; + out[3] = m[3] * x2 + m[7] * y2 + m[11] * z + m[15] * w3; + return out; + } + function transformQuat2(out, a2, q) { + var x2 = a2[0], y2 = a2[1], z = a2[2]; + var qx = q[0], qy = q[1], qz = q[2], qw = q[3]; + var ix = qw * x2 + qy * z - qz * y2; + var iy = qw * y2 + qz * x2 - qx * z; + var iz = qw * z + qx * y2 - qy * x2; + var iw = -qx * x2 - qy * y2 - qz * z; + out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; + out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; + out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; + out[3] = a2[3]; + return out; + } + var forEach4 = function() { + var vec = create4(); + return function(a2, stride, offset, count2, fn, arg) { + var i3, l2; + if (!stride) { + stride = 4; } - this.mipmaps = mipmaps; - this.setImageData({ - data, - width, - height, - depth, - format, - type, - dataFormat, - border, - mipmaps, - parameters: pixelStore, - compressed - }); - if (mipmaps) { - this.generateMipmap(); + if (!offset) { + offset = 0; } - this.setParameters(parameters); - if (recreate) { - this.data = data; + if (count2) { + l2 = Math.min(count2 * stride + offset, a2.length); + } else { + l2 = a2.length; } - if (isVideo) { - this._video = { - video: data, - parameters, - lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1 - }; + for (i3 = offset; i3 < l2; i3 += stride) { + vec[0] = a2[i3]; + vec[1] = a2[i3 + 1]; + vec[2] = a2[i3 + 2]; + vec[3] = a2[i3 + 3]; + fn(vec, vec, arg); + a2[i3] = vec[0]; + a2[i3 + 1] = vec[1]; + a2[i3 + 2] = vec[2]; + a2[i3 + 3] = vec[3]; } - return this; + return a2; + }; + }(); + + // node_modules/@math.gl/core/dist/esm/classes/matrix4.js + var INDICES2; + (function(INDICES3) { + INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0"; + INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1"; + INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2"; + INDICES3[INDICES3["COL0ROW3"] = 3] = "COL0ROW3"; + INDICES3[INDICES3["COL1ROW0"] = 4] = "COL1ROW0"; + INDICES3[INDICES3["COL1ROW1"] = 5] = "COL1ROW1"; + INDICES3[INDICES3["COL1ROW2"] = 6] = "COL1ROW2"; + INDICES3[INDICES3["COL1ROW3"] = 7] = "COL1ROW3"; + INDICES3[INDICES3["COL2ROW0"] = 8] = "COL2ROW0"; + INDICES3[INDICES3["COL2ROW1"] = 9] = "COL2ROW1"; + INDICES3[INDICES3["COL2ROW2"] = 10] = "COL2ROW2"; + INDICES3[INDICES3["COL2ROW3"] = 11] = "COL2ROW3"; + INDICES3[INDICES3["COL3ROW0"] = 12] = "COL3ROW0"; + INDICES3[INDICES3["COL3ROW1"] = 13] = "COL3ROW1"; + INDICES3[INDICES3["COL3ROW2"] = 14] = "COL3ROW2"; + INDICES3[INDICES3["COL3ROW3"] = 15] = "COL3ROW3"; + })(INDICES2 || (INDICES2 = {})); + var DEFAULT_FOVY = 45 * Math.PI / 180; + var DEFAULT_ASPECT = 1; + var DEFAULT_NEAR = 0.1; + var DEFAULT_FAR = 500; + var IDENTITY_MATRIX2 = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]); + var Matrix4 = class extends Matrix { + static get IDENTITY() { + return getIdentityMatrix2(); } - update() { - if (this._video) { - const { - video, - parameters, - lastTime - } = this._video; - if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) { - return; - } - this.setSubImageData({ - data: video, - parameters - }); - if (this.mipmaps) { - this.generateMipmap(); - } - this._video.lastTime = video.currentTime; - } + static get ZERO() { + return getZeroMatrix2(); } - resize(_ref) { - let { - height, - width, - mipmaps = false - } = _ref; - if (width !== this.width || height !== this.height) { - return this.initialize({ - width, - height, - format: this.format, - type: this.type, - dataFormat: this.dataFormat, - border: this.border, - mipmaps - }); - } - return this; + get ELEMENTS() { + return 16; } - generateMipmap() { - let params = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if (this._isNPOT()) { - log2.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))(); - return this; - } - this.mipmaps = true; - this.gl.bindTexture(this.target, this.handle); - withParameters(this.gl, params, () => { - this.gl.generateMipmap(this.target); - }); - this.gl.bindTexture(this.target, null); - return this; + get RANK() { + return 4; } - setImageData(options) { - this._trackDeallocatedMemory("Texture"); - const { - target = this.target, - pixels = null, - level = 0, - format = this.format, - border = this.border, - offset = 0, - parameters = {} - } = options; - let { - data = null, - type = this.type, - width = this.width, - height = this.height, - dataFormat = this.dataFormat, - compressed = false - } = options; - if (!data) { - data = pixels; - } - ({ - type, - dataFormat, - compressed, - width, - height - } = this._deduceParameters({ - format, - type, - dataFormat, - compressed, - data, - width, - height - })); - const { - gl - } = this; - gl.bindTexture(this.target, this.handle); - let dataType = null; - ({ - data, - dataType - } = this._getDataType({ - data, - compressed - })); - let gl2; - let compressedTextureSize = 0; - withParameters(this.gl, parameters, () => { - switch (dataType) { - case "null": - gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data); - break; - case "typed-array": - gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data, offset); - break; - case "buffer": - gl2 = assertWebGL2Context(gl); - gl2.bindBuffer(35052, data.handle || data); - gl2.texImage2D(target, level, format, width, height, border, dataFormat, type, offset); - gl2.bindBuffer(35052, null); - break; - case "browser-object": - if (isWebGL2(gl)) { - gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data); - } else { - gl.texImage2D(target, level, format, dataFormat, type, data); - } - break; - case "compressed": - for (const [levelIndex, levelData] of data.entries()) { - gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, border, levelData.data); - compressedTextureSize += levelData.levelSize; - } - break; - default: - assert6(false, "Unknown image data type"); - } - }); - if (dataType === "compressed") { - this._trackAllocatedMemory(compressedTextureSize, "Texture"); - } else if (data && data.byteLength) { - this._trackAllocatedMemory(data.byteLength, "Texture"); + get INDICES() { + return INDICES2; + } + constructor(array) { + super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0); + if (arguments.length === 1 && Array.isArray(array)) { + this.copy(array); } else { - const channels = DATA_FORMAT_CHANNELS[this.dataFormat] || 4; - const channelSize = TYPE_SIZES[this.type] || 1; - this._trackAllocatedMemory(this.width * this.height * channels * channelSize, "Texture"); + this.identity(); } - this.loaded = true; - return this; } - setSubImageData(_ref2) { - let { - target = this.target, - pixels = null, - data = null, - x: x2 = 0, - y: y2 = 0, - width = this.width, - height = this.height, - level = 0, - format = this.format, - type = this.type, - dataFormat = this.dataFormat, - compressed = false, - offset = 0, - border = this.border, - parameters = {} - } = _ref2; - ({ - type, - dataFormat, - compressed, - width, - height - } = this._deduceParameters({ - format, - type, - dataFormat, - compressed, - data, - width, - height - })); - assert6(this.depth === 0, "texSubImage not supported for 3D textures"); - if (!data) { - data = pixels; - } - if (data && data.data) { - const ndarray = data; - data = ndarray.data; - width = ndarray.shape[0]; - height = ndarray.shape[1]; - } - if (data instanceof Buffer2) { - data = data.handle; - } - this.gl.bindTexture(this.target, this.handle); - withParameters(this.gl, parameters, () => { - if (compressed) { - this.gl.compressedTexSubImage2D(target, level, x2, y2, width, height, format, data); - } else if (data === null) { - this.gl.texSubImage2D(target, level, x2, y2, width, height, dataFormat, type, null); - } else if (ArrayBuffer.isView(data)) { - this.gl.texSubImage2D(target, level, x2, y2, width, height, dataFormat, type, data, offset); - } else if (data instanceof WebGLBuffer) { - const gl2 = assertWebGL2Context(this.gl); - gl2.bindBuffer(35052, data); - gl2.texSubImage2D(target, level, x2, y2, width, height, dataFormat, type, offset); - gl2.bindBuffer(35052, null); - } else if (isWebGL2(this.gl)) { - const gl2 = assertWebGL2Context(this.gl); - gl2.texSubImage2D(target, level, x2, y2, width, height, dataFormat, type, data); - } else { - this.gl.texSubImage2D(target, level, x2, y2, dataFormat, type, data); - } - }); - this.gl.bindTexture(this.target, null); + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + this[3] = array[3]; + this[4] = array[4]; + this[5] = array[5]; + this[6] = array[6]; + this[7] = array[7]; + this[8] = array[8]; + this[9] = array[9]; + this[10] = array[10]; + this[11] = array[11]; + this[12] = array[12]; + this[13] = array[13]; + this[14] = array[14]; + this[15] = array[15]; + return this.check(); + } + set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) { + this[0] = m00; + this[1] = m10; + this[2] = m20; + this[3] = m30; + this[4] = m01; + this[5] = m11; + this[6] = m21; + this[7] = m31; + this[8] = m02; + this[9] = m12; + this[10] = m22; + this[11] = m32; + this[12] = m03; + this[13] = m13; + this[14] = m23; + this[15] = m33; + return this.check(); } - copyFramebuffer() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - log2.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")(); - return null; + setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + this[0] = m00; + this[1] = m10; + this[2] = m20; + this[3] = m30; + this[4] = m01; + this[5] = m11; + this[6] = m21; + this[7] = m31; + this[8] = m02; + this[9] = m12; + this[10] = m22; + this[11] = m32; + this[12] = m03; + this[13] = m13; + this[14] = m23; + this[15] = m33; + return this.check(); } - getActiveUnit() { - return this.gl.getParameter(34016) - 33984; + toRowMajor(result) { + result[0] = this[0]; + result[1] = this[4]; + result[2] = this[8]; + result[3] = this[12]; + result[4] = this[1]; + result[5] = this[5]; + result[6] = this[9]; + result[7] = this[13]; + result[8] = this[2]; + result[9] = this[6]; + result[10] = this[10]; + result[11] = this[14]; + result[12] = this[3]; + result[13] = this[7]; + result[14] = this[11]; + result[15] = this[15]; + return result; } - bind() { - let textureUnit = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.textureUnit; + identity() { + return this.copy(IDENTITY_MATRIX2); + } + fromObject(object) { + return this.check(); + } + fromQuaternion(quaternion) { + fromQuat2(this, quaternion); + return this.check(); + } + frustum(view) { const { - gl - } = this; - if (textureUnit !== void 0) { - this.textureUnit = textureUnit; - gl.activeTexture(33984 + textureUnit); + left, + right, + bottom, + top, + near = DEFAULT_NEAR, + far = DEFAULT_FAR + } = view; + if (far === Infinity) { + computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near); + } else { + frustum(this, left, right, bottom, top, near, far); } - gl.bindTexture(this.target, this.handle); - return textureUnit; + return this.check(); } - unbind() { - let textureUnit = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.textureUnit; + lookAt(view) { const { - gl - } = this; - if (textureUnit !== void 0) { - this.textureUnit = textureUnit; - gl.activeTexture(33984 + textureUnit); - } - gl.bindTexture(this.target, null); - return textureUnit; + eye, + center = [0, 0, 0], + up = [0, 1, 0] + } = view; + lookAt(this, eye, center, up); + return this.check(); } - _getDataType(_ref3) { - let { - data, - compressed = false - } = _ref3; - if (compressed) { - return { - data, - dataType: "compressed" - }; - } - if (data === null) { - return { - data, - dataType: "null" - }; - } - if (ArrayBuffer.isView(data)) { - return { - data, - dataType: "typed-array" - }; - } - if (data instanceof Buffer2) { - return { - data: data.handle, - dataType: "buffer" - }; - } - if (data instanceof WebGLBuffer) { - return { - data, - dataType: "buffer" - }; - } - return { - data, - dataType: "browser-object" - }; + ortho(view) { + const { + left, + right, + bottom, + top, + near = DEFAULT_NEAR, + far = DEFAULT_FAR + } = view; + ortho(this, left, right, bottom, top, near, far); + return this.check(); } - _deduceParameters(opts) { + orthographic(view) { const { - format, - data - } = opts; - let { - width, - height, - dataFormat, - type, - compressed - } = opts; - const textureFormat = TEXTURE_FORMATS[format]; - dataFormat = dataFormat || textureFormat && textureFormat.dataFormat; - type = type || textureFormat && textureFormat.types[0]; - compressed = compressed || textureFormat && textureFormat.compressed; - ({ - width, - height - } = this._deduceImageSize(data, width, height)); - return { - dataFormat, - type, - compressed, - width, - height, - format, - data - }; + fovy = DEFAULT_FOVY, + aspect = DEFAULT_ASPECT, + focalDistance = 1, + near = DEFAULT_NEAR, + far = DEFAULT_FAR + } = view; + checkRadians(fovy); + const halfY = fovy / 2; + const top = focalDistance * Math.tan(halfY); + const right = top * aspect; + return this.ortho({ + left: -right, + right, + bottom: -top, + top, + near, + far + }); } - _deduceImageSize(data, width, height) { - let size; - if (typeof ImageData !== "undefined" && data instanceof ImageData) { - size = { - width: data.width, - height: data.height - }; - } else if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) { - size = { - width: data.naturalWidth, - height: data.naturalHeight - }; - } else if (typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement) { - size = { - width: data.width, - height: data.height - }; - } else if (typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap) { - size = { - width: data.width, - height: data.height - }; - } else if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) { - size = { - width: data.videoWidth, - height: data.videoHeight - }; - } else if (!data) { - size = { - width: width >= 0 ? width : 1, - height: height >= 0 ? height : 1 - }; - } else { - size = { - width, - height - }; - } - assert6(size, "Could not deduced texture size"); - assert6(width === void 0 || size.width === width, "Deduced texture width does not match supplied width"); - assert6(height === void 0 || size.height === height, "Deduced texture height does not match supplied height"); - return size; + perspective(view) { + const { + fovy = 45 * Math.PI / 180, + aspect = 1, + near = 0.1, + far = 500 + } = view; + checkRadians(fovy); + perspective(this, fovy, aspect, near, far); + return this.check(); } - _createHandle() { - return this.gl.createTexture(); + determinant() { + return determinant2(this); } - _deleteHandle() { - this.gl.deleteTexture(this.handle); - this._trackDeallocatedMemory("Texture"); + getScale(result = [-0, -0, -0]) { + result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]); + result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]); + result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]); + return result; } - _getParameter(pname) { - switch (pname) { - case 4096: - return this.width; - case 4097: - return this.height; - default: - this.gl.bindTexture(this.target, this.handle); - const value = this.gl.getTexParameter(this.target, pname); - this.gl.bindTexture(this.target, null); - return value; + getTranslation(result = [-0, -0, -0]) { + result[0] = this[12]; + result[1] = this[13]; + result[2] = this[14]; + return result; + } + getRotation(result, scaleResult) { + result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0]; + scaleResult = scaleResult || [-0, -0, -0]; + const scale5 = this.getScale(scaleResult); + const inverseScale0 = 1 / scale5[0]; + const inverseScale1 = 1 / scale5[1]; + const inverseScale2 = 1 / scale5[2]; + result[0] = this[0] * inverseScale0; + result[1] = this[1] * inverseScale1; + result[2] = this[2] * inverseScale2; + result[3] = 0; + result[4] = this[4] * inverseScale0; + result[5] = this[5] * inverseScale1; + result[6] = this[6] * inverseScale2; + result[7] = 0; + result[8] = this[8] * inverseScale0; + result[9] = this[9] * inverseScale1; + result[10] = this[10] * inverseScale2; + result[11] = 0; + result[12] = 0; + result[13] = 0; + result[14] = 0; + result[15] = 1; + return result; + } + getRotationMatrix3(result, scaleResult) { + result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0]; + scaleResult = scaleResult || [-0, -0, -0]; + const scale5 = this.getScale(scaleResult); + const inverseScale0 = 1 / scale5[0]; + const inverseScale1 = 1 / scale5[1]; + const inverseScale2 = 1 / scale5[2]; + result[0] = this[0] * inverseScale0; + result[1] = this[1] * inverseScale1; + result[2] = this[2] * inverseScale2; + result[3] = this[4] * inverseScale0; + result[4] = this[5] * inverseScale1; + result[5] = this[6] * inverseScale2; + result[6] = this[8] * inverseScale0; + result[7] = this[9] * inverseScale1; + result[8] = this[10] * inverseScale2; + return result; + } + transpose() { + transpose2(this, this); + return this.check(); + } + invert() { + invert2(this, this); + return this.check(); + } + multiplyLeft(a2) { + multiply2(this, a2, this); + return this.check(); + } + multiplyRight(a2) { + multiply2(this, this, a2); + return this.check(); + } + rotateX(radians2) { + rotateX2(this, this, radians2); + return this.check(); + } + rotateY(radians2) { + rotateY2(this, this, radians2); + return this.check(); + } + rotateZ(radians2) { + rotateZ2(this, this, radians2); + return this.check(); + } + rotateXYZ(angleXYZ) { + return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]); + } + rotateAxis(radians2, axis) { + rotate2(this, this, radians2, axis); + return this.check(); + } + scale(factor) { + scale2(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]); + return this.check(); + } + translate(vector) { + translate2(this, this, vector); + return this.check(); + } + transform(vector, result) { + if (vector.length === 4) { + result = transformMat43(result || [-0, -0, -0, -0], vector, this); + checkVector(result, 4); + return result; } + return this.transformAsPoint(vector, result); } - _setParameter(pname, param) { - this.gl.bindTexture(this.target, this.handle); - param = this._getNPOTParam(pname, param); - switch (pname) { - case 33082: - case 33083: - this.gl.texParameterf(this.handle, pname, param); + transformAsPoint(vector, result) { + const { + length: length4 + } = vector; + let out; + switch (length4) { + case 2: + out = transformMat4(result || [-0, -0], vector, this); break; - case 4096: - case 4097: - assert6(false); + case 3: + out = transformMat42(result || [-0, -0, -0], vector, this); break; default: - this.gl.texParameteri(this.target, pname, param); - break; + throw new Error("Illegal vector"); } - this.gl.bindTexture(this.target, null); - return this; + checkVector(out, vector.length); + return out; } - _isNPOT() { - if (isWebGL2(this.gl)) { - return false; - } - if (!this.width || !this.height) { - return false; + transformAsVector(vector, result) { + let out; + switch (vector.length) { + case 2: + out = vec2_transformMat4AsVector(result || [-0, -0], vector, this); + break; + case 3: + out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this); + break; + default: + throw new Error("Illegal vector"); } - return !isPowerOfTwo(this.width) || !isPowerOfTwo(this.height); + checkVector(out, vector.length); + return out; } - _updateForNPOT(parameters) { - if (parameters[this.gl.TEXTURE_MIN_FILTER] === void 0) { - parameters[this.gl.TEXTURE_MIN_FILTER] = this.gl.LINEAR; - } - if (parameters[this.gl.TEXTURE_WRAP_S] === void 0) { - parameters[this.gl.TEXTURE_WRAP_S] = this.gl.CLAMP_TO_EDGE; - } - if (parameters[this.gl.TEXTURE_WRAP_T] === void 0) { - parameters[this.gl.TEXTURE_WRAP_T] = this.gl.CLAMP_TO_EDGE; - } + transformPoint(vector, result) { + return this.transformAsPoint(vector, result); } - _getNPOTParam(pname, param) { - if (this._isNPOT()) { - switch (pname) { - case 10241: - if (NPOT_MIN_FILTERS.indexOf(param) === -1) { - param = 9729; - } - break; - case 10242: - case 10243: - if (param !== 33071) { - param = 33071; - } - break; - default: - break; - } - } - return param; + transformVector(vector, result) { + return this.transformAsPoint(vector, result); + } + transformDirection(vector, result) { + return this.transformAsVector(vector, result); + } + makeRotationX(radians2) { + return this.identity().rotateX(radians2); + } + makeTranslation(x2, y2, z) { + return this.identity().translate([x2, y2, z]); } }; + var ZERO3; + var IDENTITY; + function getZeroMatrix2() { + if (!ZERO3) { + ZERO3 = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); + Object.freeze(ZERO3); + } + return ZERO3; + } + function getIdentityMatrix2() { + if (!IDENTITY) { + IDENTITY = new Matrix4(); + Object.freeze(IDENTITY); + } + return IDENTITY; + } + function checkRadians(possiblyDegrees) { + if (possiblyDegrees > Math.PI * 2) { + throw Error("expected radians"); + } + } + function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) { + const column0Row0 = 2 * near / (right - left); + const column1Row1 = 2 * near / (top - bottom); + const column2Row0 = (right + left) / (right - left); + const column2Row1 = (top + bottom) / (top - bottom); + const column2Row2 = -1; + const column2Row3 = -1; + const column3Row2 = -2 * near; + result[0] = column0Row0; + result[1] = 0; + result[2] = 0; + result[3] = 0; + result[4] = 0; + result[5] = column1Row1; + result[6] = 0; + result[7] = 0; + result[8] = column2Row0; + result[9] = column2Row1; + result[10] = column2Row2; + result[11] = column2Row3; + result[12] = 0; + result[13] = 0; + result[14] = column3Row2; + result[15] = 0; + return result; + } - // node_modules/@luma.gl/webgl/dist/esm/utils/load-file.js - var pathPrefix2 = ""; - function loadImage(url, opts) { - assert6(typeof url === "string"); - url = pathPrefix2 + url; - return new Promise((resolve2, reject) => { - try { - const image = new Image(); - image.onload = () => resolve2(image); - image.onerror = () => reject(new Error("Could not load image ".concat(url, "."))); - image.crossOrigin = opts && opts.crossOrigin || "anonymous"; - image.src = url; - } catch (error2) { - reject(error2); - } - }); + // node_modules/gl-matrix/esm/quat.js + function create5() { + var out = new ARRAY_TYPE(4); + if (ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + out[3] = 1; + return out; + } + function identity2(out) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; } - - // node_modules/@luma.gl/webgl/dist/esm/classes/texture-2d.js - var Texture2D = class extends Texture { - get [Symbol.toStringTag]() { - return "Texture2D"; + function setAxisAngle(out, axis, rad) { + rad = rad * 0.5; + var s = Math.sin(rad); + out[0] = s * axis[0]; + out[1] = s * axis[1]; + out[2] = s * axis[2]; + out[3] = Math.cos(rad); + return out; + } + function multiply3(out, a2, b2) { + var ax = a2[0], ay = a2[1], az = a2[2], aw = a2[3]; + var bx = b2[0], by = b2[1], bz = b2[2], bw = b2[3]; + out[0] = ax * bw + aw * bx + ay * bz - az * by; + out[1] = ay * bw + aw * by + az * bx - ax * bz; + out[2] = az * bw + aw * bz + ax * by - ay * bx; + out[3] = aw * bw - ax * bx - ay * by - az * bz; + return out; + } + function rotateX3(out, a2, rad) { + rad *= 0.5; + var ax = a2[0], ay = a2[1], az = a2[2], aw = a2[3]; + var bx = Math.sin(rad), bw = Math.cos(rad); + out[0] = ax * bw + aw * bx; + out[1] = ay * bw + az * bx; + out[2] = az * bw - ay * bx; + out[3] = aw * bw - ax * bx; + return out; + } + function rotateY3(out, a2, rad) { + rad *= 0.5; + var ax = a2[0], ay = a2[1], az = a2[2], aw = a2[3]; + var by = Math.sin(rad), bw = Math.cos(rad); + out[0] = ax * bw - az * by; + out[1] = ay * bw + aw * by; + out[2] = az * bw + ax * by; + out[3] = aw * bw - ay * by; + return out; + } + function rotateZ3(out, a2, rad) { + rad *= 0.5; + var ax = a2[0], ay = a2[1], az = a2[2], aw = a2[3]; + var bz = Math.sin(rad), bw = Math.cos(rad); + out[0] = ax * bw + ay * bz; + out[1] = ay * bw - ax * bz; + out[2] = az * bw + aw * bz; + out[3] = aw * bw - az * bz; + return out; + } + function calculateW(out, a2) { + var x2 = a2[0], y2 = a2[1], z = a2[2]; + out[0] = x2; + out[1] = y2; + out[2] = z; + out[3] = Math.sqrt(Math.abs(1 - x2 * x2 - y2 * y2 - z * z)); + return out; + } + function slerp(out, a2, b2, t2) { + var ax = a2[0], ay = a2[1], az = a2[2], aw = a2[3]; + var bx = b2[0], by = b2[1], bz = b2[2], bw = b2[3]; + var omega, cosom, sinom, scale0, scale1; + cosom = ax * bx + ay * by + az * bz + aw * bw; + if (cosom < 0) { + cosom = -cosom; + bx = -bx; + by = -by; + bz = -bz; + bw = -bw; + } + if (1 - cosom > EPSILON) { + omega = Math.acos(cosom); + sinom = Math.sin(omega); + scale0 = Math.sin((1 - t2) * omega) / sinom; + scale1 = Math.sin(t2 * omega) / sinom; + } else { + scale0 = 1 - t2; + scale1 = t2; } - static isSupported(gl, opts) { - return Texture.isSupported(gl, opts); + out[0] = scale0 * ax + scale1 * bx; + out[1] = scale0 * ay + scale1 * by; + out[2] = scale0 * az + scale1 * bz; + out[3] = scale0 * aw + scale1 * bw; + return out; + } + function invert3(out, a2) { + var a0 = a2[0], a1 = a2[1], a22 = a2[2], a3 = a2[3]; + var dot4 = a0 * a0 + a1 * a1 + a22 * a22 + a3 * a3; + var invDot = dot4 ? 1 / dot4 : 0; + out[0] = -a0 * invDot; + out[1] = -a1 * invDot; + out[2] = -a22 * invDot; + out[3] = a3 * invDot; + return out; + } + function conjugate(out, a2) { + out[0] = -a2[0]; + out[1] = -a2[1]; + out[2] = -a2[2]; + out[3] = a2[3]; + return out; + } + function fromMat3(out, m) { + var fTrace = m[0] + m[4] + m[8]; + var fRoot; + if (fTrace > 0) { + fRoot = Math.sqrt(fTrace + 1); + out[3] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + out[0] = (m[5] - m[7]) * fRoot; + out[1] = (m[6] - m[2]) * fRoot; + out[2] = (m[1] - m[3]) * fRoot; + } else { + var i3 = 0; + if (m[4] > m[0]) + i3 = 1; + if (m[8] > m[i3 * 3 + i3]) + i3 = 2; + var j = (i3 + 1) % 3; + var k = (i3 + 2) % 3; + fRoot = Math.sqrt(m[i3 * 3 + i3] - m[j * 3 + j] - m[k * 3 + k] + 1); + out[i3] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot; + out[j] = (m[j * 3 + i3] + m[i3 * 3 + j]) * fRoot; + out[k] = (m[k * 3 + i3] + m[i3 * 3 + k]) * fRoot; } - constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - assertWebGLContext(gl); - if (props instanceof Promise || typeof props === "string") { - props = { - data: props - }; + return out; + } + var add3 = add2; + var scale4 = scale3; + var dot3 = dot2; + var lerp5 = lerp4; + var length3 = length2; + var squaredLength3 = squaredLength2; + var normalize3 = normalize2; + var rotationTo = function() { + var tmpvec3 = create2(); + var xUnitVec3 = fromValues(1, 0, 0); + var yUnitVec3 = fromValues(0, 1, 0); + return function(out, a2, b2) { + var dot4 = dot(a2, b2); + if (dot4 < -0.999999) { + cross(tmpvec3, xUnitVec3, a2); + if (len(tmpvec3) < 1e-6) + cross(tmpvec3, yUnitVec3, a2); + normalize(tmpvec3, tmpvec3); + setAxisAngle(out, tmpvec3, Math.PI); + return out; + } else if (dot4 > 0.999999) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; + } else { + cross(tmpvec3, a2, b2); + out[0] = tmpvec3[0]; + out[1] = tmpvec3[1]; + out[2] = tmpvec3[2]; + out[3] = 1 + dot4; + return normalize3(out, out); } - if (typeof props.data === "string") { - props = Object.assign({}, props, { - data: loadImage(props.data) - }); + }; + }(); + var sqlerp = function() { + var temp1 = create5(); + var temp2 = create5(); + return function(out, a2, b2, c2, d2, t2) { + slerp(temp1, a2, d2, t2); + slerp(temp2, b2, c2, t2); + slerp(out, temp1, temp2, 2 * t2 * (1 - t2)); + return out; + }; + }(); + var setAxes = function() { + var matr = create3(); + return function(out, view, right, up) { + matr[0] = right[0]; + matr[3] = right[1]; + matr[6] = right[2]; + matr[1] = up[0]; + matr[4] = up[1]; + matr[7] = up[2]; + matr[2] = -view[0]; + matr[5] = -view[1]; + matr[8] = -view[2]; + return normalize3(out, fromMat3(out, matr)); + }; + }(); + + // node_modules/@math.gl/core/dist/esm/classes/quaternion.js + var IDENTITY_QUATERNION = [0, 0, 0, 1]; + var Quaternion = class extends MathArray { + constructor(x2 = 0, y2 = 0, z = 0, w3 = 1) { + super(-0, -0, -0, -0); + if (Array.isArray(x2) && arguments.length === 1) { + this.copy(x2); + } else { + this.set(x2, y2, z, w3); } - super(gl, Object.assign({}, props, { - target: 3553 - })); - this.initialize(props); - Object.seal(this); } - }; - - // node_modules/@luma.gl/webgl/dist/esm/classes/texture-cube.js - var FACES = [34069, 34070, 34071, 34072, 34073, 34074]; - var TextureCube = class extends Texture { - get [Symbol.toStringTag]() { - return "TextureCube"; + copy(array) { + this[0] = array[0]; + this[1] = array[1]; + this[2] = array[2]; + this[3] = array[3]; + return this.check(); } - constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - assertWebGLContext(gl); - super(gl, Object.assign({}, props, { - target: 34067 - })); - this.initialize(props); - Object.seal(this); + set(x2, y2, z, w3) { + this[0] = x2; + this[1] = y2; + this[2] = z; + this[3] = w3; + return this.check(); } - initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - mipmaps = true, - parameters = {} - } = props; - this.opts = props; - this.setCubeMapImageData(props).then(() => { - this.loaded = true; - if (mipmaps) { - this.generateMipmap(props); - } - this.setParameters(parameters); - }); - return this; + fromObject(object) { + this[0] = object.x; + this[1] = object.y; + this[2] = object.z; + this[3] = object.w; + return this.check(); } - subImage(_ref) { - let { - face, - data, - x: x2 = 0, - y: y2 = 0, - mipmapLevel = 0 - } = _ref; - return this._subImage({ - target: face, - data, - x: x2, - y: y2, - mipmapLevel - }); + fromMatrix3(m) { + fromMat3(this, m); + return this.check(); } - async setCubeMapImageData(_ref2) { - let { - width, - height, - pixels, - data, - border = 0, - format = 6408, - type = 5121 - } = _ref2; - const { - gl - } = this; - const imageDataMap = pixels || data; - const resolvedFaces = await Promise.all(FACES.map((face) => { - const facePixels = imageDataMap[face]; - return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]); - })); - this.bind(); - FACES.forEach((face, index) => { - if (resolvedFaces[index].length > 1 && this.opts.mipmaps !== false) { - log2.warn("".concat(this.id, " has mipmap and multiple LODs."))(); - } - resolvedFaces[index].forEach((image, lodLevel) => { - if (width && height) { - gl.texImage2D(face, lodLevel, format, width, height, border, format, type, image); - } else { - gl.texImage2D(face, lodLevel, format, format, type, image); - } - }); - }); - this.unbind(); + fromAxisRotation(axis, rad) { + setAxisAngle(this, axis, rad); + return this.check(); } - setImageDataForFace(options) { - const { - face, - width, - height, - pixels, - data, - border = 0, - format = 6408, - type = 5121 - } = options; - const { - gl - } = this; - const imageData = pixels || data; - this.bind(); - if (imageData instanceof Promise) { - imageData.then((resolvedImageData) => this.setImageDataForFace(Object.assign({}, options, { - face, - data: resolvedImageData, - pixels: resolvedImageData - }))); - } else if (this.width || this.height) { - gl.texImage2D(face, 0, format, width, height, border, format, type, imageData); - } else { - gl.texImage2D(face, 0, format, format, type, imageData); - } - return this; + identity() { + identity2(this); + return this.check(); } - }; - TextureCube.FACES = FACES; - - // node_modules/@luma.gl/webgl/dist/esm/classes/texture-3d.js - var Texture3D = class extends Texture { - get [Symbol.toStringTag]() { - return "Texture3D"; + setAxisAngle(axis, rad) { + return this.fromAxisRotation(axis, rad); } - static isSupported(gl) { - return isWebGL2(gl); + get ELEMENTS() { + return 4; } - constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - assertWebGL2Context(gl); - props = Object.assign({ - depth: 1 - }, props, { - target: 32879, - unpackFlipY: false - }); - super(gl, props); - this.initialize(props); - Object.seal(this); + get x() { + return this[0]; } - setImageData(_ref) { - let { - level = 0, - dataFormat = 6408, - width, - height, - depth = 1, - border = 0, - format, - type = 5121, - offset = 0, - data, - parameters = {} - } = _ref; - this._trackDeallocatedMemory("Texture"); - this.gl.bindTexture(this.target, this.handle); - withParameters(this.gl, parameters, () => { - if (ArrayBuffer.isView(data)) { - this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, border, format, type, data); - } - if (data instanceof Buffer2) { - this.gl.bindBuffer(35052, data.handle); - this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, border, format, type, offset); - } - }); - if (data && data.byteLength) { - this._trackAllocatedMemory(data.byteLength, "Texture"); - } else { - const channels = DATA_FORMAT_CHANNELS[this.dataFormat] || 4; - const channelSize = TYPE_SIZES[this.type] || 1; - this._trackAllocatedMemory(this.width * this.height * this.depth * channels * channelSize, "Texture"); - } - this.loaded = true; - return this; + set x(value) { + this[0] = checkNumber(value); } - }; - - // node_modules/@luma.gl/webgl/dist/esm/classes/renderbuffer-formats.js - var EXT_FLOAT_WEBGL2 = "EXT_color_buffer_float"; - var renderbuffer_formats_default = { - [33189]: { - bpp: 2 - }, - [33190]: { - gl2: true, - bpp: 3 - }, - [36012]: { - gl2: true, - bpp: 4 - }, - [36168]: { - bpp: 1 - }, - [34041]: { - bpp: 4 - }, - [35056]: { - gl2: true, - bpp: 4 - }, - [36013]: { - gl2: true, - bpp: 5 - }, - [32854]: { - bpp: 2 - }, - [36194]: { - bpp: 2 - }, - [32855]: { - bpp: 2 - }, - [33321]: { - gl2: true, - bpp: 1 - }, - [33330]: { - gl2: true, - bpp: 1 - }, - [33329]: { - gl2: true, - bpp: 1 - }, - [33332]: { - gl2: true, - bpp: 2 - }, - [33331]: { - gl2: true, - bpp: 2 - }, - [33334]: { - gl2: true, - bpp: 4 - }, - [33333]: { - gl2: true, - bpp: 4 - }, - [33323]: { - gl2: true, - bpp: 2 - }, - [33336]: { - gl2: true, - bpp: 2 - }, - [33335]: { - gl2: true, - bpp: 2 - }, - [33338]: { - gl2: true, - bpp: 4 - }, - [33337]: { - gl2: true, - bpp: 4 - }, - [33340]: { - gl2: true, - bpp: 8 - }, - [33339]: { - gl2: true, - bpp: 8 - }, - [32849]: { - gl2: true, - bpp: 3 - }, - [32856]: { - gl2: true, - bpp: 4 - }, - [32857]: { - gl2: true, - bpp: 4 - }, - [36220]: { - gl2: true, - bpp: 4 - }, - [36238]: { - gl2: true, - bpp: 4 - }, - [36975]: { - gl2: true, - bpp: 4 - }, - [36214]: { - gl2: true, - bpp: 8 - }, - [36232]: { - gl2: true, - bpp: 8 - }, - [36226]: { - gl2: true, - bpp: 16 - }, - [36208]: { - gl2: true, - bpp: 16 - }, - [33325]: { - gl2: EXT_FLOAT_WEBGL2, - bpp: 2 - }, - [33327]: { - gl2: EXT_FLOAT_WEBGL2, - bpp: 4 - }, - [34842]: { - gl2: EXT_FLOAT_WEBGL2, - bpp: 8 - }, - [33326]: { - gl2: EXT_FLOAT_WEBGL2, - bpp: 4 - }, - [33328]: { - gl2: EXT_FLOAT_WEBGL2, - bpp: 8 - }, - [34836]: { - gl2: EXT_FLOAT_WEBGL2, - bpp: 16 - }, - [35898]: { - gl2: EXT_FLOAT_WEBGL2, - bpp: 4 + get y() { + return this[1]; } - }; - - // node_modules/@luma.gl/webgl/dist/esm/classes/renderbuffer.js - function isFormatSupported2(gl, format, formats) { - const info = formats[format]; - if (!info) { - return false; + set y(value) { + this[1] = checkNumber(value); } - const value = isWebGL2(gl) ? info.gl2 || info.gl1 : info.gl1; - if (typeof value === "string") { - return gl.getExtension(value); + get z() { + return this[2]; } - return value; - } - var Renderbuffer = class extends Resource { - get [Symbol.toStringTag]() { - return "Renderbuffer"; + set z(value) { + this[2] = checkNumber(value); } - static isSupported(gl) { - let { - format - } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : { - format: null - }; - return !format || isFormatSupported2(gl, format, renderbuffer_formats_default); + get w() { + return this[3]; } - static getSamplesForFormat(gl, _ref) { - let { - format - } = _ref; - return gl.getInternalformatParameter(36161, format, 32937); + set w(value) { + this[3] = checkNumber(value); } - constructor(gl) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - super(gl, opts); - this.initialize(opts); - Object.seal(this); + len() { + return length3(this); } - initialize(_ref2) { - let { - format, - width = 1, - height = 1, - samples = 0 - } = _ref2; - assert6(format, "Needs format"); - this._trackDeallocatedMemory(); - this.gl.bindRenderbuffer(36161, this.handle); - if (samples !== 0 && isWebGL2(this.gl)) { - this.gl.renderbufferStorageMultisample(36161, samples, format, width, height); - } else { - this.gl.renderbufferStorage(36161, format, width, height); - } - this.format = format; - this.width = width; - this.height = height; - this.samples = samples; - this._trackAllocatedMemory(this.width * this.height * (this.samples || 1) * renderbuffer_formats_default[this.format].bpp); - return this; + lengthSquared() { + return squaredLength3(this); } - resize(_ref3) { - let { - width, - height - } = _ref3; - if (width !== this.width || height !== this.height) { - return this.initialize({ - width, - height, - format: this.format, - samples: this.samples - }); - } - return this; + dot(a2) { + return dot3(this, a2); } - _createHandle() { - return this.gl.createRenderbuffer(); + rotationTo(vectorA, vectorB) { + rotationTo(this, vectorA, vectorB); + return this.check(); } - _deleteHandle() { - this.gl.deleteRenderbuffer(this.handle); - this._trackDeallocatedMemory(); + add(a2) { + add3(this, this, a2); + return this.check(); } - _bindHandle(handle) { - this.gl.bindRenderbuffer(36161, handle); + calculateW() { + calculateW(this, this); + return this.check(); } - _syncHandle(handle) { - this.format = this.getParameter(36164); - this.width = this.getParameter(36162); - this.height = this.getParameter(36163); - this.samples = this.getParameter(36011); + conjugate() { + conjugate(this, this); + return this.check(); + } + invert() { + invert3(this, this); + return this.check(); + } + lerp(a2, b2, t2) { + if (t2 === void 0) { + return this.lerp(this, a2, b2); + } + lerp5(this, a2, b2, t2); + return this.check(); } - _getParameter(pname) { - this.gl.bindRenderbuffer(36161, this.handle); - const value = this.gl.getRenderbufferParameter(36161, pname); - return value; + multiplyRight(a2) { + multiply3(this, this, a2); + return this.check(); } - }; - - // node_modules/@luma.gl/webgl/dist/esm/classes/clear.js - var GL_DEPTH_BUFFER_BIT = 256; - var GL_STENCIL_BUFFER_BIT = 1024; - var GL_COLOR_BUFFER_BIT = 16384; - var GL_COLOR = 6144; - var GL_DEPTH = 6145; - var GL_STENCIL = 6146; - var GL_DEPTH_STENCIL = 34041; - var ERR_ARGUMENTS = "clear: bad arguments"; - function clear(gl) { - let { - framebuffer = null, - color = null, - depth = null, - stencil = null - } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const parameters = {}; - if (framebuffer) { - parameters.framebuffer = framebuffer; + multiplyLeft(a2) { + multiply3(this, a2, this); + return this.check(); } - let clearFlags = 0; - if (color) { - clearFlags |= GL_COLOR_BUFFER_BIT; - if (color !== true) { - parameters.clearColor = color; + normalize() { + const length4 = this.len(); + const l2 = length4 > 0 ? 1 / length4 : 0; + this[0] = this[0] * l2; + this[1] = this[1] * l2; + this[2] = this[2] * l2; + this[3] = this[3] * l2; + if (length4 === 0) { + this[3] = 1; } + return this.check(); } - if (depth) { - clearFlags |= GL_DEPTH_BUFFER_BIT; - if (depth !== true) { - parameters.clearDepth = depth; - } + rotateX(rad) { + rotateX3(this, this, rad); + return this.check(); } - if (stencil) { - clearFlags |= GL_STENCIL_BUFFER_BIT; - if (depth !== true) { - parameters.clearStencil = depth; - } + rotateY(rad) { + rotateY3(this, this, rad); + return this.check(); } - assert6(clearFlags !== 0, ERR_ARGUMENTS); - withParameters(gl, parameters, () => { - gl.clear(clearFlags); - }); - } - function clearBuffer(gl) { - let { - framebuffer = null, - buffer = GL_COLOR, - drawBuffer = 0, - value = [0, 0, 0, 0] - } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - assertWebGL2Context(gl); - withParameters(gl, { - framebuffer - }, () => { - switch (buffer) { - case GL_COLOR: - switch (value.constructor) { - case Int32Array: - gl.clearBufferiv(buffer, drawBuffer, value); - break; - case Uint32Array: - gl.clearBufferuiv(buffer, drawBuffer, value); - break; - case Float32Array: - default: - gl.clearBufferfv(buffer, drawBuffer, value); - } - break; - case GL_DEPTH: - gl.clearBufferfv(GL_DEPTH, 0, [value]); - break; - case GL_STENCIL: - gl.clearBufferiv(GL_STENCIL, 0, [value]); + rotateZ(rad) { + rotateZ3(this, this, rad); + return this.check(); + } + scale(b2) { + scale4(this, this, b2); + return this.check(); + } + slerp(arg0, arg1, arg2) { + let start; + let target; + let ratio; + switch (arguments.length) { + case 1: + ({ + start = IDENTITY_QUATERNION, + target, + ratio + } = arg0); break; - case GL_DEPTH_STENCIL: - const [depth, stencil] = value; - gl.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil); + case 2: + start = this; + target = arg0; + ratio = arg1; break; default: - assert6(false, ERR_ARGUMENTS); + start = arg0; + target = arg1; + ratio = arg2; } - }); - } - - // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/format-utils.js - function glFormatToComponents(format) { - switch (format) { - case 6406: - case 33326: - case 6403: - return 1; - case 33328: - case 33319: - return 2; - case 6407: - case 34837: - return 3; - case 6408: - case 34836: - return 4; - default: - assert6(false); - return 0; + slerp(this, start, target, ratio); + return this.check(); } - } - - // node_modules/@luma.gl/webgl/dist/esm/classes/copy-and-blit.js - function readPixelsToArray(source) { - let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const { - sourceX = 0, - sourceY = 0, - sourceFormat = 6408 - } = options; - let { - sourceAttachment = 36064, - target = null, - sourceWidth, - sourceHeight, - sourceType - } = options; - const { - framebuffer, - deleteFramebuffer - } = getFramebuffer(source); - assert6(framebuffer); - const { - gl, - handle, - attachments - } = framebuffer; - sourceWidth = sourceWidth || framebuffer.width; - sourceHeight = sourceHeight || framebuffer.height; - if (sourceAttachment === 36064 && handle === null) { - sourceAttachment = 1028; + transformVector4(vector, result = new Vector4()) { + transformQuat2(result, vector, this); + return checkVector(result, 4); } - assert6(attachments[sourceAttachment]); - sourceType = sourceType || attachments[sourceAttachment].type; - target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight); - sourceType = sourceType || getGLTypeFromTypedArray(target); - const prevHandle = gl.bindFramebuffer(36160, handle); - gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target); - gl.bindFramebuffer(36160, prevHandle || null); - if (deleteFramebuffer) { - framebuffer.delete(); + lengthSq() { + return this.lengthSquared(); } - return target; - } - function copyToDataUrl(source) { - let { - sourceAttachment = 36064, - targetMaxHeight = Number.MAX_SAFE_INTEGER - } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - let data = readPixelsToArray(source, { - sourceAttachment - }); - let { - width, - height - } = source; - while (height > targetMaxHeight) { - ({ - data, - width, - height - } = scalePixels2({ - data, - width, - height - })); + setFromAxisAngle(axis, rad) { + return this.setAxisAngle(axis, rad); } - flipRows({ - data, - width, - height - }); - const canvas = document.createElement("canvas"); - canvas.width = width; - canvas.height = height; - const context = canvas.getContext("2d"); - const imageData = context.createImageData(width, height); - imageData.data.set(data); - context.putImageData(imageData, 0, 0); - return canvas.toDataURL(); - } - function getFramebuffer(source) { - if (!(source instanceof Framebuffer)) { - return { - framebuffer: toFramebuffer(source), - deleteFramebuffer: true - }; + premultiply(a2) { + return this.multiplyLeft(a2); } - return { - framebuffer: source, - deleteFramebuffer: false - }; - } - function getPixelArray(pixelArray, type, format, width, height) { - if (pixelArray) { - return pixelArray; + multiply(a2) { + return this.multiplyRight(a2); } - type = type || 5121; - const ArrayType = getTypedArrayFromGLType(type, { - clamped: false - }); - const components = glFormatToComponents(format); - return new ArrayType(width * height * components); - } - - // node_modules/@luma.gl/webgl/dist/esm/features/webgl-features-table.js - var FEATURES = { - WEBGL2: "WEBGL2", - VERTEX_ARRAY_OBJECT: "VERTEX_ARRAY_OBJECT", - TIMER_QUERY: "TIMER_QUERY", - INSTANCED_RENDERING: "INSTANCED_RENDERING", - MULTIPLE_RENDER_TARGETS: "MULTIPLE_RENDER_TARGETS", - ELEMENT_INDEX_UINT32: "ELEMENT_INDEX_UINT32", - BLEND_EQUATION_MINMAX: "BLEND_EQUATION_MINMAX", - FLOAT_BLEND: "FLOAT_BLEND", - COLOR_ENCODING_SRGB: "COLOR_ENCODING_SRGB", - TEXTURE_DEPTH: "TEXTURE_DEPTH", - TEXTURE_FLOAT: "TEXTURE_FLOAT", - TEXTURE_HALF_FLOAT: "TEXTURE_HALF_FLOAT", - TEXTURE_FILTER_LINEAR_FLOAT: "TEXTURE_FILTER_LINEAR_FLOAT", - TEXTURE_FILTER_LINEAR_HALF_FLOAT: "TEXTURE_FILTER_LINEAR_HALF_FLOAT", - TEXTURE_FILTER_ANISOTROPIC: "TEXTURE_FILTER_ANISOTROPIC", - COLOR_ATTACHMENT_RGBA32F: "COLOR_ATTACHMENT_RGBA32F", - COLOR_ATTACHMENT_FLOAT: "COLOR_ATTACHMENT_FLOAT", - COLOR_ATTACHMENT_HALF_FLOAT: "COLOR_ATTACHMENT_HALF_FLOAT", - GLSL_FRAG_DATA: "GLSL_FRAG_DATA", - GLSL_FRAG_DEPTH: "GLSL_FRAG_DEPTH", - GLSL_DERIVATIVES: "GLSL_DERIVATIVES", - GLSL_TEXTURE_LOD: "GLSL_TEXTURE_LOD" }; - function checkFloat32ColorAttachment(gl) { - const testTexture = new Texture2D(gl, { - format: 6408, - type: 5126, - dataFormat: 6408 - }); - const testFb = new Framebuffer(gl, { - id: "test-framebuffer", - check: false, - attachments: { - [36064]: testTexture - } - }); - const status = testFb.getStatus(); - testTexture.delete(); - testFb.delete(); - return status === 36053; - } - var webgl_features_table_default = { - [FEATURES.WEBGL2]: [false, true], - [FEATURES.VERTEX_ARRAY_OBJECT]: ["OES_vertex_array_object", true], - [FEATURES.TIMER_QUERY]: ["EXT_disjoint_timer_query", "EXT_disjoint_timer_query_webgl2"], - [FEATURES.INSTANCED_RENDERING]: ["ANGLE_instanced_arrays", true], - [FEATURES.MULTIPLE_RENDER_TARGETS]: ["WEBGL_draw_buffers", true], - [FEATURES.ELEMENT_INDEX_UINT32]: ["OES_element_index_uint", true], - [FEATURES.BLEND_EQUATION_MINMAX]: ["EXT_blend_minmax", true], - [FEATURES.FLOAT_BLEND]: ["EXT_float_blend"], - [FEATURES.COLOR_ENCODING_SRGB]: ["EXT_sRGB", true], - [FEATURES.TEXTURE_DEPTH]: ["WEBGL_depth_texture", true], - [FEATURES.TEXTURE_FLOAT]: ["OES_texture_float", true], - [FEATURES.TEXTURE_HALF_FLOAT]: ["OES_texture_half_float", true], - [FEATURES.TEXTURE_FILTER_LINEAR_FLOAT]: ["OES_texture_float_linear"], - [FEATURES.TEXTURE_FILTER_LINEAR_HALF_FLOAT]: ["OES_texture_half_float_linear"], - [FEATURES.TEXTURE_FILTER_ANISOTROPIC]: ["EXT_texture_filter_anisotropic"], - [FEATURES.COLOR_ATTACHMENT_RGBA32F]: [checkFloat32ColorAttachment, "EXT_color_buffer_float"], - [FEATURES.COLOR_ATTACHMENT_FLOAT]: [false, "EXT_color_buffer_float"], - [FEATURES.COLOR_ATTACHMENT_HALF_FLOAT]: ["EXT_color_buffer_half_float"], - [FEATURES.GLSL_FRAG_DATA]: ["WEBGL_draw_buffers", true], - [FEATURES.GLSL_FRAG_DEPTH]: ["EXT_frag_depth", true], - [FEATURES.GLSL_DERIVATIVES]: ["OES_standard_derivatives", true], - [FEATURES.GLSL_TEXTURE_LOD]: ["EXT_shader_texture_lod", true] + + // node_modules/@math.gl/core/dist/esm/lib/math-utils.js + var math_utils_default = { + EPSILON1: 0.1, + EPSILON2: 0.01, + EPSILON3: 1e-3, + EPSILON4: 1e-4, + EPSILON5: 1e-5, + EPSILON6: 1e-6, + EPSILON7: 1e-7, + EPSILON8: 1e-8, + EPSILON9: 1e-9, + EPSILON10: 1e-10, + EPSILON11: 1e-11, + EPSILON12: 1e-12, + EPSILON13: 1e-13, + EPSILON14: 1e-14, + EPSILON15: 1e-15, + EPSILON16: 1e-16, + EPSILON17: 1e-17, + EPSILON18: 1e-18, + EPSILON19: 1e-19, + EPSILON20: 1e-20, + PI_OVER_TWO: Math.PI / 2, + PI_OVER_FOUR: Math.PI / 4, + PI_OVER_SIX: Math.PI / 6, + TWO_PI: Math.PI * 2 }; - // node_modules/@luma.gl/webgl/dist/esm/features/features.js - var LOG_UNSUPPORTED_FEATURE = 2; - function hasFeature(gl, feature) { - return hasFeatures(gl, feature); + // node_modules/@luma.gl/shadertools/dist/esm/modules/lights/lights.glsl.js + var lights_glsl_default = "#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\n\nstruct AmbientLight {\n vec3 color;\n};\n\nstruct PointLight {\n vec3 color;\n vec3 position;\n vec3 attenuation;\n};\n\nstruct DirectionalLight {\n vec3 color;\n vec3 direction;\n};\n\nuniform AmbientLight lighting_uAmbientLight;\nuniform PointLight lighting_uPointLight[MAX_LIGHTS];\nuniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];\nuniform int lighting_uPointLightCount;\nuniform int lighting_uDirectionalLightCount;\n\nuniform bool lighting_uEnabled;\n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n return pointLight.attenuation.x\n + pointLight.attenuation.y * distance\n + pointLight.attenuation.z * distance * distance;\n}\n\n#endif\n"; + + // node_modules/@luma.gl/shadertools/dist/esm/modules/lights/lights.js + var INITIAL_MODULE_OPTIONS = { + lightSources: {} + }; + function convertColor() { + let { + color = [0, 0, 0], + intensity = 1 + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + return color.map((component) => component * intensity / 255); } - function hasFeatures(gl, features) { - features = Array.isArray(features) ? features : [features]; - return features.every((feature) => { - return isFeatureSupported(gl, feature); + function getLightSourceUniforms(_ref) { + let { + ambientLight, + pointLights = [], + directionalLights = [] + } = _ref; + const lightSourceUniforms = {}; + if (ambientLight) { + lightSourceUniforms["lighting_uAmbientLight.color"] = convertColor(ambientLight); + } else { + lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0]; + } + pointLights.forEach((pointLight, index) => { + lightSourceUniforms["lighting_uPointLight[".concat(index, "].color")] = convertColor(pointLight); + lightSourceUniforms["lighting_uPointLight[".concat(index, "].position")] = pointLight.position; + lightSourceUniforms["lighting_uPointLight[".concat(index, "].attenuation")] = pointLight.attenuation || [1, 0, 0]; + }); + lightSourceUniforms.lighting_uPointLightCount = pointLights.length; + directionalLights.forEach((directionalLight, index) => { + lightSourceUniforms["lighting_uDirectionalLight[".concat(index, "].color")] = convertColor(directionalLight); + lightSourceUniforms["lighting_uDirectionalLight[".concat(index, "].direction")] = directionalLight.direction; }); + lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length; + return lightSourceUniforms; } - function getFeatures(gl) { - gl.luma = gl.luma || {}; - gl.luma.caps = gl.luma.caps || {}; - for (const cap in webgl_features_table_default) { - if (gl.luma.caps[cap] === void 0) { - gl.luma.caps[cap] = isFeatureSupported(gl, cap); + function getUniforms() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : INITIAL_MODULE_OPTIONS; + if ("lightSources" in opts) { + const { + ambientLight, + pointLights, + directionalLights + } = opts.lightSources || {}; + const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0; + if (!hasLights) { + return { + lighting_uEnabled: false + }; } + return Object.assign({}, getLightSourceUniforms({ + ambientLight, + pointLights, + directionalLights + }), { + lighting_uEnabled: true + }); } - return gl.luma.caps; - } - function isFeatureSupported(gl, cap) { - gl.luma = gl.luma || {}; - gl.luma.caps = gl.luma.caps || {}; - if (gl.luma.caps[cap] === void 0) { - gl.luma.caps[cap] = queryFeature(gl, cap); - } - if (!gl.luma.caps[cap]) { - log2.log(LOG_UNSUPPORTED_FEATURE, "Feature: ".concat(cap, " not supported"))(); - } - return gl.luma.caps[cap]; - } - function queryFeature(gl, cap) { - const feature = webgl_features_table_default[cap]; - assert6(feature, cap); - let isSupported; - const featureDefinition = isWebGL2(gl) ? feature[1] || feature[0] : feature[0]; - if (typeof featureDefinition === "function") { - isSupported = featureDefinition(gl); - } else if (Array.isArray(featureDefinition)) { - isSupported = true; - for (const extension of featureDefinition) { - isSupported = isSupported && Boolean(gl.getExtension(extension)); + if ("lights" in opts) { + const lightSources = { + pointLights: [], + directionalLights: [] + }; + for (const light of opts.lights || []) { + switch (light.type) { + case "ambient": + lightSources.ambientLight = light; + break; + case "directional": + lightSources.directionalLights.push(light); + break; + case "point": + lightSources.pointLights.push(light); + break; + default: + } } - } else if (typeof featureDefinition === "string") { - isSupported = Boolean(gl.getExtension(featureDefinition)); - } else if (typeof featureDefinition === "boolean") { - isSupported = featureDefinition; - } else { - assert6(false); + return getUniforms({ + lightSources + }); } - return isSupported; + return {}; } - - // node_modules/@luma.gl/webgl/dist/esm/classes/framebuffer.js - var ERR_MULTIPLE_RENDERTARGETS = "Multiple render targets not supported"; - var Framebuffer = class _Framebuffer extends Resource { - get [Symbol.toStringTag]() { - return "Framebuffer"; + var lights = { + name: "lights", + vs: lights_glsl_default, + fs: lights_glsl_default, + getUniforms, + defines: { + MAX_LIGHTS: 3 } - static isSupported(gl) { - let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const { - colorBufferFloat, - colorBufferHalfFloat - } = options; - let supported = true; - if (colorBufferFloat) { - supported = Boolean(gl.getExtension("EXT_color_buffer_float") || gl.getExtension("WEBGL_color_buffer_float") || gl.getExtension("OES_texture_float")); - } - if (colorBufferHalfFloat) { - supported = supported && Boolean(gl.getExtension("EXT_color_buffer_float") || gl.getExtension("EXT_color_buffer_half_float")); + }; + + // node_modules/@luma.gl/shadertools/dist/esm/modules/picking/picking.js + var DEFAULT_HIGHLIGHT_COLOR = new Uint8Array([0, 255, 255, 255]); + var DEFAULT_MODULE_OPTIONS = { + pickingSelectedColor: null, + pickingHighlightColor: DEFAULT_HIGHLIGHT_COLOR, + pickingActive: false, + pickingAttribute: false + }; + function getUniforms2() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_MODULE_OPTIONS; + const uniforms = {}; + if (opts.pickingSelectedColor !== void 0) { + if (!opts.pickingSelectedColor) { + uniforms.picking_uSelectedColorValid = 0; + } else { + const selectedColor = opts.pickingSelectedColor.slice(0, 3); + uniforms.picking_uSelectedColorValid = 1; + uniforms.picking_uSelectedColor = selectedColor; } - return supported; - } - static getDefaultFramebuffer(gl) { - gl.luma = gl.luma || {}; - gl.luma.defaultFramebuffer = gl.luma.defaultFramebuffer || new _Framebuffer(gl, { - id: "default-framebuffer", - handle: null, - attachments: {} - }); - return gl.luma.defaultFramebuffer; } - get MAX_COLOR_ATTACHMENTS() { - const gl2 = assertWebGL2Context(this.gl); - return gl2.getParameter(gl2.MAX_COLOR_ATTACHMENTS); - } - get MAX_DRAW_BUFFERS() { - const gl2 = assertWebGL2Context(this.gl); - return gl2.getParameter(gl2.MAX_DRAW_BUFFERS); + if (opts.pickingHighlightColor) { + const color = Array.from(opts.pickingHighlightColor, (x2) => x2 / 255); + if (!Number.isFinite(color[3])) { + color[3] = 1; + } + uniforms.picking_uHighlightColor = color; } - constructor(gl) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - super(gl, opts); - this.width = null; - this.height = null; - this.attachments = {}; - this.readBuffer = 36064; - this.drawBuffers = [36064]; - this.ownResources = []; - this.initialize(opts); - Object.seal(this); + if (opts.pickingActive !== void 0) { + uniforms.picking_uActive = Boolean(opts.pickingActive); + uniforms.picking_uAttribute = Boolean(opts.pickingAttribute); } - get color() { - return this.attachments[36064] || null; + return uniforms; + } + var vs = "uniform bool picking_uActive;\nuniform bool picking_uAttribute;\nuniform vec3 picking_uSelectedColor;\nuniform bool picking_uSelectedColorValid;\n\nout vec4 picking_vRGBcolor_Avalid;\n\nconst float COLOR_SCALE = 1. / 255.;\n\nbool picking_isColorValid(vec3 color) {\n return dot(color, vec3(1.0)) > 0.001;\n}\n\nbool isVertexPicked(vec3 vertexColor) {\n return\n picking_uSelectedColorValid &&\n !picking_isColorValid(abs(vertexColor - picking_uSelectedColor));\n}\n\nvoid picking_setPickingColor(vec3 pickingColor) {\n if (picking_uActive) {\n picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));\n\n if (!picking_uAttribute) {\n picking_vRGBcolor_Avalid.rgb = pickingColor * COLOR_SCALE;\n }\n } else {\n picking_vRGBcolor_Avalid.a = float(isVertexPicked(pickingColor));\n }\n}\n\nvoid picking_setPickingAttribute(float value) {\n if (picking_uAttribute) {\n picking_vRGBcolor_Avalid.r = value;\n }\n}\nvoid picking_setPickingAttribute(vec2 value) {\n if (picking_uAttribute) {\n picking_vRGBcolor_Avalid.rg = value;\n }\n}\nvoid picking_setPickingAttribute(vec3 value) {\n if (picking_uAttribute) {\n picking_vRGBcolor_Avalid.rgb = value;\n }\n}\n"; + var fs = "uniform bool picking_uActive;\nuniform vec3 picking_uSelectedColor;\nuniform vec4 picking_uHighlightColor;\n\nin vec4 picking_vRGBcolor_Avalid;\nvec4 picking_filterHighlightColor(vec4 color) {\n if (picking_uActive) {\n return color;\n }\n bool selected = bool(picking_vRGBcolor_Avalid.a);\n\n if (selected) {\n float highLightAlpha = picking_uHighlightColor.a;\n float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n float highLightRatio = highLightAlpha / blendedAlpha;\n\n vec3 blendedRGB = mix(color.rgb, picking_uHighlightColor.rgb, highLightRatio);\n return vec4(blendedRGB, blendedAlpha);\n } else {\n return color;\n }\n}\nvec4 picking_filterPickingColor(vec4 color) {\n if (picking_uActive) {\n if (picking_vRGBcolor_Avalid.a == 0.0) {\n discard;\n }\n return picking_vRGBcolor_Avalid;\n }\n return color;\n}\nvec4 picking_filterColor(vec4 color) {\n vec4 highightColor = picking_filterHighlightColor(color);\n return picking_filterPickingColor(highightColor);\n}\n\n"; + var picking = { + name: "picking", + vs, + fs, + getUniforms: getUniforms2 + }; + + // node_modules/@luma.gl/shadertools/dist/esm/modules/phong-lighting/phong-lighting.glsl.js + var phong_lighting_glsl_default = "\nuniform float lighting_uAmbient;\nuniform float lighting_uDiffuse;\nuniform float lighting_uShininess;\nuniform vec3 lighting_uSpecularColor;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n vec3 halfway_direction = normalize(light_direction + view_direction);\n float lambertian = dot(light_direction, normal_worldspace);\n float specular = 0.0;\n if (lambertian > 0.0) {\n float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n specular = pow(specular_angle, lighting_uShininess);\n }\n lambertian = max(lambertian, 0.0);\n return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n vec3 lightColor = surfaceColor;\n\n if (lighting_uEnabled) {\n vec3 view_direction = normalize(cameraPosition - position_worldspace);\n lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;\n\n for (int i = 0; i < MAX_LIGHTS; i++) {\n if (i >= lighting_uPointLightCount) {\n break;\n }\n PointLight pointLight = lighting_uPointLight[i];\n vec3 light_position_worldspace = pointLight.position;\n vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n }\n\n for (int i = 0; i < MAX_LIGHTS; i++) {\n if (i >= lighting_uDirectionalLightCount) {\n break;\n }\n DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n }\n }\n return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n vec3 lightColor = vec3(0, 0, 0);\n vec3 surfaceColor = vec3(0, 0, 0);\n\n if (lighting_uEnabled) {\n vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n for (int i = 0; i < MAX_LIGHTS; i++) {\n if (i >= lighting_uPointLightCount) {\n break;\n }\n PointLight pointLight = lighting_uPointLight[i];\n vec3 light_position_worldspace = pointLight.position;\n vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n }\n\n for (int i = 0; i < MAX_LIGHTS; i++) {\n if (i >= lighting_uDirectionalLightCount) {\n break;\n }\n DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n }\n }\n return lightColor;\n}\n"; + + // node_modules/@luma.gl/shadertools/dist/esm/modules/phong-lighting/phong-lighting.js + var INITIAL_MODULE_OPTIONS2 = {}; + function getMaterialUniforms(material) { + const { + ambient = 0.35, + diffuse = 0.6, + shininess = 32, + specularColor = [30, 30, 30] + } = material; + return { + lighting_uAmbient: ambient, + lighting_uDiffuse: diffuse, + lighting_uShininess: shininess, + lighting_uSpecularColor: specularColor.map((x2) => x2 / 255) + }; + } + function getUniforms3() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : INITIAL_MODULE_OPTIONS2; + if (!("material" in opts)) { + return {}; } - get texture() { - return this.attachments[36064] || null; + const { + material + } = opts; + if (!material) { + return { + lighting_uEnabled: false + }; } - get depth() { - return this.attachments[36096] || this.attachments[33306] || null; + return getMaterialUniforms(material); + } + var gouraudLighting = { + name: "gouraud-lighting", + dependencies: [lights], + vs: phong_lighting_glsl_default, + defines: { + LIGHTING_VERTEX: 1 + }, + getUniforms: getUniforms3 + }; + + // node_modules/@luma.gl/shadertools/dist/esm/modules/transform/transform.js + var vs2 = "attribute float transform_elementID;\nvec2 transform_getPixelSizeHalf(vec2 size) {\n return vec2(1.) / (2. * size);\n}\n\nvec2 transform_getPixelIndices(vec2 texSize, vec2 pixelSizeHalf) {\n float yIndex = floor((transform_elementID / texSize[0]) + pixelSizeHalf[1]);\n float xIndex = transform_elementID - (yIndex * texSize[0]);\n return vec2(xIndex, yIndex);\n}\nvec2 transform_getTexCoord(vec2 size) {\n vec2 pixelSizeHalf = transform_getPixelSizeHalf(size);\n vec2 indices = transform_getPixelIndices(size, pixelSizeHalf);\n vec2 coord = indices / size + pixelSizeHalf;\n return coord;\n}\nvec2 transform_getPos(vec2 size) {\n vec2 texCoord = transform_getTexCoord(size);\n vec2 pos = (texCoord * (2.0, 2.0)) - (1., 1.);\n return pos;\n}\nvec4 transform_getInput(sampler2D texSampler, vec2 size) {\n vec2 texCoord = transform_getTexCoord(size);\n vec4 textureColor = texture2D(texSampler, texCoord);\n return textureColor;\n}\n"; + var transform = { + name: "transform", + vs: vs2, + fs: null + }; + + // node_modules/@luma.gl/engine/dist/esm/lib/program-manager.js + var ProgramManager = class _ProgramManager { + static getDefaultProgramManager(gl) { + gl.luma = gl.luma || {}; + gl.luma.defaultProgramManager = gl.luma.defaultProgramManager || new _ProgramManager(gl); + return gl.luma.defaultProgramManager; } - get stencil() { - return this.attachments[36128] || this.attachments[33306] || null; + constructor(gl) { + this.gl = gl; + this._programCache = {}; + this._getUniforms = {}; + this._registeredModules = {}; + this._hookFunctions = []; + this._defaultModules = []; + this._hashes = {}; + this._hashCounter = 0; + this.stateHash = 0; + this._useCounts = {}; } - initialize(_ref) { - let { - width = 1, - height = 1, - attachments = null, - color = true, - depth = true, - stencil = false, - check = true, - readBuffer = void 0, - drawBuffers = void 0 - } = _ref; - assert6(width >= 0 && height >= 0, "Width and height need to be integers"); - this.width = width; - this.height = height; - if (attachments) { - for (const attachment in attachments) { - const target = attachments[attachment]; - const object = Array.isArray(target) ? target[0] : target; - object.resize({ - width, - height - }); - } - } else { - attachments = this._createDefaultAttachments(color, depth, stencil, width, height); - } - this.update({ - clearAttachments: true, - attachments, - readBuffer, - drawBuffers - }); - if (attachments && check) { - this.checkStatus(); + addDefaultModule(module) { + if (!this._defaultModules.find((m) => m.name === module.name)) { + this._defaultModules.push(module); } + this.stateHash++; } - delete() { - for (const resource of this.ownResources) { - resource.delete(); - } - super.delete(); - return this; + removeDefaultModule(module) { + const moduleName = typeof module === "string" ? module : module.name; + this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName); + this.stateHash++; } - update(_ref2) { - let { - attachments = {}, - readBuffer, - drawBuffers, - clearAttachments = false, - resizeAttachments = true - } = _ref2; - this.attach(attachments, { - clearAttachments, - resizeAttachments - }); - const { - gl - } = this; - const prevHandle = gl.bindFramebuffer(36160, this.handle); - if (readBuffer) { - this._setReadBuffer(readBuffer); - } - if (drawBuffers) { - this._setDrawBuffers(drawBuffers); + addShaderHook(hook, opts) { + if (opts) { + hook = Object.assign(opts, { + hook + }); } - gl.bindFramebuffer(36160, prevHandle || null); - return this; + this._hookFunctions.push(hook); + this.stateHash++; } - resize() { - let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - let { - width, - height - } = options; - if (this.handle === null) { - assert6(width === void 0 && height === void 0); - this.width = this.gl.drawingBufferWidth; - this.height = this.gl.drawingBufferHeight; - return this; - } - if (width === void 0) { - width = this.gl.drawingBufferWidth; - } - if (height === void 0) { - height = this.gl.drawingBufferHeight; + get() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + vs: vs8 = "", + fs: fs6 = "", + defines: defines2 = {}, + inject = {}, + varyings = [], + bufferMode = 35981, + transpileToGLSL100 = false + } = props; + const modules = this._getModuleList(props.modules); + const vsHash = this._getHash(vs8); + const fsHash = this._getHash(fs6); + const moduleHashes = modules.map((m) => this._getHash(m.name)).sort(); + const varyingHashes = varyings.map((v2) => this._getHash(v2)); + const defineKeys = Object.keys(defines2).sort(); + const injectKeys = Object.keys(inject).sort(); + const defineHashes = []; + const injectHashes = []; + for (const key of defineKeys) { + defineHashes.push(this._getHash(key)); + defineHashes.push(this._getHash(defines2[key])); } - if (width !== this.width && height !== this.height) { - log2.log(2, "Resizing framebuffer ".concat(this.id, " to ").concat(width, "x").concat(height))(); + for (const key of injectKeys) { + injectHashes.push(this._getHash(key)); + injectHashes.push(this._getHash(inject[key])); } - for (const attachmentPoint in this.attachments) { - this.attachments[attachmentPoint].resize({ - width, - height + const hash = "".concat(vsHash, "/").concat(fsHash, "D").concat(defineHashes.join("/"), "M").concat(moduleHashes.join("/"), "I").concat(injectHashes.join("/"), "V").concat(varyingHashes.join("/"), "H").concat(this.stateHash, "B").concat(bufferMode).concat(transpileToGLSL100 ? "T" : ""); + if (!this._programCache[hash]) { + const assembled = assembleShaders(this.gl, { + vs: vs8, + fs: fs6, + modules, + inject, + defines: defines2, + hookFunctions: this._hookFunctions, + transpileToGLSL100 }); - } - this.width = width; - this.height = height; - return this; - } - attach(attachments) { - let { - clearAttachments = false, - resizeAttachments = true - } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const newAttachments = {}; - if (clearAttachments) { - Object.keys(this.attachments).forEach((key) => { - newAttachments[key] = null; + this._programCache[hash] = new Program(this.gl, { + hash, + vs: assembled.vs, + fs: assembled.fs, + varyings, + bufferMode }); + this._getUniforms[hash] = assembled.getUniforms || ((x2) => { + }); + this._useCounts[hash] = 0; } - Object.assign(newAttachments, attachments); - const prevHandle = this.gl.bindFramebuffer(36160, this.handle); - for (const key in newAttachments) { - assert6(key !== void 0, "Misspelled framebuffer binding point?"); - const attachment = Number(key); - const descriptor = newAttachments[attachment]; - let object = descriptor; - if (!object) { - this._unattach(attachment); - } else if (object instanceof Renderbuffer) { - this._attachRenderbuffer({ - attachment, - renderbuffer: object - }); - } else if (Array.isArray(descriptor)) { - const [texture, layer = 0, level = 0] = descriptor; - object = texture; - this._attachTexture({ - attachment, - texture, - layer, - level - }); - } else { - this._attachTexture({ - attachment, - texture: object, - layer: 0, - level: 0 - }); - } - if (resizeAttachments && object) { - object.resize({ - width: this.width, - height: this.height - }); - } - } - this.gl.bindFramebuffer(36160, prevHandle || null); - Object.assign(this.attachments, attachments); - Object.keys(this.attachments).filter((key) => !this.attachments[key]).forEach((key) => { - delete this.attachments[key]; - }); + this._useCounts[hash]++; + return this._programCache[hash]; } - checkStatus() { - const { - gl - } = this; - const status = this.getStatus(); - if (status !== 36053) { - throw new Error(_getFrameBufferStatus(status)); - } - return this; + getUniforms(program) { + return this._getUniforms[program.hash] || null; } - getStatus() { - const { - gl - } = this; - const prevHandle = gl.bindFramebuffer(36160, this.handle); - const status = gl.checkFramebufferStatus(36160); - gl.bindFramebuffer(36160, prevHandle || null); - return status; + release(program) { + const hash = program.hash; + this._useCounts[hash]--; + if (this._useCounts[hash] === 0) { + this._programCache[hash].delete(); + delete this._programCache[hash]; + delete this._getUniforms[hash]; + delete this._useCounts[hash]; + } } - clear() { - let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - color, - depth, - stencil, - drawBuffers = [] - } = options; - const prevHandle = this.gl.bindFramebuffer(36160, this.handle); - if (color || depth || stencil) { - clear(this.gl, { - color, - depth, - stencil - }); + _getHash(key) { + if (this._hashes[key] === void 0) { + this._hashes[key] = this._hashCounter++; } - drawBuffers.forEach((value, drawBuffer) => { - clearBuffer(this.gl, { - drawBuffer, - value - }); - }); - this.gl.bindFramebuffer(36160, prevHandle || null); - return this; + return this._hashes[key]; } - readPixels() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - log2.error("Framebuffer.readPixels() is no logner supported, use readPixelsToArray(framebuffer)")(); - return null; + _getModuleList() { + let appModules = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []; + const modules = new Array(this._defaultModules.length + appModules.length); + const seen = {}; + let count2 = 0; + for (let i3 = 0, len2 = this._defaultModules.length; i3 < len2; ++i3) { + const module = this._defaultModules[i3]; + const name = module.name; + modules[count2++] = module; + seen[name] = true; + } + for (let i3 = 0, len2 = appModules.length; i3 < len2; ++i3) { + const module = appModules[i3]; + const name = module.name; + if (!seen[name]) { + modules[count2++] = module; + seen[name] = true; + } + } + modules.length = count2; + return modules; } - readPixelsToBuffer() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - log2.error("Framebuffer.readPixelsToBuffer()is no logner supported, use readPixelsToBuffer(framebuffer)")(); - return null; + }; + + // node_modules/@luma.gl/engine/dist/esm/lib/model-utils.js + var GLTF_TO_LUMA_ATTRIBUTE_MAP = { + POSITION: "positions", + NORMAL: "normals", + COLOR_0: "colors", + TEXCOORD_0: "texCoords", + TEXCOORD_1: "texCoords1", + TEXCOORD_2: "texCoords2" + }; + function getBuffersFromGeometry(gl, geometry, options) { + const buffers = {}; + let indices = geometry.indices; + for (const name in geometry.attributes) { + const attribute = geometry.attributes[name]; + const remappedName = mapAttributeName(name, options); + if (name === "indices") { + indices = attribute; + } else if (attribute.constant) { + buffers[remappedName] = attribute.value; + } else { + const typedArray = attribute.value; + const accessor = { + ...attribute + }; + delete accessor.value; + buffers[remappedName] = [new Buffer2(gl, typedArray), accessor]; + inferAttributeAccessor(name, accessor); + } } - copyToDataUrl() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - log2.error("Framebuffer.copyToDataUrl() is no logner supported, use copyToDataUrl(framebuffer)")(); - return null; + if (indices) { + const data = indices.value || indices; + assert6(data instanceof Uint16Array || data instanceof Uint32Array, 'attribute array for "indices" must be of integer type'); + const accessor = { + size: 1, + isIndexed: indices.isIndexed === void 0 ? true : indices.isIndexed + }; + buffers.indices = [new Buffer2(gl, { + data, + target: 34963 + }), accessor]; } - copyToImage() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - log2.error("Framebuffer.copyToImage() is no logner supported, use copyToImage(framebuffer)")(); - return null; + return buffers; + } + function mapAttributeName(name, options) { + const { + attributeMap = GLTF_TO_LUMA_ATTRIBUTE_MAP + } = options || {}; + return attributeMap && attributeMap[name] || name; + } + function inferAttributeAccessor(attributeName, attribute) { + let category; + switch (attributeName) { + case "texCoords": + case "texCoord1": + case "texCoord2": + case "texCoord3": + category = "uvs"; + break; + case "vertices": + case "positions": + case "normals": + case "pickingColors": + category = "vectors"; + break; + default: } - copyToTexture() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - log2.error("Framebuffer.copyToTexture({...}) is no logner supported, use copyToTexture(source, target, opts})")(); - return null; + switch (category) { + case "vectors": + attribute.size = attribute.size || 3; + break; + case "uvs": + attribute.size = attribute.size || 2; + break; + default: } - blit() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - log2.error("Framebuffer.blit({...}) is no logner supported, use blit(source, target, opts)")(); - return null; + assert6(Number.isFinite(attribute.size), "attribute ".concat(attributeName, " needs size")); + } + + // node_modules/@luma.gl/engine/dist/esm/lib/model.js + var LOG_DRAW_PRIORITY = 2; + var LOG_DRAW_TIMEOUT = 1e4; + var ERR_MODEL_PARAMS = "Model needs drawMode and vertexCount"; + var NOOP2 = () => { + }; + var DRAW_PARAMS = {}; + var Model = class { + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + const { + id = uid("model") + } = props; + assert6(isWebGL(gl)); + this.id = id; + this.gl = gl; + this.id = props.id || uid("Model"); + this.lastLogTime = 0; + this.animated = false; + this.initialize(props); } - invalidate(_ref3) { - let { - attachments = [], - x: x2 = 0, - y: y2 = 0, - width, - height - } = _ref3; - const gl2 = assertWebGL2Context(this.gl); - const prevHandle = gl2.bindFramebuffer(36008, this.handle); - const invalidateAll = x2 === 0 && y2 === 0 && width === void 0 && height === void 0; - if (invalidateAll) { - gl2.invalidateFramebuffer(36008, attachments); - } else { - gl2.invalidateFramebuffer(36008, attachments, x2, y2, width, height); - } - gl2.bindFramebuffer(36008, prevHandle); - return this; + initialize(props) { + this.props = {}; + this.programManager = props.programManager || ProgramManager.getDefaultProgramManager(this.gl); + this._programManagerState = -1; + this._managedProgram = false; + const { + program = null, + vs: vs8, + fs: fs6, + modules, + defines: defines2, + inject, + varyings, + bufferMode, + transpileToGLSL100 + } = props; + this.programProps = { + program, + vs: vs8, + fs: fs6, + modules, + defines: defines2, + inject, + varyings, + bufferMode, + transpileToGLSL100 + }; + this.program = null; + this.vertexArray = null; + this._programDirty = true; + this.userData = {}; + this.needsRedraw = true; + this._attributes = {}; + this.attributes = {}; + this.uniforms = {}; + this.pickable = true; + this._checkProgram(); + this.setUniforms(Object.assign({}, this.getModuleUniforms(props.moduleSettings))); + this.drawMode = props.drawMode !== void 0 ? props.drawMode : 4; + this.vertexCount = props.vertexCount || 0; + this.geometryBuffers = {}; + this.isInstanced = props.isInstanced || props.instanced || props.instanceCount > 0; + this._setModelProps(props); + this.geometry = {}; + assert6(this.drawMode !== void 0 && Number.isFinite(this.vertexCount), ERR_MODEL_PARAMS); } - getAttachmentParameter(attachment, pname, keys) { - let value = this._getAttachmentParameterFallback(pname); - if (value === null) { - this.gl.bindFramebuffer(36160, this.handle); - value = this.gl.getFramebufferAttachmentParameter(36160, attachment, pname); - this.gl.bindFramebuffer(36160, null); + setProps(props) { + this._setModelProps(props); + } + delete() { + for (const key in this._attributes) { + if (this._attributes[key] !== this.attributes[key]) { + this._attributes[key].delete(); + } } - if (keys && value > 1e3) { - value = getKey(this.gl, value); + if (this._managedProgram) { + this.programManager.release(this.program); + this._managedProgram = false; } - return value; + this.vertexArray.delete(); + this._deleteGeometryBuffers(); } - getAttachmentParameters() { - let attachment = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 36064; - let keys = arguments.length > 1 ? arguments[1] : void 0; - let parameters = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : this.constructor.ATTACHMENT_PARAMETERS || []; - const values = {}; - for (const pname of parameters) { - const key = keys ? getKey(this.gl, pname) : pname; - values[key] = this.getAttachmentParameter(attachment, pname, keys); - } - return values; + getDrawMode() { + return this.drawMode; } - getParameters() { - let keys = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; - const attachments = Object.keys(this.attachments); - const parameters = {}; - for (const attachmentName of attachments) { - const attachment = Number(attachmentName); - const key = keys ? getKey(this.gl, attachment) : attachment; - parameters[key] = this.getAttachmentParameters(attachment, keys); - } - return parameters; + getVertexCount() { + return this.vertexCount; } - show() { - if (typeof window !== "undefined") { - window.open(copyToDataUrl(this), "luma-debug-texture"); - } + getInstanceCount() { + return this.instanceCount; + } + getAttributes() { + return this.attributes; + } + getProgram() { + return this.program; + } + setProgram(props) { + const { + program, + vs: vs8, + fs: fs6, + modules, + defines: defines2, + inject, + varyings, + bufferMode, + transpileToGLSL100 + } = props; + this.programProps = { + program, + vs: vs8, + fs: fs6, + modules, + defines: defines2, + inject, + varyings, + bufferMode, + transpileToGLSL100 + }; + this._programDirty = true; + } + getUniforms() { + return this.uniforms; + } + setDrawMode(drawMode) { + this.drawMode = drawMode; return this; } - log() { - let logLevel = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0; - let message = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ""; - if (logLevel > log2.level || typeof window === "undefined") { - return this; - } - message = message || "Framebuffer ".concat(this.id); - const image = copyToDataUrl(this, { - targetMaxHeight: 100 - }); - log2.image({ - logLevel, - message, - image - }, message)(); + setVertexCount(vertexCount) { + assert6(Number.isFinite(vertexCount)); + this.vertexCount = vertexCount; return this; } - bind() { - let { - target = 36160 - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this.gl.bindFramebuffer(target, this.handle); + setInstanceCount(instanceCount) { + assert6(Number.isFinite(instanceCount)); + this.instanceCount = instanceCount; return this; } - unbind() { - let { - target = 36160 - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this.gl.bindFramebuffer(target, null); + setGeometry(geometry) { + this.drawMode = geometry.drawMode; + this.vertexCount = geometry.getVertexCount(); + this._deleteGeometryBuffers(); + this.geometryBuffers = getBuffersFromGeometry(this.gl, geometry); + this.vertexArray.setAttributes(this.geometryBuffers); return this; } - _createDefaultAttachments(color, depth, stencil, width, height) { - let defaultAttachments = null; - if (color) { - defaultAttachments = defaultAttachments || {}; - defaultAttachments[36064] = new Texture2D(this.gl, { - id: "".concat(this.id, "-color0"), - pixels: null, - format: 6408, - type: 5121, - width, - height, - mipmaps: false, - parameters: { - [10241]: 9729, - [10240]: 9729, - [10242]: 33071, - [10243]: 33071 - } - }); - this.ownResources.push(defaultAttachments[36064]); + setAttributes() { + let attributes = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (isObjectEmpty2(attributes)) { + return this; } - if (depth && stencil) { - defaultAttachments = defaultAttachments || {}; - defaultAttachments[33306] = new Renderbuffer(this.gl, { - id: "".concat(this.id, "-depth-stencil"), - format: 35056, - width, - height: 111 - }); - this.ownResources.push(defaultAttachments[33306]); - } else if (depth) { - defaultAttachments = defaultAttachments || {}; - defaultAttachments[36096] = new Renderbuffer(this.gl, { - id: "".concat(this.id, "-depth"), - format: 33189, - width, - height - }); - this.ownResources.push(defaultAttachments[36096]); - } else if (stencil) { - assert6(false); + const normalizedAttributes = {}; + for (const name in attributes) { + const attribute = attributes[name]; + normalizedAttributes[name] = attribute.getValue ? attribute.getValue() : attribute; } - return defaultAttachments; + this.vertexArray.setAttributes(normalizedAttributes); + return this; } - _unattach(attachment) { - const oldAttachment = this.attachments[attachment]; - if (!oldAttachment) { - return; - } - if (oldAttachment instanceof Renderbuffer) { - this.gl.framebufferRenderbuffer(36160, attachment, 36161, null); - } else { - this.gl.framebufferTexture2D(36160, attachment, 3553, null, 0); + setUniforms() { + let uniforms = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + Object.assign(this.uniforms, uniforms); + return this; + } + getModuleUniforms(opts) { + this._checkProgram(); + const getUniforms5 = this.programManager.getUniforms(this.program); + if (getUniforms5) { + return getUniforms5(opts); } - delete this.attachments[attachment]; + return {}; } - _attachRenderbuffer(_ref4) { - let { - attachment = 36064, - renderbuffer - } = _ref4; - const { - gl - } = this; - gl.framebufferRenderbuffer(36160, attachment, 36161, renderbuffer.handle); - this.attachments[attachment] = renderbuffer; + updateModuleSettings(opts) { + const uniforms = this.getModuleUniforms(opts || {}); + return this.setUniforms(uniforms); } - _attachTexture(_ref5) { - let { - attachment = 36064, - texture, - layer, - level - } = _ref5; + clear(opts) { + clear(this.program.gl, opts); + return this; + } + draw() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this._checkProgram(); const { - gl - } = this; - gl.bindTexture(texture.target, texture.handle); - switch (texture.target) { - case 35866: - case 32879: - const gl2 = assertWebGL2Context(gl); - gl2.framebufferTextureLayer(36160, attachment, texture.target, level, layer); - break; - case 34067: - const face = mapIndexToCubeMapFace(layer); - gl.framebufferTexture2D(36160, attachment, face, texture.handle, level); - break; - case 3553: - gl.framebufferTexture2D(36160, attachment, 3553, texture.handle, level); - break; - default: - assert6(false, "Illegal texture type"); + moduleSettings = null, + framebuffer, + uniforms = {}, + attributes = {}, + transformFeedback = this.transformFeedback, + parameters = {}, + vertexArray = this.vertexArray + } = opts; + this.setAttributes(attributes); + this.updateModuleSettings(moduleSettings); + this.setUniforms(uniforms); + let logPriority; + if (log2.priority >= LOG_DRAW_PRIORITY) { + logPriority = this._logDrawCallStart(LOG_DRAW_PRIORITY); } - gl.bindTexture(texture.target, null); - this.attachments[attachment] = texture; - } - _setReadBuffer(readBuffer) { - const gl2 = getWebGL2Context(this.gl); - if (gl2) { - gl2.readBuffer(readBuffer); - } else { - assert6(readBuffer === 36064 || readBuffer === 1029, ERR_MULTIPLE_RENDERTARGETS); + const drawParams = this.vertexArray.getDrawParams(); + const { + isIndexed = drawParams.isIndexed, + indexType = drawParams.indexType, + indexOffset = drawParams.indexOffset, + vertexArrayInstanced = drawParams.isInstanced + } = this.props; + if (vertexArrayInstanced && !this.isInstanced) { + log2.warn("Found instanced attributes on non-instanced model", this.id)(); } - this.readBuffer = readBuffer; - } - _setDrawBuffers(drawBuffers) { const { - gl + isInstanced, + instanceCount } = this; - const gl2 = assertWebGL2Context(gl); - if (gl2) { - gl2.drawBuffers(drawBuffers); - } else { - const ext = gl.getExtension("WEBGL_draw_buffers"); - if (ext) { - ext.drawBuffersWEBGL(drawBuffers); - } else { - assert6(drawBuffers.length === 1 && (drawBuffers[0] === 36064 || drawBuffers[0] === 1029), ERR_MULTIPLE_RENDERTARGETS); - } + const { + onBeforeRender = NOOP2, + onAfterRender = NOOP2 + } = this.props; + onBeforeRender(); + this.program.setUniforms(this.uniforms); + const didDraw = this.program.draw(Object.assign(DRAW_PARAMS, opts, { + logPriority, + uniforms: null, + framebuffer, + parameters, + drawMode: this.getDrawMode(), + vertexCount: this.getVertexCount(), + vertexArray, + transformFeedback, + isIndexed, + indexType, + isInstanced, + instanceCount, + offset: isIndexed ? indexOffset : 0 + })); + onAfterRender(); + if (log2.priority >= LOG_DRAW_PRIORITY) { + this._logDrawCallEnd(logPriority, vertexArray, framebuffer); } - this.drawBuffers = drawBuffers; + return didDraw; } - _getAttachmentParameterFallback(pname) { - const caps = getFeatures(this.gl); - switch (pname) { - case 36052: - return !caps.WEBGL2 ? 0 : null; - case 33298: - case 33299: - case 33300: - case 33301: - case 33302: - case 33303: - return !caps.WEBGL2 ? 8 : null; - case 33297: - return !caps.WEBGL2 ? 5125 : null; - case 33296: - return !caps.WEBGL2 && !caps.EXT_sRGB ? 9729 : null; - default: - return null; + transform() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + discard = true, + feedbackBuffers, + unbindModels = [] + } = opts; + let { + parameters + } = opts; + if (feedbackBuffers) { + this._setFeedbackBuffers(feedbackBuffers); } + if (discard) { + parameters = Object.assign({}, parameters, { + [35977]: discard + }); + } + unbindModels.forEach((model) => model.vertexArray.unbindBuffers()); + try { + this.draw(Object.assign({}, opts, { + parameters + })); + } finally { + unbindModels.forEach((model) => model.vertexArray.bindBuffers()); + } + return this; } - _createHandle() { - return this.gl.createFramebuffer(); - } - _deleteHandle() { - this.gl.deleteFramebuffer(this.handle); - } - _bindHandle(handle) { - return this.gl.bindFramebuffer(36160, handle); + render() { + let uniforms = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + log2.warn("Model.render() is deprecated. Use Model.setUniforms() and Model.draw()")(); + return this.setUniforms(uniforms).draw(); } - }; - function mapIndexToCubeMapFace(layer) { - return layer < 34069 ? layer + 34069 : layer; - } - function _getFrameBufferStatus(status) { - const STATUS = Framebuffer.STATUS || {}; - return STATUS[status] || "Framebuffer error ".concat(status); - } - var FRAMEBUFFER_ATTACHMENT_PARAMETERS = [36049, 36048, 33296, 33298, 33299, 33300, 33301, 33302, 33303]; - Framebuffer.ATTACHMENT_PARAMETERS = FRAMEBUFFER_ATTACHMENT_PARAMETERS; - - // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/texture-utils.js - function cloneTextureFrom(refTexture, overrides) { - assert6(refTexture instanceof Texture2D || refTexture instanceof TextureCube || refTexture instanceof Texture3D); - const TextureType = refTexture.constructor; - const { - gl, - width, - height, - format, - type, - dataFormat, - border, - mipmaps - } = refTexture; - const textureOptions = Object.assign({ - width, - height, - format, - type, - dataFormat, - border, - mipmaps - }, overrides); - return new TextureType(gl, textureOptions); - } - function toFramebuffer(texture, opts) { - const { - gl, - width, - height, - id - } = texture; - const framebuffer = new Framebuffer(gl, Object.assign({}, opts, { - id: "framebuffer-for-".concat(id), - width, - height, - attachments: { - [36064]: texture + _setModelProps(props) { + Object.assign(this.props, props); + if ("uniforms" in props) { + this.setUniforms(props.uniforms); + } + if ("pickable" in props) { + this.pickable = props.pickable; + } + if ("instanceCount" in props) { + this.instanceCount = props.instanceCount; + } + if ("geometry" in props) { + this.setGeometry(props.geometry); + } + if ("attributes" in props) { + this.setAttributes(props.attributes); + } + if ("_feedbackBuffers" in props) { + this._setFeedbackBuffers(props._feedbackBuffers); } - })); - return framebuffer; - } - - // node_modules/@luma.gl/webgl/dist/esm/glsl-utils/get-shader-name.js - function getShaderName(shader) { - let defaultName = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "unnamed"; - const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/; - const match = shader.match(SHADER_NAME_REGEXP); - return match ? match[1] : defaultName; - } - - // node_modules/@luma.gl/webgl/dist/esm/glsl-utils/get-shader-type-name.js - var GL_FRAGMENT_SHADER = 35632; - var GL_VERTEX_SHADER = 35633; - function getShaderTypeName(type) { - switch (type) { - case GL_FRAGMENT_SHADER: - return "fragment"; - case GL_VERTEX_SHADER: - return "vertex"; - default: - return "unknown type"; } - } - - // node_modules/@luma.gl/webgl/dist/esm/glsl-utils/format-glsl-error.js - function parseGLSLCompilerError(errLog, src, shaderType, shaderName) { - const errorStrings = errLog.split(/\r?\n/); - const errors = {}; - const warnings = {}; - const name = shaderName || getShaderName(src) || "(unnamed)"; - const shaderDescription = "".concat(getShaderTypeName(shaderType), " shader ").concat(name); - for (let i2 = 0; i2 < errorStrings.length; i2++) { - const errorString = errorStrings[i2]; - if (errorString.length <= 1) { - continue; + _checkProgram() { + const needsUpdate = this._programDirty || this.programManager.stateHash !== this._programManagerState; + if (!needsUpdate) { + return; } - const segments = errorString.split(":"); - const type = segments[0]; - const line = parseInt(segments[2], 10); - if (isNaN(line)) { - throw new Error("GLSL compilation error in ".concat(shaderDescription, ": ").concat(errLog)); + let { + program + } = this.programProps; + if (program) { + this._managedProgram = false; + } else { + const { + vs: vs8, + fs: fs6, + modules, + inject, + defines: defines2, + varyings, + bufferMode, + transpileToGLSL100 + } = this.programProps; + program = this.programManager.get({ + vs: vs8, + fs: fs6, + modules, + inject, + defines: defines2, + varyings, + bufferMode, + transpileToGLSL100 + }); + if (this.program && this._managedProgram) { + this.programManager.release(this.program); + } + this._programManagerState = this.programManager.stateHash; + this._managedProgram = true; + } + assert6(program instanceof Program, "Model needs a program"); + this._programDirty = false; + if (program === this.program) { + return; } - if (type !== "WARNING") { - errors[line] = errorString; + this.program = program; + if (this.vertexArray) { + this.vertexArray.setProps({ + program: this.program, + attributes: this.vertexArray.attributes + }); } else { - warnings[line] = errorString; + this.vertexArray = new VertexArray(this.gl, { + program: this.program + }); } + this.setUniforms(Object.assign({}, this.getModuleUniforms())); } - const lines = addLineNumbers(src); - return { - shaderName: shaderDescription, - errors: formatErrors(errors, lines), - warnings: formatErrors(warnings, lines) - }; - } - function formatErrors(errors, lines) { - let message = ""; - for (let i2 = 0; i2 < lines.length; i2++) { - const line = lines[i2]; - if (!errors[i2 + 3] && !errors[i2 + 2] && !errors[i2 + 1]) { - continue; - } - message += "".concat(line, "\n"); - if (errors[i2 + 1]) { - const error2 = errors[i2 + 1]; - const segments = error2.split(":", 3); - const type = segments[0]; - const column = parseInt(segments[1], 10) || 0; - const err = error2.substring(segments.join(":").length + 1).trim(); - message += padLeft("^^^ ".concat(type, ": ").concat(err, "\n\n"), column); + _deleteGeometryBuffers() { + for (const name in this.geometryBuffers) { + const buffer = this.geometryBuffers[name][0] || this.geometryBuffers[name]; + if (buffer instanceof Buffer2) { + buffer.delete(); + } } } - return message; - } - function addLineNumbers(string) { - let start = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1; - let delim = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ": "; - const lines = string.split(/\r?\n/); - const maxDigits = String(lines.length + start - 1).length; - return lines.map((line, i2) => { - const lineNumber = String(i2 + start); - const digits = lineNumber.length; - const prefix = padLeft(lineNumber, maxDigits - digits); - return prefix + delim + line; - }); - } - function padLeft(string, digits) { - let result = ""; - for (let i2 = 0; i2 < digits; ++i2) { - result += " "; - } - return "".concat(result).concat(string); - } - - // node_modules/@luma.gl/webgl/dist/esm/glsl-utils/get-shader-version.js - function getShaderVersion(source) { - let version = 100; - const words = source.match(/[^\s]+/g); - if (words.length >= 2 && words[0] === "#version") { - const v2 = parseInt(words[1], 10); - if (Number.isFinite(v2)) { - version = v2; + _setAnimationProps(animationProps) { + if (this.animated) { + assert6(animationProps, "Model.draw(): animated uniforms but no animationProps"); } } - return version; - } - - // node_modules/@luma.gl/webgl/dist/esm/classes/shader.js - var ERR_SOURCE = "Shader: GLSL source code must be a JavaScript string"; - var Shader = class _Shader extends Resource { - get [Symbol.toStringTag]() { - return "Shader"; - } - static getTypeName(shaderType) { - switch (shaderType) { - case 35633: - return "vertex-shader"; - case 35632: - return "fragment-shader"; - default: - assert6(false); - return "unknown"; + _setFeedbackBuffers() { + let feedbackBuffers = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if (isObjectEmpty2(feedbackBuffers)) { + return this; } - } - constructor(gl, props) { - assertWebGLContext(gl); - assert6(typeof props.source === "string", ERR_SOURCE); - const id = getShaderName(props.source, null) || props.id || uid("unnamed ".concat(_Shader.getTypeName(props.shaderType))); - super(gl, { - id + const { + gl + } = this.program; + this.transformFeedback = this.transformFeedback || new TransformFeedback(gl, { + program: this.program }); - this.shaderType = props.shaderType; - this.source = props.source; - this.initialize(props); + this.transformFeedback.setBuffers(feedbackBuffers); + return this; } - initialize(_ref) { - let { - source - } = _ref; - const shaderName = getShaderName(source, null); - if (shaderName) { - this.id = uid(shaderName); + _logDrawCallStart(logLevel) { + const logDrawTimeout = logLevel > 3 ? 0 : LOG_DRAW_TIMEOUT; + if (Date.now() - this.lastLogTime < logDrawTimeout) { + return void 0; } - this._compile(source); - } - getParameter(pname) { - return this.gl.getShaderParameter(this.handle, pname); - } - toString() { - return "".concat(_Shader.getTypeName(this.shaderType), ":").concat(this.id); - } - getName() { - return getShaderName(this.source) || "unnamed-shader"; + this.lastLogTime = Date.now(); + log2.group(LOG_DRAW_PRIORITY, ">>> DRAWING MODEL ".concat(this.id), { + collapsed: log2.level <= 2 + })(); + return logLevel; } - getSource() { - return this.gl.getShaderSource(this.handle); + _logDrawCallEnd(logLevel, vertexArray, uniforms, framebuffer) { + if (logLevel === void 0) { + return; + } + const attributeTable = getDebugTableForVertexArray({ + vertexArray, + header: "".concat(this.id, " attributes"), + attributes: this._attributes + }); + const { + table: uniformTable, + unusedTable, + unusedCount + } = getDebugTableForUniforms({ + header: "".concat(this.id, " uniforms"), + program: this.program, + uniforms: Object.assign({}, this.program.uniforms, uniforms) + }); + const { + table: missingTable, + count: missingCount + } = getDebugTableForUniforms({ + header: "".concat(this.id, " uniforms"), + program: this.program, + uniforms: Object.assign({}, this.program.uniforms, uniforms), + undefinedOnly: true + }); + if (missingCount > 0) { + log2.log("MISSING UNIFORMS", Object.keys(missingTable))(); + } + if (unusedCount > 0) { + log2.log("UNUSED UNIFORMS", Object.keys(unusedTable))(); + } + const configTable = getDebugTableForProgramConfiguration(this.vertexArray.configuration); + log2.table(logLevel, attributeTable)(); + log2.table(logLevel, uniformTable)(); + log2.table(logLevel + 1, configTable)(); + if (framebuffer) { + framebuffer.log({ + logLevel: LOG_DRAW_PRIORITY, + message: "Rendered to ".concat(framebuffer.id) + }); + } + log2.groupEnd(LOG_DRAW_PRIORITY)(); } - getTranslatedSource() { - const extension = this.gl.getExtension("WEBGL_debug_shaders"); - return extension ? extension.getTranslatedShaderSource(this.handle) : "No translated source available. WEBGL_debug_shaders not implemented"; + }; + + // node_modules/@luma.gl/engine/dist/esm/transform/buffer-transform.js + var BufferTransform = class { + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + this.gl = gl; + this.currentIndex = 0; + this.feedbackMap = {}; + this.varyings = null; + this.bindings = []; + this.resources = {}; + this._initialize(props); + Object.seal(this); } - _compile() { - let source = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.source; - if (!source.startsWith("#version ")) { - source = "#version 100\n".concat(source); - } - this.source = source; - this.gl.shaderSource(this.handle, this.source); - this.gl.compileShader(this.handle); - const compileStatus = this.getParameter(35713); - if (!compileStatus) { - const infoLog = this.gl.getShaderInfoLog(this.handle); - const { - shaderName, - errors, - warnings - } = parseGLSLCompilerError(infoLog, this.source, this.shaderType, this.id); - log2.error("GLSL compilation errors in ".concat(shaderName, "\n").concat(errors))(); - log2.warn("GLSL compilation warnings in ".concat(shaderName, "\n").concat(warnings))(); - throw new Error("GLSL compilation errors in ".concat(shaderName)); + setupResources(opts) { + for (const binding of this.bindings) { + this._setupTransformFeedback(binding, opts); } } - _deleteHandle() { - this.gl.deleteShader(this.handle); + updateModelProps() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + varyings + } = this; + if (varyings.length > 0) { + props = Object.assign({}, props, { + varyings + }); + } + return props; } - _getOptsFromHandle() { + getDrawOptions() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const binding = this.bindings[this.currentIndex]; + const { + sourceBuffers, + transformFeedback + } = binding; + const attributes = Object.assign({}, sourceBuffers, opts.attributes); return { - type: this.getParameter(35663), - source: this.getSource() + attributes, + transformFeedback }; } - }; - var VertexShader = class extends Shader { - get [Symbol.toStringTag]() { - return "VertexShader"; - } - constructor(gl, props) { - if (typeof props === "string") { - props = { - source: props - }; + swap() { + if (this.feedbackMap) { + this.currentIndex = this._getNextIndex(); + return true; } - super(gl, Object.assign({}, props, { - shaderType: 35633 - })); - } - _createHandle() { - return this.gl.createShader(35633); + return false; } - }; - var FragmentShader = class extends Shader { - get [Symbol.toStringTag]() { - return "FragmentShader"; + update() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this._setupBuffers(opts); } - constructor(gl, props) { - if (typeof props === "string") { - props = { - source: props - }; + getBuffer(varyingName) { + const { + feedbackBuffers + } = this.bindings[this.currentIndex]; + const bufferOrParams = varyingName ? feedbackBuffers[varyingName] : null; + if (!bufferOrParams) { + return null; } - super(gl, Object.assign({}, props, { - shaderType: 35632 - })); + return bufferOrParams instanceof Buffer2 ? bufferOrParams : bufferOrParams.buffer; } - _createHandle() { - return this.gl.createShader(35632); + getData() { + let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + varyingName + } = options; + const buffer = this.getBuffer(varyingName); + if (buffer) { + return buffer.getData(); + } + return null; } - }; - - // node_modules/@luma.gl/webgl/dist/esm/classes/uniforms.js - var UNIFORM_SETTERS = { - [5126]: getArraySetter.bind(null, "uniform1fv", toFloatArray, 1, setVectorUniform), - [35664]: getArraySetter.bind(null, "uniform2fv", toFloatArray, 2, setVectorUniform), - [35665]: getArraySetter.bind(null, "uniform3fv", toFloatArray, 3, setVectorUniform), - [35666]: getArraySetter.bind(null, "uniform4fv", toFloatArray, 4, setVectorUniform), - [5124]: getArraySetter.bind(null, "uniform1iv", toIntArray, 1, setVectorUniform), - [35667]: getArraySetter.bind(null, "uniform2iv", toIntArray, 2, setVectorUniform), - [35668]: getArraySetter.bind(null, "uniform3iv", toIntArray, 3, setVectorUniform), - [35669]: getArraySetter.bind(null, "uniform4iv", toIntArray, 4, setVectorUniform), - [35670]: getArraySetter.bind(null, "uniform1iv", toIntArray, 1, setVectorUniform), - [35671]: getArraySetter.bind(null, "uniform2iv", toIntArray, 2, setVectorUniform), - [35672]: getArraySetter.bind(null, "uniform3iv", toIntArray, 3, setVectorUniform), - [35673]: getArraySetter.bind(null, "uniform4iv", toIntArray, 4, setVectorUniform), - [35674]: getArraySetter.bind(null, "uniformMatrix2fv", toFloatArray, 4, setMatrixUniform), - [35675]: getArraySetter.bind(null, "uniformMatrix3fv", toFloatArray, 9, setMatrixUniform), - [35676]: getArraySetter.bind(null, "uniformMatrix4fv", toFloatArray, 16, setMatrixUniform), - [35678]: getSamplerSetter, - [35680]: getSamplerSetter, - [5125]: getArraySetter.bind(null, "uniform1uiv", toUIntArray, 1, setVectorUniform), - [36294]: getArraySetter.bind(null, "uniform2uiv", toUIntArray, 2, setVectorUniform), - [36295]: getArraySetter.bind(null, "uniform3uiv", toUIntArray, 3, setVectorUniform), - [36296]: getArraySetter.bind(null, "uniform4uiv", toUIntArray, 4, setVectorUniform), - [35685]: getArraySetter.bind(null, "uniformMatrix2x3fv", toFloatArray, 6, setMatrixUniform), - [35686]: getArraySetter.bind(null, "uniformMatrix2x4fv", toFloatArray, 8, setMatrixUniform), - [35687]: getArraySetter.bind(null, "uniformMatrix3x2fv", toFloatArray, 6, setMatrixUniform), - [35688]: getArraySetter.bind(null, "uniformMatrix3x4fv", toFloatArray, 12, setMatrixUniform), - [35689]: getArraySetter.bind(null, "uniformMatrix4x2fv", toFloatArray, 8, setMatrixUniform), - [35690]: getArraySetter.bind(null, "uniformMatrix4x3fv", toFloatArray, 12, setMatrixUniform), - [35678]: getSamplerSetter, - [35680]: getSamplerSetter, - [35679]: getSamplerSetter, - [35682]: getSamplerSetter, - [36289]: getSamplerSetter, - [36292]: getSamplerSetter, - [36293]: getSamplerSetter, - [36298]: getSamplerSetter, - [36299]: getSamplerSetter, - [36300]: getSamplerSetter, - [36303]: getSamplerSetter, - [36306]: getSamplerSetter, - [36307]: getSamplerSetter, - [36308]: getSamplerSetter, - [36311]: getSamplerSetter - }; - var FLOAT_ARRAY = {}; - var INT_ARRAY = {}; - var UINT_ARRAY = {}; - var array1 = [0]; - function toTypedArray(value, uniformLength, Type, cache3) { - if (uniformLength === 1 && typeof value === "boolean") { - value = value ? 1 : 0; + delete() { + for (const name in this.resources) { + this.resources[name].delete(); + } } - if (Number.isFinite(value)) { - array1[0] = value; - value = array1; + _initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this._setupBuffers(props); + this.varyings = props.varyings || Object.keys(this.bindings[this.currentIndex].feedbackBuffers); + if (this.varyings.length > 0) { + assert6(isWebGL2(this.gl)); + } } - const length = value.length; - if (length % uniformLength) { - log2.warn("Uniform size should be multiples of ".concat(uniformLength), value)(); + _getFeedbackBuffers(props) { + const { + sourceBuffers = {} + } = props; + const feedbackBuffers = {}; + if (this.bindings[this.currentIndex]) { + Object.assign(feedbackBuffers, this.bindings[this.currentIndex].feedbackBuffers); + } + if (this.feedbackMap) { + for (const sourceName in this.feedbackMap) { + const feedbackName = this.feedbackMap[sourceName]; + if (sourceName in sourceBuffers) { + feedbackBuffers[feedbackName] = sourceName; + } + } + } + Object.assign(feedbackBuffers, props.feedbackBuffers); + for (const bufferName in feedbackBuffers) { + const bufferOrRef = feedbackBuffers[bufferName]; + if (typeof bufferOrRef === "string") { + const sourceBuffer = sourceBuffers[bufferOrRef]; + const { + byteLength, + usage, + accessor + } = sourceBuffer; + feedbackBuffers[bufferName] = this._createNewBuffer(bufferName, { + byteLength, + usage, + accessor + }); + } + } + return feedbackBuffers; } - if (value instanceof Type) { - return value; + _setupBuffers() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + sourceBuffers = null + } = props; + Object.assign(this.feedbackMap, props.feedbackMap); + const feedbackBuffers = this._getFeedbackBuffers(props); + this._updateBindings({ + sourceBuffers, + feedbackBuffers + }); } - let result = cache3[length]; - if (!result) { - result = new Type(length); - cache3[length] = result; + _setupTransformFeedback(binding, _ref) { + let { + model + } = _ref; + const { + program + } = model; + binding.transformFeedback = new TransformFeedback(this.gl, { + program, + buffers: binding.feedbackBuffers + }); } - for (let i2 = 0; i2 < length; i2++) { - result[i2] = value[i2]; + _updateBindings(opts) { + this.bindings[this.currentIndex] = this._updateBinding(this.bindings[this.currentIndex], opts); + if (this.feedbackMap) { + const { + sourceBuffers, + feedbackBuffers + } = this._swapBuffers(this.bindings[this.currentIndex]); + const nextIndex = this._getNextIndex(); + this.bindings[nextIndex] = this._updateBinding(this.bindings[nextIndex], { + sourceBuffers, + feedbackBuffers + }); + } } - return result; - } - function toFloatArray(value, uniformLength) { - return toTypedArray(value, uniformLength, Float32Array, FLOAT_ARRAY); - } - function toIntArray(value, uniformLength) { - return toTypedArray(value, uniformLength, Int32Array, INT_ARRAY); - } - function toUIntArray(value, uniformLength) { - return toTypedArray(value, uniformLength, Uint32Array, UINT_ARRAY); - } - function getUniformSetter(gl, location, info) { - const setter = UNIFORM_SETTERS[info.type]; - if (!setter) { - throw new Error("Unknown GLSL uniform type ".concat(info.type)); + _updateBinding(binding, opts) { + if (!binding) { + return { + sourceBuffers: Object.assign({}, opts.sourceBuffers), + feedbackBuffers: Object.assign({}, opts.feedbackBuffers) + }; + } + Object.assign(binding.sourceBuffers, opts.sourceBuffers); + Object.assign(binding.feedbackBuffers, opts.feedbackBuffers); + if (binding.transformFeedback) { + binding.transformFeedback.setBuffers(binding.feedbackBuffers); + } + return binding; } - return setter().bind(null, gl, location); - } - function parseUniformName(name) { - if (name[name.length - 1] !== "]") { + _swapBuffers(opts) { + if (!this.feedbackMap) { + return null; + } + const sourceBuffers = Object.assign({}, opts.sourceBuffers); + const feedbackBuffers = Object.assign({}, opts.feedbackBuffers); + for (const srcName in this.feedbackMap) { + const dstName = this.feedbackMap[srcName]; + sourceBuffers[srcName] = opts.feedbackBuffers[dstName]; + feedbackBuffers[dstName] = opts.sourceBuffers[srcName]; + assert6(feedbackBuffers[dstName] instanceof Buffer2); + } return { - name, - length: 1, - isArray: false + sourceBuffers, + feedbackBuffers }; } - const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/; - const matches3 = name.match(UNIFORM_NAME_REGEXP); - if (!matches3 || matches3.length < 2) { - throw new Error("Failed to parse GLSL uniform name ".concat(name)); - } - return { - name: matches3[1], - length: matches3[2] || 1, - isArray: Boolean(matches3[2]) - }; - } - function checkUniformValues(uniforms, source, uniformMap) { - for (const uniformName in uniforms) { - const value = uniforms[uniformName]; - const shouldCheck = !uniformMap || Boolean(uniformMap[uniformName]); - if (shouldCheck && !checkUniformValue(value)) { - source = source ? "".concat(source, " ") : ""; - console.error("".concat(source, " Bad uniform ").concat(uniformName), value); - throw new Error("".concat(source, " Bad uniform ").concat(uniformName)); + _createNewBuffer(name, opts) { + const buffer = new Buffer2(this.gl, opts); + if (this.resources[name]) { + this.resources[name].delete(); } + this.resources[name] = buffer; + return buffer; } - return true; - } - function checkUniformValue(value) { - if (Array.isArray(value) || ArrayBuffer.isView(value)) { - return checkUniformArray(value); - } - if (isFinite(value)) { - return true; - } else if (value === true || value === false) { - return true; - } else if (value instanceof Texture) { - return true; - } else if (value instanceof Renderbuffer) { - return true; - } else if (value instanceof Framebuffer) { - return Boolean(value.texture); + _getNextIndex() { + return (this.currentIndex + 1) % 2; } - return false; - } - function copyUniform(uniforms, key, value) { - if (Array.isArray(value) || ArrayBuffer.isView(value)) { - if (uniforms[key]) { - const dest = uniforms[key]; - for (let i2 = 0, len = value.length; i2 < len; ++i2) { - dest[i2] = value[i2]; + }; + + // node_modules/@luma.gl/engine/dist/esm/transform/transform-shader-utils.js + var SAMPLER_UNIFORM_PREFIX = "transform_uSampler_"; + var SIZE_UNIFORM_PREFIX = "transform_uSize_"; + var VS_POS_VARIABLE = "transform_position"; + function updateForTextures(_ref) { + let { + vs: vs8, + sourceTextureMap, + targetTextureVarying, + targetTexture + } = _ref; + const texAttributeNames = Object.keys(sourceTextureMap); + let sourceCount = texAttributeNames.length; + let targetTextureType = null; + const samplerTextureMap = {}; + let updatedVs = vs8; + let finalInject = {}; + if (sourceCount > 0 || targetTextureVarying) { + const vsLines = updatedVs.split("\n"); + const updateVsLines = vsLines.slice(); + vsLines.forEach((line, index, lines) => { + if (sourceCount > 0) { + const updated = processAttributeDefinition(line, sourceTextureMap); + if (updated) { + const { + updatedLine, + inject + } = updated; + updateVsLines[index] = updatedLine; + finalInject = combineInjects([finalInject, inject]); + Object.assign(samplerTextureMap, updated.samplerTextureMap); + sourceCount--; + } } - } else { - uniforms[key] = value.slice(); + if (targetTextureVarying && !targetTextureType) { + targetTextureType = getVaryingType(line, targetTextureVarying); + } + }); + if (targetTextureVarying) { + assert6(targetTexture); + const sizeName = "".concat(SIZE_UNIFORM_PREFIX).concat(targetTextureVarying); + const uniformDeclaration = "uniform vec2 ".concat(sizeName, ";\n"); + const posInstructions = " vec2 ".concat(VS_POS_VARIABLE, " = transform_getPos(").concat(sizeName, ");\n gl_Position = vec4(").concat(VS_POS_VARIABLE, ", 0, 1.);\n"); + const inject = { + "vs:#decl": uniformDeclaration, + "vs:#main-start": posInstructions + }; + finalInject = combineInjects([finalInject, inject]); } - } else { - uniforms[key] = value; + updatedVs = updateVsLines.join("\n"); } + return { + vs: updatedVs, + targetTextureType, + inject: finalInject, + samplerTextureMap + }; } - function checkUniformArray(value) { - if (value.length === 0) { - return false; + function getSizeUniforms(_ref2) { + let { + sourceTextureMap, + targetTextureVarying, + targetTexture + } = _ref2; + const uniforms = {}; + let width; + let height; + if (targetTextureVarying) { + ({ + width, + height + } = targetTexture); + uniforms["".concat(SIZE_UNIFORM_PREFIX).concat(targetTextureVarying)] = [width, height]; } - const checkLength = Math.min(value.length, 16); - for (let i2 = 0; i2 < checkLength; ++i2) { - if (!Number.isFinite(value[i2])) { - return false; - } + for (const textureName in sourceTextureMap) { + ({ + width, + height + } = sourceTextureMap[textureName]); + uniforms["".concat(SIZE_UNIFORM_PREFIX).concat(textureName)] = [width, height]; } - return true; + return uniforms; } - function getSamplerSetter() { - let cache3 = null; - return (gl, location, value) => { - const update = cache3 !== value; - if (update) { - gl.uniform1i(location, value); - cache3 = value; - } - return update; - }; + function getAttributeDefinition(line) { + return getQualifierDetails(line, ["attribute", "in"]); } - function getArraySetter(functionName, toArray, size, uniformSetter) { - let cache3 = null; - let cacheLength = null; - return (gl, location, value) => { - const arrayValue = toArray(value, size); - const length = arrayValue.length; - let update = false; - if (cache3 === null) { - cache3 = new Float32Array(length); - cacheLength = length; - update = true; - } else { - assert6(cacheLength === length, "Uniform length cannot change."); - for (let i2 = 0; i2 < length; ++i2) { - if (arrayValue[i2] !== cache3[i2]) { - update = true; - break; - } - } - } - if (update) { - uniformSetter(gl, functionName, location, arrayValue); - cache3.set(arrayValue); - } - return update; + function getSamplerDeclerations(textureName) { + const samplerName = "".concat(SAMPLER_UNIFORM_PREFIX).concat(textureName); + const sizeName = "".concat(SIZE_UNIFORM_PREFIX).concat(textureName); + const uniformDeclerations = " uniform sampler2D ".concat(samplerName, ";\n uniform vec2 ").concat(sizeName, ";"); + return { + samplerName, + sizeName, + uniformDeclerations }; } - function setVectorUniform(gl, functionName, location, value) { - gl[functionName](location, value); - } - function setMatrixUniform(gl, functionName, location, value) { - gl[functionName](location, false, value); - } - - // node_modules/@luma.gl/webgl/dist/esm/webgl-utils/attribute-utils.js - var GL_BYTE = 5120; - var GL_UNSIGNED_BYTE = 5121; - var GL_SHORT = 5122; - var GL_UNSIGNED_SHORT = 5123; - var GL_POINTS = 0; - var GL_LINES = 1; - var GL_LINE_LOOP = 2; - var GL_LINE_STRIP = 3; - var GL_TRIANGLES = 4; - var GL_TRIANGLE_STRIP = 5; - var GL_TRIANGLE_FAN = 6; - var GL_FLOAT = 5126; - var GL_FLOAT_VEC2 = 35664; - var GL_FLOAT_VEC3 = 35665; - var GL_FLOAT_VEC4 = 35666; - var GL_INT = 5124; - var GL_INT_VEC2 = 35667; - var GL_INT_VEC3 = 35668; - var GL_INT_VEC4 = 35669; - var GL_UNSIGNED_INT = 5125; - var GL_UNSIGNED_INT_VEC2 = 36294; - var GL_UNSIGNED_INT_VEC3 = 36295; - var GL_UNSIGNED_INT_VEC4 = 36296; - var GL_BOOL = 35670; - var GL_BOOL_VEC2 = 35671; - var GL_BOOL_VEC3 = 35672; - var GL_BOOL_VEC4 = 35673; - var GL_FLOAT_MAT2 = 35674; - var GL_FLOAT_MAT3 = 35675; - var GL_FLOAT_MAT4 = 35676; - var GL_FLOAT_MAT2x3 = 35685; - var GL_FLOAT_MAT2x4 = 35686; - var GL_FLOAT_MAT3x2 = 35687; - var GL_FLOAT_MAT3x4 = 35688; - var GL_FLOAT_MAT4x2 = 35689; - var GL_FLOAT_MAT4x3 = 35690; - var COMPOSITE_GL_TYPES = { - [GL_FLOAT]: [GL_FLOAT, 1, "float"], - [GL_FLOAT_VEC2]: [GL_FLOAT, 2, "vec2"], - [GL_FLOAT_VEC3]: [GL_FLOAT, 3, "vec3"], - [GL_FLOAT_VEC4]: [GL_FLOAT, 4, "vec4"], - [GL_INT]: [GL_INT, 1, "int"], - [GL_INT_VEC2]: [GL_INT, 2, "ivec2"], - [GL_INT_VEC3]: [GL_INT, 3, "ivec3"], - [GL_INT_VEC4]: [GL_INT, 4, "ivec4"], - [GL_UNSIGNED_INT]: [GL_UNSIGNED_INT, 1, "uint"], - [GL_UNSIGNED_INT_VEC2]: [GL_UNSIGNED_INT, 2, "uvec2"], - [GL_UNSIGNED_INT_VEC3]: [GL_UNSIGNED_INT, 3, "uvec3"], - [GL_UNSIGNED_INT_VEC4]: [GL_UNSIGNED_INT, 4, "uvec4"], - [GL_BOOL]: [GL_FLOAT, 1, "bool"], - [GL_BOOL_VEC2]: [GL_FLOAT, 2, "bvec2"], - [GL_BOOL_VEC3]: [GL_FLOAT, 3, "bvec3"], - [GL_BOOL_VEC4]: [GL_FLOAT, 4, "bvec4"], - [GL_FLOAT_MAT2]: [GL_FLOAT, 8, "mat2"], - [GL_FLOAT_MAT2x3]: [GL_FLOAT, 8, "mat2x3"], - [GL_FLOAT_MAT2x4]: [GL_FLOAT, 8, "mat2x4"], - [GL_FLOAT_MAT3]: [GL_FLOAT, 12, "mat3"], - [GL_FLOAT_MAT3x2]: [GL_FLOAT, 12, "mat3x2"], - [GL_FLOAT_MAT3x4]: [GL_FLOAT, 12, "mat3x4"], - [GL_FLOAT_MAT4]: [GL_FLOAT, 16, "mat4"], - [GL_FLOAT_MAT4x2]: [GL_FLOAT, 16, "mat4x2"], - [GL_FLOAT_MAT4x3]: [GL_FLOAT, 16, "mat4x3"] - }; - function getPrimitiveDrawMode(drawMode) { - switch (drawMode) { - case GL_POINTS: - return GL_POINTS; - case GL_LINES: - return GL_LINES; - case GL_LINE_STRIP: - return GL_LINES; - case GL_LINE_LOOP: - return GL_LINES; - case GL_TRIANGLES: - return GL_TRIANGLES; - case GL_TRIANGLE_STRIP: - return GL_TRIANGLES; - case GL_TRIANGLE_FAN: - return GL_TRIANGLES; - default: - assert6(false); - return 0; + function getVaryingType(line, varying) { + const qualaiferDetails = getQualifierDetails(line, ["varying", "out"]); + if (!qualaiferDetails) { + return null; } + return qualaiferDetails.name === varying ? qualaiferDetails.type : null; } - function decomposeCompositeGLType(compositeGLType) { - const typeAndSize = COMPOSITE_GL_TYPES[compositeGLType]; - if (!typeAndSize) { + function processAttributeDefinition(line, textureMap) { + const samplerTextureMap = {}; + const attributeData = getAttributeDefinition(line); + if (!attributeData) { return null; } - const [type, components] = typeAndSize; - return { + const { type, - components - }; - } - function getCompositeGLType(type, components) { - switch (type) { - case GL_BYTE: - case GL_UNSIGNED_BYTE: - case GL_SHORT: - case GL_UNSIGNED_SHORT: - type = GL_FLOAT; - break; - default: - } - for (const glType in COMPOSITE_GL_TYPES) { - const [compType, compComponents, name] = COMPOSITE_GL_TYPES[glType]; - if (compType === type && compComponents === components) { - return { - glType, - name - }; - } + name + } = attributeData; + if (name && textureMap[name]) { + const updatedLine = "// ".concat(line, " => Replaced by Transform with a sampler"); + const { + samplerName, + sizeName, + uniformDeclerations + } = getSamplerDeclerations(name); + const channels2 = typeToChannelSuffix(type); + const sampleInstruction = " ".concat(type, " ").concat(name, " = transform_getInput(").concat(samplerName, ", ").concat(sizeName, ").").concat(channels2, ";\n"); + samplerTextureMap[samplerName] = name; + const inject = { + "vs:#decl": uniformDeclerations, + "vs:#main-start": sampleInstruction + }; + return { + updatedLine, + inject, + samplerTextureMap + }; } return null; } - // node_modules/@luma.gl/webgl/dist/esm/classes/program-configuration.js - var ProgramConfiguration = class { - constructor(program) { - this.id = program.id; - this.attributeInfos = []; - this.attributeInfosByName = {}; - this.attributeInfosByLocation = []; - this.varyingInfos = []; - this.varyingInfosByName = {}; + // node_modules/@luma.gl/engine/dist/esm/transform/texture-transform.js + var SRC_TEX_PARAMETER_OVERRIDES = { + [10241]: 9728, + [10240]: 9728, + [10242]: 33071, + [10243]: 33071 + }; + var FS_OUTPUT_VARIABLE = "transform_output"; + var TextureTransform = class { + constructor(gl) { + let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + this.gl = gl; + this.id = this.currentIndex = 0; + this._swapTexture = null; + this.targetTextureVarying = null; + this.targetTextureType = null; + this.samplerTextureMap = null; + this.bindings = []; + this.resources = {}; + this._initialize(props); Object.seal(this); - this._readAttributesFromProgram(program); - this._readVaryingsFromProgram(program); } - getAttributeInfo(locationOrName) { - const location = Number(locationOrName); - if (Number.isFinite(location)) { - return this.attributeInfosByLocation[location]; + updateModelProps() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const updatedModelProps = this._processVertexShader(props); + return Object.assign({}, props, updatedModelProps); + } + getDrawOptions() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + sourceBuffers, + sourceTextures, + framebuffer, + targetTexture + } = this.bindings[this.currentIndex]; + const attributes = Object.assign({}, sourceBuffers, opts.attributes); + const uniforms = Object.assign({}, opts.uniforms); + const parameters = Object.assign({}, opts.parameters); + let discard = opts.discard; + if (this.hasSourceTextures || this.hasTargetTexture) { + attributes.transform_elementID = this.elementIDBuffer; + for (const sampler in this.samplerTextureMap) { + const textureName = this.samplerTextureMap[sampler]; + uniforms[sampler] = sourceTextures[textureName]; + } + this._setSourceTextureParameters(); + const sizeUniforms = getSizeUniforms({ + sourceTextureMap: sourceTextures, + targetTextureVarying: this.targetTextureVarying, + targetTexture + }); + Object.assign(uniforms, sizeUniforms); } - return this.attributeInfosByName[locationOrName] || null; + if (this.hasTargetTexture) { + discard = false; + parameters.viewport = [0, 0, framebuffer.width, framebuffer.height]; + } + return { + attributes, + framebuffer, + uniforms, + discard, + parameters + }; } - getAttributeLocation(locationOrName) { - const attributeInfo = this.getAttributeInfo(locationOrName); - return attributeInfo ? attributeInfo.location : -1; + swap() { + if (this._swapTexture) { + this.currentIndex = this._getNextIndex(); + return true; + } + return false; } - getAttributeAccessor(locationOrName) { - const attributeInfo = this.getAttributeInfo(locationOrName); - return attributeInfo ? attributeInfo.accessor : null; + update() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + this._setupTextures(opts); } - getVaryingInfo(locationOrName) { - const location = Number(locationOrName); - if (Number.isFinite(location)) { - return this.varyingInfos[location]; + getTargetTexture() { + const { + targetTexture + } = this.bindings[this.currentIndex]; + return targetTexture; + } + getData() { + let { + packed = false + } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + framebuffer + } = this.bindings[this.currentIndex]; + const pixels = readPixelsToArray(framebuffer); + if (!packed) { + return pixels; } - return this.varyingInfosByName[locationOrName] || null; + const ArrayType = pixels.constructor; + const channelCount = typeToChannelCount(this.targetTextureType); + const packedPixels = new ArrayType(pixels.length * channelCount / 4); + let packCount = 0; + for (let i3 = 0; i3 < pixels.length; i3 += 4) { + for (let j = 0; j < channelCount; j++) { + packedPixels[packCount++] = pixels[i3 + j]; + } + } + return packedPixels; } - getVaryingIndex(locationOrName) { - const varying = this.getVaryingInfo(); - return varying ? varying.location : -1; + getFramebuffer() { + const currentResources = this.bindings[this.currentIndex]; + return currentResources.framebuffer; } - getVaryingAccessor(locationOrName) { - const varying = this.getVaryingInfo(); - return varying ? varying.accessor : null; + delete() { + if (this.ownTexture) { + this.ownTexture.delete(); + } + if (this.elementIDBuffer) { + this.elementIDBuffer.delete(); + } } - _readAttributesFromProgram(program) { + _initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; const { - gl - } = program; - const count2 = gl.getProgramParameter(program.handle, 35721); - for (let index = 0; index < count2; index++) { + _targetTextureVarying, + _swapTexture + } = props; + this._swapTexture = _swapTexture; + this.targetTextureVarying = _targetTextureVarying; + this.hasTargetTexture = _targetTextureVarying; + this._setupTextures(props); + } + _createTargetTexture(props) { + const { + sourceTextures, + textureOrReference + } = props; + if (textureOrReference instanceof Texture2D) { + return textureOrReference; + } + const refTexture = sourceTextures[textureOrReference]; + if (!refTexture) { + return null; + } + this._targetRefTexName = textureOrReference; + return this._createNewTexture(refTexture); + } + _setupTextures() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + sourceBuffers, + _sourceTextures = {}, + _targetTexture + } = props; + const targetTexture = this._createTargetTexture({ + sourceTextures: _sourceTextures, + textureOrReference: _targetTexture + }); + this.hasSourceTextures = this.hasSourceTextures || _sourceTextures && Object.keys(_sourceTextures).length > 0; + this._updateBindings({ + sourceBuffers, + sourceTextures: _sourceTextures, + targetTexture + }); + if ("elementCount" in props) { + this._updateElementIDBuffer(props.elementCount); + } + } + _updateElementIDBuffer(elementCount) { + if (typeof elementCount !== "number" || this.elementCount >= elementCount) { + return; + } + const elementIds = new Float32Array(elementCount); + elementIds.forEach((_2, index, array) => { + array[index] = index; + }); + if (!this.elementIDBuffer) { + this.elementIDBuffer = new Buffer2(this.gl, { + data: elementIds, + accessor: { + size: 1 + } + }); + } else { + this.elementIDBuffer.setData({ + data: elementIds + }); + } + this.elementCount = elementCount; + } + _updateBindings(opts) { + this.bindings[this.currentIndex] = this._updateBinding(this.bindings[this.currentIndex], opts); + if (this._swapTexture) { const { - name, - type, - size - } = gl.getActiveAttrib(program.handle, index); - const location = gl.getAttribLocation(program.handle, name); - if (location >= 0) { - this._addAttribute(location, name, type, size); - } + sourceTextures, + targetTexture + } = this._swapTextures(this.bindings[this.currentIndex]); + const nextIndex = this._getNextIndex(); + this.bindings[nextIndex] = this._updateBinding(this.bindings[nextIndex], { + sourceTextures, + targetTexture + }); } - this.attributeInfos.sort((a2, b2) => a2.location - b2.location); } - _readVaryingsFromProgram(program) { + _updateBinding(binding, opts) { const { - gl - } = program; - if (!isWebGL2(gl)) { - return; + sourceBuffers, + sourceTextures, + targetTexture + } = opts; + if (!binding) { + binding = { + sourceBuffers: {}, + sourceTextures: {}, + targetTexture: null + }; } - const count2 = gl.getProgramParameter(program.handle, 35971); - for (let location = 0; location < count2; location++) { + Object.assign(binding.sourceTextures, sourceTextures); + Object.assign(binding.sourceBuffers, sourceBuffers); + if (targetTexture) { + binding.targetTexture = targetTexture; const { - name, - type, - size - } = gl.getTransformFeedbackVarying(program.handle, location); - this._addVarying(location, name, type, size); + width, + height + } = targetTexture; + const { + framebuffer + } = binding; + if (framebuffer) { + framebuffer.update({ + attachments: { + [36064]: targetTexture + }, + resizeAttachments: false + }); + framebuffer.resize({ + width, + height + }); + } else { + binding.framebuffer = new Framebuffer(this.gl, { + id: "transform-framebuffer", + width, + height, + attachments: { + [36064]: targetTexture + } + }); + } } - this.varyingInfos.sort((a2, b2) => a2.location - b2.location); + return binding; } - _addAttribute(location, name, compositeType, size) { + _setSourceTextureParameters() { + const index = this.currentIndex; const { - type, - components - } = decomposeCompositeGLType(compositeType); - const accessor = { - type, - size: size * components - }; - this._inferProperties(location, name, accessor); - const attributeInfo = { - location, - name, - accessor: new Accessor(accessor) + sourceTextures + } = this.bindings[index]; + for (const name in sourceTextures) { + sourceTextures[name].setParameters(SRC_TEX_PARAMETER_OVERRIDES); + } + } + _swapTextures(opts) { + if (!this._swapTexture) { + return null; + } + const sourceTextures = Object.assign({}, opts.sourceTextures); + sourceTextures[this._swapTexture] = opts.targetTexture; + const targetTexture = opts.sourceTextures[this._swapTexture]; + return { + sourceTextures, + targetTexture }; - this.attributeInfos.push(attributeInfo); - this.attributeInfosByLocation[location] = attributeInfo; - this.attributeInfosByName[attributeInfo.name] = attributeInfo; } - _inferProperties(location, name, accessor) { - if (/instance/i.test(name)) { - accessor.divisor = 1; + _createNewTexture(refTexture) { + const texture = cloneTextureFrom(refTexture, { + parameters: { + [10241]: 9728, + [10240]: 9728, + [10242]: 33071, + [10243]: 33071 + }, + pixelStore: { + [37440]: false + } + }); + if (this.ownTexture) { + this.ownTexture.delete(); } + this.ownTexture = texture; + return texture; } - _addVarying(location, name, compositeType, size) { + _getNextIndex() { + return (this.currentIndex + 1) % 2; + } + _processVertexShader() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; const { - type, - components - } = decomposeCompositeGLType(compositeType); - const accessor = new Accessor({ - type, - size: size * components + sourceTextures, + targetTexture + } = this.bindings[this.currentIndex]; + const { + vs: vs8, + uniforms, + targetTextureType, + inject, + samplerTextureMap + } = updateForTextures({ + vs: props.vs, + sourceTextureMap: sourceTextures, + targetTextureVarying: this.targetTextureVarying, + targetTexture }); - const varying = { - location, - name, - accessor + const combinedInject = combineInjects([props.inject || {}, inject]); + this.targetTextureType = targetTextureType; + this.samplerTextureMap = samplerTextureMap; + const fs6 = props._fs || getPassthroughFS({ + version: getShaderVersion(vs8), + input: this.targetTextureVarying, + inputType: targetTextureType, + output: FS_OUTPUT_VARIABLE + }); + const modules = this.hasSourceTextures || this.targetTextureVarying ? [transform].concat(props.modules || []) : props.modules; + return { + vs: vs8, + fs: fs6, + modules, + uniforms, + inject: combinedInject }; - this.varyingInfos.push(varying); - this.varyingInfosByName[varying.name] = varying; } }; - // node_modules/@luma.gl/webgl/dist/esm/classes/program.js - var LOG_PROGRAM_PERF_PRIORITY = 4; - var GL_SEPARATE_ATTRIBS = 35981; - var V6_DEPRECATED_METHODS = ["setVertexArray", "setAttributes", "setBuffers", "unsetBuffers", "use", "getUniformCount", "getUniformInfo", "getUniformLocation", "getUniformValue", "getVarying", "getFragDataLocation", "getAttachedShaders", "getAttributeCount", "getAttributeLocation", "getAttributeInfo"]; - var Program = class extends Resource { - get [Symbol.toStringTag]() { - return "Program"; + // node_modules/@luma.gl/engine/dist/esm/transform/transform.js + var Transform = class { + static isSupported(gl) { + return isWebGL2(gl); } constructor(gl) { let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - super(gl, props); - this.stubRemovedMethods("Program", "v6.0", V6_DEPRECATED_METHODS); - this._isCached = false; - this.initialize(props); + this.gl = gl; + this.model = null; + this.elementCount = 0; + this.bufferTransform = null; + this.textureTransform = null; + this.elementIDBuffer = null; + this._initialize(props); Object.seal(this); - this._setId(props.id); } - initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + delete() { const { - hash, - vs: vs7, - fs: fs4, - varyings, - bufferMode = GL_SEPARATE_ATTRIBS - } = props; - this.hash = hash || ""; - this.vs = typeof vs7 === "string" ? new VertexShader(this.gl, { - id: "".concat(props.id, "-vs"), - source: vs7 - }) : vs7; - this.fs = typeof fs4 === "string" ? new FragmentShader(this.gl, { - id: "".concat(props.id, "-fs"), - source: fs4 - }) : fs4; - assert6(this.vs instanceof VertexShader); - assert6(this.fs instanceof FragmentShader); - this.uniforms = {}; - this._textureUniforms = {}; - if (varyings && varyings.length > 0) { - assertWebGL2Context(this.gl); - this.varyings = varyings; - this.gl2.transformFeedbackVaryings(this.handle, varyings, bufferMode); + model, + bufferTransform, + textureTransform + } = this; + if (model) { + model.delete(); + } + if (bufferTransform) { + bufferTransform.delete(); + } + if (textureTransform) { + textureTransform.delete(); } - this._compileAndLink(); - this._readUniformLocationsFromLinkedProgram(); - this.configuration = new ProgramConfiguration(this); - return this.setProps(props); } - delete() { - let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if (this._isCached) { - return this; + run() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + clearRenderTarget = true + } = opts; + const updatedOpts = this._updateDrawOptions(opts); + if (clearRenderTarget && updatedOpts.framebuffer) { + updatedOpts.framebuffer.clear({ + color: true + }); } - return super.delete(options); + this.model.transform(updatedOpts); } - setProps(props) { - if ("uniforms" in props) { - this.setUniforms(props.uniforms); + swap() { + let swapped = false; + const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); + for (const resourceTransform of resourceTransforms) { + swapped = swapped || resourceTransform.swap(); } - return this; + assert6(swapped, "Nothing to swap"); } - draw(_ref) { - let { - logPriority, - drawMode = 4, - vertexCount, - offset = 0, - start, - end, - isIndexed = false, - indexType = 5123, - instanceCount = 0, - isInstanced = instanceCount > 0, - vertexArray = null, - transformFeedback, - framebuffer, - parameters = {}, - uniforms, - samplers - } = _ref; - if (uniforms || samplers) { - log2.deprecated("Program.draw({uniforms})", "Program.setUniforms(uniforms)")(); - this.setUniforms(uniforms || {}); + getBuffer() { + let varyingName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; + return this.bufferTransform && this.bufferTransform.getBuffer(varyingName); + } + getData() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); + for (const resourceTransform of resourceTransforms) { + const data = resourceTransform.getData(opts); + if (data) { + return data; + } } - if (log2.priority >= logPriority) { - const fb = framebuffer ? framebuffer.id : "default"; - const message = "mode=".concat(getKey(this.gl, drawMode), " verts=").concat(vertexCount, " ") + "instances=".concat(instanceCount, " indexType=").concat(getKey(this.gl, indexType), " ") + "isInstanced=".concat(isInstanced, " isIndexed=").concat(isIndexed, " ") + "Framebuffer=".concat(fb); - log2.log(logPriority, message)(); + return null; + } + getFramebuffer() { + return this.textureTransform && this.textureTransform.getFramebuffer(); + } + update() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + if ("elementCount" in opts) { + this.model.setVertexCount(opts.elementCount); } - assert6(vertexArray); - this.gl.useProgram(this.handle); - if (!this._areTexturesRenderable() || vertexCount === 0 || isInstanced && instanceCount === 0) { - return false; + const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); + for (const resourceTransform of resourceTransforms) { + resourceTransform.update(opts); } - vertexArray.bindForDraw(vertexCount, instanceCount, () => { - if (framebuffer !== void 0) { - parameters = Object.assign({}, parameters, { - framebuffer - }); - } - if (transformFeedback) { - const primitiveMode = getPrimitiveDrawMode(drawMode); - transformFeedback.begin(primitiveMode); - } - this._bindTextures(); - withParameters(this.gl, parameters, () => { - if (isIndexed && isInstanced) { - this.gl2.drawElementsInstanced(drawMode, vertexCount, indexType, offset, instanceCount); - } else if (isIndexed && isWebGL2(this.gl) && !isNaN(start) && !isNaN(end)) { - this.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset); - } else if (isIndexed) { - this.gl.drawElements(drawMode, vertexCount, indexType, offset); - } else if (isInstanced) { - this.gl2.drawArraysInstanced(drawMode, offset, vertexCount, instanceCount); - } else { - this.gl.drawArrays(drawMode, offset, vertexCount); - } - }); - if (transformFeedback) { - transformFeedback.end(); - } + } + _initialize() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + gl + } = this; + this._buildResourceTransforms(gl, props); + props = this._updateModelProps(props); + this.model = new Model(gl, Object.assign({}, props, { + fs: props.fs || getPassthroughFS({ + version: getShaderVersion(props.vs) + }), + id: props.id || "transform-model", + drawMode: props.drawMode || 0, + vertexCount: props.elementCount + })); + this.bufferTransform && this.bufferTransform.setupResources({ + model: this.model }); - return true; } - setUniforms() { - let uniforms = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if (log2.priority >= 2) { - checkUniformValues(uniforms, this.id, this._uniformSetters); - } - this.gl.useProgram(this.handle); - for (const uniformName in uniforms) { - const uniform = uniforms[uniformName]; - const uniformSetter = this._uniformSetters[uniformName]; - if (uniformSetter) { - let value = uniform; - let textureUpdate = false; - if (value instanceof Framebuffer) { - value = value.texture; - } - if (value instanceof Texture) { - textureUpdate = this.uniforms[uniformName] !== uniform; - if (textureUpdate) { - if (uniformSetter.textureIndex === void 0) { - uniformSetter.textureIndex = this._textureIndexCounter++; - } - const texture = value; - const { - textureIndex - } = uniformSetter; - texture.bind(textureIndex); - value = textureIndex; - this._textureUniforms[uniformName] = texture; - } else { - value = uniformSetter.textureIndex; - } - } else if (this._textureUniforms[uniformName]) { - delete this._textureUniforms[uniformName]; - } - if (uniformSetter(value) || textureUpdate) { - copyUniform(this.uniforms, uniformName, uniform); - } - } + _updateModelProps(props) { + let updatedProps = Object.assign({}, props); + const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); + for (const resourceTransform of resourceTransforms) { + updatedProps = resourceTransform.updateModelProps(updatedProps); } - return this; + return updatedProps; } - _areTexturesRenderable() { - let texturesRenderable = true; - for (const uniformName in this._textureUniforms) { - const texture = this._textureUniforms[uniformName]; - texture.update(); - texturesRenderable = texturesRenderable && texture.loaded; + _buildResourceTransforms(gl, props) { + if (canCreateBufferTransform(props)) { + this.bufferTransform = new BufferTransform(gl, props); } - return texturesRenderable; + if (canCreateTextureTransform(props)) { + this.textureTransform = new TextureTransform(gl, props); + } + assert6(this.bufferTransform || this.textureTransform, "must provide source/feedback buffers or source/target textures"); } - _bindTextures() { - for (const uniformName in this._textureUniforms) { - const textureIndex = this._uniformSetters[uniformName].textureIndex; - this._textureUniforms[uniformName].bind(textureIndex); + _updateDrawOptions(opts) { + let updatedOpts = Object.assign({}, opts); + const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); + for (const resourceTransform of resourceTransforms) { + updatedOpts = Object.assign(updatedOpts, resourceTransform.getDrawOptions(updatedOpts)); } + return updatedOpts; } - _createHandle() { - return this.gl.createProgram(); + }; + function canCreateBufferTransform(props) { + if (!isObjectEmpty2(props.feedbackBuffers) || !isObjectEmpty2(props.feedbackMap) || props.varyings && props.varyings.length > 0) { + return true; } - _deleteHandle() { - this.gl.deleteProgram(this.handle); + return false; + } + function canCreateTextureTransform(props) { + if (!isObjectEmpty2(props._sourceTextures) || props._targetTexture || props._targetTextureVarying) { + return true; } - _getOptionsFromHandle(handle) { - const shaderHandles = this.gl.getAttachedShaders(handle); - const opts = {}; - for (const shaderHandle of shaderHandles) { - const type = this.gl.getShaderParameter(this.handle, 35663); - switch (type) { - case 35633: - opts.vs = new VertexShader({ - handle: shaderHandle - }); - break; - case 35632: - opts.fs = new FragmentShader({ - handle: shaderHandle - }); - break; - default: - } - } - return opts; + return false; + } + + // node_modules/@luma.gl/engine/dist/esm/geometry/geometry.js + var DRAW_MODE = { + POINTS: 0, + LINES: 1, + LINE_LOOP: 2, + LINE_STRIP: 3, + TRIANGLES: 4, + TRIANGLE_STRIP: 5, + TRIANGLE_FAN: 6 + }; + var Geometry = class { + static get DRAW_MODE() { + return DRAW_MODE; } - _getParameter(pname) { - return this.gl.getProgramParameter(this.handle, pname); + constructor() { + let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + const { + id = uid("geometry"), + drawMode = DRAW_MODE.TRIANGLES, + attributes = {}, + indices = null, + vertexCount = null + } = props; + this.id = id; + this.drawMode = drawMode | 0; + this.attributes = {}; + this.userData = {}; + this._setAttributes(attributes, indices); + this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices); } - _setId(id) { - if (!id) { - const programName = this._getName(); - this.id = uid(programName); - } + get mode() { + return this.drawMode; } - _getName() { - let programName = this.vs.getName() || this.fs.getName(); - programName = programName.replace(/shader/i, ""); - programName = programName ? "".concat(programName, "-program") : "program"; - return programName; + getVertexCount() { + return this.vertexCount; } - _compileAndLink() { - const { - gl - } = this; - gl.attachShader(this.handle, this.vs.handle); - gl.attachShader(this.handle, this.fs.handle); - log2.time(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))(); - gl.linkProgram(this.handle); - log2.timeEnd(LOG_PROGRAM_PERF_PRIORITY, "linkProgram for ".concat(this._getName()))(); - if (gl.debug || log2.level > 0) { - const linked = gl.getProgramParameter(this.handle, 35714); - if (!linked) { - throw new Error("Error linking: ".concat(gl.getProgramInfoLog(this.handle))); + getAttributes() { + return this.indices ? { + indices: this.indices, + ...this.attributes + } : this.attributes; + } + _print(attributeName) { + return "Geometry ".concat(this.id, " attribute ").concat(attributeName); + } + _setAttributes(attributes, indices) { + if (indices) { + this.indices = ArrayBuffer.isView(indices) ? { + value: indices, + size: 1 + } : indices; + } + for (const attributeName in attributes) { + let attribute = attributes[attributeName]; + attribute = ArrayBuffer.isView(attribute) ? { + value: attribute + } : attribute; + assert6(ArrayBuffer.isView(attribute.value), "".concat(this._print(attributeName), ": must be typed array or object with value as typed array")); + if ((attributeName === "POSITION" || attributeName === "positions") && !attribute.size) { + attribute.size = 3; } - gl.validateProgram(this.handle); - const validated = gl.getProgramParameter(this.handle, 35715); - if (!validated) { - throw new Error("Error validating: ".concat(gl.getProgramInfoLog(this.handle))); + if (attributeName === "indices") { + assert6(!this.indices); + this.indices = attribute; + } else { + this.attributes[attributeName] = attribute; } } + if (this.indices && this.indices.isIndexed !== void 0) { + this.indices = Object.assign({}, this.indices); + delete this.indices.isIndexed; + } + return this; } - _readUniformLocationsFromLinkedProgram() { - const { - gl - } = this; - this._uniformSetters = {}; - this._uniformCount = this._getParameter(35718); - for (let i2 = 0; i2 < this._uniformCount; i2++) { - const info = this.gl.getActiveUniform(this.handle, i2); + _calculateVertexCount(attributes, indices) { + if (indices) { + return indices.value.length; + } + let vertexCount = Infinity; + for (const attributeName in attributes) { + const attribute = attributes[attributeName]; const { - name - } = parseUniformName(info.name); - let location = gl.getUniformLocation(this.handle, name); - this._uniformSetters[name] = getUniformSetter(gl, location, info); - if (info.size > 1) { - for (let l2 = 0; l2 < info.size; l2++) { - location = gl.getUniformLocation(this.handle, "".concat(name, "[").concat(l2, "]")); - this._uniformSetters["".concat(name, "[").concat(l2, "]")] = getUniformSetter(gl, location, info); - } + value, + size, + constant + } = attribute; + if (!constant && value && size >= 1) { + vertexCount = Math.min(vertexCount, value.length / size); } } - this._textureIndexCounter = 0; - } - getActiveUniforms(uniformIndices, pname) { - return this.gl2.getActiveUniforms(this.handle, uniformIndices, pname); - } - getUniformBlockIndex(blockName) { - return this.gl2.getUniformBlockIndex(this.handle, blockName); - } - getActiveUniformBlockParameter(blockIndex, pname) { - return this.gl2.getActiveUniformBlockParameter(this.handle, blockIndex, pname); - } - uniformBlockBinding(blockIndex, blockBinding) { - this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding); + assert6(Number.isFinite(vertexCount)); + return vertexCount; } }; - // node_modules/@luma.gl/webgl/dist/esm/classes/query.js - var GL_QUERY_RESULT = 34918; - var GL_QUERY_RESULT_AVAILABLE = 34919; - var GL_TIME_ELAPSED_EXT = 35007; - var GL_GPU_DISJOINT_EXT2 = 36795; - var GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 35976; - var GL_ANY_SAMPLES_PASSED = 35887; - var GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 36202; - var Query = class _Query extends Resource { - get [Symbol.toStringTag]() { - return "Query"; + // node_modules/@luma.gl/engine/dist/esm/animation/timeline.js + var channelHandles = 1; + var animationHandles = 1; + var Timeline = class { + constructor() { + this.time = 0; + this.channels = /* @__PURE__ */ new Map(); + this.animations = /* @__PURE__ */ new Map(); + this.playing = false; + this.lastEngineTime = -1; } - static isSupported(gl) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : []; - const webgl2 = isWebGL2(gl); - const hasTimerQuery = hasFeatures(gl, FEATURES.TIMER_QUERY); - let supported = webgl2 || hasTimerQuery; - for (const key of opts) { - switch (key) { - case "queries": - supported = supported && webgl2; - break; - case "timers": - supported = supported && hasTimerQuery; - break; - default: - assert6(false); + addChannel(props) { + const { + delay: delay2 = 0, + duration = Number.POSITIVE_INFINITY, + rate = 1, + repeat = 1 + } = props; + const handle = channelHandles++; + const channel = { + time: 0, + delay: delay2, + duration, + rate, + repeat + }; + this._setChannelTime(channel, this.time); + this.channels.set(handle, channel); + return handle; + } + removeChannel(handle) { + this.channels.delete(handle); + for (const [animationHandle, animation] of this.animations) { + if (animation.channel === handle) { + this.detachAnimation(animationHandle); } } - return supported; - } - constructor(gl) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - super(gl, opts); - this.target = null; - this._queryPending = false; - this._pollingPromise = null; - Object.seal(this); - } - beginTimeElapsedQuery() { - return this.begin(GL_TIME_ELAPSED_EXT); - } - beginOcclusionQuery() { - let { - conservative = false - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - return this.begin(conservative ? GL_ANY_SAMPLES_PASSED_CONSERVATIVE : GL_ANY_SAMPLES_PASSED); - } - beginTransformFeedbackQuery() { - return this.begin(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); } - begin(target) { - if (this._queryPending) { - return this; + isFinished(handle) { + const channel = this.channels.get(handle); + if (channel === void 0) { + return false; } - this.target = target; - this.gl2.beginQuery(this.target, this.handle); - return this; + return this.time >= channel.delay + channel.duration * channel.repeat; } - end() { - if (this._queryPending) { - return this; + getTime(handle) { + if (handle === void 0) { + return this.time; } - if (this.target) { - this.gl2.endQuery(this.target); - this.target = null; - this._queryPending = true; + const channel = this.channels.get(handle); + if (channel === void 0) { + return -1; } - return this; + return channel.time; } - isResultAvailable() { - if (!this._queryPending) { - return false; + setTime(time) { + this.time = Math.max(0, time); + const channels2 = this.channels.values(); + for (const channel of channels2) { + this._setChannelTime(channel, this.time); } - const resultAvailable = this.gl2.getQueryParameter(this.handle, GL_QUERY_RESULT_AVAILABLE); - if (resultAvailable) { - this._queryPending = false; + const animations = this.animations.values(); + for (const animationData of animations) { + const { + animation, + channel + } = animationData; + animation.setTime(this.getTime(channel)); } - return resultAvailable; } - isTimerDisjoint() { - return this.gl2.getParameter(GL_GPU_DISJOINT_EXT2); + play() { + this.playing = true; } - getResult() { - return this.gl2.getQueryParameter(this.handle, GL_QUERY_RESULT); + pause() { + this.playing = false; + this.lastEngineTime = -1; } - getTimerMilliseconds() { - return this.getResult() / 1e6; + reset() { + this.setTime(0); } - createPoll() { - let limit = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Number.POSITIVE_INFINITY; - if (this._pollingPromise) { - return this._pollingPromise; - } - let counter2 = 0; - this._pollingPromise = new Promise((resolve2, reject) => { - const poll = () => { - if (this.isResultAvailable()) { - resolve2(this.getResult()); - this._pollingPromise = null; - } else if (counter2++ > limit) { - reject("Timed out"); - this._pollingPromise = null; - } else { - requestAnimationFrame(poll); - } - }; - requestAnimationFrame(poll); + attachAnimation(animation, channelHandle) { + const animationHandle = animationHandles++; + this.animations.set(animationHandle, { + animation, + channel: channelHandle }); - return this._pollingPromise; + animation.setTime(this.getTime(channelHandle)); + return animationHandle; } - _createHandle() { - return _Query.isSupported(this.gl) ? this.gl2.createQuery() : null; + detachAnimation(handle) { + this.animations.delete(handle); } - _deleteHandle() { - this.gl2.deleteQuery(this.handle); + update(engineTime) { + if (this.playing) { + if (this.lastEngineTime === -1) { + this.lastEngineTime = engineTime; + } + this.setTime(this.time + (engineTime - this.lastEngineTime)); + this.lastEngineTime = engineTime; + } + } + _setChannelTime(channel, time) { + const offsetTime = time - channel.delay; + const totalDuration = channel.duration * channel.repeat; + if (offsetTime >= totalDuration) { + channel.time = channel.duration * channel.rate; + } else { + channel.time = Math.max(0, offsetTime) % channel.duration; + channel.time *= channel.rate; + } } }; - // node_modules/@luma.gl/webgl/dist/esm/classes/transform-feedback.js - var TransformFeedback = class extends Resource { - get [Symbol.toStringTag]() { - return "TransformFeedback"; - } - static isSupported(gl) { - return isWebGL2(gl); + // node_modules/@deck.gl/core/dist/esm/effects/lighting/ambient-light.js + var DEFAULT_LIGHT_COLOR = [255, 255, 255]; + var DEFAULT_LIGHT_INTENSITY = 1; + var idCount = 0; + var AmbientLight = class { + constructor(props = {}) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "color", void 0); + _defineProperty(this, "intensity", void 0); + _defineProperty(this, "type", "ambient"); + const { + color = DEFAULT_LIGHT_COLOR + } = props; + const { + intensity = DEFAULT_LIGHT_INTENSITY + } = props; + this.id = props.id || "ambient-".concat(idCount++); + this.color = color; + this.intensity = intensity; } - constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - assertWebGL2Context(gl); - super(gl, props); - this.initialize(props); - this.stubRemovedMethods("TransformFeedback", "v6.0", ["pause", "resume"]); - Object.seal(this); + }; + + // node_modules/@deck.gl/core/dist/esm/effects/lighting/directional-light.js + var DEFAULT_LIGHT_COLOR2 = [255, 255, 255]; + var DEFAULT_LIGHT_INTENSITY2 = 1; + var DEFAULT_LIGHT_DIRECTION = [0, 0, -1]; + var idCount2 = 0; + var DirectionalLight = class { + constructor(props = {}) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "color", void 0); + _defineProperty(this, "intensity", void 0); + _defineProperty(this, "type", "directional"); + _defineProperty(this, "direction", void 0); + _defineProperty(this, "shadow", void 0); + const { + color = DEFAULT_LIGHT_COLOR2 + } = props; + const { + intensity = DEFAULT_LIGHT_INTENSITY2 + } = props; + const { + direction = DEFAULT_LIGHT_DIRECTION + } = props; + const { + _shadow = false + } = props; + this.id = props.id || "directional-".concat(idCount2++); + this.color = color; + this.intensity = intensity; + this.type = "directional"; + this.direction = new Vector3(direction).normalize().toArray(); + this.shadow = _shadow; } - initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this.buffers = {}; - this.unused = {}; - this.configuration = null; - this.bindOnUse = true; - if (!isObjectEmpty2(this.buffers)) { - this.bind(() => this._unbindBuffers()); - } - this.setProps(props); + getProjectedLight(opts) { return this; } + }; + + // node_modules/@deck.gl/core/dist/esm/passes/pass.js + var Pass = class { + constructor(gl, props = { + id: "pass" + }) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "gl", void 0); + _defineProperty(this, "props", void 0); + const { + id + } = props; + this.id = id; + this.gl = gl; + this.props = { + ...props + }; + } setProps(props) { - if ("program" in props) { - this.configuration = props.program && props.program.configuration; + Object.assign(this.props, props); + } + render(params) { + } + cleanup() { + } + }; + + // node_modules/@deck.gl/core/dist/esm/passes/layers-pass.js + var LayersPass = class extends Pass { + constructor(...args) { + super(...args); + _defineProperty(this, "_lastRenderIndex", -1); + } + render(options) { + const gl = this.gl; + setParameters(gl, { + framebuffer: options.target + }); + return this._drawLayers(options); + } + _drawLayers(options) { + const { + target, + moduleParameters, + viewports, + views, + onViewportActive, + clearStack = true, + clearCanvas = true + } = options; + options.pass = options.pass || "unknown"; + const gl = this.gl; + if (clearCanvas) { + clearGLCanvas(gl, target); } - if ("configuration" in props) { - this.configuration = props.configuration; + if (clearStack) { + this._lastRenderIndex = -1; } - if ("bindOnUse" in props) { - props = props.bindOnUse; + const renderStats = []; + for (const viewport of viewports) { + const view = views && views[viewport.id]; + onViewportActive === null || onViewportActive === void 0 ? void 0 : onViewportActive(viewport); + const drawLayerParams = this._getDrawLayerParams(viewport, options); + const subViewports = viewport.subViewports || [viewport]; + for (const subViewport of subViewports) { + const stats = this._drawLayersInViewport(gl, { + target, + moduleParameters, + viewport: subViewport, + view, + pass: options.pass, + layers: options.layers + }, drawLayerParams); + renderStats.push(stats); + } } - if ("buffers" in props) { - this.setBuffers(props.buffers); + return renderStats; + } + _getDrawLayerParams(viewport, { + layers, + pass, + isPicking = false, + layerFilter, + cullRect, + effects, + moduleParameters + }, evaluateShouldDrawOnly = false) { + const drawLayerParams = []; + const indexResolver = layerIndexResolver(this._lastRenderIndex + 1); + const drawContext = { + layer: layers[0], + viewport, + isPicking, + renderPass: pass, + cullRect + }; + const layerFilterCache = {}; + for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) { + const layer = layers[layerIndex]; + const shouldDrawLayer = this._shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache); + const layerParam = { + shouldDrawLayer + }; + if (shouldDrawLayer && !evaluateShouldDrawOnly) { + layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer); + layerParam.moduleParameters = this._getModuleParameters(layer, effects, pass, moduleParameters); + layerParam.layerParameters = this.getLayerParameters(layer, layerIndex, viewport); + } + drawLayerParams[layerIndex] = layerParam; } + return drawLayerParams; } - setBuffers() { - let buffers = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this.bind(() => { - for (const bufferName in buffers) { - this.setBuffer(bufferName, buffers[bufferName]); + _drawLayersInViewport(gl, { + layers, + moduleParameters: globalModuleParameters, + pass, + target, + viewport, + view + }, drawLayerParams) { + const glViewport = getGLViewport(gl, { + moduleParameters: globalModuleParameters, + target, + viewport + }); + if (view && view.props.clear) { + const clearOpts = view.props.clear === true ? { + color: true, + depth: true + } : view.props.clear; + withParameters(gl, { + scissorTest: true, + scissor: glViewport + }, () => clear(gl, clearOpts)); + } + const renderStatus = { + totalCount: layers.length, + visibleCount: 0, + compositeCount: 0, + pickableCount: 0 + }; + setParameters(gl, { + viewport: glViewport + }); + for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) { + const layer = layers[layerIndex]; + const { + shouldDrawLayer, + layerRenderIndex, + moduleParameters, + layerParameters + } = drawLayerParams[layerIndex]; + if (shouldDrawLayer && layer.props.pickable) { + renderStatus.pickableCount++; + } + if (layer.isComposite) { + renderStatus.compositeCount++; + } else if (shouldDrawLayer) { + renderStatus.visibleCount++; + this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex); + moduleParameters.viewport = viewport; + try { + layer._drawLayer({ + moduleParameters, + uniforms: { + layerIndex: layerRenderIndex + }, + parameters: layerParameters + }); + } catch (err3) { + layer.raiseError(err3, "drawing ".concat(layer, " to ").concat(pass)); + } } - }); - return this; - } - setBuffer(locationOrName, bufferOrParams) { - const location = this._getVaryingIndex(locationOrName); - const { - buffer, - byteSize, - byteOffset - } = this._getBufferParams(bufferOrParams); - if (location < 0) { - this.unused[locationOrName] = buffer; - log2.warn("".concat(this.id, " unused varying buffer ").concat(locationOrName))(); - return this; - } - this.buffers[location] = bufferOrParams; - if (!this.bindOnUse) { - this._bindBuffer(location, buffer, byteOffset, byteSize); } - return this; - } - begin() { - let primitiveMode = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0; - this.gl.bindTransformFeedback(36386, this.handle); - this._bindBuffers(); - this.gl.beginTransformFeedback(primitiveMode); - return this; + return renderStatus; } - end() { - this.gl.endTransformFeedback(); - this._unbindBuffers(); - this.gl.bindTransformFeedback(36386, null); - return this; + shouldDrawLayer(layer) { + return true; } - _getBufferParams(bufferOrParams) { - let byteOffset; - let byteSize; - let buffer; - if (bufferOrParams instanceof Buffer2 === false) { - buffer = bufferOrParams.buffer; - byteSize = bufferOrParams.byteSize; - byteOffset = bufferOrParams.byteOffset; - } else { - buffer = bufferOrParams; - } - if (byteOffset !== void 0 || byteSize !== void 0) { - byteOffset = byteOffset || 0; - byteSize = byteSize || buffer.byteLength - byteOffset; - } - return { - buffer, - byteOffset, - byteSize - }; + getModuleParameters(layer, effects) { + return null; } - _getVaryingInfo(locationOrName) { - return this.configuration && this.configuration.getVaryingInfo(locationOrName); + getLayerParameters(layer, layerIndex, viewport) { + return layer.props.parameters; } - _getVaryingIndex(locationOrName) { - if (this.configuration) { - return this.configuration.getVaryingInfo(locationOrName).location; + _shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache) { + const shouldDrawLayer = layer.props.visible && this.shouldDrawLayer(layer); + if (!shouldDrawLayer) { + return false; } - const location = Number(locationOrName); - return Number.isFinite(location) ? location : -1; - } - _bindBuffers() { - if (this.bindOnUse) { - for (const bufferIndex in this.buffers) { - const { - buffer, - byteSize, - byteOffset - } = this._getBufferParams(this.buffers[bufferIndex]); - this._bindBuffer(bufferIndex, buffer, byteOffset, byteSize); + drawContext.layer = layer; + let parent = layer.parent; + while (parent) { + if (!parent.props.visible || !parent.filterSubLayer(drawContext)) { + return false; } + drawContext.layer = parent; + parent = parent.parent; } - } - _unbindBuffers() { - if (this.bindOnUse) { - for (const bufferIndex in this.buffers) { - this._bindBuffer(bufferIndex, null); + if (layerFilter) { + const rootLayerId = drawContext.layer.id; + if (!(rootLayerId in layerFilterCache)) { + layerFilterCache[rootLayerId] = layerFilter(drawContext); + } + if (!layerFilterCache[rootLayerId]) { + return false; } } + layer.activateViewport(drawContext.viewport); + return true; } - _bindBuffer(index, buffer) { - let byteOffset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0; - let byteSize = arguments.length > 3 ? arguments[3] : void 0; - const handle = buffer && buffer.handle; - if (!handle || byteSize === void 0) { - this.gl.bindBufferBase(35982, index, handle); - } else { - this.gl.bindBufferRange(35982, index, handle, byteOffset, byteSize); + _getModuleParameters(layer, effects, pass, overrides) { + var _layer$internalState; + const moduleParameters = Object.assign(Object.create(((_layer$internalState = layer.internalState) === null || _layer$internalState === void 0 ? void 0 : _layer$internalState.propsInTransition) || layer.props), { + autoWrapLongitude: layer.wrapLongitude, + viewport: layer.context.viewport, + mousePosition: layer.context.mousePosition, + pickingActive: 0, + devicePixelRatio: cssToDeviceRatio(this.gl) + }); + if (effects) { + for (const effect of effects) { + var _effect$getModulePara; + Object.assign(moduleParameters, (_effect$getModulePara = effect.getModuleParameters) === null || _effect$getModulePara === void 0 ? void 0 : _effect$getModulePara.call(effect, layer)); + } } - return this; - } - _createHandle() { - return this.gl.createTransformFeedback(); - } - _deleteHandle() { - this.gl.deleteTransformFeedback(this.handle); - } - _bindHandle(handle) { - this.gl.bindTransformFeedback(36386, this.handle); + return Object.assign(moduleParameters, this.getModuleParameters(layer, effects), overrides); } }; - - // node_modules/@luma.gl/webgl/dist/esm/utils/array-utils-flat.js - var arrayBuffer = null; - function getScratchArrayBuffer(byteLength) { - if (!arrayBuffer || arrayBuffer.byteLength < byteLength) { - arrayBuffer = new ArrayBuffer(byteLength); - } - return arrayBuffer; - } - function getScratchArray(Type, length) { - const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length); - return new Type(scratchArrayBuffer, 0, length); - } - function fillArray(_ref) { - let { - target, - source, - start = 0, - count: count2 = 1 - } = _ref; - const length = source.length; - const total = count2 * length; - let copied = 0; - for (let i2 = start; copied < length; copied++) { - target[i2++] = source[copied]; - } - while (copied < total) { - if (copied < total - copied) { - target.copyWithin(start + copied, start, start + copied); - copied *= 2; + function layerIndexResolver(startIndex = 0, layerIndices = {}) { + const resolvers = {}; + const resolveLayerIndex = (layer, isDrawn) => { + const indexOverride = layer.props._offset; + const layerId = layer.id; + const parentId = layer.parent && layer.parent.id; + let index; + if (parentId && !(parentId in layerIndices)) { + resolveLayerIndex(layer.parent, false); + } + if (parentId in resolvers) { + const resolver = resolvers[parentId] = resolvers[parentId] || layerIndexResolver(layerIndices[parentId], layerIndices); + index = resolver(layer, isDrawn); + resolvers[layerId] = resolver; + } else if (Number.isFinite(indexOverride)) { + index = indexOverride + (layerIndices[parentId] || 0); + resolvers[layerId] = null; } else { - target.copyWithin(start + copied, start, start + total - copied); - copied = total; + index = startIndex; } - } - return target; + if (isDrawn && index >= startIndex) { + startIndex = index + 1; + } + layerIndices[layerId] = index; + return index; + }; + return resolveLayerIndex; + } + function getGLViewport(gl, { + moduleParameters, + target, + viewport + }) { + const useTarget = target && target.id !== "default-framebuffer"; + const pixelRatio = moduleParameters && moduleParameters.devicePixelRatio || cssToDeviceRatio(gl); + const height = useTarget ? target.height : gl.drawingBufferHeight; + const dimensions = viewport; + return [dimensions.x * pixelRatio, height - (dimensions.y + dimensions.height) * pixelRatio, dimensions.width * pixelRatio, dimensions.height * pixelRatio]; + } + function clearGLCanvas(gl, targetFramebuffer) { + const width = targetFramebuffer ? targetFramebuffer.width : gl.drawingBufferWidth; + const height = targetFramebuffer ? targetFramebuffer.height : gl.drawingBufferHeight; + setParameters(gl, { + viewport: [0, 0, width, height] + }); + gl.clear(16384 | 256); } - // node_modules/@luma.gl/webgl/dist/esm/classes/vertex-array-object.js - var ERR_ELEMENTS = "elements must be GL.ELEMENT_ARRAY_BUFFER"; - var VertexArrayObject = class _VertexArrayObject extends Resource { - get [Symbol.toStringTag]() { - return "VertexArrayObject"; - } - static isSupported(gl) { - let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - if (options.constantAttributeZero) { - return isWebGL2(gl) || getBrowser() === "Chrome"; - } - return true; + // node_modules/@deck.gl/core/dist/esm/passes/shadow-pass.js + var ShadowPass = class extends LayersPass { + constructor(gl, props) { + super(gl, props); + _defineProperty(this, "shadowMap", void 0); + _defineProperty(this, "depthBuffer", void 0); + _defineProperty(this, "fbo", void 0); + this.shadowMap = new Texture2D(gl, { + width: 1, + height: 1, + parameters: { + [10241]: 9729, + [10240]: 9729, + [10242]: 33071, + [10243]: 33071 + } + }); + this.depthBuffer = new Renderbuffer(gl, { + format: 33189, + width: 1, + height: 1 + }); + this.fbo = new Framebuffer(gl, { + id: "shadowmap", + width: 1, + height: 1, + attachments: { + [36064]: this.shadowMap, + [36096]: this.depthBuffer + } + }); } - static getDefaultArray(gl) { - gl.luma = gl.luma || {}; - if (!gl.luma.defaultVertexArray) { - gl.luma.defaultVertexArray = new _VertexArrayObject(gl, { - handle: null, - isDefaultArray: true + render(params) { + const target = this.fbo; + withParameters(this.gl, { + depthRange: [0, 1], + depthTest: true, + blend: false, + clearColor: [1, 1, 1, 1] + }, () => { + const viewport = params.viewports[0]; + const pixelRatio = cssToDeviceRatio(this.gl); + const width = viewport.width * pixelRatio; + const height = viewport.height * pixelRatio; + if (width !== target.width || height !== target.height) { + target.resize({ + width, + height + }); + } + super.render({ + ...params, + target, + pass: "shadow" }); - } - return gl.luma.defaultVertexArray; - } - static getMaxAttributes(gl) { - _VertexArrayObject.MAX_ATTRIBUTES = _VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(34921); - return _VertexArrayObject.MAX_ATTRIBUTES; + }); } - static setConstant(gl, location, array) { - switch (array.constructor) { - case Float32Array: - _VertexArrayObject._setConstantFloatArray(gl, location, array); - break; - case Int32Array: - _VertexArrayObject._setConstantIntArray(gl, location, array); - break; - case Uint32Array: - _VertexArrayObject._setConstantUintArray(gl, location, array); - break; - default: - assert6(false); - } + shouldDrawLayer(layer) { + return layer.props.shadowEnabled !== false; } - constructor(gl) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const id = opts.id || opts.program && opts.program.id; - super(gl, Object.assign({}, opts, { - id - })); - this.buffer = null; - this.bufferValue = null; - this.isDefaultArray = opts.isDefaultArray || false; - this.gl2 = gl; - this.initialize(opts); - Object.seal(this); + getModuleParameters() { + return { + drawToShadowMap: true + }; } delete() { - super.delete(); - if (this.buffer) { - this.buffer.delete(); - } - return this; - } - get MAX_ATTRIBUTES() { - return _VertexArrayObject.getMaxAttributes(this.gl); - } - initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - return this.setProps(props); - } - setProps(props) { - return this; - } - setElementBuffer() { - let elementBuffer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - assert6(!elementBuffer || elementBuffer.target === 34963, ERR_ELEMENTS); - this.bind(() => { - this.gl.bindBuffer(34963, elementBuffer ? elementBuffer.handle : null); - }); - return this; - } - setBuffer(location, buffer, accessor) { - if (buffer.target === 34963) { - return this.setElementBuffer(buffer, accessor); + if (this.fbo) { + this.fbo.delete(); + this.fbo = null; } - const { - size, - type, - stride, - offset, - normalized, - integer, - divisor - } = accessor; - const { - gl, - gl2 - } = this; - location = Number(location); - this.bind(() => { - gl.bindBuffer(34962, buffer.handle); - if (integer) { - assert6(isWebGL2(gl)); - gl2.vertexAttribIPointer(location, size, type, stride, offset); - } else { - gl.vertexAttribPointer(location, size, type, normalized, stride, offset); - } - gl.enableVertexAttribArray(location); - gl2.vertexAttribDivisor(location, divisor || 0); - }); - return this; - } - enable(location) { - let enable2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true; - const disablingAttributeZero = !enable2 && location === 0 && !_VertexArrayObject.isSupported(this.gl, { - constantAttributeZero: true - }); - if (!disablingAttributeZero) { - location = Number(location); - this.bind(() => enable2 ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location)); + if (this.shadowMap) { + this.shadowMap.delete(); + this.shadowMap = null; } - return this; - } - getConstantBuffer(elementCount, value) { - const constantValue = this._normalizeConstantArrayValue(value); - const byteLength = constantValue.byteLength * elementCount; - const length = constantValue.length * elementCount; - let updateNeeded = !this.buffer; - this.buffer = this.buffer || new Buffer2(this.gl, byteLength); - updateNeeded = updateNeeded || this.buffer.reallocate(byteLength); - updateNeeded = updateNeeded || !this._compareConstantArrayValues(constantValue, this.bufferValue); - if (updateNeeded) { - const typedArray = getScratchArray(value.constructor, length); - fillArray({ - target: typedArray, - source: constantValue, - start: 0, - count: length - }); - this.buffer.subData(typedArray); - this.bufferValue = value; + if (this.depthBuffer) { + this.depthBuffer.delete(); + this.depthBuffer = null; } - return this.buffer; } - _normalizeConstantArrayValue(arrayValue) { - if (Array.isArray(arrayValue)) { - return new Float32Array(arrayValue); - } - return arrayValue; + }; + + // node_modules/@deck.gl/core/dist/esm/shaderlib/misc/geometry.js + var defines = "#define SMOOTH_EDGE_RADIUS 0.5"; + var vs3 = "\n".concat(defines, "\n\nstruct VertexGeometry {\n vec4 position;\n vec3 worldPosition;\n vec3 worldPositionAlt;\n vec3 normal;\n vec2 uv;\n vec3 pickingColor;\n} geometry = VertexGeometry(\n vec4(0.0, 0.0, 1.0, 0.0),\n vec3(0.0),\n vec3(0.0),\n vec3(0.0),\n vec2(0.0),\n vec3(0.0)\n);\n"); + var fs2 = "\n".concat(defines, "\n\nstruct FragmentGeometry {\n vec2 uv;\n} geometry;\n\nfloat smoothedge(float edge, float x) {\n return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n"); + var geometry_default = { + name: "geometry", + vs: vs3, + fs: fs2 + }; + + // node_modules/@deck.gl/core/dist/esm/shaderlib/project/project.glsl.js + var COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => "const int COORDINATE_SYSTEM_".concat(key, " = ").concat(COORDINATE_SYSTEM[key], ";")).join(""); + var PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => "const int PROJECTION_MODE_".concat(key, " = ").concat(PROJECTION_MODE[key], ";")).join(""); + var UNIT_GLSL_CONSTANTS = Object.keys(UNIT).map((key) => "const int UNIT_".concat(key.toUpperCase(), " = ").concat(UNIT[key], ";")).join(""); + var project_glsl_default = "".concat(COORDINATE_SYSTEM_GLSL_CONSTANTS, "\n").concat(PROJECTION_MODE_GLSL_CONSTANTS, "\n").concat(UNIT_GLSL_CONSTANTS, "\n\nuniform int project_uCoordinateSystem;\nuniform int project_uProjectionMode;\nuniform float project_uScale;\nuniform bool project_uWrapLongitude;\nuniform vec3 project_uCommonUnitsPerMeter;\nuniform vec3 project_uCommonUnitsPerWorldUnit;\nuniform vec3 project_uCommonUnitsPerWorldUnit2;\nuniform vec4 project_uCenter;\nuniform mat4 project_uModelMatrix;\nuniform mat4 project_uViewProjectionMatrix;\nuniform vec2 project_uViewportSize;\nuniform float project_uDevicePixelRatio;\nuniform float project_uFocalDistance;\nuniform vec3 project_uCameraPosition;\nuniform vec3 project_uCoordinateOrigin;\nuniform vec3 project_uCommonOrigin;\nuniform bool project_uPseudoMeters;\n\nconst float TILE_SIZE = 512.0;\nconst float PI = 3.1415926536;\nconst float WORLD_SCALE = TILE_SIZE / (PI * 2.0);\nconst vec3 ZERO_64_LOW = vec3(0.0);\nconst float EARTH_RADIUS = 6370972.0;\nconst float GLOBE_RADIUS = 256.0;\nfloat project_size_at_latitude(float lat) {\n float y = clamp(lat, -89.9, 89.9);\n return 1.0 / cos(radians(y));\n}\n\nfloat project_size() {\n if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR &&\n project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT &&\n project_uPseudoMeters == false) {\n \n if (geometry.position.w == 0.0) {\n return project_size_at_latitude(geometry.worldPosition.y);\n }\n \n float y = geometry.position.y / TILE_SIZE * 2.0 - 1.0;\n float y2 = y * y;\n float y4 = y2 * y2;\n float y6 = y4 * y2;\n return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;\n }\n return 1.0;\n}\n\nfloat project_size_at_latitude(float meters, float lat) {\n return meters * project_uCommonUnitsPerMeter.z * project_size_at_latitude(lat);\n}\nfloat project_size(float meters) {\n return meters * project_uCommonUnitsPerMeter.z * project_size();\n}\n\nvec2 project_size(vec2 meters) {\n return meters * project_uCommonUnitsPerMeter.xy * project_size();\n}\n\nvec3 project_size(vec3 meters) {\n return meters * project_uCommonUnitsPerMeter * project_size();\n}\n\nvec4 project_size(vec4 meters) {\n return vec4(meters.xyz * project_uCommonUnitsPerMeter, meters.w);\n}\nmat3 project_get_orientation_matrix(vec3 up) {\n vec3 uz = normalize(up);\n vec3 ux = abs(uz.z) == 1.0 ? vec3(1.0, 0.0, 0.0) : normalize(vec3(uz.y, -uz.x, 0));\n vec3 uy = cross(uz, ux);\n return mat3(ux, uy, uz);\n}\n\nbool project_needs_rotation(vec3 commonPosition, out mat3 transform) {\n if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {\n transform = project_get_orientation_matrix(commonPosition);\n return true;\n }\n return false;\n}\nvec3 project_normal(vec3 vector) {\n vec4 normal_modelspace = project_uModelMatrix * vec4(vector, 0.0);\n vec3 n = normalize(normal_modelspace.xyz * project_uCommonUnitsPerMeter);\n mat3 rotation;\n if (project_needs_rotation(geometry.position.xyz, rotation)) {\n n = rotation * n;\n }\n return n;\n}\n\nvec4 project_offset_(vec4 offset) {\n float dy = offset.y;\n vec3 commonUnitsPerWorldUnit = project_uCommonUnitsPerWorldUnit + project_uCommonUnitsPerWorldUnit2 * dy;\n return vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w);\n}\nvec2 project_mercator_(vec2 lnglat) {\n float x = lnglat.x;\n if (project_uWrapLongitude) {\n x = mod(x + 180., 360.0) - 180.;\n }\n float y = clamp(lnglat.y, -89.9, 89.9);\n return vec2(\n radians(x) + PI,\n PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))\n ) * WORLD_SCALE;\n}\n\nvec3 project_globe_(vec3 lnglatz) {\n float lambda = radians(lnglatz.x);\n float phi = radians(lnglatz.y);\n float cosPhi = cos(phi);\n float D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;\n\n return vec3(\n sin(lambda) * cosPhi,\n -cos(lambda) * cosPhi,\n sin(phi)\n ) * D;\n}\nvec4 project_position(vec4 position, vec3 position64Low) {\n vec4 position_world = project_uModelMatrix * position;\n if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR) {\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n return vec4(\n project_mercator_(position_world.xy),\n project_size_at_latitude(position_world.z, position_world.y),\n position_world.w\n );\n }\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {\n position_world.xyz += project_uCoordinateOrigin;\n }\n }\n if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n return vec4(\n project_globe_(position_world.xyz),\n position_world.w\n );\n }\n }\n if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n if (abs(position_world.y - project_uCoordinateOrigin.y) > 0.25) {\n return vec4(\n project_mercator_(position_world.xy) - project_uCommonOrigin.xy,\n project_size(position_world.z),\n position_world.w\n );\n }\n }\n }\n if (project_uProjectionMode == PROJECTION_MODE_IDENTITY ||\n (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&\n (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||\n project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {\n position_world.xyz -= project_uCoordinateOrigin;\n }\n return project_offset_(position_world) + project_offset_(project_uModelMatrix * vec4(position64Low, 0.0));\n}\n\nvec4 project_position(vec4 position) {\n return project_position(position, ZERO_64_LOW);\n}\n\nvec3 project_position(vec3 position, vec3 position64Low) {\n vec4 projected_position = project_position(vec4(position, 1.0), position64Low);\n return projected_position.xyz;\n}\n\nvec3 project_position(vec3 position) {\n vec4 projected_position = project_position(vec4(position, 1.0), ZERO_64_LOW);\n return projected_position.xyz;\n}\n\nvec2 project_position(vec2 position) {\n vec4 projected_position = project_position(vec4(position, 0.0, 1.0), ZERO_64_LOW);\n return projected_position.xy;\n}\n\nvec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) {\n return viewProjectionMatrix * position + center;\n}\nvec4 project_common_position_to_clipspace(vec4 position) {\n return project_common_position_to_clipspace(position, project_uViewProjectionMatrix, project_uCenter);\n}\nvec2 project_pixel_size_to_clipspace(vec2 pixels) {\n vec2 offset = pixels / project_uViewportSize * project_uDevicePixelRatio * 2.0;\n return offset * project_uFocalDistance;\n}\n\nfloat project_size_to_pixel(float meters) {\n return project_size(meters) * project_uScale;\n}\nfloat project_size_to_pixel(float size, int unit) {\n if (unit == UNIT_METERS) return project_size_to_pixel(size);\n if (unit == UNIT_COMMON) return size * project_uScale;\n return size;\n}\nfloat project_pixel_size(float pixels) {\n return pixels / project_uScale;\n}\nvec2 project_pixel_size(vec2 pixels) {\n return pixels / project_uScale;\n}\n"); + + // node_modules/@deck.gl/core/dist/esm/utils/memoize.js + function isEqual(a2, b2) { + if (a2 === b2) { + return true; } - _compareConstantArrayValues(v1, v2) { - if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) { + if (Array.isArray(a2)) { + const len2 = a2.length; + if (!b2 || b2.length !== len2) { return false; } - for (let i2 = 0; i2 < v1.length; ++i2) { - if (v1[i2] !== v2[i2]) { + for (let i3 = 0; i3 < len2; i3++) { + if (a2[i3] !== b2[i3]) { return false; } } return true; } - static _setConstantFloatArray(gl, location, array) { - switch (array.length) { - case 1: - gl.vertexAttrib1fv(location, array); - break; - case 2: - gl.vertexAttrib2fv(location, array); - break; - case 3: - gl.vertexAttrib3fv(location, array); - break; - case 4: - gl.vertexAttrib4fv(location, array); - break; - default: - assert6(false); - } + return false; + } + function memoize(compute) { + let cachedArgs = {}; + let cachedResult; + return (args) => { + for (const key in args) { + if (!isEqual(args[key], cachedArgs[key])) { + cachedResult = compute(args); + cachedArgs = args; + break; + } + } + return cachedResult; + }; + } + + // node_modules/@deck.gl/core/dist/esm/shaderlib/project/viewport-uniforms.js + var ZERO_VECTOR = [0, 0, 0, 0]; + var VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]; + var IDENTITY_MATRIX4 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; + var DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0]; + var DEFAULT_COORDINATE_ORIGIN = [0, 0, 0]; + var getMemoizedViewportUniforms = memoize(calculateViewportUniforms); + function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN) { + if (coordinateOrigin.length < 3) { + coordinateOrigin = [coordinateOrigin[0], coordinateOrigin[1], 0]; + } + let shaderCoordinateOrigin = coordinateOrigin; + let geospatialOrigin; + let offsetMode = true; + if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS || coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) { + geospatialOrigin = coordinateOrigin; + } else { + geospatialOrigin = viewport.isGeospatial ? [Math.fround(viewport.longitude), Math.fround(viewport.latitude), 0] : null; + } + switch (viewport.projectionMode) { + case PROJECTION_MODE.WEB_MERCATOR: + if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) { + geospatialOrigin = [0, 0, 0]; + offsetMode = false; + } + break; + case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET: + if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) { + shaderCoordinateOrigin = geospatialOrigin; + } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) { + shaderCoordinateOrigin = [Math.fround(viewport.center[0]), Math.fround(viewport.center[1]), 0]; + geospatialOrigin = viewport.unprojectPosition(shaderCoordinateOrigin); + shaderCoordinateOrigin[0] -= coordinateOrigin[0]; + shaderCoordinateOrigin[1] -= coordinateOrigin[1]; + shaderCoordinateOrigin[2] -= coordinateOrigin[2]; + } + break; + case PROJECTION_MODE.IDENTITY: + shaderCoordinateOrigin = viewport.position.map(Math.fround); + shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0; + break; + case PROJECTION_MODE.GLOBE: + offsetMode = false; + geospatialOrigin = null; + break; + default: + offsetMode = false; + } + return { + geospatialOrigin, + shaderCoordinateOrigin, + offsetMode + }; + } + function calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin) { + const { + viewMatrixUncentered, + projectionMatrix + } = viewport; + let { + viewMatrix: viewMatrix2, + viewProjectionMatrix + } = viewport; + let projectionCenter = ZERO_VECTOR; + let originCommon = ZERO_VECTOR; + let cameraPosCommon = viewport.cameraPosition; + const { + geospatialOrigin, + shaderCoordinateOrigin, + offsetMode + } = getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin); + if (offsetMode) { + originCommon = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin); + cameraPosCommon = [cameraPosCommon[0] - originCommon[0], cameraPosCommon[1] - originCommon[1], cameraPosCommon[2] - originCommon[2]]; + originCommon[3] = 1; + projectionCenter = transformMat43([], originCommon, viewProjectionMatrix); + viewMatrix2 = viewMatrixUncentered || viewMatrix2; + viewProjectionMatrix = multiply2([], projectionMatrix, viewMatrix2); + viewProjectionMatrix = multiply2([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX); + } + return { + viewMatrix: viewMatrix2, + viewProjectionMatrix, + projectionCenter, + originCommon, + cameraPosCommon, + shaderCoordinateOrigin, + geospatialOrigin + }; + } + function getUniformsFromViewport({ + viewport, + devicePixelRatio = 1, + modelMatrix = null, + coordinateSystem = COORDINATE_SYSTEM.DEFAULT, + coordinateOrigin = DEFAULT_COORDINATE_ORIGIN, + autoWrapLongitude = false + }) { + if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { + coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN; } - static _setConstantIntArray(gl, location, array) { - assert6(isWebGL2(gl)); - switch (array.length) { - case 1: - gl.vertexAttribI1iv(location, array); - break; - case 2: - gl.vertexAttribI2iv(location, array); + const uniforms = getMemoizedViewportUniforms({ + viewport, + devicePixelRatio, + coordinateSystem, + coordinateOrigin + }); + uniforms.project_uWrapLongitude = autoWrapLongitude; + uniforms.project_uModelMatrix = modelMatrix || IDENTITY_MATRIX4; + return uniforms; + } + function calculateViewportUniforms({ + viewport, + devicePixelRatio, + coordinateSystem, + coordinateOrigin + }) { + const { + projectionCenter, + viewProjectionMatrix, + originCommon, + cameraPosCommon, + shaderCoordinateOrigin, + geospatialOrigin + } = calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin); + const distanceScales = viewport.getDistanceScales(); + const viewportSize = [viewport.width * devicePixelRatio, viewport.height * devicePixelRatio]; + const focalDistance = transformMat43([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1; + const uniforms = { + project_uCoordinateSystem: coordinateSystem, + project_uProjectionMode: viewport.projectionMode, + project_uCoordinateOrigin: shaderCoordinateOrigin, + project_uCommonOrigin: originCommon.slice(0, 3), + project_uCenter: projectionCenter, + project_uPseudoMeters: Boolean(viewport._pseudoMeters), + project_uViewportSize: viewportSize, + project_uDevicePixelRatio: devicePixelRatio, + project_uFocalDistance: focalDistance, + project_uCommonUnitsPerMeter: distanceScales.unitsPerMeter, + project_uCommonUnitsPerWorldUnit: distanceScales.unitsPerMeter, + project_uCommonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2, + project_uScale: viewport.scale, + project_uWrapLongitude: false, + project_uViewProjectionMatrix: viewProjectionMatrix, + project_uModelMatrix: IDENTITY_MATRIX4, + project_uCameraPosition: cameraPosCommon + }; + if (geospatialOrigin) { + const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin); + switch (coordinateSystem) { + case COORDINATE_SYSTEM.METER_OFFSETS: + uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter; + uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2; break; - case 3: - gl.vertexAttribI3iv(location, array); + case COORDINATE_SYSTEM.LNGLAT: + case COORDINATE_SYSTEM.LNGLAT_OFFSETS: + if (!viewport._pseudoMeters) { + uniforms.project_uCommonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter; + } + uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree; + uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2; break; - case 4: - gl.vertexAttribI4iv(location, array); + case COORDINATE_SYSTEM.CARTESIAN: + uniforms.project_uCommonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]]; + uniforms.project_uCommonUnitsPerWorldUnit2 = [0, 0, distanceScalesAtOrigin.unitsPerMeter2[2]]; break; default: - assert6(false); - } - } - static _setConstantUintArray(gl, location, array) { - assert6(isWebGL2(gl)); - switch (array.length) { - case 1: - gl.vertexAttribI1uiv(location, array); - break; - case 2: - gl.vertexAttribI2uiv(location, array); - break; - case 3: - gl.vertexAttribI3uiv(location, array); - break; - case 4: - gl.vertexAttribI4uiv(location, array); break; - default: - assert6(false); } } - _createHandle() { - const gl2 = this.gl; - return gl2.createVertexArray(); - } - _deleteHandle(handle) { - this.gl2.deleteVertexArray(handle); - return [this.elements]; - } - _bindHandle(handle) { - this.gl2.bindVertexArray(handle); - } - _getParameter(pname, _ref) { - let { - location - } = _ref; - assert6(Number.isFinite(location)); - return this.bind(() => { - switch (pname) { - case 34373: - return this.gl.getVertexAttribOffset(location, pname); - default: - return this.gl.getVertexAttrib(location, pname); - } - }); + return uniforms; + } + + // node_modules/@deck.gl/core/dist/esm/shaderlib/project/project.js + var INITIAL_MODULE_OPTIONS3 = {}; + function getUniforms4(opts = INITIAL_MODULE_OPTIONS3) { + if ("viewport" in opts) { + return getUniformsFromViewport(opts); } + return {}; + } + var project_default = { + name: "project", + dependencies: [fp32, geometry_default], + vs: project_glsl_default, + getUniforms: getUniforms4 }; - // node_modules/@luma.gl/webgl/dist/esm/classes/vertex-array.js - var ERR_ATTRIBUTE_TYPE = "VertexArray: attributes must be Buffers or constants (i.e. typed array)"; - var MULTI_LOCATION_ATTRIBUTE_REGEXP = /^(.+)__LOCATION_([0-9]+)$/; - var DEPRECATIONS_V6 = ["setBuffers", "setGeneric", "clearBindings", "setLocations", "setGenericValues", "setDivisor", "enable", "disable"]; - var VertexArray = class { - constructor(gl) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const id = opts.id || opts.program && opts.program.id; - this.id = id; - this.gl = gl; - this.configuration = null; - this.elements = null; - this.elementsAccessor = null; - this.values = null; - this.accessors = null; - this.unused = null; - this.drawParams = null; - this.buffer = null; - this.attributes = {}; - this.vertexArrayObject = new VertexArrayObject(gl); - stubRemovedMethods(this, "VertexArray", "v6.0", DEPRECATIONS_V6); - this.initialize(opts); - Object.seal(this); - } - delete() { - if (this.buffer) { - this.buffer.delete(); - } - this.vertexArrayObject.delete(); + // node_modules/@math.gl/web-mercator/dist/esm/math-utils.js + function createMat4() { + return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; + } + function transformVector(matrix, vector) { + const result = transformMat43([], vector, matrix); + scale3(result, result, 1 / result[3]); + return result; + } + function mod(value, divisor) { + const modulus = value % divisor; + return modulus < 0 ? divisor + modulus : modulus; + } + function clamp2(x2, min, max) { + return x2 < min ? min : x2 > max ? max : x2; + } + function ieLog2(x2) { + return Math.log(x2) * Math.LOG2E; + } + var log22 = Math.log2 || ieLog2; + + // node_modules/@math.gl/web-mercator/dist/esm/assert.js + function assert9(condition, message) { + if (!condition) { + throw new Error(message || "@math.gl/web-mercator: assertion failed."); } - initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this.reset(); - this.configuration = null; - this.bindOnUse = false; - return this.setProps(props); + } + + // node_modules/@math.gl/web-mercator/dist/esm/web-mercator-utils.js + var PI = Math.PI; + var PI_4 = PI / 4; + var DEGREES_TO_RADIANS2 = PI / 180; + var RADIANS_TO_DEGREES2 = 180 / PI; + var TILE_SIZE = 512; + var EARTH_CIRCUMFERENCE = 4003e4; + var MAX_LATITUDE = 85.051129; + var DEFAULT_ALTITUDE = 1.5; + function scaleToZoom(scale5) { + return log22(scale5); + } + function lngLatToWorld(lngLat) { + const [lng, lat] = lngLat; + assert9(Number.isFinite(lng)); + assert9(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude"); + const lambda2 = lng * DEGREES_TO_RADIANS2; + const phi2 = lat * DEGREES_TO_RADIANS2; + const x2 = TILE_SIZE * (lambda2 + PI) / (2 * PI); + const y2 = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI); + return [x2, y2]; + } + function worldToLngLat(xy) { + const [x2, y2] = xy; + const lambda2 = x2 / TILE_SIZE * (2 * PI) - PI; + const phi2 = 2 * (Math.atan(Math.exp(y2 / TILE_SIZE * (2 * PI) - PI)) - PI_4); + return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2]; + } + function getMeterZoom(options) { + const { + latitude + } = options; + assert9(Number.isFinite(latitude)); + const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); + return scaleToZoom(EARTH_CIRCUMFERENCE * latCosine) - 9; + } + function unitsPerMeter(latitude) { + const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); + return TILE_SIZE / EARTH_CIRCUMFERENCE / latCosine; + } + function getDistanceScales(options) { + const { + latitude, + longitude, + highPrecision = false + } = options; + assert9(Number.isFinite(latitude) && Number.isFinite(longitude)); + const worldSize = TILE_SIZE; + const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); + const unitsPerDegreeX = worldSize / 360; + const unitsPerDegreeY = unitsPerDegreeX / latCosine; + const altUnitsPerMeter = worldSize / EARTH_CIRCUMFERENCE / latCosine; + const result = { + unitsPerMeter: [altUnitsPerMeter, altUnitsPerMeter, altUnitsPerMeter], + metersPerUnit: [1 / altUnitsPerMeter, 1 / altUnitsPerMeter, 1 / altUnitsPerMeter], + unitsPerDegree: [unitsPerDegreeX, unitsPerDegreeY, altUnitsPerMeter], + degreesPerUnit: [1 / unitsPerDegreeX, 1 / unitsPerDegreeY, 1 / altUnitsPerMeter] + }; + if (highPrecision) { + const latCosine2 = DEGREES_TO_RADIANS2 * Math.tan(latitude * DEGREES_TO_RADIANS2) / latCosine; + const unitsPerDegreeY2 = unitsPerDegreeX * latCosine2 / 2; + const altUnitsPerDegree2 = worldSize / EARTH_CIRCUMFERENCE * latCosine2; + const altUnitsPerMeter2 = altUnitsPerDegree2 / unitsPerDegreeY * altUnitsPerMeter; + result.unitsPerDegree2 = [0, unitsPerDegreeY2, altUnitsPerDegree2]; + result.unitsPerMeter2 = [altUnitsPerMeter2, 0, altUnitsPerMeter2]; } - reset() { - this.elements = null; - this.elementsAccessor = null; - const { - MAX_ATTRIBUTES - } = this.vertexArrayObject; - this.values = new Array(MAX_ATTRIBUTES).fill(null); - this.accessors = new Array(MAX_ATTRIBUTES).fill(null); - this.unused = {}; - this.drawParams = null; - return this; + return result; + } + function addMetersToLngLat(lngLatZ, xyz) { + const [longitude, latitude, z0] = lngLatZ; + const [x2, y2, z] = xyz; + const { + unitsPerMeter: unitsPerMeter2, + unitsPerMeter2: unitsPerMeter22 + } = getDistanceScales({ + longitude, + latitude, + highPrecision: true + }); + const worldspace = lngLatToWorld(lngLatZ); + worldspace[0] += x2 * (unitsPerMeter2[0] + unitsPerMeter22[0] * y2); + worldspace[1] += y2 * (unitsPerMeter2[1] + unitsPerMeter22[1] * y2); + const newLngLat = worldToLngLat(worldspace); + const newZ = (z0 || 0) + (z || 0); + return Number.isFinite(z0) || Number.isFinite(z) ? [newLngLat[0], newLngLat[1], newZ] : newLngLat; + } + function getViewMatrix(options) { + const { + height, + pitch, + bearing, + altitude, + scale: scale5, + center + } = options; + const vm = createMat4(); + translate2(vm, vm, [0, 0, -altitude]); + rotateX2(vm, vm, -pitch * DEGREES_TO_RADIANS2); + rotateZ2(vm, vm, bearing * DEGREES_TO_RADIANS2); + const relativeScale = scale5 / height; + scale2(vm, vm, [relativeScale, relativeScale, relativeScale]); + if (center) { + translate2(vm, vm, negate2([], center)); } - setProps(props) { - if ("program" in props) { - this.configuration = props.program && props.program.configuration; - } - if ("configuration" in props) { - this.configuration = props.configuration; - } - if ("attributes" in props) { - this.setAttributes(props.attributes); - } - if ("elements" in props) { - this.setElementBuffer(props.elements); - } - if ("bindOnUse" in props) { - props = props.bindOnUse; - } - return this; + return vm; + } + function getProjectionParameters(options) { + const { + width, + height, + altitude, + pitch = 0, + offset, + center, + scale: scale5, + nearZMultiplier = 1, + farZMultiplier = 1 + } = options; + let { + fovy = altitudeToFovy(DEFAULT_ALTITUDE) + } = options; + if (altitude !== void 0) { + fovy = altitudeToFovy(altitude); } - clearDrawParams() { - this.drawParams = null; + const fovRadians = fovy * DEGREES_TO_RADIANS2; + const pitchRadians = pitch * DEGREES_TO_RADIANS2; + const focalDistance = fovyToAltitude(fovy); + let cameraToSeaLevelDistance = focalDistance; + if (center) { + cameraToSeaLevelDistance += center[2] * scale5 / Math.cos(pitchRadians) / height; } - getDrawParams() { - this.drawParams = this.drawParams || this._updateDrawParams(); - return this.drawParams; + const fovAboveCenter = fovRadians * (0.5 + (offset ? offset[1] : 0) / height); + const topHalfSurfaceDistance = Math.sin(fovAboveCenter) * cameraToSeaLevelDistance / Math.sin(clamp2(Math.PI / 2 - pitchRadians - fovAboveCenter, 0.01, Math.PI - 0.01)); + const furthestDistance = Math.sin(pitchRadians) * topHalfSurfaceDistance + cameraToSeaLevelDistance; + const horizonDistance = cameraToSeaLevelDistance * 10; + const farZ = Math.min(furthestDistance * farZMultiplier, horizonDistance); + return { + fov: fovRadians, + aspect: width / height, + focalDistance, + near: nearZMultiplier, + far: farZ + }; + } + function altitudeToFovy(altitude) { + return 2 * Math.atan(0.5 / altitude) * RADIANS_TO_DEGREES2; + } + function fovyToAltitude(fovy) { + return 0.5 / Math.tan(0.5 * fovy * DEGREES_TO_RADIANS2); + } + function worldToPixels(xyz, pixelProjectionMatrix) { + const [x2, y2, z = 0] = xyz; + assert9(Number.isFinite(x2) && Number.isFinite(y2) && Number.isFinite(z)); + return transformVector(pixelProjectionMatrix, [x2, y2, z, 1]); + } + function pixelsToWorld(xyz, pixelUnprojectionMatrix, targetZ = 0) { + const [x2, y2, z] = xyz; + assert9(Number.isFinite(x2) && Number.isFinite(y2), "invalid pixel coordinate"); + if (Number.isFinite(z)) { + const coord = transformVector(pixelUnprojectionMatrix, [x2, y2, z, 1]); + return coord; } - setAttributes(attributes) { - Object.assign(this.attributes, attributes); - this.vertexArrayObject.bind(() => { - for (const locationOrName in attributes) { - const value = attributes[locationOrName]; - this._setAttribute(locationOrName, value); - } - this.gl.bindBuffer(34962, null); - }); - return this; + const coord0 = transformVector(pixelUnprojectionMatrix, [x2, y2, 0, 1]); + const coord1 = transformVector(pixelUnprojectionMatrix, [x2, y2, 1, 1]); + const z0 = coord0[2]; + const z1 = coord1[2]; + const t2 = z0 === z1 ? 0 : ((targetZ || 0) - z0) / (z1 - z0); + return lerp2([], coord0, coord1, t2); + } + + // node_modules/@math.gl/web-mercator/dist/esm/fit-bounds.js + function fitBounds(options) { + const { + width, + height, + bounds, + minExtent = 0, + maxZoom = 24, + offset = [0, 0] + } = options; + const [[west, south], [east, north]] = bounds; + const padding = getPaddingObject(options.padding); + const nw = lngLatToWorld([west, clamp2(north, -MAX_LATITUDE, MAX_LATITUDE)]); + const se = lngLatToWorld([east, clamp2(south, -MAX_LATITUDE, MAX_LATITUDE)]); + const size = [Math.max(Math.abs(se[0] - nw[0]), minExtent), Math.max(Math.abs(se[1] - nw[1]), minExtent)]; + const targetSize = [width - padding.left - padding.right - Math.abs(offset[0]) * 2, height - padding.top - padding.bottom - Math.abs(offset[1]) * 2]; + assert9(targetSize[0] > 0 && targetSize[1] > 0); + const scaleX2 = targetSize[0] / size[0]; + const scaleY2 = targetSize[1] / size[1]; + const offsetX = (padding.right - padding.left) / 2 / scaleX2; + const offsetY = (padding.top - padding.bottom) / 2 / scaleY2; + const center = [(se[0] + nw[0]) / 2 + offsetX, (se[1] + nw[1]) / 2 + offsetY]; + const centerLngLat = worldToLngLat(center); + const zoom = Math.min(maxZoom, log22(Math.abs(Math.min(scaleX2, scaleY2)))); + assert9(Number.isFinite(zoom)); + return { + longitude: centerLngLat[0], + latitude: centerLngLat[1], + zoom + }; + } + function getPaddingObject(padding = 0) { + if (typeof padding === "number") { + return { + top: padding, + bottom: padding, + left: padding, + right: padding + }; } - setElementBuffer() { - let elementBuffer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; - let accessor = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - this.elements = elementBuffer; - this.elementsAccessor = accessor; - this.clearDrawParams(); - this.vertexArrayObject.setElementBuffer(elementBuffer, accessor); - return this; + assert9(Number.isFinite(padding.top) && Number.isFinite(padding.bottom) && Number.isFinite(padding.left) && Number.isFinite(padding.right)); + return padding; + } + + // node_modules/@math.gl/web-mercator/dist/esm/get-bounds.js + var DEGREES_TO_RADIANS3 = Math.PI / 180; + function getBounds(viewport, z = 0) { + const { + width, + height, + unproject + } = viewport; + const unprojectOps = { + targetZ: z + }; + const bottomLeft = unproject([0, height], unprojectOps); + const bottomRight = unproject([width, height], unprojectOps); + let topLeft; + let topRight; + const halfFov = viewport.fovy ? 0.5 * viewport.fovy * DEGREES_TO_RADIANS3 : Math.atan(0.5 / viewport.altitude); + const angleToGround = (90 - viewport.pitch) * DEGREES_TO_RADIANS3; + if (halfFov > angleToGround - 0.01) { + topLeft = unprojectOnFarPlane(viewport, 0, z); + topRight = unprojectOnFarPlane(viewport, width, z); + } else { + topLeft = unproject([0, 0], unprojectOps); + topRight = unproject([width, 0], unprojectOps); } - setBuffer(locationOrName, buffer) { - let appAccessor = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; - if (buffer.target === 34963) { - return this.setElementBuffer(buffer, appAccessor); - } - const { - location, - accessor - } = this._resolveLocationAndAccessor(locationOrName, buffer, buffer.accessor, appAccessor); - if (location >= 0) { - this.values[location] = buffer; - this.accessors[location] = accessor; - this.clearDrawParams(); - this.vertexArrayObject.setBuffer(location, buffer, accessor); - } - return this; + return [bottomLeft, bottomRight, topRight, topLeft]; + } + function unprojectOnFarPlane(viewport, x2, targetZ) { + const { + pixelUnprojectionMatrix + } = viewport; + const coord0 = transformVector(pixelUnprojectionMatrix, [x2, 0, 1, 1]); + const coord1 = transformVector(pixelUnprojectionMatrix, [x2, viewport.height, 1, 1]); + const z = targetZ * viewport.distanceScales.unitsPerMeter[2]; + const t2 = (z - coord0[2]) / (coord1[2] - coord0[2]); + const coord = lerp2([], coord0, coord1, t2); + const result = worldToLngLat(coord); + result.push(targetZ); + return result; + } + + // node_modules/@math.gl/web-mercator/dist/esm/normalize-viewport-props.js + var TILE_SIZE2 = 512; + function normalizeViewportProps(props) { + const { + width, + height, + pitch = 0 + } = props; + let { + longitude, + latitude, + zoom, + bearing = 0 + } = props; + if (longitude < -180 || longitude > 180) { + longitude = mod(longitude + 180, 360) - 180; } - setConstant(locationOrName, arrayValue) { - let appAccessor = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; - const { - location, - accessor - } = this._resolveLocationAndAccessor(locationOrName, arrayValue, Object.assign({ - size: arrayValue.length - }, appAccessor)); - if (location >= 0) { - arrayValue = this.vertexArrayObject._normalizeConstantArrayValue(arrayValue); - this.values[location] = arrayValue; - this.accessors[location] = accessor; - this.clearDrawParams(); - this.vertexArrayObject.enable(location, false); - } - return this; + if (bearing < -180 || bearing > 180) { + bearing = mod(bearing + 180, 360) - 180; } - unbindBuffers() { - this.vertexArrayObject.bind(() => { - if (this.elements) { - this.vertexArrayObject.setElementBuffer(null); - } - this.buffer = this.buffer || new Buffer2(this.gl, { - accessor: { - size: 4 - } - }); - for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) { - if (this.values[location] instanceof Buffer2) { - this.gl.disableVertexAttribArray(location); - this.gl.bindBuffer(34962, this.buffer.handle); - this.gl.vertexAttribPointer(location, 1, 5126, false, 0, 0); - } + const minZoom = log22(height / TILE_SIZE2); + if (zoom <= minZoom) { + zoom = minZoom; + latitude = 0; + } else { + const halfHeightPixels = height / 2 / Math.pow(2, zoom); + const minLatitude = worldToLngLat([0, halfHeightPixels])[1]; + if (latitude < minLatitude) { + latitude = minLatitude; + } else { + const maxLatitude = worldToLngLat([0, TILE_SIZE2 - halfHeightPixels])[1]; + if (latitude > maxLatitude) { + latitude = maxLatitude; } - }); - return this; + } } - bindBuffers() { - this.vertexArrayObject.bind(() => { - if (this.elements) { - this.setElementBuffer(this.elements); - } - for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) { - const buffer = this.values[location]; - if (buffer instanceof Buffer2) { - this.setBuffer(location, buffer); - } - } - }); - return this; + return { + width, + height, + longitude, + latitude, + zoom, + pitch, + bearing + }; + } + + // node_modules/@deck.gl/core/dist/esm/shaderlib/shadow/shadow.js + var vs4 = "\nconst int max_lights = 2;\nuniform mat4 shadow_uViewProjectionMatrices[max_lights];\nuniform vec4 shadow_uProjectCenters[max_lights];\nuniform bool shadow_uDrawShadowMap;\nuniform bool shadow_uUseShadowMap;\nuniform int shadow_uLightId;\nuniform float shadow_uLightCount;\n\nvarying vec3 shadow_vPosition[max_lights];\n\nvec4 shadow_setVertexPosition(vec4 position_commonspace) {\n if (shadow_uDrawShadowMap) {\n return project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[shadow_uLightId], shadow_uProjectCenters[shadow_uLightId]);\n }\n if (shadow_uUseShadowMap) {\n for (int i = 0; i < max_lights; i++) {\n if(i < int(shadow_uLightCount)) {\n vec4 shadowMap_position = project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[i], shadow_uProjectCenters[i]);\n shadow_vPosition[i] = (shadowMap_position.xyz / shadowMap_position.w + 1.0) / 2.0;\n }\n }\n }\n return gl_Position;\n}\n"; + var fs3 = "\nconst int max_lights = 2;\nuniform bool shadow_uDrawShadowMap;\nuniform bool shadow_uUseShadowMap;\nuniform sampler2D shadow_uShadowMap0;\nuniform sampler2D shadow_uShadowMap1;\nuniform vec4 shadow_uColor;\nuniform float shadow_uLightCount;\n\nvarying vec3 shadow_vPosition[max_lights];\n\nconst vec4 bitPackShift = vec4(1.0, 255.0, 65025.0, 16581375.0);\nconst vec4 bitUnpackShift = 1.0 / bitPackShift;\nconst vec4 bitMask = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0);\n\nfloat shadow_getShadowWeight(vec3 position, sampler2D shadowMap) {\n vec4 rgbaDepth = texture2D(shadowMap, position.xy);\n\n float z = dot(rgbaDepth, bitUnpackShift);\n return smoothstep(0.001, 0.01, position.z - z);\n}\n\nvec4 shadow_filterShadowColor(vec4 color) {\n if (shadow_uDrawShadowMap) {\n vec4 rgbaDepth = fract(gl_FragCoord.z * bitPackShift);\n rgbaDepth -= rgbaDepth.gbaa * bitMask;\n return rgbaDepth;\n }\n if (shadow_uUseShadowMap) {\n float shadowAlpha = 0.0;\n shadowAlpha += shadow_getShadowWeight(shadow_vPosition[0], shadow_uShadowMap0);\n if(shadow_uLightCount > 1.0) {\n shadowAlpha += shadow_getShadowWeight(shadow_vPosition[1], shadow_uShadowMap1);\n }\n shadowAlpha *= shadow_uColor.a / shadow_uLightCount;\n float blendedAlpha = shadowAlpha + color.a * (1.0 - shadowAlpha);\n\n return vec4(\n mix(color.rgb, shadow_uColor.rgb, shadowAlpha / blendedAlpha),\n blendedAlpha\n );\n }\n return color;\n}\n"; + var getMemoizedViewportCenterPosition = memoize(getViewportCenterPosition); + var getMemoizedViewProjectionMatrices = memoize(getViewProjectionMatrices); + var DEFAULT_SHADOW_COLOR = [0, 0, 0, 1]; + var VECTOR_TO_POINT_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]; + function screenToCommonSpace(xyz, pixelUnprojectionMatrix) { + const [x2, y2, z] = xyz; + const coord = pixelsToWorld([x2, y2, z], pixelUnprojectionMatrix); + if (Number.isFinite(z)) { + return coord; } - bindForDraw(vertexCount, instanceCount, func) { - let value; - this.vertexArrayObject.bind(() => { - this._setConstantAttributes(vertexCount, instanceCount); - value = func(); + return [coord[0], coord[1], 0]; + } + function getViewportCenterPosition({ + viewport, + center + }) { + return new Matrix4(viewport.viewProjectionMatrix).invert().transform(center); + } + function getViewProjectionMatrices({ + viewport, + shadowMatrices + }) { + const projectionMatrices = []; + const pixelUnprojectionMatrix = viewport.pixelUnprojectionMatrix; + const farZ = viewport.isGeospatial ? void 0 : 1; + const corners = [[0, 0, farZ], [viewport.width, 0, farZ], [0, viewport.height, farZ], [viewport.width, viewport.height, farZ], [0, 0, -1], [viewport.width, 0, -1], [0, viewport.height, -1], [viewport.width, viewport.height, -1]].map((pixel) => screenToCommonSpace(pixel, pixelUnprojectionMatrix)); + for (const shadowMatrix of shadowMatrices) { + const viewMatrix2 = shadowMatrix.clone().translate(new Vector3(viewport.center).negate()); + const positions = corners.map((corner) => viewMatrix2.transform(corner)); + const projectionMatrix = new Matrix4().ortho({ + left: Math.min(...positions.map((position) => position[0])), + right: Math.max(...positions.map((position) => position[0])), + bottom: Math.min(...positions.map((position) => position[1])), + top: Math.max(...positions.map((position) => position[1])), + near: Math.min(...positions.map((position) => -position[2])), + far: Math.max(...positions.map((position) => -position[2])) }); - return value; - } - _resolveLocationAndAccessor(locationOrName, value, valueAccessor, appAccessor) { - const INVALID_RESULT = { - location: -1, - accessor: null - }; - const { - location, - name - } = this._getAttributeIndex(locationOrName); - if (!Number.isFinite(location) || location < 0) { - this.unused[locationOrName] = value; - log2.once(3, () => "unused value ".concat(locationOrName, " in ").concat(this.id))(); - return INVALID_RESULT; - } - const accessInfo = this._getAttributeInfo(name || location); - if (!accessInfo) { - return INVALID_RESULT; - } - const currentAccessor = this.accessors[location] || {}; - const accessor = Accessor.resolve(accessInfo.accessor, currentAccessor, valueAccessor, appAccessor); - const { - size, - type - } = accessor; - assert6(Number.isFinite(size) && Number.isFinite(type)); - return { - location, - accessor - }; - } - _getAttributeInfo(attributeName) { - return this.configuration && this.configuration.getAttributeInfo(attributeName); + projectionMatrices.push(projectionMatrix.multiplyRight(shadowMatrix)); } - _getAttributeIndex(locationOrName) { - const location = Number(locationOrName); - if (Number.isFinite(location)) { - return { - location - }; - } - const multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(locationOrName); - const name = multiLocation ? multiLocation[1] : locationOrName; - const locationOffset = multiLocation ? Number(multiLocation[2]) : 0; - if (this.configuration) { - return { - location: this.configuration.getAttributeLocation(name) + locationOffset, - name - }; - } + return projectionMatrices; + } + function createShadowUniforms(opts, context) { + const { + shadowEnabled = true + } = opts; + if (!shadowEnabled || !opts.shadowMatrices || !opts.shadowMatrices.length) { return { - location: -1 + shadow_uDrawShadowMap: false, + shadow_uUseShadowMap: false }; } - _setAttribute(locationOrName, value) { - if (value instanceof Buffer2) { - this.setBuffer(locationOrName, value); - } else if (Array.isArray(value) && value.length && value[0] instanceof Buffer2) { - const buffer = value[0]; - const accessor = value[1]; - this.setBuffer(locationOrName, buffer, accessor); - } else if (ArrayBuffer.isView(value) || Array.isArray(value)) { - const constant = value; - this.setConstant(locationOrName, constant); - } else if (value.buffer instanceof Buffer2) { - const accessor = value; - this.setBuffer(locationOrName, accessor.buffer, accessor); + const uniforms = { + shadow_uDrawShadowMap: Boolean(opts.drawToShadowMap), + shadow_uUseShadowMap: opts.shadowMaps ? opts.shadowMaps.length > 0 : false, + shadow_uColor: opts.shadowColor || DEFAULT_SHADOW_COLOR, + shadow_uLightId: opts.shadowLightId || 0, + shadow_uLightCount: opts.shadowMatrices.length + }; + const center = getMemoizedViewportCenterPosition({ + viewport: opts.viewport, + center: context.project_uCenter + }); + const projectCenters = []; + const viewProjectionMatrices = getMemoizedViewProjectionMatrices({ + shadowMatrices: opts.shadowMatrices, + viewport: opts.viewport + }).slice(); + for (let i3 = 0; i3 < opts.shadowMatrices.length; i3++) { + const viewProjectionMatrix = viewProjectionMatrices[i3]; + const viewProjectionMatrixCentered = viewProjectionMatrix.clone().translate(new Vector3(opts.viewport.center).negate()); + if (context.project_uCoordinateSystem === COORDINATE_SYSTEM.LNGLAT && context.project_uProjectionMode === PROJECTION_MODE.WEB_MERCATOR) { + viewProjectionMatrices[i3] = viewProjectionMatrixCentered; + projectCenters[i3] = center; } else { - throw new Error(ERR_ATTRIBUTE_TYPE); + viewProjectionMatrices[i3] = viewProjectionMatrix.clone().multiplyRight(VECTOR_TO_POINT_MATRIX2); + projectCenters[i3] = viewProjectionMatrixCentered.transform(center); } } - _setConstantAttributes(vertexCount, instanceCount) { - const elementCount = Math.max(vertexCount | 0, instanceCount | 0); - let constant = this.values[0]; - if (ArrayBuffer.isView(constant)) { - this._setConstantAttributeZero(constant, elementCount); - } - for (let location = 1; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) { - constant = this.values[location]; - if (ArrayBuffer.isView(constant)) { - this._setConstantAttribute(location, constant); - } + for (let i3 = 0; i3 < viewProjectionMatrices.length; i3++) { + uniforms["shadow_uViewProjectionMatrices[".concat(i3, "]")] = viewProjectionMatrices[i3]; + uniforms["shadow_uProjectCenters[".concat(i3, "]")] = projectCenters[i3]; + if (opts.shadowMaps && opts.shadowMaps.length > 0) { + uniforms["shadow_uShadowMap".concat(i3)] = opts.shadowMaps[i3]; + } else { + uniforms["shadow_uShadowMap".concat(i3)] = opts.dummyShadowMap; } } - _setConstantAttributeZero(constant, elementCount) { - if (VertexArrayObject.isSupported(this.gl, { - constantAttributeZero: true - })) { - this._setConstantAttribute(0, constant); - return; + return uniforms; + } + var shadow_default = { + name: "shadow", + dependencies: [project_default], + vs: vs4, + fs: fs3, + inject: { + "vs:DECKGL_FILTER_GL_POSITION": "\n position = shadow_setVertexPosition(geometry.position);\n ", + "fs:DECKGL_FILTER_COLOR": "\n color = shadow_filterShadowColor(color);\n " + }, + getUniforms: (opts = {}, context = {}) => { + if ("viewport" in opts && (opts.drawToShadowMap || opts.shadowMaps && opts.shadowMaps.length > 0)) { + return createShadowUniforms(opts, context); } - const buffer = this.vertexArrayObject.getConstantBuffer(elementCount, constant); - this.vertexArrayObject.setBuffer(0, buffer, this.accessors[0]); + return {}; } - _setConstantAttribute(location, constant) { - VertexArrayObject.setConstant(this.gl, location, constant); + }; + + // node_modules/@deck.gl/core/dist/esm/effects/lighting/lighting-effect.js + var DEFAULT_AMBIENT_LIGHT_PROPS = { + color: [255, 255, 255], + intensity: 1 + }; + var DEFAULT_DIRECTIONAL_LIGHT_PROPS = [{ + color: [255, 255, 255], + intensity: 1, + direction: [-1, 3, -1] + }, { + color: [255, 255, 255], + intensity: 0.9, + direction: [1, -8, -2.5] + }]; + var DEFAULT_SHADOW_COLOR2 = [0, 0, 0, 200 / 255]; + var LightingEffect = class { + constructor(props = {}) { + _defineProperty(this, "id", "lighting-effect"); + _defineProperty(this, "props", void 0); + _defineProperty(this, "shadowColor", DEFAULT_SHADOW_COLOR2); + _defineProperty(this, "shadow", void 0); + _defineProperty(this, "ambientLight", void 0); + _defineProperty(this, "directionalLights", void 0); + _defineProperty(this, "pointLights", void 0); + _defineProperty(this, "shadowPasses", []); + _defineProperty(this, "shadowMaps", []); + _defineProperty(this, "dummyShadowMap", null); + _defineProperty(this, "programManager", void 0); + _defineProperty(this, "shadowMatrices", void 0); + this.setProps(props); } - _updateDrawParams() { - const drawParams = { - isIndexed: false, - isInstanced: false, - indexCount: Infinity, - vertexCount: Infinity, - instanceCount: Infinity - }; - for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) { - this._updateDrawParamsForLocation(drawParams, location); - } - if (this.elements) { - drawParams.elementCount = this.elements.getElementCount(this.elements.accessor); - drawParams.isIndexed = true; - drawParams.indexType = this.elementsAccessor.type || this.elements.accessor.type; - drawParams.indexOffset = this.elementsAccessor.offset || 0; - } - if (drawParams.indexCount === Infinity) { - drawParams.indexCount = 0; - } - if (drawParams.vertexCount === Infinity) { - drawParams.vertexCount = 0; - } - if (drawParams.instanceCount === Infinity) { - drawParams.instanceCount = 0; + setProps(props) { + this.ambientLight = null; + this.directionalLights = []; + this.pointLights = []; + for (const key in props) { + const lightSource = props[key]; + switch (lightSource.type) { + case "ambient": + this.ambientLight = lightSource; + break; + case "directional": + this.directionalLights.push(lightSource); + break; + case "point": + this.pointLights.push(lightSource); + break; + default: + } } - return drawParams; + this._applyDefaultLights(); + this.shadow = this.directionalLights.some((light) => light.shadow); + this.props = props; } - _updateDrawParamsForLocation(drawParams, location) { - const value = this.values[location]; - const accessor = this.accessors[location]; - if (!value) { + preRender(gl, { + layers, + layerFilter, + viewports, + onViewportActive, + views + }) { + if (!this.shadow) return; + this.shadowMatrices = this._calculateMatrices(); + if (this.shadowPasses.length === 0) { + this._createShadowPasses(gl); } - const { - divisor - } = accessor; - const isInstanced = divisor > 0; - drawParams.isInstanced = drawParams.isInstanced || isInstanced; - if (value instanceof Buffer2) { - const buffer = value; - if (isInstanced) { - const instanceCount = buffer.getVertexCount(accessor); - drawParams.instanceCount = Math.min(drawParams.instanceCount, instanceCount); - } else { - const vertexCount = buffer.getVertexCount(accessor); - drawParams.vertexCount = Math.min(drawParams.vertexCount, vertexCount); + if (!this.programManager) { + this.programManager = ProgramManager.getDefaultProgramManager(gl); + if (shadow_default) { + this.programManager.addDefaultModule(shadow_default); } } - } - setElements() { - let elementBuffer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; - let accessor = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - log2.deprecated("setElements", "setElementBuffer")(); - return this.setElementBuffer(elementBuffer, accessor); - } - }; - - // node_modules/@luma.gl/webgl/dist/esm/utils/format-value.js - function formatArrayValue(v2, opts) { - const { - maxElts = 16, - size = 1 - } = opts; - let string = "["; - for (let i2 = 0; i2 < v2.length && i2 < maxElts; ++i2) { - if (i2 > 0) { - string += ",".concat(i2 % size === 0 ? " " : ""); + if (!this.dummyShadowMap) { + this.dummyShadowMap = new Texture2D(gl, { + width: 1, + height: 1 + }); } - string += formatValue(v2[i2], opts); - } - const terminator = v2.length > maxElts ? "..." : "]"; - return "".concat(string).concat(terminator); - } - function formatValue(v2) { - let opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const EPSILON3 = 1e-16; - const { - isInteger = false - } = opts; - if (Array.isArray(v2) || ArrayBuffer.isView(v2)) { - return formatArrayValue(v2, opts); - } - if (!Number.isFinite(v2)) { - return String(v2); - } - if (Math.abs(v2) < EPSILON3) { - return isInteger ? "0" : "0."; - } - if (isInteger) { - return v2.toFixed(0); - } - if (Math.abs(v2) > 100 && Math.abs(v2) < 1e4) { - return v2.toFixed(0); - } - const string = v2.toPrecision(2); - const decimal = string.indexOf(".0"); - return decimal === string.length - 2 ? string.slice(0, -1) : string; - } - - // node_modules/@luma.gl/webgl/dist/esm/debug/debug-uniforms.js - function getDebugTableForUniforms(_ref) { - let { - header = "Uniforms", - program, - uniforms, - undefinedOnly = false - } = _ref; - assert6(program); - const SHADER_MODULE_UNIFORM_REGEXP = ".*_.*"; - const PROJECT_MODULE_UNIFORM_REGEXP = ".*Matrix"; - const uniformLocations = program._uniformSetters; - const table = {}; - const uniformNames = Object.keys(uniformLocations).sort(); - let count2 = 0; - for (const uniformName of uniformNames) { - if (!uniformName.match(SHADER_MODULE_UNIFORM_REGEXP) && !uniformName.match(PROJECT_MODULE_UNIFORM_REGEXP)) { - if (addUniformToTable({ - table, - header, - uniforms, - uniformName, - undefinedOnly - })) { - count2++; - } + for (let i3 = 0; i3 < this.shadowPasses.length; i3++) { + const shadowPass = this.shadowPasses[i3]; + shadowPass.render({ + layers, + layerFilter, + viewports, + onViewportActive, + views, + moduleParameters: { + shadowLightId: i3, + dummyShadowMap: this.dummyShadowMap, + shadowMatrices: this.shadowMatrices + } + }); } } - for (const uniformName of uniformNames) { - if (uniformName.match(PROJECT_MODULE_UNIFORM_REGEXP)) { - if (addUniformToTable({ - table, - header, - uniforms, - uniformName, - undefinedOnly - })) { - count2++; - } + getModuleParameters(layer) { + const parameters = this.shadow ? { + shadowMaps: this.shadowMaps, + dummyShadowMap: this.dummyShadowMap, + shadowColor: this.shadowColor, + shadowMatrices: this.shadowMatrices + } : {}; + parameters.lightSources = { + ambientLight: this.ambientLight, + directionalLights: this.directionalLights.map((directionalLight) => directionalLight.getProjectedLight({ + layer + })), + pointLights: this.pointLights.map((pointLight) => pointLight.getProjectedLight({ + layer + })) + }; + return parameters; + } + cleanup() { + for (const shadowPass of this.shadowPasses) { + shadowPass.delete(); + } + this.shadowPasses.length = 0; + this.shadowMaps.length = 0; + if (this.dummyShadowMap) { + this.dummyShadowMap.delete(); + this.dummyShadowMap = null; + } + if (this.shadow && this.programManager) { + this.programManager.removeDefaultModule(shadow_default); + this.programManager = null; } } - for (const uniformName of uniformNames) { - if (!table[uniformName]) { - if (addUniformToTable({ - table, - header, - uniforms, - uniformName, - undefinedOnly - })) { - count2++; - } + _calculateMatrices() { + const lightMatrices = []; + for (const light of this.directionalLights) { + const viewMatrix2 = new Matrix4().lookAt({ + eye: new Vector3(light.direction).negate() + }); + lightMatrices.push(viewMatrix2); } + return lightMatrices; } - let unusedCount = 0; - const unusedTable = {}; - if (!undefinedOnly) { - for (const uniformName in uniforms) { - const uniform = uniforms[uniformName]; - if (!table[uniformName]) { - unusedCount++; - unusedTable[uniformName] = { - Type: "NOT USED: ".concat(uniform), - [header]: formatValue(uniform) - }; - } + _createShadowPasses(gl) { + for (let i3 = 0; i3 < this.directionalLights.length; i3++) { + const shadowPass = new ShadowPass(gl); + this.shadowPasses[i3] = shadowPass; + this.shadowMaps[i3] = shadowPass.shadowMap; } } - return { - table, - count: count2, - unusedTable, - unusedCount - }; - } - function addUniformToTable(_ref2) { - let { - table, - header, - uniforms, - uniformName, - undefinedOnly - } = _ref2; - const value = uniforms[uniformName]; - const isDefined = isUniformDefined(value); - if (!undefinedOnly || !isDefined) { - table[uniformName] = { - [header]: isDefined ? formatValue(value) : "N/A", - "Uniform Type": isDefined ? value : "NOT PROVIDED" - }; - return true; + _applyDefaultLights() { + const { + ambientLight, + pointLights, + directionalLights + } = this; + if (!ambientLight && pointLights.length === 0 && directionalLights.length === 0) { + this.ambientLight = new AmbientLight(DEFAULT_AMBIENT_LIGHT_PROPS); + this.directionalLights.push(new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[0]), new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[1])); + } } - return false; - } - function isUniformDefined(value) { - return value !== void 0 && value !== null; - } + }; - // node_modules/@luma.gl/webgl/dist/esm/debug/debug-vertex-array.js - function getDebugTableForVertexArray(_ref) { - let { - vertexArray, - header = "Attributes" - } = _ref; - if (!vertexArray.configuration) { - return {}; + // node_modules/@deck.gl/core/dist/esm/utils/typed-array-manager.js + var TypedArrayManager = class { + constructor(options = {}) { + _defineProperty(this, "_pool", []); + _defineProperty(this, "opts", { + overAlloc: 2, + poolSize: 100 + }); + this.setOptions(options); } - const table = {}; - if (vertexArray.elements) { - table.ELEMENT_ARRAY_BUFFER = getDebugTableRow(vertexArray, vertexArray.elements, null, header); + setOptions(options) { + Object.assign(this.opts, options); } - const attributes = vertexArray.values; - for (const attributeLocation in attributes) { - const info = vertexArray._getAttributeInfo(attributeLocation); - if (info) { - let rowHeader = "".concat(attributeLocation, ": ").concat(info.name); - const accessor = vertexArray.accessors[info.location]; - if (accessor) { - rowHeader = "".concat(attributeLocation, ": ").concat(getGLSLDeclaration(info.name, accessor)); + allocate(typedArray, count2, { + size = 1, + type, + padding = 0, + copy: copy3 = false, + initialize = false, + maxCount + }) { + const Type = type || typedArray && typedArray.constructor || Float32Array; + const newSize = count2 * size + padding; + if (ArrayBuffer.isView(typedArray)) { + if (newSize <= typedArray.length) { + return typedArray; } - table[rowHeader] = getDebugTableRow(vertexArray, attributes[attributeLocation], accessor, header); + if (newSize * typedArray.BYTES_PER_ELEMENT <= typedArray.buffer.byteLength) { + return new Type(typedArray.buffer, 0, newSize); + } + } + let maxSize = Infinity; + if (maxCount) { + maxSize = maxCount * size + padding; + } + const newArray = this._allocate(Type, newSize, initialize, maxSize); + if (typedArray && copy3) { + newArray.set(typedArray); + } else if (!initialize) { + newArray.fill(0, 0, 4); } + this._release(typedArray); + return newArray; } - return table; - } - function getDebugTableRow(vertexArray, attribute, accessor, header) { - const { - gl - } = vertexArray; - if (!attribute) { - return { - [header]: "null", - "Format ": "N/A" - }; + release(typedArray) { + this._release(typedArray); } - let type = "NOT PROVIDED"; - let size = 1; - let verts = 0; - let bytes = 0; - let isInteger; - let marker; - let value; - if (accessor) { - type = accessor.type; - size = accessor.size; - type = String(type).replace("Array", ""); - isInteger = type.indexOf("nt") !== -1; + _allocate(Type, size, initialize, maxSize) { + let sizeToAllocate = Math.max(Math.ceil(size * this.opts.overAlloc), 1); + if (sizeToAllocate > maxSize) { + sizeToAllocate = maxSize; + } + const pool = this._pool; + const byteLength = Type.BYTES_PER_ELEMENT * sizeToAllocate; + const i3 = pool.findIndex((b2) => b2.byteLength >= byteLength); + if (i3 >= 0) { + const array = new Type(pool.splice(i3, 1)[0], 0, sizeToAllocate); + if (initialize) { + array.fill(0); + } + return array; + } + return new Type(sizeToAllocate); } - if (attribute instanceof Buffer2) { - const buffer = attribute; + _release(typedArray) { + if (!ArrayBuffer.isView(typedArray)) { + return; + } + const pool = this._pool; const { - data, - changed - } = buffer.getDebugData(); - marker = changed ? "*" : ""; - value = data; - bytes = buffer.byteLength; - verts = bytes / data.BYTES_PER_ELEMENT / size; - let format; - if (accessor) { - const instanced = accessor.divisor > 0; - format = "".concat(instanced ? "I " : "P ", " ").concat(verts, " (x").concat(size, "=").concat(bytes, " bytes ").concat(getKey(gl, type), ")"); - } else { - isInteger = true; - format = "".concat(bytes, " bytes"); + buffer + } = typedArray; + const { + byteLength + } = buffer; + const i3 = pool.findIndex((b2) => b2.byteLength >= byteLength); + if (i3 < 0) { + pool.push(buffer); + } else if (i3 > 0 || pool.length < this.opts.poolSize) { + pool.splice(i3, 0, buffer); + } + if (pool.length > this.opts.poolSize) { + pool.shift(); } - return { - [header]: "".concat(marker).concat(formatValue(value, { - size, - isInteger - })), - "Format ": format - }; } - value = attribute; - size = attribute.length; - type = String(attribute.constructor.name).replace("Array", ""); - isInteger = type.indexOf("nt") !== -1; + }; + var typed_array_manager_default = new TypedArrayManager(); + + // node_modules/@deck.gl/core/dist/esm/utils/math-utils.js + function createMat42() { + return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; + } + function mod2(value, divisor) { + const modulus = value % divisor; + return modulus < 0 ? divisor + modulus : modulus; + } + function getCameraPosition(viewMatrixInverse) { + return [viewMatrixInverse[12], viewMatrixInverse[13], viewMatrixInverse[14]]; + } + function getFrustumPlanes(viewProjectionMatrix) { return { - [header]: "".concat(formatValue(value, { - size, - isInteger - }), " (constant)"), - "Format ": "".concat(size, "x").concat(type, " (constant)") + left: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[0], viewProjectionMatrix[7] + viewProjectionMatrix[4], viewProjectionMatrix[11] + viewProjectionMatrix[8], viewProjectionMatrix[15] + viewProjectionMatrix[12]), + right: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[0], viewProjectionMatrix[7] - viewProjectionMatrix[4], viewProjectionMatrix[11] - viewProjectionMatrix[8], viewProjectionMatrix[15] - viewProjectionMatrix[12]), + bottom: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[1], viewProjectionMatrix[7] + viewProjectionMatrix[5], viewProjectionMatrix[11] + viewProjectionMatrix[9], viewProjectionMatrix[15] + viewProjectionMatrix[13]), + top: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[1], viewProjectionMatrix[7] - viewProjectionMatrix[5], viewProjectionMatrix[11] - viewProjectionMatrix[9], viewProjectionMatrix[15] - viewProjectionMatrix[13]), + near: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[2], viewProjectionMatrix[7] + viewProjectionMatrix[6], viewProjectionMatrix[11] + viewProjectionMatrix[10], viewProjectionMatrix[15] + viewProjectionMatrix[14]), + far: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[2], viewProjectionMatrix[7] - viewProjectionMatrix[6], viewProjectionMatrix[11] - viewProjectionMatrix[10], viewProjectionMatrix[15] - viewProjectionMatrix[14]) }; } - function getGLSLDeclaration(name, accessor) { - const { - type, - size - } = accessor; - const typeAndName = getCompositeGLType(type, size); - return typeAndName ? "".concat(name, " (").concat(typeAndName.name, ")") : name; + var scratchVector = new Vector3(); + function getFrustumPlane(a2, b2, c2, d2) { + scratchVector.set(a2, b2, c2); + const L = scratchVector.len(); + return { + distance: d2 / L, + normal: new Vector3(-a2 / L, -b2 / L, -c2 / L) + }; } - - // node_modules/@luma.gl/webgl/dist/esm/debug/debug-program-configuration.js - function getDebugTableForProgramConfiguration(config2) { - const table = {}; - const header = "Accessors for ".concat(config2.id); - for (const attributeInfo of config2.attributeInfos) { - if (attributeInfo) { - const glslDeclaration = getGLSLDeclaration2(attributeInfo); - table["in ".concat(glslDeclaration)] = { - [header]: JSON.stringify(attributeInfo.accessor) - }; - } - } - for (const varyingInfo of config2.varyingInfos) { - if (varyingInfo) { - const glslDeclaration = getGLSLDeclaration2(varyingInfo); - table["out ".concat(glslDeclaration)] = { - [header]: JSON.stringify(varyingInfo.accessor) - }; + function fp64LowPart(x2) { + return x2 - Math.fround(x2); + } + var scratchArray; + function toDoublePrecisionArray(typedArray, options) { + const { + size = 1, + startIndex = 0 + } = options; + const endIndex = options.endIndex !== void 0 ? options.endIndex : typedArray.length; + const count2 = (endIndex - startIndex) / size; + scratchArray = typed_array_manager_default.allocate(scratchArray, count2, { + type: Float32Array, + size: size * 2 + }); + let sourceIndex = startIndex; + let targetIndex = 0; + while (sourceIndex < endIndex) { + for (let j = 0; j < size; j++) { + const value = typedArray[sourceIndex++]; + scratchArray[targetIndex + j] = value; + scratchArray[targetIndex + j + size] = fp64LowPart(value); } + targetIndex += size * 2; } - return table; + return scratchArray.subarray(0, count2 * size * 2); } - function getGLSLDeclaration2(attributeInfo) { - const { - type, - size - } = attributeInfo.accessor; - const typeAndName = getCompositeGLType(type, size); - if (typeAndName) { - return "".concat(typeAndName.name, " ").concat(attributeInfo.name); + function mergeBounds(boundsList) { + let mergedBounds = null; + let isMerged = false; + for (const bounds of boundsList) { + if (!bounds) + continue; + if (!mergedBounds) { + mergedBounds = bounds; + } else { + if (!isMerged) { + mergedBounds = [[mergedBounds[0][0], mergedBounds[0][1]], [mergedBounds[1][0], mergedBounds[1][1]]]; + isMerged = true; + } + mergedBounds[0][0] = Math.min(mergedBounds[0][0], bounds[0][0]); + mergedBounds[0][1] = Math.min(mergedBounds[0][1], bounds[0][1]); + mergedBounds[1][0] = Math.max(mergedBounds[1][0], bounds[1][0]); + mergedBounds[1][1] = Math.max(mergedBounds[1][1], bounds[1][1]); + } } - return attributeInfo.name; + return mergedBounds; } - // node_modules/@luma.gl/engine/dist/esm/lib/animation-loop.js - var isPage2 = isBrowser5() && typeof document !== "undefined"; - var statIdCounter = 0; - var AnimationLoop = class { - constructor() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + // node_modules/@deck.gl/core/dist/esm/viewports/viewport.js + var DEGREES_TO_RADIANS4 = Math.PI / 180; + var IDENTITY2 = createMat42(); + var ZERO_VECTOR2 = [0, 0, 0]; + var DEFAULT_DISTANCE_SCALES = { + unitsPerMeter: [1, 1, 1], + metersPerUnit: [1, 1, 1] + }; + function createProjectionMatrix({ + width, + height, + orthographic, + fovyRadians, + focalDistance, + padding, + near, + far + }) { + const aspect = width / height; + const matrix = orthographic ? new Matrix4().orthographic({ + fovy: fovyRadians, + aspect, + focalDistance, + near, + far + }) : new Matrix4().perspective({ + fovy: fovyRadians, + aspect, + near, + far + }); + if (padding) { const { - onCreateContext = (opts) => createGLContext(opts), - onAddHTML = null, - onInitialize = () => { - }, - onRender = () => { - }, - onFinalize = () => { - }, - onError, - gl = null, - glOptions = {}, - debug: debug2 = false, - createFramebuffer = false, - autoResizeViewport = true, - autoResizeDrawingBuffer = true, - stats = lumaStats.get("animation-loop-".concat(statIdCounter++)) - } = props; - let { - useDevicePixels = true - } = props; - if ("useDevicePixelRatio" in props) { - log2.deprecated("useDevicePixelRatio", "useDevicePixels")(); - useDevicePixels = props.useDevicePixelRatio; - } - this.props = { - onCreateContext, - onAddHTML, - onInitialize, - onRender, - onFinalize, - onError, - gl, - glOptions, - debug: debug2, - createFramebuffer - }; - this.gl = gl; - this.needsRedraw = null; - this.timeline = null; - this.stats = stats; - this.cpuTime = this.stats.get("CPU Time"); - this.gpuTime = this.stats.get("GPU Time"); - this.frameRate = this.stats.get("Frame Rate"); - this._initialized = false; - this._running = false; - this._animationFrameId = null; - this._nextFramePromise = null; - this._resolveNextFrame = null; - this._cpuStartTime = 0; - this.setProps({ - autoResizeViewport, - autoResizeDrawingBuffer, - useDevicePixels - }); - this.start = this.start.bind(this); - this.stop = this.stop.bind(this); - this._pageLoadPromise = null; - this._onMousemove = this._onMousemove.bind(this); - this._onMouseleave = this._onMouseleave.bind(this); + left = 0, + right = 0, + top = 0, + bottom = 0 + } = padding; + const offsetX = clamp((left + width - right) / 2, 0, width) - width / 2; + const offsetY = clamp((top + height - bottom) / 2, 0, height) - height / 2; + matrix[8] -= offsetX * 2 / width; + matrix[9] += offsetY * 2 / height; } - delete() { - this.stop(); - this._setDisplay(null); + return matrix; + } + var Viewport = class _Viewport { + constructor(opts = {}) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "x", void 0); + _defineProperty(this, "y", void 0); + _defineProperty(this, "width", void 0); + _defineProperty(this, "height", void 0); + _defineProperty(this, "padding", void 0); + _defineProperty(this, "isGeospatial", void 0); + _defineProperty(this, "zoom", void 0); + _defineProperty(this, "focalDistance", void 0); + _defineProperty(this, "position", void 0); + _defineProperty(this, "modelMatrix", void 0); + _defineProperty(this, "distanceScales", void 0); + _defineProperty(this, "scale", void 0); + _defineProperty(this, "center", void 0); + _defineProperty(this, "cameraPosition", void 0); + _defineProperty(this, "projectionMatrix", void 0); + _defineProperty(this, "viewMatrix", void 0); + _defineProperty(this, "viewMatrixUncentered", void 0); + _defineProperty(this, "viewMatrixInverse", void 0); + _defineProperty(this, "viewProjectionMatrix", void 0); + _defineProperty(this, "pixelProjectionMatrix", void 0); + _defineProperty(this, "pixelUnprojectionMatrix", void 0); + _defineProperty(this, "resolution", void 0); + _defineProperty(this, "_frustumPlanes", {}); + this.id = opts.id || this.constructor.displayName || "viewport"; + this.x = opts.x || 0; + this.y = opts.y || 0; + this.width = opts.width || 1; + this.height = opts.height || 1; + this.zoom = opts.zoom || 0; + this.padding = opts.padding; + this.distanceScales = opts.distanceScales || DEFAULT_DISTANCE_SCALES; + this.focalDistance = opts.focalDistance || 1; + this.position = opts.position || ZERO_VECTOR2; + this.modelMatrix = opts.modelMatrix || null; + const { + longitude, + latitude + } = opts; + this.isGeospatial = Number.isFinite(latitude) && Number.isFinite(longitude); + this._initProps(opts); + this._initMatrices(opts); + this.equals = this.equals.bind(this); + this.project = this.project.bind(this); + this.unproject = this.unproject.bind(this); + this.projectPosition = this.projectPosition.bind(this); + this.unprojectPosition = this.unprojectPosition.bind(this); + this.projectFlat = this.projectFlat.bind(this); + this.unprojectFlat = this.unprojectFlat.bind(this); } - setNeedsRedraw(reason) { - assert6(typeof reason === "string"); - this.needsRedraw = this.needsRedraw || reason; - return this; + get subViewports() { + return null; } - setProps(props) { - if ("autoResizeViewport" in props) { - this.autoResizeViewport = props.autoResizeViewport; - } - if ("autoResizeDrawingBuffer" in props) { - this.autoResizeDrawingBuffer = props.autoResizeDrawingBuffer; - } - if ("useDevicePixels" in props) { - this.useDevicePixels = props.useDevicePixels; - } - return this; + get metersPerPixel() { + return this.distanceScales.metersPerUnit[2] / this.scale; } - start() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if (this._running) { - return this; - } - this._running = true; - const startPromise = this._getPageLoadPromise().then(() => { - if (!this._running || this._initialized) { - return null; - } - this._createWebGLContext(opts); - this._createFramebuffer(); - this._startEventHandling(); - this._initializeCallbackData(); - this._updateCallbackData(); - this._resizeCanvasDrawingBuffer(); - this._resizeViewport(); - this._gpuTimeQuery = Query.isSupported(this.gl, ["timers"]) ? new Query(this.gl) : null; - this._initialized = true; - return this.onInitialize(this.animationProps); - }).then((appContext) => { - if (this._running) { - this._addCallbackData(appContext || {}); - if (appContext !== false) { - this._startLoop(); - } - } - }); - if (this.props.onError) { - startPromise.catch(this.props.onError); + get projectionMode() { + if (this.isGeospatial) { + return this.zoom < 12 ? PROJECTION_MODE.WEB_MERCATOR : PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET; } - return this; + return PROJECTION_MODE.IDENTITY; } - redraw() { - if (this.isContextLost()) { - return this; - } - this._beginTimers(); - this._setupFrame(); - this._updateCallbackData(); - this._renderFrame(this.animationProps); - this._clearNeedsRedraw(); - if (this.offScreen && this.gl.commit) { - this.gl.commit(); - } - if (this._resolveNextFrame) { - this._resolveNextFrame(this); - this._nextFramePromise = null; - this._resolveNextFrame = null; + equals(viewport) { + if (!(viewport instanceof _Viewport)) { + return false; } - this._endTimers(); - return this; - } - stop() { - if (this._running) { - this._finalizeCallbackData(); - this._cancelAnimationFrame(this._animationFrameId); - this._nextFramePromise = null; - this._resolveNextFrame = null; - this._animationFrameId = null; - this._running = false; + if (this === viewport) { + return true; } - return this; - } - attachTimeline(timeline) { - this.timeline = timeline; - return this.timeline; + return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix); } - detachTimeline() { - this.timeline = null; + project(xyz, { + topLeft = true + } = {}) { + const worldPosition = this.projectPosition(xyz); + const coord = worldToPixels(worldPosition, this.pixelProjectionMatrix); + const [x2, y2] = coord; + const y22 = topLeft ? y2 : this.height - y2; + return xyz.length === 2 ? [x2, y22] : [x2, y22, coord[2]]; } - waitForRender() { - this.setNeedsRedraw("waitForRender"); - if (!this._nextFramePromise) { - this._nextFramePromise = new Promise((resolve2) => { - this._resolveNextFrame = resolve2; - }); + unproject(xyz, { + topLeft = true, + targetZ + } = {}) { + const [x2, y2, z] = xyz; + const y22 = topLeft ? y2 : this.height - y2; + const targetZWorld = targetZ && targetZ * this.distanceScales.unitsPerMeter[2]; + const coord = pixelsToWorld([x2, y22, z], this.pixelUnprojectionMatrix, targetZWorld); + const [X, Y, Z] = this.unprojectPosition(coord); + if (Number.isFinite(z)) { + return [X, Y, Z]; } - return this._nextFramePromise; - } - async toDataURL() { - this.setNeedsRedraw("toDataURL"); - await this.waitForRender(); - return this.gl.canvas.toDataURL(); - } - isContextLost() { - return this.gl.isContextLost(); - } - onCreateContext() { - return this.props.onCreateContext(...arguments); - } - onInitialize() { - return this.props.onInitialize(...arguments); + return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y]; } - onRender() { - return this.props.onRender(...arguments); + projectPosition(xyz) { + const [X, Y] = this.projectFlat(xyz); + const Z = (xyz[2] || 0) * this.distanceScales.unitsPerMeter[2]; + return [X, Y, Z]; } - onFinalize() { - return this.props.onFinalize(...arguments); + unprojectPosition(xyz) { + const [X, Y] = this.unprojectFlat(xyz); + const Z = (xyz[2] || 0) * this.distanceScales.metersPerUnit[2]; + return [X, Y, Z]; } - getHTMLControlValue(id) { - let defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1; - const element = document.getElementById(id); - return element ? Number(element.value) : defaultValue; + projectFlat(xyz) { + if (this.isGeospatial) { + const result = lngLatToWorld(xyz); + result[1] = clamp(result[1], -318, 830); + return result; + } + return xyz; } - setViewParameters() { - log2.removed("AnimationLoop.setViewParameters", "AnimationLoop.setProps")(); - return this; + unprojectFlat(xyz) { + if (this.isGeospatial) { + return worldToLngLat(xyz); + } + return xyz; } - _startLoop() { - const renderFrame = () => { - if (!this._running) { - return; - } - this.redraw(); - this._animationFrameId = this._requestAnimationFrame(renderFrame); + getBounds(options = {}) { + const unprojectOption = { + targetZ: options.z || 0 }; - this._cancelAnimationFrame(this._animationFrameId); - this._animationFrameId = this._requestAnimationFrame(renderFrame); + const topLeft = this.unproject([0, 0], unprojectOption); + const topRight = this.unproject([this.width, 0], unprojectOption); + const bottomLeft = this.unproject([0, this.height], unprojectOption); + const bottomRight = this.unproject([this.width, this.height], unprojectOption); + return [Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]), Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1])]; } - _getPageLoadPromise() { - if (!this._pageLoadPromise) { - this._pageLoadPromise = isPage2 ? new Promise((resolve2, reject) => { - if (isPage2 && document.readyState === "complete") { - resolve2(document); - return; - } - window.addEventListener("load", () => { - resolve2(document); - }); - }) : Promise.resolve({}); + getDistanceScales(coordinateOrigin) { + if (coordinateOrigin) { + return getDistanceScales({ + longitude: coordinateOrigin[0], + latitude: coordinateOrigin[1], + highPrecision: true + }); } - return this._pageLoadPromise; + return this.distanceScales; } - _setDisplay(display) { - if (this.display) { - this.display.delete(); - this.display.animationLoop = null; - } - if (display) { - display.animationLoop = this; - } - this.display = display; + containsPixel({ + x: x2, + y: y2, + width = 1, + height = 1 + }) { + return x2 < this.x + this.width && this.x < x2 + width && y2 < this.y + this.height && this.y < y2 + height; } - _cancelAnimationFrame(animationFrameId) { - if (this.display && this.display.cancelAnimationFrame) { - return this.display.cancelAnimationFrame(animationFrameId); + getFrustumPlanes() { + if (this._frustumPlanes.near) { + return this._frustumPlanes; } - return cancelAnimationFrame(animationFrameId); + Object.assign(this._frustumPlanes, getFrustumPlanes(this.viewProjectionMatrix)); + return this._frustumPlanes; } - _requestAnimationFrame(renderFrameCallback) { - if (this._running) { - if (this.display && this.display.requestAnimationFrame) { - return this.display.requestAnimationFrame(renderFrameCallback); - } - return requestAnimationFrame2(renderFrameCallback); - } - return void 0; + panByPosition(coords, pixel) { + return null; } - _renderFrame() { - if (this.display) { - this.display._renderFrame(...arguments); - return; + _initProps(opts) { + const longitude = opts.longitude; + const latitude = opts.latitude; + if (this.isGeospatial) { + if (!Number.isFinite(opts.zoom)) { + this.zoom = getMeterZoom({ + latitude + }) + Math.log2(this.focalDistance); + } + this.distanceScales = opts.distanceScales || getDistanceScales({ + latitude, + longitude + }); } - this.onRender(...arguments); - } - _clearNeedsRedraw() { - this.needsRedraw = null; - } - _setupFrame() { - this._resizeCanvasDrawingBuffer(); - this._resizeViewport(); - this._resizeFramebuffer(); - } - _initializeCallbackData() { - this.animationProps = { - gl: this.gl, - stop: this.stop, - canvas: this.gl.canvas, - framebuffer: this.framebuffer, - useDevicePixels: this.useDevicePixels, - needsRedraw: null, - startTime: Date.now(), - engineTime: 0, - tick: 0, - tock: 0, - time: 0, - _timeline: this.timeline, - _loop: this, - _animationLoop: this, - _mousePosition: null - }; - } - _updateCallbackData() { + const scale5 = Math.pow(2, this.zoom); + this.scale = scale5; const { - width, - height, - aspect - } = this._getSizeAndAspect(); - if (width !== this.animationProps.width || height !== this.animationProps.height) { - this.setNeedsRedraw("drawing buffer resized"); - } - if (aspect !== this.animationProps.aspect) { - this.setNeedsRedraw("drawing buffer aspect changed"); - } - this.animationProps.width = width; - this.animationProps.height = height; - this.animationProps.aspect = aspect; - this.animationProps.needsRedraw = this.needsRedraw; - this.animationProps.engineTime = Date.now() - this.animationProps.startTime; - if (this.timeline) { - this.timeline.update(this.animationProps.engineTime); + position, + modelMatrix + } = opts; + let meterOffset = ZERO_VECTOR2; + if (position) { + meterOffset = modelMatrix ? new Matrix4(modelMatrix).transformAsVector(position, []) : position; } - this.animationProps.tick = Math.floor(this.animationProps.time / 1e3 * 60); - this.animationProps.tock++; - this.animationProps.time = this.timeline ? this.timeline.getTime() : this.animationProps.engineTime; - this.animationProps._offScreen = this.offScreen; - } - _finalizeCallbackData() { - this.onFinalize(this.animationProps); - } - _addCallbackData(appContext) { - if (typeof appContext === "object" && appContext !== null) { - this.animationProps = Object.assign({}, this.animationProps, appContext); + if (this.isGeospatial) { + const center = this.projectPosition([longitude, latitude, 0]); + this.center = new Vector3(meterOffset).scale(this.distanceScales.unitsPerMeter).add(center); + } else { + this.center = this.projectPosition(meterOffset); } } - _createWebGLContext(opts) { - this.offScreen = opts.canvas && typeof OffscreenCanvas !== "undefined" && opts.canvas instanceof OffscreenCanvas; - opts = Object.assign({}, opts, this.props.glOptions); - this.gl = this.props.gl ? instrumentGLContext(this.props.gl, opts) : this.onCreateContext(opts); - if (!isWebGL(this.gl)) { - throw new Error("AnimationLoop.onCreateContext - illegal context returned"); + _initMatrices(opts) { + const { + viewMatrix: viewMatrix2 = IDENTITY2, + projectionMatrix = null, + orthographic = false, + fovyRadians, + fovy = 75, + near = 0.1, + far = 1e3, + padding = null, + focalDistance = 1 + } = opts; + this.viewMatrixUncentered = viewMatrix2; + this.viewMatrix = new Matrix4().multiplyRight(viewMatrix2).translate(new Vector3(this.center).negate()); + this.projectionMatrix = projectionMatrix || createProjectionMatrix({ + width: this.width, + height: this.height, + orthographic, + fovyRadians: fovyRadians || fovy * DEGREES_TO_RADIANS4, + focalDistance, + padding, + near, + far + }); + const vpm = createMat42(); + multiply2(vpm, vpm, this.projectionMatrix); + multiply2(vpm, vpm, this.viewMatrix); + this.viewProjectionMatrix = vpm; + this.viewMatrixInverse = invert2([], this.viewMatrix) || this.viewMatrix; + this.cameraPosition = getCameraPosition(this.viewMatrixInverse); + const viewportMatrix = createMat42(); + const pixelProjectionMatrix = createMat42(); + scale2(viewportMatrix, viewportMatrix, [this.width / 2, -this.height / 2, 1]); + translate2(viewportMatrix, viewportMatrix, [1, -1, 0]); + multiply2(pixelProjectionMatrix, viewportMatrix, this.viewProjectionMatrix); + this.pixelProjectionMatrix = pixelProjectionMatrix; + this.pixelUnprojectionMatrix = invert2(createMat42(), this.pixelProjectionMatrix); + if (!this.pixelUnprojectionMatrix) { + log_default.warn("Pixel project matrix not invertible")(); } - resetParameters(this.gl); - this._createInfoDiv(); } - _createInfoDiv() { - if (this.gl.canvas && this.props.onAddHTML) { - const wrapperDiv = document.createElement("div"); - document.body.appendChild(wrapperDiv); - wrapperDiv.style.position = "relative"; - const div = document.createElement("div"); - div.style.position = "absolute"; - div.style.left = "10px"; - div.style.bottom = "10px"; - div.style.width = "300px"; - div.style.background = "white"; - wrapperDiv.appendChild(this.gl.canvas); - wrapperDiv.appendChild(div); - const html = this.props.onAddHTML(div); - if (html) { - div.innerHTML = html; + }; + _defineProperty(Viewport, "displayName", "Viewport"); + + // node_modules/@deck.gl/core/dist/esm/viewports/web-mercator-viewport.js + var WebMercatorViewport2 = class _WebMercatorViewport extends Viewport { + constructor(opts = {}) { + const { + latitude = 0, + longitude = 0, + zoom = 0, + pitch = 0, + bearing = 0, + nearZMultiplier = 0.1, + farZMultiplier = 1.01, + nearZ, + farZ, + orthographic = false, + projectionMatrix, + repeat = false, + worldOffset = 0, + position, + padding, + legacyMeterSizes = false + } = opts; + let { + width, + height, + altitude = 1.5 + } = opts; + const scale5 = Math.pow(2, zoom); + width = width || 1; + height = height || 1; + let fovy; + let projectionParameters = null; + if (projectionMatrix) { + altitude = projectionMatrix[5] / 2; + fovy = altitudeToFovy(altitude); + } else { + if (opts.fovy) { + fovy = opts.fovy; + altitude = fovyToAltitude(fovy); + } else { + fovy = altitudeToFovy(altitude); + } + let offset; + if (padding) { + const { + top = 0, + bottom = 0 + } = padding; + offset = [0, clamp((top + height - bottom) / 2, 0, height) - height / 2]; + } + projectionParameters = getProjectionParameters({ + width, + height, + scale: scale5, + center: position && [0, 0, position[2] * unitsPerMeter(latitude)], + offset, + pitch, + fovy, + nearZMultiplier, + farZMultiplier + }); + if (Number.isFinite(nearZ)) { + projectionParameters.near = nearZ; + } + if (Number.isFinite(farZ)) { + projectionParameters.far = farZ; } } - } - _getSizeAndAspect() { - const width = this.gl.drawingBufferWidth; - const height = this.gl.drawingBufferHeight; - let aspect = 1; - const { - canvas - } = this.gl; - if (canvas && canvas.clientHeight) { - aspect = canvas.clientWidth / canvas.clientHeight; - } else if (width > 0 && height > 0) { - aspect = width / height; + let viewMatrixUncentered = getViewMatrix({ + height, + pitch, + bearing, + scale: scale5, + altitude + }); + if (worldOffset) { + const viewOffset = new Matrix4().translate([512 * worldOffset, 0, 0]); + viewMatrixUncentered = viewOffset.multiplyLeft(viewMatrixUncentered); } - return { + super({ + ...opts, width, height, - aspect - }; + viewMatrix: viewMatrixUncentered, + longitude, + latitude, + zoom, + ...projectionParameters, + fovy, + focalDistance: altitude + }); + _defineProperty(this, "longitude", void 0); + _defineProperty(this, "latitude", void 0); + _defineProperty(this, "pitch", void 0); + _defineProperty(this, "bearing", void 0); + _defineProperty(this, "altitude", void 0); + _defineProperty(this, "fovy", void 0); + _defineProperty(this, "orthographic", void 0); + _defineProperty(this, "_subViewports", void 0); + _defineProperty(this, "_pseudoMeters", void 0); + this.latitude = latitude; + this.longitude = longitude; + this.zoom = zoom; + this.pitch = pitch; + this.bearing = bearing; + this.altitude = altitude; + this.fovy = fovy; + this.orthographic = orthographic; + this._subViewports = repeat ? [] : null; + this._pseudoMeters = legacyMeterSizes; + Object.freeze(this); } - _resizeViewport() { - if (this.autoResizeViewport) { - this.gl.viewport(0, 0, this.gl.drawingBufferWidth, this.gl.drawingBufferHeight); + get subViewports() { + if (this._subViewports && !this._subViewports.length) { + const bounds = this.getBounds(); + const minOffset = Math.floor((bounds[0] + 180) / 360); + const maxOffset = Math.ceil((bounds[2] - 180) / 360); + for (let x2 = minOffset; x2 <= maxOffset; x2++) { + const offsetViewport = x2 ? new _WebMercatorViewport({ + ...this, + worldOffset: x2 + }) : this; + this._subViewports.push(offsetViewport); + } } + return this._subViewports; } - _resizeCanvasDrawingBuffer() { - if (this.autoResizeDrawingBuffer) { - resizeGLContext(this.gl, { - useDevicePixels: this.useDevicePixels - }); + projectPosition(xyz) { + if (this._pseudoMeters) { + return super.projectPosition(xyz); } + const [X, Y] = this.projectFlat(xyz); + const Z = (xyz[2] || 0) * unitsPerMeter(xyz[1]); + return [X, Y, Z]; } - _createFramebuffer() { - if (this.props.createFramebuffer) { - this.framebuffer = new Framebuffer(this.gl); + unprojectPosition(xyz) { + if (this._pseudoMeters) { + return super.unprojectPosition(xyz); } + const [X, Y] = this.unprojectFlat(xyz); + const Z = (xyz[2] || 0) / unitsPerMeter(Y); + return [X, Y, Z]; } - _resizeFramebuffer() { - if (this.framebuffer) { - this.framebuffer.resize({ - width: this.gl.drawingBufferWidth, - height: this.gl.drawingBufferHeight - }); - } + addMetersToLngLat(lngLatZ, xyz) { + return addMetersToLngLat(lngLatZ, xyz); } - _beginTimers() { - this.frameRate.timeEnd(); - this.frameRate.timeStart(); - if (this._gpuTimeQuery && this._gpuTimeQuery.isResultAvailable() && !this._gpuTimeQuery.isTimerDisjoint()) { - this.stats.get("GPU Time").addTime(this._gpuTimeQuery.getTimerMilliseconds()); - } - if (this._gpuTimeQuery) { - this._gpuTimeQuery.beginTimeElapsedQuery(); - } - this.cpuTime.timeStart(); + panByPosition(coords, pixel) { + const fromLocation = pixelsToWorld(pixel, this.pixelUnprojectionMatrix); + const toLocation = this.projectFlat(coords); + const translate3 = add([], toLocation, negate([], fromLocation)); + const newCenter = add([], this.center, translate3); + const [longitude, latitude] = this.unprojectFlat(newCenter); + return { + longitude, + latitude + }; } - _endTimers() { - this.cpuTime.timeEnd(); - if (this._gpuTimeQuery) { - this._gpuTimeQuery.end(); - } + getBounds(options = {}) { + const corners = getBounds(this, options.z || 0); + return [Math.min(corners[0][0], corners[1][0], corners[2][0], corners[3][0]), Math.min(corners[0][1], corners[1][1], corners[2][1], corners[3][1]), Math.max(corners[0][0], corners[1][0], corners[2][0], corners[3][0]), Math.max(corners[0][1], corners[1][1], corners[2][1], corners[3][1])]; } - _startEventHandling() { + fitBounds(bounds, options = {}) { const { - canvas - } = this.gl; - if (canvas) { - canvas.addEventListener("mousemove", this._onMousemove); - canvas.addEventListener("mouseleave", this._onMouseleave); - } - } - _onMousemove(e2) { - this.animationProps._mousePosition = [e2.offsetX, e2.offsetY]; - } - _onMouseleave(e2) { - this.animationProps._mousePosition = null; + width, + height + } = this; + const { + longitude, + latitude, + zoom + } = fitBounds({ + width, + height, + bounds, + ...options + }); + return new _WebMercatorViewport({ + width, + height, + longitude, + latitude, + zoom + }); } }; + _defineProperty(WebMercatorViewport2, "displayName", "WebMercatorViewport"); - // node_modules/@luma.gl/shadertools/dist/esm/lib/constants.js - var VERTEX_SHADER = "vs"; - var FRAGMENT_SHADER = "fs"; - - // node_modules/@luma.gl/shadertools/dist/esm/utils/assert.js - function assert7(condition, message) { - if (!condition) { - throw new Error(message || "shadertools: assertion failed."); + // node_modules/@deck.gl/core/dist/esm/shaderlib/project/project-functions.js + var DEFAULT_COORDINATE_ORIGIN2 = [0, 0, 0]; + function lngLatZToWorldPosition(lngLatZ, viewport, offsetMode = false) { + const p2 = viewport.projectPosition(lngLatZ); + if (offsetMode && viewport instanceof WebMercatorViewport2) { + const [longitude, latitude, z = 0] = lngLatZ; + const distanceScales = viewport.getDistanceScales([longitude, latitude]); + p2[2] = z * distanceScales.unitsPerMeter[2]; } + return p2; } - - // node_modules/@luma.gl/shadertools/dist/esm/lib/filters/prop-types.js - var TYPE_DEFINITIONS = { - number: { - validate(value, propType) { - return Number.isFinite(value) && (!("max" in propType) || value <= propType.max) && (!("min" in propType) || value >= propType.min); - } - }, - array: { - validate(value, propType) { - return Array.isArray(value) || ArrayBuffer.isView(value); - } + function normalizeParameters(opts) { + const { + viewport, + modelMatrix, + coordinateOrigin + } = opts; + let { + coordinateSystem, + fromCoordinateSystem, + fromCoordinateOrigin + } = opts; + if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { + coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN; } - }; - function parsePropTypes(propDefs) { - const propTypes = {}; - for (const propName in propDefs) { - const propDef = propDefs[propName]; - const propType = parsePropType(propDef); - propTypes[propName] = propType; + if (fromCoordinateSystem === void 0) { + fromCoordinateSystem = coordinateSystem; } - return propTypes; + if (fromCoordinateOrigin === void 0) { + fromCoordinateOrigin = coordinateOrigin; + } + return { + viewport, + coordinateSystem, + coordinateOrigin, + modelMatrix, + fromCoordinateSystem, + fromCoordinateOrigin + }; } - function parsePropType(propDef) { - let type = getTypeOf(propDef); - if (type === "object") { - if (!propDef) { - return { - type: "object", - value: null - }; - } - if ("type" in propDef) { - return Object.assign({}, propDef, TYPE_DEFINITIONS[propDef.type]); - } - if (!("value" in propDef)) { - return { - type: "object", - value: propDef - }; - } - type = getTypeOf(propDef.value); - return Object.assign({ - type - }, propDef, TYPE_DEFINITIONS[type]); + function getWorldPosition(position, { + viewport, + modelMatrix, + coordinateSystem, + coordinateOrigin, + offsetMode + }) { + let [x2, y2, z = 0] = position; + if (modelMatrix) { + [x2, y2, z] = transformMat43([], [x2, y2, z, 1], modelMatrix); + } + switch (coordinateSystem) { + case COORDINATE_SYSTEM.LNGLAT: + return lngLatZToWorldPosition([x2, y2, z], viewport, offsetMode); + case COORDINATE_SYSTEM.LNGLAT_OFFSETS: + return lngLatZToWorldPosition([x2 + coordinateOrigin[0], y2 + coordinateOrigin[1], z + (coordinateOrigin[2] || 0)], viewport, offsetMode); + case COORDINATE_SYSTEM.METER_OFFSETS: + return lngLatZToWorldPosition(addMetersToLngLat(coordinateOrigin, [x2, y2, z]), viewport, offsetMode); + case COORDINATE_SYSTEM.CARTESIAN: + default: + return viewport.isGeospatial ? [x2 + coordinateOrigin[0], y2 + coordinateOrigin[1], z + coordinateOrigin[2]] : viewport.projectPosition([x2, y2, z]); } - return Object.assign({ - type, - value: propDef - }, TYPE_DEFINITIONS[type]); } - function getTypeOf(value) { - if (Array.isArray(value) || ArrayBuffer.isView(value)) { - return "array"; + function projectPosition(position, params) { + const { + viewport, + coordinateSystem, + coordinateOrigin, + modelMatrix, + fromCoordinateSystem, + fromCoordinateOrigin + } = normalizeParameters(params); + const { + autoOffset = true + } = params; + const { + geospatialOrigin = DEFAULT_COORDINATE_ORIGIN2, + shaderCoordinateOrigin = DEFAULT_COORDINATE_ORIGIN2, + offsetMode = false + } = autoOffset ? getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin) : {}; + const worldPosition = getWorldPosition(position, { + viewport, + modelMatrix, + coordinateSystem: fromCoordinateSystem, + coordinateOrigin: fromCoordinateOrigin, + offsetMode + }); + if (offsetMode) { + const positionCommonSpace = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin); + sub(worldPosition, worldPosition, positionCommonSpace); } - return typeof value; + return worldPosition; } - // node_modules/@luma.gl/shadertools/dist/esm/lib/shader-module.js - var VERTEX_SHADER2 = "vs"; - var FRAGMENT_SHADER2 = "fs"; - var ShaderModule = class { - constructor(_ref) { - let { - name, - vs: vs7, - fs: fs4, - dependencies = [], - uniforms, - getUniforms: getUniforms5, - deprecations = [], - defines: defines2 = {}, - inject = {}, - vertexShader, - fragmentShader - } = _ref; - assert7(typeof name === "string"); - this.name = name; - this.vs = vs7 || vertexShader; - this.fs = fs4 || fragmentShader; - this.getModuleUniforms = getUniforms5; - this.dependencies = dependencies; - this.deprecations = this._parseDeprecationDefinitions(deprecations); - this.defines = defines2; - this.injections = normalizeInjections(inject); - if (uniforms) { - this.uniforms = parsePropTypes(uniforms); - } - } - getModuleSource(type) { - let moduleSource; - switch (type) { - case VERTEX_SHADER2: - moduleSource = this.vs || ""; - break; - case FRAGMENT_SHADER2: - moduleSource = this.fs || ""; - break; - default: - assert7(false); - } - return "#define MODULE_".concat(this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_"), "\n").concat(moduleSource, "// END MODULE_").concat(this.name, "\n\n"); + // node_modules/@deck.gl/core/dist/esm/passes/pick-layers-pass.js + var PICKING_PARAMETERS = { + blendFunc: [1, 0, 32771, 0], + blendEquation: 32774 + }; + var PickLayersPass = class extends LayersPass { + constructor(...args) { + super(...args); + _defineProperty(this, "pickZ", void 0); + _defineProperty(this, "_colorEncoderState", null); } - getUniforms(opts, uniforms) { - if (this.getModuleUniforms) { - return this.getModuleUniforms(opts, uniforms); - } - if (this.uniforms) { - return this._defaultGetUniforms(opts); + render(props) { + if ("pickingFBO" in props) { + return this._drawPickingBuffer(props); } - return {}; + return super.render(props); } - getDefines() { - return this.defines; + _drawPickingBuffer({ + layers, + layerFilter, + views, + viewports, + onViewportActive, + pickingFBO, + deviceRect: { + x: x2, + y: y2, + width, + height + }, + cullRect, + effects, + pass = "picking", + pickZ, + moduleParameters + }) { + const gl = this.gl; + this.pickZ = pickZ; + const colorEncoderState = this._resetColorEncoder(pickZ); + const renderStatus = withParameters(gl, { + scissorTest: true, + scissor: [x2, y2, width, height], + clearColor: [0, 0, 0, 0], + depthMask: true, + depthTest: true, + depthRange: [0, 1], + colorMask: [true, true, true, true], + ...PICKING_PARAMETERS, + blend: !pickZ + }, () => super.render({ + target: pickingFBO, + layers, + layerFilter, + views, + viewports, + onViewportActive, + cullRect, + effects: effects === null || effects === void 0 ? void 0 : effects.filter((e2) => e2.useInPicking), + pass, + isPicking: true, + moduleParameters + })); + this._colorEncoderState = null; + const decodePickingColor = colorEncoderState && decodeColor.bind(null, colorEncoderState); + return { + decodePickingColor, + stats: renderStatus + }; } - checkDeprecations(shaderSource, log4) { - this.deprecations.forEach((def) => { - if (def.regex.test(shaderSource)) { - if (def.deprecated) { - log4.deprecated(def.old, def.new)(); - } else { - log4.removed(def.old, def.new)(); - } - } - }); + shouldDrawLayer(layer) { + const { + pickable, + operation + } = layer.props; + return pickable && operation.includes("draw") || operation.includes("terrain") || operation.includes("mask"); } - _parseDeprecationDefinitions(deprecations) { - deprecations.forEach((def) => { - switch (def.type) { - case "function": - def.regex = new RegExp("\\b".concat(def.old, "\\(")); - break; - default: - def.regex = new RegExp("".concat(def.type, " ").concat(def.old, ";")); - } - }); - return deprecations; + getModuleParameters() { + return { + pickingActive: 1, + pickingAttribute: this.pickZ, + lightSources: {} + }; } - _defaultGetUniforms() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const uniforms = {}; - const propTypes = this.uniforms; - for (const key in propTypes) { - const propDef = propTypes[key]; - if (key in opts && !propDef.private) { - if (propDef.validate) { - assert7(propDef.validate(opts[key], propDef), "".concat(this.name, ": invalid ").concat(key)); - } - uniforms[key] = opts[key]; - } else { - uniforms[key] = propDef.value; - } + getLayerParameters(layer, layerIndex, viewport) { + const pickParameters = { + ...layer.props.parameters + }; + const { + pickable, + operation + } = layer.props; + if (!this._colorEncoderState) { + pickParameters.blend = false; + } else if (pickable && operation.includes("draw")) { + Object.assign(pickParameters, PICKING_PARAMETERS); + pickParameters.blend = true; + pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport); } - return uniforms; - } - }; - function normalizeInjections(injections) { - const result = { - vs: {}, - fs: {} - }; - for (const hook in injections) { - let injection = injections[hook]; - const stage = hook.slice(0, 2); - if (typeof injection === "string") { - injection = { - order: 0, - injection - }; + if (operation.includes("terrain")) { + pickParameters.blend = false; } - result[stage][hook] = injection; - } - return result; - } - - // node_modules/@luma.gl/shadertools/dist/esm/lib/resolve-modules.js - function resolveModules(modules) { - return getShaderDependencies(instantiateModules(modules)); - } - function getShaderDependencies(modules) { - const moduleMap = {}; - const moduleDepth = {}; - getDependencyGraph({ - modules, - level: 0, - moduleMap, - moduleDepth - }); - return Object.keys(moduleDepth).sort((a2, b2) => moduleDepth[b2] - moduleDepth[a2]).map((name) => moduleMap[name]); - } - function getDependencyGraph(_ref) { - let { - modules, - level, - moduleMap, - moduleDepth - } = _ref; - if (level >= 5) { - throw new Error("Possible loop in shader dependency graph"); + return pickParameters; } - for (const module of modules) { - moduleMap[module.name] = module; - if (moduleDepth[module.name] === void 0 || moduleDepth[module.name] < level) { - moduleDepth[module.name] = level; - } + _resetColorEncoder(pickZ) { + this._colorEncoderState = pickZ ? null : { + byLayer: /* @__PURE__ */ new Map(), + byAlpha: [] + }; + return this._colorEncoderState; } - for (const module of modules) { - if (module.dependencies) { - getDependencyGraph({ - modules: module.dependencies, - level: level + 1, - moduleMap, - moduleDepth - }); + }; + function encodeColor(encoded, layer, viewport) { + const { + byLayer, + byAlpha + } = encoded; + let a2; + let entry = byLayer.get(layer); + if (entry) { + entry.viewports.push(viewport); + a2 = entry.a; + } else { + a2 = byLayer.size + 1; + if (a2 <= 255) { + entry = { + a: a2, + layer, + viewports: [viewport] + }; + byLayer.set(layer, entry); + byAlpha[a2] = entry; + } else { + log_default.warn("Too many pickable layers, only picking the first 255")(); + a2 = 0; } } + return [0, 0, 0, a2 / 255]; } - function instantiateModules(modules, seen) { - return modules.map((module) => { - if (module instanceof ShaderModule) { - return module; - } - assert7(typeof module !== "string", "Shader module use by name is deprecated. Import shader module '".concat(module, "' and use it directly.")); - assert7(module.name, "shader module has no name"); - module = new ShaderModule(module); - module.dependencies = instantiateModules(module.dependencies); - return module; - }); - } - - // node_modules/@luma.gl/shadertools/dist/esm/utils/is-old-ie.js - function isOldIE() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const navigator2 = typeof window !== "undefined" ? window.navigator || {} : {}; - const userAgent2 = opts.userAgent || navigator2.userAgent || ""; - const isMSIE = userAgent2.indexOf("MSIE ") !== -1; - const isTrident = userAgent2.indexOf("Trident/") !== -1; - return isMSIE || isTrident; + function decodeColor(encoded, pickedColor) { + const entry = encoded.byAlpha[pickedColor[3]]; + return entry && { + pickedLayer: entry.layer, + pickedViewports: entry.viewports, + pickedObjectIndex: entry.layer.decodePickingColor(pickedColor) + }; } - // node_modules/@luma.gl/shadertools/dist/esm/utils/webgl-info.js - var GL_VENDOR = 7936; - var GL_RENDERER = 7937; - var GL_VERSION = 7938; - var GL_SHADING_LANGUAGE_VERSION = 35724; - var WEBGL_FEATURES = { - GLSL_FRAG_DATA: ["WEBGL_draw_buffers", true], - GLSL_FRAG_DEPTH: ["EXT_frag_depth", true], - GLSL_DERIVATIVES: ["OES_standard_derivatives", true], - GLSL_TEXTURE_LOD: ["EXT_shader_texture_lod", true] + // node_modules/@deck.gl/core/dist/esm/lifecycle/constants.js + var LIFECYCLE = { + NO_STATE: "Awaiting state", + MATCHED: "Matched. State transferred from previous layer", + INITIALIZED: "Initialized", + AWAITING_GC: "Discarded. Awaiting garbage collection", + AWAITING_FINALIZATION: "No longer matched. Awaiting garbage collection", + FINALIZED: "Finalized! Awaiting garbage collection" }; - var FEATURES2 = {}; - Object.keys(WEBGL_FEATURES).forEach((key) => { - FEATURES2[key] = key; - }); - function isWebGL22(gl) { - if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) { - return true; + var COMPONENT_SYMBOL = Symbol.for("component"); + var PROP_TYPES_SYMBOL = Symbol.for("propTypes"); + var DEPRECATED_PROPS_SYMBOL = Symbol.for("deprecatedProps"); + var ASYNC_DEFAULTS_SYMBOL = Symbol.for("asyncPropDefaults"); + var ASYNC_ORIGINAL_SYMBOL = Symbol.for("asyncPropOriginal"); + var ASYNC_RESOLVED_SYMBOL = Symbol.for("asyncPropResolved"); + + // node_modules/@deck.gl/core/dist/esm/utils/flatten.js + function flatten(array, filter = () => true) { + if (!Array.isArray(array)) { + return filter(array) ? [array] : []; } - return Boolean(gl && gl._version === 2); - } - function getContextInfo(gl) { - const info = gl.getExtension("WEBGL_debug_renderer_info"); - const vendor = gl.getParameter(info && info.UNMASKED_VENDOR_WEBGL || GL_VENDOR); - const renderer = gl.getParameter(info && info.UNMASKED_RENDERER_WEBGL || GL_RENDERER); - const gpuVendor = identifyGPUVendor(vendor, renderer); - const gpuInfo = { - gpuVendor, - vendor, - renderer, - version: gl.getParameter(GL_VERSION), - shadingLanguageVersion: gl.getParameter(GL_SHADING_LANGUAGE_VERSION) - }; - return gpuInfo; + return flattenArray(array, filter, []); } - function identifyGPUVendor(vendor, renderer) { - if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) { - return "NVIDIA"; - } - if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) { - return "INTEL"; - } - if (vendor.match(/AMD/i) || renderer.match(/AMD/i) || vendor.match(/ATI/i) || renderer.match(/ATI/i)) { - return "AMD"; + function flattenArray(array, filter, result) { + let index = -1; + while (++index < array.length) { + const value = array[index]; + if (Array.isArray(value)) { + flattenArray(value, filter, result); + } else if (filter(value)) { + result.push(value); + } } - return "UNKNOWN GPU"; + return result; } - var compiledGlslExtensions = {}; - function canCompileGLGSExtension(gl, cap) { - let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; - const feature = WEBGL_FEATURES[cap]; - assert7(feature, cap); - if (!isOldIE(opts)) { - return true; + function fillArray2({ + target, + source, + start = 0, + count: count2 = 1 + }) { + const length4 = source.length; + const total = count2 * length4; + let copied = 0; + for (let i3 = start; copied < length4; copied++) { + target[i3++] = source[copied]; } - if (cap in compiledGlslExtensions) { - return compiledGlslExtensions[cap]; + while (copied < total) { + if (copied < total - copied) { + target.copyWithin(start + copied, start, start + copied); + copied *= 2; + } else { + target.copyWithin(start + copied, start, start + total - copied); + copied = total; + } } - const extensionName = feature[0]; - const behavior = opts.behavior || "enable"; - const source = "#extension GL_".concat(extensionName, " : ").concat(behavior, "\nvoid main(void) {}"); - const shader = gl.createShader(35633); - gl.shaderSource(shader, source); - gl.compileShader(shader); - const canCompile = gl.getShaderParameter(shader, 35713); - gl.deleteShader(shader); - compiledGlslExtensions[cap] = canCompile; - return canCompile; - } - function getFeature(gl, cap) { - const feature = WEBGL_FEATURES[cap]; - assert7(feature, cap); - const extensionName = isWebGL22(gl) ? feature[1] || feature[0] : feature[0]; - const value = typeof extensionName === "string" ? Boolean(gl.getExtension(extensionName)) : extensionName; - assert7(value === false || value === true); - return value; - } - function hasFeatures2(gl, features) { - features = Array.isArray(features) ? features : [features]; - return features.every((feature) => getFeature(gl, feature)); + return target; } - // node_modules/@luma.gl/shadertools/dist/esm/lib/platform-defines.js - function getPlatformShaderDefines(gl) { - const debugInfo = getContextInfo(gl); - switch (debugInfo.gpuVendor.toLowerCase()) { - case "nvidia": - return "#define NVIDIA_GPU\n// Nvidia optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n"; - case "intel": - return "#define INTEL_GPU\n// Intel optimizes away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n"; - case "amd": - return "#define AMD_GPU\n"; - default: - return "#define DEFAULT_GPU\n// Prevent driver from optimizing away the calculation necessary for emulated fp64\n#define LUMA_FP64_CODE_ELIMINATION_WORKAROUND 1\n// Intel's built-in 'tan' function doesn't have acceptable precision\n#define LUMA_FP32_TAN_PRECISION_WORKAROUND 1\n// Intel GPU doesn't have full 32 bits precision in same cases, causes overflow\n#define LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND 1\n"; + // node_modules/@deck.gl/core/dist/esm/lib/resource/resource.js + var Resource2 = class { + constructor(id, data, context) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "context", void 0); + _defineProperty(this, "isLoaded", void 0); + _defineProperty(this, "persistent", void 0); + _defineProperty(this, "_loadCount", 0); + _defineProperty(this, "_subscribers", /* @__PURE__ */ new Set()); + _defineProperty(this, "_data", void 0); + _defineProperty(this, "_loader", void 0); + _defineProperty(this, "_error", void 0); + _defineProperty(this, "_content", void 0); + this.id = id; + this.context = context; + this.setData(data); } - } - function getVersionDefines(gl, glslVersion, isFragment) { - let versionDefines = "#if (__VERSION__ > 120)\n\n# define FEATURE_GLSL_DERIVATIVES\n# define FEATURE_GLSL_DRAW_BUFFERS\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FEATURE_GLSL_TEXTURE_LOD\n\n// DEPRECATED FLAGS, remove in v9\n# define FRAG_DEPTH\n# define DERIVATIVES\n# define DRAW_BUFFERS\n# define TEXTURE_LOD\n\n#endif // __VERSION\n"; - if (hasFeatures2(gl, FEATURES2.GLSL_FRAG_DEPTH)) { - versionDefines += "\n// FRAG_DEPTH => gl_FragDepth is available\n#ifdef GL_EXT_frag_depth\n#extension GL_EXT_frag_depth : enable\n# define FEATURE_GLSL_FRAG_DEPTH\n# define FRAG_DEPTH\n# define gl_FragDepth gl_FragDepthEXT\n#endif\n"; + subscribe(consumer) { + this._subscribers.add(consumer); } - if (hasFeatures2(gl, FEATURES2.GLSL_DERIVATIVES) && canCompileGLGSExtension(gl, FEATURES2.GLSL_DERIVATIVES)) { - versionDefines += "\n// DERIVATIVES => dxdF, dxdY and fwidth are available\n#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n# define FEATURE_GLSL_DERIVATIVES\n# define DERIVATIVES\n#endif\n"; + unsubscribe(consumer) { + this._subscribers.delete(consumer); } - if (hasFeatures2(gl, FEATURES2.GLSL_FRAG_DATA) && canCompileGLGSExtension(gl, FEATURES2.GLSL_FRAG_DATA, { - behavior: "require" - })) { - versionDefines += "\n// DRAW_BUFFERS => gl_FragData[] is available\n#ifdef GL_EXT_draw_buffers\n#extension GL_EXT_draw_buffers : require\n#define FEATURE_GLSL_DRAW_BUFFERS\n#define DRAW_BUFFERS\n#endif\n"; + inUse() { + return this._subscribers.size > 0; } - if (hasFeatures2(gl, FEATURES2.GLSL_TEXTURE_LOD)) { - versionDefines += "// TEXTURE_LOD => texture2DLod etc are available\n#ifdef GL_EXT_shader_texture_lod\n#extension GL_EXT_shader_texture_lod : enable\n\n# define FEATURE_GLSL_TEXTURE_LOD\n# define TEXTURE_LOD\n\n#endif\n"; + delete() { } - return versionDefines; - } - - // node_modules/@luma.gl/shadertools/dist/esm/modules/module-injectors.js - var MODULE_INJECTORS_VS = "#ifdef MODULE_LOGDEPTH\n logdepth_adjustPosition(gl_Position);\n#endif\n"; - var MODULE_INJECTORS_FS = "#ifdef MODULE_MATERIAL\n gl_FragColor = material_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LIGHTING\n gl_FragColor = lighting_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_FOG\n gl_FragColor = fog_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_PICKING\n gl_FragColor = picking_filterHighlightColor(gl_FragColor);\n gl_FragColor = picking_filterPickingColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LOGDEPTH\n logdepth_setFragDepth();\n#endif\n"; - - // node_modules/@luma.gl/shadertools/dist/esm/lib/inject-shader.js - var MODULE_INJECTORS = { - [VERTEX_SHADER]: MODULE_INJECTORS_VS, - [FRAGMENT_SHADER]: MODULE_INJECTORS_FS - }; - var DECLARATION_INJECT_MARKER = "__LUMA_INJECT_DECLARATIONS__"; - var REGEX_START_OF_MAIN = /void\s+main\s*\([^)]*\)\s*\{\n?/; - var REGEX_END_OF_MAIN = /}\n?[^{}]*$/; - var fragments = []; - function injectShader(source, type, inject) { - let injectStandardStubs = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false; - const isVertex = type === VERTEX_SHADER; - for (const key in inject) { - const fragmentData = inject[key]; - fragmentData.sort((a2, b2) => a2.order - b2.order); - fragments.length = fragmentData.length; - for (let i2 = 0, len = fragmentData.length; i2 < len; ++i2) { - fragments[i2] = fragmentData[i2].injection; + getData() { + return this.isLoaded ? this._error ? Promise.reject(this._error) : this._content : this._loader.then(() => this.getData()); + } + setData(data, forceUpdate) { + if (data === this._data && !forceUpdate) { + return; } - const fragmentString = "".concat(fragments.join("\n"), "\n"); - switch (key) { - case "vs:#decl": - if (isVertex) { - source = source.replace(DECLARATION_INJECT_MARKER, fragmentString); - } - break; - case "vs:#main-start": - if (isVertex) { - source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString); - } - break; - case "vs:#main-end": - if (isVertex) { - source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match); - } - break; - case "fs:#decl": - if (!isVertex) { - source = source.replace(DECLARATION_INJECT_MARKER, fragmentString); - } - break; - case "fs:#main-start": - if (!isVertex) { - source = source.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString); + this._data = data; + const loadCount = ++this._loadCount; + let loader = data; + if (typeof data === "string") { + loader = load(data); + } + if (loader instanceof Promise) { + this.isLoaded = false; + this._loader = loader.then((result) => { + if (this._loadCount === loadCount) { + this.isLoaded = true; + this._error = void 0; + this._content = result; } - break; - case "fs:#main-end": - if (!isVertex) { - source = source.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match); + }).catch((error2) => { + if (this._loadCount === loadCount) { + this.isLoaded = true; + this._error = error2 || true; } - break; - default: - source = source.replace(key, (match) => match + fragmentString); + }); + } else { + this.isLoaded = true; + this._error = void 0; + this._content = data; } - } - source = source.replace(DECLARATION_INJECT_MARKER, ""); - if (injectStandardStubs) { - source = source.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[type]); - } - return source; - } - function combineInjects(injects) { - const result = {}; - assert7(Array.isArray(injects) && injects.length > 1); - injects.forEach((inject) => { - for (const key in inject) { - result[key] = result[key] ? "".concat(result[key], "\n").concat(inject[key]) : inject[key]; + for (const subscriber of this._subscribers) { + subscriber.onChange(this.getData()); } - }); - return result; - } - - // node_modules/@luma.gl/shadertools/dist/esm/lib/transpile-shader.js - function testVariable(qualifier) { - return new RegExp("\\b".concat(qualifier, "[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)"), "g"); - } - var ES300_REPLACEMENTS = [[/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, "#version 300 es\n"], [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, "textureLod("], [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, "texture("]]; - var ES300_VERTEX_REPLACEMENTS = [...ES300_REPLACEMENTS, [testVariable("attribute"), "in $1"], [testVariable("varying"), "out $1"]]; - var ES300_FRAGMENT_REPLACEMENTS = [...ES300_REPLACEMENTS, [testVariable("varying"), "in $1"]]; - var ES100_REPLACEMENTS = [[/^#version[ \t]+300[ \t]+es/, "#version 100"], [/\btexture(2D|2DProj|Cube)Lod\(/g, "texture$1LodEXT("], [/\btexture\(/g, "texture2D("], [/\btextureLod\(/g, "texture2DLodEXT("]]; - var ES100_VERTEX_REPLACEMENTS = [...ES100_REPLACEMENTS, [testVariable("in"), "attribute $1"], [testVariable("out"), "varying $1"]]; - var ES100_FRAGMENT_REPLACEMENTS = [...ES100_REPLACEMENTS, [testVariable("in"), "varying $1"]]; - var ES100_FRAGMENT_OUTPUT_NAME = "gl_FragColor"; - var ES300_FRAGMENT_OUTPUT_REGEX = /\bout[ \t]+vec4[ \t]+(\w+)[ \t]*;\n?/; - var REGEX_START_OF_MAIN2 = /void\s+main\s*\([^)]*\)\s*\{\n?/; - function transpileShader(source, targetGLSLVersion, isVertex) { - switch (targetGLSLVersion) { - case 300: - return isVertex ? convertShader(source, ES300_VERTEX_REPLACEMENTS) : convertFragmentShaderTo300(source); - case 100: - return isVertex ? convertShader(source, ES100_VERTEX_REPLACEMENTS) : convertFragmentShaderTo100(source); - default: - throw new Error("unknown GLSL version ".concat(targetGLSLVersion)); - } - } - function convertShader(source, replacements) { - for (const [pattern, replacement] of replacements) { - source = source.replace(pattern, replacement); - } - return source; - } - function convertFragmentShaderTo300(source) { - source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS); - const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX); - if (outputMatch) { - const outputName = outputMatch[1]; - source = source.replace(new RegExp("\\b".concat(ES100_FRAGMENT_OUTPUT_NAME, "\\b"), "g"), outputName); - } else { - const outputName = "fragmentColor"; - source = source.replace(REGEX_START_OF_MAIN2, (match) => "out vec4 ".concat(outputName, ";\n").concat(match)).replace(new RegExp("\\b".concat(ES100_FRAGMENT_OUTPUT_NAME, "\\b"), "g"), outputName); - } - return source; - } - function convertFragmentShaderTo100(source) { - source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS); - const outputMatch = source.match(ES300_FRAGMENT_OUTPUT_REGEX); - if (outputMatch) { - const outputName = outputMatch[1]; - source = source.replace(ES300_FRAGMENT_OUTPUT_REGEX, "").replace(new RegExp("\\b".concat(outputName, "\\b"), "g"), ES100_FRAGMENT_OUTPUT_NAME); } - return source; - } - - // node_modules/@luma.gl/shadertools/dist/esm/lib/assemble-shaders.js - var INJECT_SHADER_DECLARATIONS = "\n\n".concat(DECLARATION_INJECT_MARKER, "\n\n"); - var SHADER_TYPE = { - [VERTEX_SHADER]: "vertex", - [FRAGMENT_SHADER]: "fragment" }; - var FRAGMENT_SHADER_PROLOGUE = "precision highp float;\n\n"; - function assembleShaders(gl, opts) { - const { - vs: vs7, - fs: fs4 - } = opts; - const modules = resolveModules(opts.modules || []); - return { + + // node_modules/@deck.gl/core/dist/esm/lib/resource/resource-manager.js + var ResourceManager = class { + constructor({ gl, - vs: assembleShader(gl, Object.assign({}, opts, { - source: vs7, - type: VERTEX_SHADER, - modules - })), - fs: assembleShader(gl, Object.assign({}, opts, { - source: fs4, - type: FRAGMENT_SHADER, - modules - })), - getUniforms: assembleGetUniforms(modules) - }; - } - function assembleShader(gl, _ref) { - let { - id, - source, - type, - modules, - defines: defines2 = {}, - hookFunctions = [], - inject = {}, - transpileToGLSL100 = false, - prologue = true, - log: log4 - } = _ref; - assert7(typeof source === "string", "shader source must be a string"); - const isVertex = type === VERTEX_SHADER; - const sourceLines = source.split("\n"); - let glslVersion = 100; - let versionLine = ""; - let coreSource = source; - if (sourceLines[0].indexOf("#version ") === 0) { - glslVersion = 300; - versionLine = sourceLines[0]; - coreSource = sourceLines.slice(1).join("\n"); - } else { - versionLine = "#version ".concat(glslVersion); - } - const allDefines = {}; - modules.forEach((module) => { - Object.assign(allDefines, module.getDefines()); - }); - Object.assign(allDefines, defines2); - let assembledSource = prologue ? "".concat(versionLine, "\n").concat(getShaderName2({ - id, - source, - type - }), "\n").concat(getShaderType({ - type - }), "\n").concat(getPlatformShaderDefines(gl), "\n").concat(getVersionDefines(gl, glslVersion, !isVertex), "\n").concat(getApplicationDefines(allDefines), "\n").concat(isVertex ? "" : FRAGMENT_SHADER_PROLOGUE, "\n") : "".concat(versionLine, "\n"); - const hookFunctionMap = normalizeHookFunctions(hookFunctions); - const hookInjections = {}; - const declInjections = {}; - const mainInjections = {}; - for (const key in inject) { - const injection = typeof inject[key] === "string" ? { - injection: inject[key], - order: 0 - } : inject[key]; - const match = key.match(/^(v|f)s:(#)?([\w-]+)$/); - if (match) { - const hash = match[2]; - const name = match[3]; - if (hash) { - if (name === "decl") { - declInjections[key] = [injection]; - } else { - mainInjections[key] = [injection]; - } - } else { - hookInjections[key] = [injection]; - } - } else { - mainInjections[key] = [injection]; - } + protocol + }) { + _defineProperty(this, "protocol", void 0); + _defineProperty(this, "_context", void 0); + _defineProperty(this, "_resources", void 0); + _defineProperty(this, "_consumers", void 0); + _defineProperty(this, "_pruneRequest", void 0); + this.protocol = protocol || "resource://"; + this._context = { + gl, + resourceManager: this + }; + this._resources = {}; + this._consumers = {}; + this._pruneRequest = null; } - for (const module of modules) { - if (log4) { - module.checkDeprecations(coreSource, log4); - } - const moduleSource = module.getModuleSource(type, glslVersion); - assembledSource += moduleSource; - const injections = module.injections[type]; - for (const key in injections) { - const match = key.match(/^(v|f)s:#([\w-]+)$/); - if (match) { - const name = match[2]; - const injectionType = name === "decl" ? declInjections : mainInjections; - injectionType[key] = injectionType[key] || []; - injectionType[key].push(injections[key]); - } else { - hookInjections[key] = hookInjections[key] || []; - hookInjections[key].push(injections[key]); - } + contains(resourceId) { + if (resourceId.startsWith(this.protocol)) { + return true; } + return resourceId in this._resources; } - assembledSource += INJECT_SHADER_DECLARATIONS; - assembledSource = injectShader(assembledSource, type, declInjections); - assembledSource += getHookFunctions(hookFunctionMap[type], hookInjections); - assembledSource += coreSource; - assembledSource = injectShader(assembledSource, type, mainInjections); - assembledSource = transpileShader(assembledSource, transpileToGLSL100 ? 100 : glslVersion, isVertex); - return assembledSource; - } - function assembleGetUniforms(modules) { - return function getUniforms5(opts) { - const uniforms = {}; - for (const module of modules) { - const moduleUniforms = module.getUniforms(opts, uniforms); - Object.assign(uniforms, moduleUniforms); - } - return uniforms; - }; - } - function getShaderType(_ref2) { - let { - type - } = _ref2; - return "\n#define SHADER_TYPE_".concat(SHADER_TYPE[type].toUpperCase(), "\n"); - } - function getShaderName2(_ref3) { - let { - id, - source, - type - } = _ref3; - const injectShaderName = id && typeof id === "string" && source.indexOf("SHADER_NAME") === -1; - return injectShaderName ? "\n#define SHADER_NAME ".concat(id, "_").concat(SHADER_TYPE[type], "\n\n") : ""; - } - function getApplicationDefines() { - let defines2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - let count2 = 0; - let sourceText = ""; - for (const define2 in defines2) { - if (count2 === 0) { - sourceText += "\n// APPLICATION DEFINES\n"; - } - count2++; - const value = defines2[define2]; - if (value || Number.isFinite(value)) { - sourceText += "#define ".concat(define2.toUpperCase(), " ").concat(defines2[define2], "\n"); + add({ + resourceId, + data, + forceUpdate = false, + persistent = true + }) { + let res = this._resources[resourceId]; + if (res) { + res.setData(data, forceUpdate); + } else { + res = new Resource2(resourceId, data, this._context); + this._resources[resourceId] = res; } + res.persistent = persistent; } - if (count2 === 0) { - sourceText += "\n"; + remove(resourceId) { + const res = this._resources[resourceId]; + if (res) { + res.delete(); + delete this._resources[resourceId]; + } } - return sourceText; - } - function getHookFunctions(hookFunctions, hookInjections) { - let result = ""; - for (const hookName in hookFunctions) { - const hookFunction = hookFunctions[hookName]; - result += "void ".concat(hookFunction.signature, " {\n"); - if (hookFunction.header) { - result += " ".concat(hookFunction.header); + unsubscribe({ + consumerId + }) { + const consumer = this._consumers[consumerId]; + if (consumer) { + for (const requestId in consumer) { + const request = consumer[requestId]; + const resource = this._resources[request.resourceId]; + if (resource) { + resource.unsubscribe(request); + } + } + delete this._consumers[consumerId]; + this.prune(); } - if (hookInjections[hookName]) { - const injections = hookInjections[hookName]; - injections.sort((a2, b2) => a2.order - b2.order); - for (const injection of injections) { - result += " ".concat(injection.injection, "\n"); + } + subscribe({ + resourceId, + onChange, + consumerId, + requestId = "default" + }) { + const { + _resources: resources, + protocol + } = this; + if (resourceId.startsWith(protocol)) { + resourceId = resourceId.replace(protocol, ""); + if (!resources[resourceId]) { + this.add({ + resourceId, + data: null, + persistent: false + }); } } - if (hookFunction.footer) { - result += " ".concat(hookFunction.footer); + const res = resources[resourceId]; + this._track(consumerId, requestId, res, onChange); + if (res) { + return res.getData(); } - result += "}\n"; + return void 0; } - return result; - } - function normalizeHookFunctions(hookFunctions) { - const result = { - vs: {}, - fs: {} - }; - hookFunctions.forEach((hook) => { - let opts; - if (typeof hook !== "string") { - opts = hook; - hook = opts.hook; - } else { - opts = {}; + prune() { + if (!this._pruneRequest) { + this._pruneRequest = setTimeout(() => this._prune(), 0); } - hook = hook.trim(); - const [stage, signature] = hook.split(":"); - const name = hook.replace(/\(.+/, ""); - result[stage][name] = Object.assign(opts, { - signature - }); - }); - return result; - } - - // node_modules/@luma.gl/shadertools/dist/esm/utils/shader-utils.js - var FS100 = "void main() {gl_FragColor = vec4(0);}"; - var FS_GLES = "out vec4 transform_output;\nvoid main() {\n transform_output = vec4(0);\n}"; - var FS300 = "#version 300 es\n".concat(FS_GLES); - function getQualifierDetails(line, qualifiers) { - qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers]; - const words = line.replace(/^\s+/, "").split(/\s+/); - const [qualifier, type, definition] = words; - if (!qualifiers.includes(qualifier) || !type || !definition) { - return null; } - const name = definition.split(";")[0]; - return { - qualifier, - type, - name - }; - } - function getPassthroughFS() { - let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - version = 100, - input, - inputType, - output - } = options; - if (!input) { - if (version === 300) { - return FS300; - } else if (version > 300) { - return "#version ".concat(version, "\n").concat(FS_GLES); + finalize() { + for (const key in this._resources) { + this._resources[key].delete(); } - return FS100; - } - const outputValue = convertToVec4(input, inputType); - if (version >= 300) { - return "#version ".concat(version, " ").concat(version === 300 ? "es" : "", "\nin ").concat(inputType, " ").concat(input, ";\nout vec4 ").concat(output, ";\nvoid main() {\n ").concat(output, " = ").concat(outputValue, ";\n}"); - } - return "varying ".concat(inputType, " ").concat(input, ";\nvoid main() {\n gl_FragColor = ").concat(outputValue, ";\n}"); - } - function typeToChannelSuffix(type) { - switch (type) { - case "float": - return "x"; - case "vec2": - return "xy"; - case "vec3": - return "xyz"; - case "vec4": - return "xyzw"; - default: - assert7(false); - return null; } - } - function typeToChannelCount(type) { - switch (type) { - case "float": - return 1; - case "vec2": - return 2; - case "vec3": - return 3; - case "vec4": - return 4; - default: - assert7(false); - return null; + _track(consumerId, requestId, resource, onChange) { + const consumers = this._consumers; + const consumer = consumers[consumerId] = consumers[consumerId] || {}; + const request = consumer[requestId] || {}; + const oldResource = request.resourceId && this._resources[request.resourceId]; + if (oldResource) { + oldResource.unsubscribe(request); + this.prune(); + } + if (resource) { + consumer[requestId] = request; + request.onChange = onChange; + request.resourceId = resource.id; + resource.subscribe(request); + } } - } - function convertToVec4(variable, type) { - switch (type) { - case "float": - return "vec4(".concat(variable, ", 0.0, 0.0, 1.0)"); - case "vec2": - return "vec4(".concat(variable, ", 0.0, 1.0)"); - case "vec3": - return "vec4(".concat(variable, ", 1.0)"); - case "vec4": - return variable; - default: - assert7(false); - return null; + _prune() { + this._pruneRequest = null; + for (const key of Object.keys(this._resources)) { + const res = this._resources[key]; + if (!res.persistent && !res.inUse()) { + res.delete(); + delete this._resources[key]; + } + } } - } + }; - // node_modules/@luma.gl/shadertools/dist/esm/modules/fp32/fp32.js - var fp32shader = "#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\nconst float TWO_PI = 6.2831854820251465;\nconst float PI_2 = 1.5707963705062866;\nconst float PI_16 = 0.1963495463132858;\n\nconst float SIN_TABLE_0 = 0.19509032368659973;\nconst float SIN_TABLE_1 = 0.3826834261417389;\nconst float SIN_TABLE_2 = 0.5555702447891235;\nconst float SIN_TABLE_3 = 0.7071067690849304;\n\nconst float COS_TABLE_0 = 0.9807852506637573;\nconst float COS_TABLE_1 = 0.9238795042037964;\nconst float COS_TABLE_2 = 0.8314695954322815;\nconst float COS_TABLE_3 = 0.7071067690849304;\n\nconst float INVERSE_FACTORIAL_3 = 1.666666716337204e-01;\nconst float INVERSE_FACTORIAL_5 = 8.333333767950535e-03;\nconst float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04;\nconst float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06;\n\nfloat sin_taylor_fp32(float a) {\n float r, s, t, x;\n\n if (a == 0.0) {\n return 0.0;\n }\n\n x = -a * a;\n s = a;\n r = a;\n\n r = r * x;\n t = r * INVERSE_FACTORIAL_3;\n s = s + t;\n\n r = r * x;\n t = r * INVERSE_FACTORIAL_5;\n s = s + t;\n\n r = r * x;\n t = r * INVERSE_FACTORIAL_7;\n s = s + t;\n\n r = r * x;\n t = r * INVERSE_FACTORIAL_9;\n s = s + t;\n\n return s;\n}\n\nvoid sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {\n if (a == 0.0) {\n sin_t = 0.0;\n cos_t = 1.0;\n }\n sin_t = sin_taylor_fp32(a);\n cos_t = sqrt(1.0 - sin_t * sin_t);\n}\n\nfloat tan_taylor_fp32(float a) {\n float sin_a;\n float cos_a;\n\n if (a == 0.0) {\n return 0.0;\n }\n float z = floor(a / TWO_PI);\n float r = a - TWO_PI * z;\n\n float t;\n float q = floor(r / PI_2 + 0.5);\n int j = int(q);\n\n if (j < -2 || j > 2) {\n return 1.0 / 0.0;\n }\n\n t = r - PI_2 * q;\n\n q = floor(t / PI_16 + 0.5);\n int k = int(q);\n int abs_k = int(abs(float(k)));\n\n if (abs_k > 4) {\n return 1.0 / 0.0;\n } else {\n t = t - PI_16 * q;\n }\n\n float u = 0.0;\n float v = 0.0;\n\n float sin_t, cos_t;\n float s, c;\n sincos_taylor_fp32(t, sin_t, cos_t);\n\n if (k == 0) {\n s = sin_t;\n c = cos_t;\n } else {\n if (abs(float(abs_k) - 1.0) < 0.5) {\n u = COS_TABLE_0;\n v = SIN_TABLE_0;\n } else if (abs(float(abs_k) - 2.0) < 0.5) {\n u = COS_TABLE_1;\n v = SIN_TABLE_1;\n } else if (abs(float(abs_k) - 3.0) < 0.5) {\n u = COS_TABLE_2;\n v = SIN_TABLE_2;\n } else if (abs(float(abs_k) - 4.0) < 0.5) {\n u = COS_TABLE_3;\n v = SIN_TABLE_3;\n }\n if (k > 0) {\n s = u * sin_t + v * cos_t;\n c = u * cos_t - v * sin_t;\n } else {\n s = u * sin_t - v * cos_t;\n c = u * cos_t + v * sin_t;\n }\n }\n\n if (j == 0) {\n sin_a = s;\n cos_a = c;\n } else if (j == 1) {\n sin_a = c;\n cos_a = -s;\n } else if (j == -1) {\n sin_a = -c;\n cos_a = s;\n } else {\n sin_a = -s;\n cos_a = -c;\n }\n return sin_a / cos_a;\n}\n#endif\n\nfloat tan_fp32(float a) {\n#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND\n return tan_taylor_fp32(a);\n#else\n return tan(a);\n#endif\n}\n"; - var fp32 = { - name: "fp32", - vs: fp32shader, - fs: null + // node_modules/@deck.gl/core/dist/esm/shaderlib/project32/project32.js + var vs5 = "\nvec4 project_position_to_clipspace(\n vec3 position, vec3 position64Low, vec3 offset, out vec4 commonPosition\n) {\n vec3 projectedPosition = project_position(position, position64Low);\n mat3 rotation;\n if (project_needs_rotation(projectedPosition, rotation)) {\n // offset is specified as ENU\n // when in globe projection, rotate offset so that the ground alighs with the surface of the globe\n offset = rotation * offset;\n }\n commonPosition = vec4(projectedPosition + offset, 1.0);\n return project_common_position_to_clipspace(commonPosition);\n}\n\nvec4 project_position_to_clipspace(\n vec3 position, vec3 position64Low, vec3 offset\n) {\n vec4 commonPosition;\n return project_position_to_clipspace(position, position64Low, offset, commonPosition);\n}\n"; + var project32_default = { + name: "project32", + dependencies: [project_default], + vs: vs5 }; - // node_modules/@math.gl/core/dist/esm/lib/assert.js - function assert8(condition, message) { - if (!condition) { - throw new Error("math.gl assertion ".concat(message)); + // node_modules/@deck.gl/core/dist/esm/shaderlib/picking/picking.js + var picking_default = { + inject: { + "vs:DECKGL_FILTER_GL_POSITION": "\n // for picking depth values\n picking_setPickingAttribute(position.z / position.w);\n ", + "vs:DECKGL_FILTER_COLOR": "\n picking_setPickingColor(geometry.pickingColor);\n ", + "fs:#decl": "\nuniform bool picking_uAttribute;\n ", + "fs:DECKGL_FILTER_COLOR": { + order: 99, + injection: "\n // use highlight color if this fragment belongs to the selected object.\n color = picking_filterHighlightColor(color);\n\n // use picking color if rendering to picking FBO.\n color = picking_filterPickingColor(color);\n " + } + }, + ...picking + }; + + // node_modules/@deck.gl/core/dist/esm/shaderlib/index.js + var DEFAULT_MODULES = [project_default]; + var SHADER_HOOKS = ["vs:DECKGL_FILTER_SIZE(inout vec3 size, VertexGeometry geometry)", "vs:DECKGL_FILTER_GL_POSITION(inout vec4 position, VertexGeometry geometry)", "vs:DECKGL_FILTER_COLOR(inout vec4 color, VertexGeometry geometry)", "fs:DECKGL_FILTER_COLOR(inout vec4 color, FragmentGeometry geometry)"]; + function createProgramManager(gl) { + const programManager = ProgramManager.getDefaultProgramManager(gl); + for (const shaderModule of DEFAULT_MODULES) { + programManager.addDefaultModule(shaderModule); + } + for (const shaderHook of SHADER_HOOKS) { + programManager.addShaderHook(shaderHook); } + return programManager; } - // node_modules/@math.gl/core/dist/esm/lib/common.js - 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 - }; - function formatValue2(value, { - precision = config.precision - } = {}) { - value = round(value); - return "".concat(parseFloat(value.toPrecision(precision))); - } - function isArray2(value) { - return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView); - } - function clamp(value, min, max) { - return map(value, (value2) => Math.max(min, Math.min(max, value2))); - } - function lerp(a2, b2, t2) { - if (isArray2(a2)) { - return a2.map((ai, i2) => lerp(ai, b2[i2], t2)); + // node_modules/@deck.gl/core/dist/esm/lib/layer-manager.js + var TRACE_SET_LAYERS = "layerManager.setLayers"; + var TRACE_ACTIVATE_VIEWPORT = "layerManager.activateViewport"; + var LayerManager = class { + constructor(gl, { + deck, + stats, + viewport: _viewport, + timeline + } = {}) { + _defineProperty(this, "layers", void 0); + _defineProperty(this, "context", void 0); + _defineProperty(this, "resourceManager", void 0); + _defineProperty(this, "_lastRenderedLayers", []); + _defineProperty(this, "_needsRedraw", false); + _defineProperty(this, "_needsUpdate", false); + _defineProperty(this, "_nextLayers", null); + _defineProperty(this, "_debug", false); + _defineProperty(this, "activateViewport", (viewport) => { + debug(TRACE_ACTIVATE_VIEWPORT, this, viewport); + if (viewport) { + this.context.viewport = viewport; + } + }); + this.layers = []; + this.resourceManager = new ResourceManager({ + gl, + protocol: "deck://" + }); + this.context = { + mousePosition: null, + userData: {}, + layerManager: this, + gl, + deck, + programManager: gl && createProgramManager(gl), + stats: stats || new Stats2({ + id: "deck.gl" + }), + viewport: _viewport || new Viewport({ + id: "DEFAULT-INITIAL-VIEWPORT" + }), + timeline: timeline || new Timeline(), + resourceManager: this.resourceManager, + onError: void 0 + }; + Object.seal(this); } - return t2 * b2 + (1 - t2) * a2; - } - function equals(a2, b2, epsilon) { - const oldEpsilon = config.EPSILON; - if (epsilon) { - config.EPSILON = epsilon; + finalize() { + this.resourceManager.finalize(); + for (const layer of this.layers) { + this._finalizeLayer(layer); + } } - try { - if (a2 === b2) { - return true; + needsRedraw(opts = { + clearRedrawFlags: false + }) { + let redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; } - if (isArray2(a2) && isArray2(b2)) { - if (a2.length !== b2.length) { - return false; - } - for (let i2 = 0; i2 < a2.length; ++i2) { - if (!equals(a2[i2], b2[i2])) { - return false; - } - } - return true; + for (const layer of this.layers) { + const layerNeedsRedraw = layer.getNeedsRedraw(opts); + redraw = redraw || layerNeedsRedraw; } - if (a2 && a2.equals) { - return a2.equals(b2); + return redraw; + } + needsUpdate() { + if (this._nextLayers && this._nextLayers !== this._lastRenderedLayers) { + return "layers changed"; } - if (b2 && b2.equals) { - return b2.equals(a2); + return this._needsUpdate; + } + setNeedsRedraw(reason) { + this._needsRedraw = this._needsRedraw || reason; + } + setNeedsUpdate(reason) { + this._needsUpdate = this._needsUpdate || reason; + } + getLayers({ + layerIds + } = {}) { + return layerIds ? this.layers.filter((layer) => layerIds.find((layerId) => layer.id.indexOf(layerId) === 0)) : this.layers; + } + setProps(props) { + if ("debug" in props) { + this._debug = props.debug; } - if (typeof a2 === "number" && typeof b2 === "number") { - return Math.abs(a2 - b2) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)); + if ("userData" in props) { + this.context.userData = props.userData; + } + if ("layers" in props) { + this._nextLayers = props.layers; + } + if ("onError" in props) { + this.context.onError = props.onError; } - return false; - } finally { - config.EPSILON = oldEpsilon; } - } - 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 (isArray2(value)) { - const array = value; - result = result || duplicateArray(array); - for (let i2 = 0; i2 < result.length && i2 < array.length; ++i2) { - result[i2] = func(value[i2], i2, result); + setLayers(newLayers, reason) { + debug(TRACE_SET_LAYERS, this, reason, newLayers); + this._lastRenderedLayers = newLayers; + const flatLayers = flatten(newLayers, Boolean); + for (const layer of flatLayers) { + layer.context = this.context; } - return result; + this._updateLayers(this.layers, flatLayers); } - return func(value); - } - - // node_modules/@math.gl/core/dist/esm/classes/base/math-array.js - function _extendableBuiltin(cls) { - function ExtendableBuiltin() { - var instance = Reflect.construct(cls, Array.from(arguments)); - Object.setPrototypeOf(instance, Object.getPrototypeOf(this)); - return instance; + updateLayers() { + const reason = this.needsUpdate(); + if (reason) { + this.setNeedsRedraw("updating layers: ".concat(reason)); + this.setLayers(this._nextLayers || this._lastRenderedLayers, reason); + } + this._nextLayers = null; } - ExtendableBuiltin.prototype = Object.create(cls.prototype, { - constructor: { - value: cls, - enumerable: false, - writable: true, - configurable: true + _handleError(stage, error2, layer) { + layer.raiseError(error2, "".concat(stage, " of ").concat(layer)); + } + _updateLayers(oldLayers, newLayers) { + const oldLayerMap = {}; + for (const oldLayer of oldLayers) { + if (oldLayerMap[oldLayer.id]) { + log_default.warn("Multiple old layers with same id ".concat(oldLayer.id))(); + } else { + oldLayerMap[oldLayer.id] = oldLayer; + } } - }); - if (Object.setPrototypeOf) { - Object.setPrototypeOf(ExtendableBuiltin, cls); - } else { - ExtendableBuiltin.__proto__ = cls; + const generatedLayers = []; + this._updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers); + this._finalizeOldLayers(oldLayerMap); + let needsUpdate = false; + for (const layer of generatedLayers) { + if (layer.hasUniformTransition()) { + needsUpdate = "Uniform transition in ".concat(layer); + break; + } + } + this._needsUpdate = needsUpdate; + this.layers = generatedLayers; } - return ExtendableBuiltin; - } - var MathArray = class extends _extendableBuiltin(Array) { - clone() { - return new this.constructor().copy(this); + _updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers) { + for (const newLayer of newLayers) { + newLayer.context = this.context; + const oldLayer = oldLayerMap[newLayer.id]; + if (oldLayer === null) { + log_default.warn("Multiple new layers with same id ".concat(newLayer.id))(); + } + oldLayerMap[newLayer.id] = null; + let sublayers = null; + try { + if (this._debug && oldLayer !== newLayer) { + newLayer.validateProps(); + } + if (!oldLayer) { + this._initializeLayer(newLayer); + } else { + this._transferLayerState(oldLayer, newLayer); + this._updateLayer(newLayer); + } + generatedLayers.push(newLayer); + sublayers = newLayer.isComposite ? newLayer.getSubLayers() : null; + } catch (err3) { + this._handleError("matching", err3, newLayer); + } + if (sublayers) { + this._updateSublayersRecursively(sublayers, oldLayerMap, generatedLayers); + } + } } - fromArray(array, offset = 0) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] = array[i2 + offset]; + _finalizeOldLayers(oldLayerMap) { + for (const layerId in oldLayerMap) { + const layer = oldLayerMap[layerId]; + if (layer) { + this._finalizeLayer(layer); + } } - return this.check(); } - toArray(targetArray = [], offset = 0) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - targetArray[offset + i2] = this[i2]; + _initializeLayer(layer) { + try { + layer._initialize(); + layer.lifecycle = LIFECYCLE.INITIALIZED; + } catch (err3) { + this._handleError("initialization", err3, layer); } - return targetArray; } - from(arrayOrObject) { - return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject); + _transferLayerState(oldLayer, newLayer) { + newLayer._transferState(oldLayer); + newLayer.lifecycle = LIFECYCLE.MATCHED; + if (newLayer !== oldLayer) { + oldLayer.lifecycle = LIFECYCLE.AWAITING_GC; + } } - to(arrayOrObject) { - if (arrayOrObject === this) { - return this; + _updateLayer(layer) { + try { + layer._update(); + } catch (err3) { + this._handleError("update", err3, layer); } - return isArray2(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject); - } - toTarget(target) { - return target ? this.to(target) : this; } - toFloat32Array() { - return new Float32Array(this); + _finalizeLayer(layer) { + this._needsRedraw = this._needsRedraw || "finalized ".concat(layer); + layer.lifecycle = LIFECYCLE.AWAITING_FINALIZATION; + try { + layer._finalize(); + layer.lifecycle = LIFECYCLE.FINALIZED; + } catch (err3) { + this._handleError("finalization", err3, layer); + } } - toString() { - return this.formatString(config); + }; + + // node_modules/@deck.gl/core/dist/esm/utils/deep-equal.js + function deepEqual(a2, b2, depth) { + if (a2 === b2) { + return true; } - formatString(opts) { - let string = ""; - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - string += (i2 > 0 ? ", " : "") + formatValue2(this[i2], opts); - } - return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]"); + if (!depth || !a2 || !b2) { + return false; } - equals(array) { - if (!array || this.length !== array.length) { + if (Array.isArray(a2)) { + if (!Array.isArray(b2) || a2.length !== b2.length) { return false; } - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - if (!equals(this[i2], array[i2])) { + for (let i3 = 0; i3 < a2.length; i3++) { + if (!deepEqual(a2[i3], b2[i3], depth - 1)) { return false; } } return true; } - exactEquals(array) { - if (!array || this.length !== array.length) { + if (Array.isArray(b2)) { + return false; + } + if (typeof a2 === "object" && typeof b2 === "object") { + const aKeys = Object.keys(a2); + const bKeys = Object.keys(b2); + if (aKeys.length !== bKeys.length) { return false; } - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - if (this[i2] !== array[i2]) { + for (const key of aKeys) { + if (!b2.hasOwnProperty(key)) { + return false; + } + if (!deepEqual(a2[key], b2[key], depth - 1)) { return false; } } return true; } - negate() { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] = -this[i2]; - } - return this.check(); - } - lerp(a2, b2, t2) { - if (t2 === void 0) { - return this.lerp(this, a2, b2); - } - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - const ai = a2[i2]; - this[i2] = ai + t2 * (b2[i2] - ai); - } - return this.check(); + return false; + } + + // node_modules/@deck.gl/core/dist/esm/lib/view-manager.js + var ViewManager = class { + constructor(props) { + _defineProperty(this, "width", void 0); + _defineProperty(this, "height", void 0); + _defineProperty(this, "views", void 0); + _defineProperty(this, "viewState", void 0); + _defineProperty(this, "controllers", void 0); + _defineProperty(this, "timeline", void 0); + _defineProperty(this, "_viewports", void 0); + _defineProperty(this, "_viewportMap", void 0); + _defineProperty(this, "_isUpdating", void 0); + _defineProperty(this, "_needsRedraw", void 0); + _defineProperty(this, "_needsUpdate", void 0); + _defineProperty(this, "_eventManager", void 0); + _defineProperty(this, "_eventCallbacks", void 0); + this.views = []; + this.width = 100; + this.height = 100; + this.viewState = {}; + this.controllers = {}; + this.timeline = props.timeline; + this._viewports = []; + this._viewportMap = {}; + this._isUpdating = false; + this._needsRedraw = "First render"; + this._needsUpdate = "Initialize"; + this._eventManager = props.eventManager; + this._eventCallbacks = { + onViewStateChange: props.onViewStateChange, + onInteractionStateChange: props.onInteractionStateChange + }; + Object.seal(this); + this.setProps(props); } - min(vector) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] = Math.min(vector[i2], this[i2]); + finalize() { + for (const key in this.controllers) { + const controller = this.controllers[key]; + if (controller) { + controller.finalize(); + } } - return this.check(); + this.controllers = {}; } - max(vector) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] = Math.max(vector[i2], this[i2]); + needsRedraw(opts = { + clearRedrawFlags: false + }) { + const redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; } - return this.check(); + return redraw; } - clamp(minVector, maxVector) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] = Math.min(Math.max(this[i2], minVector[i2]), maxVector[i2]); - } - return this.check(); + setNeedsUpdate(reason) { + this._needsUpdate = this._needsUpdate || reason; + this._needsRedraw = this._needsRedraw || reason; } - add(...vectors) { - for (const vector of vectors) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] += vector[i2]; + updateViewStates() { + for (const viewId in this.controllers) { + const controller = this.controllers[viewId]; + if (controller) { + controller.updateTransition(); } } - return this.check(); } - subtract(...vectors) { - for (const vector of vectors) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] -= vector[i2]; - } + getViewports(rect) { + if (rect) { + return this._viewports.filter((viewport) => viewport.containsPixel(rect)); } - return this.check(); + return this._viewports; } - scale(scale3) { - if (typeof scale3 === "number") { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] *= scale3; - } - } else { - for (let i2 = 0; i2 < this.ELEMENTS && i2 < scale3.length; ++i2) { - this[i2] *= scale3[i2]; + getViews() { + const viewMap = {}; + this.views.forEach((view) => { + viewMap[view.id] = view; + }); + return viewMap; + } + getView(viewId) { + return this.views.find((view) => view.id === viewId); + } + getViewState(viewOrViewId) { + const view = typeof viewOrViewId === "string" ? this.getView(viewOrViewId) : viewOrViewId; + const viewState = view && this.viewState[view.getViewStateId()] || this.viewState; + return view ? view.filterViewState(viewState) : viewState; + } + getViewport(viewId) { + return this._viewportMap[viewId]; + } + unproject(xyz, opts) { + const viewports = this.getViewports(); + const pixel = { + x: xyz[0], + y: xyz[1] + }; + for (let i3 = viewports.length - 1; i3 >= 0; --i3) { + const viewport = viewports[i3]; + if (viewport.containsPixel(pixel)) { + const p2 = xyz.slice(); + p2[0] -= viewport.x; + p2[1] -= viewport.y; + return viewport.unproject(p2, opts); } } - return this.check(); + return null; } - multiplyByScalar(scalar) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] *= scalar; + setProps(props) { + if (props.views) { + this._setViews(props.views); } - return this.check(); - } - check() { - if (config.debug && !this.validate()) { - throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'")); + if (props.viewState) { + this._setViewState(props.viewState); } - return this; - } - validate() { - let valid = this.length === this.ELEMENTS; - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - valid = valid && Number.isFinite(this[i2]); + if ("width" in props || "height" in props) { + this._setSize(props.width, props.height); } - return valid; - } - sub(a2) { - return this.subtract(a2); - } - setScalar(a2) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] = a2; + if (!this._isUpdating) { + this._update(); } - return this.check(); } - addScalar(a2) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] += a2; + _update() { + this._isUpdating = true; + if (this._needsUpdate) { + this._needsUpdate = false; + this._rebuildViewports(); } - return this.check(); - } - subScalar(a2) { - return this.addScalar(-a2); - } - multiplyScalar(scalar) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] *= scalar; + if (this._needsUpdate) { + this._needsUpdate = false; + this._rebuildViewports(); } - return this.check(); - } - divideScalar(a2) { - return this.multiplyByScalar(1 / a2); + this._isUpdating = false; } - clampScalar(min, max) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] = Math.min(Math.max(this[i2], min), max); + _setSize(width, height) { + if (width !== this.width || height !== this.height) { + this.width = width; + this.height = height; + this.setNeedsUpdate("Size changed"); } - return this.check(); - } - get elements() { - return this; - } - }; - - // node_modules/@math.gl/core/dist/esm/lib/validators.js - function validateVector(v2, length) { - if (v2.length !== length) { - return false; } - for (let i2 = 0; i2 < v2.length; ++i2) { - if (!Number.isFinite(v2[i2])) { - return false; + _setViews(views) { + views = flatten(views, Boolean); + const viewsChanged = this._diffViews(views, this.views); + if (viewsChanged) { + this.setNeedsUpdate("views changed"); } + this.views = views; } - return true; - } - function checkNumber(value) { - if (!Number.isFinite(value)) { - throw new Error("Invalid number ".concat(value)); - } - return value; - } - function checkVector(v2, length, callerName = "") { - if (config.debug && !validateVector(v2, length)) { - throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'")); - } - return v2; - } - - // node_modules/@math.gl/core/dist/esm/classes/base/vector.js - var Vector = class extends MathArray { - get x() { - return this[0]; - } - set x(value) { - this[0] = checkNumber(value); - } - get y() { - return this[1]; - } - set y(value) { - this[1] = checkNumber(value); - } - len() { - return Math.sqrt(this.lengthSquared()); - } - magnitude() { - return this.len(); - } - lengthSquared() { - let length = 0; - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - length += this[i2] * this[i2]; + _setViewState(viewState) { + if (viewState) { + const viewStateChanged = !deepEqual(viewState, this.viewState, 3); + if (viewStateChanged) { + this.setNeedsUpdate("viewState changed"); + } + this.viewState = viewState; + } else { + log_default.warn("missing `viewState` or `initialViewState`")(); } - return length; - } - magnitudeSquared() { - return this.lengthSquared(); - } - distance(mathArray) { - return Math.sqrt(this.distanceSquared(mathArray)); } - distanceSquared(mathArray) { - let length = 0; - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - const dist = this[i2] - mathArray[i2]; - length += dist * dist; + _onViewStateChange(viewId, event) { + if (this._eventCallbacks.onViewStateChange) { + this._eventCallbacks.onViewStateChange({ + ...event, + viewId + }); } - return checkNumber(length); } - dot(mathArray) { - let product = 0; - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - product += this[i2] * mathArray[i2]; - } - return checkNumber(product); + _createController(view, props) { + const Controller2 = props.type; + const controller = new Controller2({ + timeline: this.timeline, + eventManager: this._eventManager, + onViewStateChange: this._onViewStateChange.bind(this, props.id), + onStateChange: this._eventCallbacks.onInteractionStateChange, + makeViewport: (viewState) => { + var _this$getView; + return (_this$getView = this.getView(view.id)) === null || _this$getView === void 0 ? void 0 : _this$getView.makeViewport({ + viewState, + width: this.width, + height: this.height + }); + } + }); + return controller; } - normalize() { - const length = this.magnitude(); - if (length !== 0) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] /= length; + _updateController(view, viewState, viewport, controller) { + const controllerProps = view.controller; + if (controllerProps && viewport) { + const resolvedProps = { + ...viewState, + ...controllerProps, + id: view.id, + x: viewport.x, + y: viewport.y, + width: viewport.width, + height: viewport.height + }; + if (!controller || controller.constructor !== controllerProps.type) { + controller = this._createController(view, resolvedProps); + } + if (controller) { + controller.setProps(resolvedProps); } + return controller; } - return this.check(); + return null; } - multiply(...vectors) { - for (const vector of vectors) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] *= vector[i2]; + _rebuildViewports() { + const { + views + } = this; + const oldControllers = this.controllers; + this._viewports = []; + this.controllers = {}; + let invalidateControllers = false; + for (let i3 = views.length; i3--; ) { + const view = views[i3]; + const viewState = this.getViewState(view); + const viewport = view.makeViewport({ + viewState, + width: this.width, + height: this.height + }); + let oldController = oldControllers[view.id]; + const hasController = Boolean(view.controller); + if (hasController && !oldController) { + invalidateControllers = true; + } + if ((invalidateControllers || !hasController) && oldController) { + oldController.finalize(); + oldController = null; + } + this.controllers[view.id] = this._updateController(view, viewState, viewport, oldController); + if (viewport) { + this._viewports.unshift(viewport); } } - return this.check(); - } - divide(...vectors) { - for (const vector of vectors) { - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - this[i2] /= vector[i2]; + for (const id in oldControllers) { + const oldController = oldControllers[id]; + if (oldController && !this.controllers[id]) { + oldController.finalize(); } } - return this.check(); - } - lengthSq() { - return this.lengthSquared(); - } - distanceTo(vector) { - return this.distance(vector); - } - distanceToSquared(vector) { - return this.distanceSquared(vector); - } - getComponent(i2) { - assert8(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range"); - return checkNumber(this[i2]); - } - setComponent(i2, value) { - assert8(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range"); - this[i2] = value; - return this.check(); - } - addVectors(a2, b2) { - return this.copy(a2).add(b2); - } - subVectors(a2, b2) { - return this.copy(a2).subtract(b2); - } - multiplyVectors(a2, b2) { - return this.copy(a2).multiply(b2); + this._buildViewportMap(); } - addScaledVector(a2, b2) { - return this.add(new this.constructor(a2).multiplyScalar(b2)); + _buildViewportMap() { + this._viewportMap = {}; + this._viewports.forEach((viewport) => { + if (viewport.id) { + this._viewportMap[viewport.id] = this._viewportMap[viewport.id] || viewport; + } + }); } - }; - - // node_modules/gl-matrix/esm/common.js - var EPSILON = 1e-6; - var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array; - var degree = Math.PI / 180; - if (!Math.hypot) - Math.hypot = function() { - var y2 = 0, i2 = arguments.length; - while (i2--) { - y2 += arguments[i2] * arguments[i2]; + _diffViews(newViews, oldViews) { + if (newViews.length !== oldViews.length) { + return true; } - return Math.sqrt(y2); - }; - - // node_modules/gl-matrix/esm/vec2.js - function create() { - var out = new ARRAY_TYPE(2); - if (ARRAY_TYPE != Float32Array) { - out[0] = 0; - out[1] = 0; + return newViews.some((_2, i3) => !newViews[i3].equals(oldViews[i3])); } - return out; - } - function add(out, a2, b2) { - out[0] = a2[0] + b2[0]; - out[1] = a2[1] + b2[1]; - return out; - } - function negate(out, a2) { - out[0] = -a2[0]; - out[1] = -a2[1]; - return out; - } - function lerp2(out, a2, b2, t2) { - var ax = a2[0], ay = a2[1]; - out[0] = ax + t2 * (b2[0] - ax); - out[1] = ay + t2 * (b2[1] - ay); - return out; - } - function transformMat4(out, a2, m) { - var x2 = a2[0]; - var y2 = a2[1]; - out[0] = m[0] * x2 + m[4] * y2 + m[12]; - out[1] = m[1] * x2 + m[5] * y2 + m[13]; - return out; - } - var forEach2 = function() { - var vec = create(); - return function(a2, stride, offset, count2, fn, arg) { - var i2, l2; - if (!stride) { - stride = 2; - } - if (!offset) { - offset = 0; - } - if (count2) { - l2 = Math.min(count2 * stride + offset, a2.length); - } else { - l2 = a2.length; - } - for (i2 = offset; i2 < l2; i2 += stride) { - vec[0] = a2[i2]; - vec[1] = a2[i2 + 1]; - fn(vec, vec, arg); - a2[i2] = vec[0]; - a2[i2 + 1] = vec[1]; - } - return a2; - }; - }(); - - // node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js - function vec2_transformMat4AsVector(out, a2, m) { - const x2 = a2[0]; - const y2 = a2[1]; - const w2 = m[3] * x2 + m[7] * y2 || 1; - out[0] = (m[0] * x2 + m[4] * y2) / w2; - out[1] = (m[1] * x2 + m[5] * y2) / w2; - return out; - } - function vec3_transformMat4AsVector(out, a2, m) { - const x2 = a2[0]; - const y2 = a2[1]; - const z = a2[2]; - const w2 = m[3] * x2 + m[7] * y2 + m[11] * z || 1; - out[0] = (m[0] * x2 + m[4] * y2 + m[8] * z) / w2; - out[1] = (m[1] * x2 + m[5] * y2 + m[9] * z) / w2; - out[2] = (m[2] * x2 + m[6] * y2 + m[10] * z) / w2; - return out; - } - function vec3_transformMat2(out, a2, m) { - const x2 = a2[0]; - const y2 = a2[1]; - out[0] = m[0] * x2 + m[2] * y2; - out[1] = m[1] * x2 + m[3] * y2; - out[2] = a2[2]; - return out; - } + }; - // node_modules/gl-matrix/esm/vec3.js - function create2() { - var out = new ARRAY_TYPE(3); - if (ARRAY_TYPE != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; + // node_modules/@deck.gl/core/dist/esm/utils/positions.js + var PERCENT_OR_PIXELS_REGEX = /([0-9]+\.?[0-9]*)(%|px)/; + function parsePosition(value) { + switch (typeof value) { + case "number": + return { + position: value, + relative: false + }; + case "string": + const match = PERCENT_OR_PIXELS_REGEX.exec(value); + if (match && match.length >= 3) { + const relative = match[2] === "%"; + const position = parseFloat(match[1]); + return { + position: relative ? position / 100 : position, + relative + }; + } + default: + throw new Error("Could not parse position string ".concat(value)); } - return out; - } - function subtract(out, a2, b2) { - out[0] = a2[0] - b2[0]; - out[1] = a2[1] - b2[1]; - out[2] = a2[2] - b2[2]; - return out; - } - function negate2(out, a2) { - out[0] = -a2[0]; - out[1] = -a2[1]; - out[2] = -a2[2]; - return out; - } - function dot(a2, b2) { - return a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2]; - } - function cross(out, a2, b2) { - var ax = a2[0], ay = a2[1], az = a2[2]; - var bx = b2[0], by = b2[1], bz = b2[2]; - out[0] = ay * bz - az * by; - out[1] = az * bx - ax * bz; - out[2] = ax * by - ay * bx; - return out; - } - function transformMat42(out, a2, m) { - var x2 = a2[0], y2 = a2[1], z = a2[2]; - var w2 = m[3] * x2 + m[7] * y2 + m[11] * z + m[15]; - w2 = w2 || 1; - out[0] = (m[0] * x2 + m[4] * y2 + m[8] * z + m[12]) / w2; - out[1] = (m[1] * x2 + m[5] * y2 + m[9] * z + m[13]) / w2; - out[2] = (m[2] * x2 + m[6] * y2 + m[10] * z + m[14]) / w2; - return out; - } - function transformMat3(out, a2, m) { - var x2 = a2[0], y2 = a2[1], z = a2[2]; - out[0] = x2 * m[0] + y2 * m[3] + z * m[6]; - out[1] = x2 * m[1] + y2 * m[4] + z * m[7]; - out[2] = x2 * m[2] + y2 * m[5] + z * m[8]; - return out; - } - function transformQuat(out, a2, q) { - var qx = q[0], qy = q[1], qz = q[2], qw = q[3]; - var x2 = a2[0], y2 = a2[1], z = a2[2]; - var uvx = qy * z - qz * y2, uvy = qz * x2 - qx * z, uvz = qx * y2 - qy * x2; - var uuvx = qy * uvz - qz * uvy, uuvy = qz * uvx - qx * uvz, uuvz = qx * uvy - qy * uvx; - var w2 = qw * 2; - uvx *= w2; - uvy *= w2; - uvz *= w2; - uuvx *= 2; - uuvy *= 2; - uuvz *= 2; - out[0] = x2 + uvx + uuvx; - out[1] = y2 + uvy + uuvy; - out[2] = z + uvz + uuvz; - return out; - } - function rotateX(out, a2, b2, rad) { - var p2 = [], r2 = []; - p2[0] = a2[0] - b2[0]; - p2[1] = a2[1] - b2[1]; - p2[2] = a2[2] - b2[2]; - r2[0] = p2[0]; - r2[1] = p2[1] * Math.cos(rad) - p2[2] * Math.sin(rad); - r2[2] = p2[1] * Math.sin(rad) + p2[2] * Math.cos(rad); - out[0] = r2[0] + b2[0]; - out[1] = r2[1] + b2[1]; - out[2] = r2[2] + b2[2]; - return out; - } - function rotateY(out, a2, b2, rad) { - var p2 = [], r2 = []; - p2[0] = a2[0] - b2[0]; - p2[1] = a2[1] - b2[1]; - p2[2] = a2[2] - b2[2]; - r2[0] = p2[2] * Math.sin(rad) + p2[0] * Math.cos(rad); - r2[1] = p2[1]; - r2[2] = p2[2] * Math.cos(rad) - p2[0] * Math.sin(rad); - out[0] = r2[0] + b2[0]; - out[1] = r2[1] + b2[1]; - out[2] = r2[2] + b2[2]; - return out; } - function rotateZ(out, a2, b2, rad) { - var p2 = [], r2 = []; - p2[0] = a2[0] - b2[0]; - p2[1] = a2[1] - b2[1]; - p2[2] = a2[2] - b2[2]; - r2[0] = p2[0] * Math.cos(rad) - p2[1] * Math.sin(rad); - r2[1] = p2[0] * Math.sin(rad) + p2[1] * Math.cos(rad); - r2[2] = p2[2]; - out[0] = r2[0] + b2[0]; - out[1] = r2[1] + b2[1]; - out[2] = r2[2] + b2[2]; - return out; + function getPosition(position, extent) { + return position.relative ? Math.round(position.position * extent) : position.position; } - function angle(a2, b2) { - var ax = a2[0], ay = a2[1], az = a2[2], bx = b2[0], by = b2[1], bz = b2[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine = mag && dot(a2, b2) / mag; - return Math.acos(Math.min(Math.max(cosine, -1), 1)); + + // node_modules/@deck.gl/core/dist/esm/utils/assert.js + function assert10(condition, message) { + if (!condition) { + throw new Error(message || "deck.gl: assertion failed."); + } } - var sub = subtract; - var forEach3 = function() { - var vec = create2(); - return function(a2, stride, offset, count2, fn, arg) { - var i2, l2; - if (!stride) { - stride = 3; + + // node_modules/@deck.gl/core/dist/esm/views/view.js + var View = class { + constructor(props) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "viewportInstance", void 0); + _defineProperty(this, "_x", void 0); + _defineProperty(this, "_y", void 0); + _defineProperty(this, "_width", void 0); + _defineProperty(this, "_height", void 0); + _defineProperty(this, "_padding", void 0); + _defineProperty(this, "props", void 0); + const { + id, + x: x2 = 0, + y: y2 = 0, + width = "100%", + height = "100%", + padding = null, + viewportInstance + } = props || {}; + assert10(!viewportInstance || viewportInstance instanceof Viewport); + this.viewportInstance = viewportInstance; + this.id = id || this.constructor.displayName || "view"; + this.props = { + ...props, + id: this.id + }; + this._x = parsePosition(x2); + this._y = parsePosition(y2); + this._width = parsePosition(width); + this._height = parsePosition(height); + this._padding = padding && { + left: parsePosition(padding.left || 0), + right: parsePosition(padding.right || 0), + top: parsePosition(padding.top || 0), + bottom: parsePosition(padding.bottom || 0) + }; + this.equals = this.equals.bind(this); + Object.seal(this); + } + equals(view) { + if (this === view) { + return true; } - if (!offset) { - offset = 0; + if (this.viewportInstance) { + return view.viewportInstance ? this.viewportInstance.equals(view.viewportInstance) : false; } - if (count2) { - l2 = Math.min(count2 * stride + offset, a2.length); - } else { - l2 = a2.length; + return this.ViewportType === view.ViewportType && deepEqual(this.props, view.props, 2); + } + makeViewport({ + width, + height, + viewState + }) { + if (this.viewportInstance) { + return this.viewportInstance; } - for (i2 = offset; i2 < l2; i2 += stride) { - vec[0] = a2[i2]; - vec[1] = a2[i2 + 1]; - vec[2] = a2[i2 + 2]; - fn(vec, vec, arg); - a2[i2] = vec[0]; - a2[i2 + 1] = vec[1]; - a2[i2 + 2] = vec[2]; + viewState = this.filterViewState(viewState); + const viewportDimensions = this.getDimensions({ + width, + height + }); + if (!viewportDimensions.height || !viewportDimensions.width) { + return null; } - return a2; - }; - }(); - - // node_modules/@math.gl/core/dist/esm/classes/vector3.js - var ORIGIN = [0, 0, 0]; - var ZERO; - var Vector3 = class _Vector3 extends Vector { - static get ZERO() { - if (!ZERO) { - ZERO = new _Vector3(0, 0, 0); - Object.freeze(ZERO); + return new this.ViewportType({ + ...viewState, + ...this.props, + ...viewportDimensions + }); + } + getViewStateId() { + const { + viewState + } = this.props; + if (typeof viewState === "string") { + return viewState; } - return ZERO; + return (viewState === null || viewState === void 0 ? void 0 : viewState.id) || this.id; } - constructor(x2 = 0, y2 = 0, z = 0) { - super(-0, -0, -0); - if (arguments.length === 1 && isArray2(x2)) { - this.copy(x2); - } else { - if (config.debug) { - checkNumber(x2); - checkNumber(y2); - checkNumber(z); + filterViewState(viewState) { + if (this.props.viewState && typeof this.props.viewState === "object") { + if (!this.props.viewState.id) { + return this.props.viewState; } - this[0] = x2; - this[1] = y2; - this[2] = z; + const newViewState = { + ...viewState + }; + for (const key in this.props.viewState) { + if (key !== "id") { + newViewState[key] = this.props.viewState[key]; + } + } + return newViewState; } + return viewState; } - set(x2, y2, z) { - this[0] = x2; - this[1] = y2; - this[2] = z; - return this.check(); - } - copy(array) { - this[0] = array[0]; - this[1] = array[1]; - this[2] = array[2]; - return this.check(); + getDimensions({ + width, + height + }) { + const dimensions = { + x: getPosition(this._x, width), + y: getPosition(this._y, height), + width: getPosition(this._width, width), + height: getPosition(this._height, height) + }; + if (this._padding) { + dimensions.padding = { + left: getPosition(this._padding.left, width), + top: getPosition(this._padding.top, height), + right: getPosition(this._padding.right, width), + bottom: getPosition(this._padding.bottom, height) + }; + } + return dimensions; } - fromObject(object) { - if (config.debug) { - checkNumber(object.x); - checkNumber(object.y); - checkNumber(object.z); + get controller() { + const opts = this.props.controller; + if (!opts) { + return null; } - this[0] = object.x; - this[1] = object.y; - this[2] = object.z; - return this.check(); + if (opts === true) { + return { + type: this.ControllerType + }; + } + if (typeof opts === "function") { + return { + type: opts + }; + } + return { + type: this.ControllerType, + ...opts + }; } - toObject(object) { - object.x = this[0]; - object.y = this[1]; - object.z = this[2]; - return object; + }; + + // node_modules/@deck.gl/core/dist/esm/transitions/transition.js + var Transition = class { + constructor(timeline) { + _defineProperty(this, "_inProgress", void 0); + _defineProperty(this, "_handle", void 0); + _defineProperty(this, "_timeline", void 0); + _defineProperty(this, "time", void 0); + _defineProperty(this, "settings", void 0); + this._inProgress = false; + this._handle = null; + this._timeline = timeline; + this.time = 0; + this.settings = { + duration: 0 + }; } - get ELEMENTS() { - return 3; + get inProgress() { + return this._inProgress; } - get z() { - return this[2]; + start(settings) { + var _this$settings$onStar, _this$settings; + this.cancel(); + this.settings = settings; + this._inProgress = true; + (_this$settings$onStar = (_this$settings = this.settings).onStart) === null || _this$settings$onStar === void 0 ? void 0 : _this$settings$onStar.call(_this$settings, this); } - set z(value) { - this[2] = checkNumber(value); + end() { + if (this._inProgress) { + var _this$settings$onEnd, _this$settings2; + this._timeline.removeChannel(this._handle); + this._handle = null; + this._inProgress = false; + (_this$settings$onEnd = (_this$settings2 = this.settings).onEnd) === null || _this$settings$onEnd === void 0 ? void 0 : _this$settings$onEnd.call(_this$settings2, this); + } } - angle(vector) { - return angle(this, vector); + cancel() { + if (this._inProgress) { + var _this$settings$onInte, _this$settings3; + (_this$settings$onInte = (_this$settings3 = this.settings).onInterrupt) === null || _this$settings$onInte === void 0 ? void 0 : _this$settings$onInte.call(_this$settings3, this); + this._timeline.removeChannel(this._handle); + this._handle = null; + this._inProgress = false; + } } - cross(vector) { - cross(this, this, vector); - return this.check(); + update() { + var _this$settings$onUpda, _this$settings4; + if (!this._inProgress) { + return false; + } + if (this._handle === null) { + const { + _timeline: timeline, + settings + } = this; + this._handle = timeline.addChannel({ + delay: timeline.getTime(), + duration: settings.duration + }); + } + this.time = this._timeline.getTime(this._handle); + this._onUpdate(); + (_this$settings$onUpda = (_this$settings4 = this.settings).onUpdate) === null || _this$settings$onUpda === void 0 ? void 0 : _this$settings$onUpda.call(_this$settings4, this); + if (this._timeline.isFinished(this._handle)) { + this.end(); + } + return true; } - rotateX({ - radians: radians2, - origin = ORIGIN - }) { - rotateX(this, this, origin, radians2); - return this.check(); + _onUpdate() { } - rotateY({ - radians: radians2, - origin = ORIGIN - }) { - rotateY(this, this, origin, radians2); - return this.check(); + }; + + // node_modules/@deck.gl/core/dist/esm/controllers/transition-manager.js + var noop3 = () => { + }; + var TRANSITION_EVENTS = { + BREAK: 1, + SNAP_TO_END: 2, + IGNORE: 3 + }; + var DEFAULT_EASING = (t2) => t2; + var DEFAULT_INTERRUPTION = TRANSITION_EVENTS.BREAK; + var TransitionManager = class { + constructor(opts) { + _defineProperty(this, "getControllerState", void 0); + _defineProperty(this, "props", void 0); + _defineProperty(this, "propsInTransition", void 0); + _defineProperty(this, "transition", void 0); + _defineProperty(this, "onViewStateChange", void 0); + _defineProperty(this, "onStateChange", void 0); + _defineProperty(this, "_onTransitionUpdate", (transition) => { + const { + time, + settings: { + interpolator, + startProps, + endProps, + duration, + easing + } + } = transition; + const t2 = easing(time / duration); + const viewport = interpolator.interpolateProps(startProps, endProps, t2); + this.propsInTransition = this.getControllerState({ + ...this.props, + ...viewport + }).getViewportProps(); + this.onViewStateChange({ + viewState: this.propsInTransition, + oldViewState: this.props + }); + }); + this.getControllerState = opts.getControllerState; + this.propsInTransition = null; + this.transition = new Transition(opts.timeline); + this.onViewStateChange = opts.onViewStateChange || noop3; + this.onStateChange = opts.onStateChange || noop3; } - rotateZ({ - radians: radians2, - origin = ORIGIN - }) { - rotateZ(this, this, origin, radians2); - return this.check(); + finalize() { + this.transition.cancel(); } - transform(matrix4) { - return this.transformAsPoint(matrix4); + getViewportInTransition() { + return this.propsInTransition; } - transformAsPoint(matrix4) { - transformMat42(this, this, matrix4); - return this.check(); + processViewStateChange(nextProps) { + let transitionTriggered = false; + const currentProps = this.props; + this.props = nextProps; + if (!currentProps || this._shouldIgnoreViewportChange(currentProps, nextProps)) { + return false; + } + if (this._isTransitionEnabled(nextProps)) { + let startProps = currentProps; + if (this.transition.inProgress) { + const { + interruption, + endProps + } = this.transition.settings; + startProps = { + ...currentProps, + ...interruption === TRANSITION_EVENTS.SNAP_TO_END ? endProps : this.propsInTransition || currentProps + }; + } + this._triggerTransition(startProps, nextProps); + transitionTriggered = true; + } else { + this.transition.cancel(); + } + return transitionTriggered; } - transformAsVector(matrix4) { - vec3_transformMat4AsVector(this, this, matrix4); - return this.check(); + updateTransition() { + this.transition.update(); } - transformByMatrix3(matrix3) { - transformMat3(this, this, matrix3); - return this.check(); + _isTransitionEnabled(props) { + const { + transitionDuration, + transitionInterpolator + } = props; + return (transitionDuration > 0 || transitionDuration === "auto") && Boolean(transitionInterpolator); } - transformByMatrix2(matrix2) { - vec3_transformMat2(this, this, matrix2); - return this.check(); + _isUpdateDueToCurrentTransition(props) { + if (this.transition.inProgress && this.propsInTransition) { + return this.transition.settings.interpolator.arePropsEqual(props, this.propsInTransition); + } + return false; + } + _shouldIgnoreViewportChange(currentProps, nextProps) { + if (this.transition.inProgress) { + return this.transition.settings.interruption === TRANSITION_EVENTS.IGNORE || this._isUpdateDueToCurrentTransition(nextProps); + } + if (this._isTransitionEnabled(nextProps)) { + return nextProps.transitionInterpolator.arePropsEqual(currentProps, nextProps); + } + return true; + } + _triggerTransition(startProps, endProps) { + const startViewstate = this.getControllerState(startProps); + const endViewStateProps = this.getControllerState(endProps).shortestPathFrom(startViewstate); + const transitionInterpolator = endProps.transitionInterpolator; + const duration = transitionInterpolator.getDuration ? transitionInterpolator.getDuration(startProps, endProps) : endProps.transitionDuration; + if (duration === 0) { + return; + } + const initialProps = transitionInterpolator.initializeProps(startProps, endViewStateProps); + this.propsInTransition = {}; + const transitionSettings = { + duration, + easing: endProps.transitionEasing || DEFAULT_EASING, + interpolator: transitionInterpolator, + interruption: endProps.transitionInterruption || DEFAULT_INTERRUPTION, + startProps: initialProps.start, + endProps: initialProps.end, + onStart: endProps.onTransitionStart, + onUpdate: this._onTransitionUpdate, + onInterrupt: this._onTransitionEnd(endProps.onTransitionInterrupt), + onEnd: this._onTransitionEnd(endProps.onTransitionEnd) + }; + this.transition.start(transitionSettings); + this.onStateChange({ + inTransition: true + }); + this.updateTransition(); } - transformByQuaternion(quaternion) { - transformQuat(this, this, quaternion); - return this.check(); + _onTransitionEnd(callback) { + return (transition) => { + this.propsInTransition = null; + this.onStateChange({ + inTransition: false, + isZooming: false, + isPanning: false, + isRotating: false + }); + callback === null || callback === void 0 ? void 0 : callback(transition); + }; } }; - // node_modules/@math.gl/core/dist/esm/classes/base/matrix.js - var Matrix = class extends MathArray { - toString() { - let string = "["; - if (config.printRowMajor) { - string += "row-major:"; - for (let row = 0; row < this.RANK; ++row) { - for (let col = 0; col < this.RANK; ++col) { - string += " ".concat(this[col * this.RANK + row]); - } + // node_modules/@deck.gl/core/dist/esm/transitions/transition-interpolator.js + var TransitionInterpolator = class { + constructor(opts) { + _defineProperty(this, "_propsToCompare", void 0); + _defineProperty(this, "_propsToExtract", void 0); + _defineProperty(this, "_requiredProps", void 0); + const { + compare, + extract, + required + } = opts; + this._propsToCompare = compare; + this._propsToExtract = extract || compare; + this._requiredProps = required; + } + arePropsEqual(currentProps, nextProps) { + for (const key of this._propsToCompare) { + if (!(key in currentProps) || !(key in nextProps) || !equals(currentProps[key], nextProps[key])) { + return false; } - } else { - string += "column-major:"; - for (let i2 = 0; i2 < this.ELEMENTS; ++i2) { - string += " ".concat(this[i2]); + } + return true; + } + initializeProps(startProps, endProps) { + const startViewStateProps = {}; + const endViewStateProps = {}; + for (const key of this._propsToExtract) { + if (key in startProps || key in endProps) { + startViewStateProps[key] = startProps[key]; + endViewStateProps[key] = endProps[key]; } } - string += "]"; - return string; + this._checkRequiredProps(startViewStateProps); + this._checkRequiredProps(endViewStateProps); + return { + start: startViewStateProps, + end: endViewStateProps + }; } - getElementIndex(row, col) { - return col * this.RANK + row; + getDuration(startProps, endProps) { + return endProps.transitionDuration; } - getElement(row, col) { - return this[col * this.RANK + row]; + _checkRequiredProps(props) { + if (!this._requiredProps) { + return; + } + this._requiredProps.forEach((propName) => { + const value = props[propName]; + assert10(Number.isFinite(value) || Array.isArray(value), "".concat(propName, " is required for transition")); + }); } - setElement(row, col, value) { - this[col * this.RANK + row] = checkNumber(value); - return this; + }; + + // node_modules/@deck.gl/core/dist/esm/transitions/linear-interpolator.js + var DEFAULT_PROPS3 = ["longitude", "latitude", "zoom", "bearing", "pitch"]; + var DEFAULT_REQUIRED_PROPS = ["longitude", "latitude", "zoom"]; + var LinearInterpolator = class extends TransitionInterpolator { + constructor(opts = {}) { + const transitionProps = Array.isArray(opts) ? opts : opts.transitionProps; + const normalizedOpts = Array.isArray(opts) ? {} : opts; + normalizedOpts.transitionProps = Array.isArray(transitionProps) ? { + compare: transitionProps, + required: transitionProps + } : transitionProps || { + compare: DEFAULT_PROPS3, + required: DEFAULT_REQUIRED_PROPS + }; + super(normalizedOpts.transitionProps); + _defineProperty(this, "opts", void 0); + this.opts = normalizedOpts; } - getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) { - const firstIndex = columnIndex * this.RANK; - for (let i2 = 0; i2 < this.RANK; ++i2) { - result[i2] = this[firstIndex + i2]; + initializeProps(startProps, endProps) { + const result = super.initializeProps(startProps, endProps); + const { + makeViewport, + around + } = this.opts; + if (makeViewport && around) { + const startViewport = makeViewport(startProps); + const endViewport = makeViewport(endProps); + const aroundPosition = startViewport.unproject(around); + result.start.around = around; + Object.assign(result.end, { + around: endViewport.project(aroundPosition), + aroundPosition, + width: endProps.width, + height: endProps.height + }); } return result; } - setColumn(columnIndex, columnVector) { - const firstIndex = columnIndex * this.RANK; - for (let i2 = 0; i2 < this.RANK; ++i2) { - this[firstIndex + i2] = columnVector[i2]; + interpolateProps(startProps, endProps, t2) { + const propsInTransition = {}; + for (const key of this._propsToExtract) { + propsInTransition[key] = lerp(startProps[key] || 0, endProps[key] || 0, t2); } - return this; + if (endProps.aroundPosition && this.opts.makeViewport) { + const viewport = this.opts.makeViewport({ + ...endProps, + ...propsInTransition + }); + Object.assign(propsInTransition, viewport.panByPosition(endProps.aroundPosition, lerp(startProps.around, endProps.around, t2))); + } + return propsInTransition; } }; - // node_modules/gl-matrix/esm/mat4.js - function identity(out) { - out[0] = 1; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = 1; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 1; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; - } - function transpose(out, a2) { - if (out === a2) { - var a01 = a2[1], a02 = a2[2], a03 = a2[3]; - var a12 = a2[6], a13 = a2[7]; - var a23 = a2[11]; - out[1] = a2[4]; - out[2] = a2[8]; - out[3] = a2[12]; - out[4] = a01; - out[6] = a2[9]; - out[7] = a2[13]; - out[8] = a02; - out[9] = a12; - out[11] = a2[14]; - out[12] = a03; - out[13] = a13; - out[14] = a23; - } else { - out[0] = a2[0]; - out[1] = a2[4]; - out[2] = a2[8]; - out[3] = a2[12]; - out[4] = a2[1]; - out[5] = a2[5]; - out[6] = a2[9]; - out[7] = a2[13]; - out[8] = a2[2]; - out[9] = a2[6]; - out[10] = a2[10]; - out[11] = a2[14]; - out[12] = a2[3]; - out[13] = a2[7]; - out[14] = a2[11]; - out[15] = a2[15]; - } - return out; - } - function invert(out, a2) { - var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3]; - var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7]; - var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11]; - var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15]; - var b00 = a00 * a11 - a01 * a10; - var b01 = a00 * a12 - a02 * a10; - var b02 = a00 * a13 - a03 * a10; - var b03 = a01 * a12 - a02 * a11; - var b04 = a01 * a13 - a03 * a11; - var b05 = a02 * a13 - a03 * a12; - var b06 = a20 * a31 - a21 * a30; - var b07 = a20 * a32 - a22 * a30; - var b08 = a20 * a33 - a23 * a30; - var b09 = a21 * a32 - a22 * a31; - var b10 = a21 * a33 - a23 * a31; - var b11 = a22 * a33 - a23 * a32; - var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; - if (!det) { - return null; - } - det = 1 / det; - out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; - out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; - out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; - out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; - out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; - out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; - out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; - out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; - out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; - out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; - out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; - out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; - out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; - out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; - out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; - out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; - return out; - } - function determinant(a2) { - var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3]; - var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7]; - var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11]; - var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15]; - var b00 = a00 * a11 - a01 * a10; - var b01 = a00 * a12 - a02 * a10; - var b02 = a00 * a13 - a03 * a10; - var b03 = a01 * a12 - a02 * a11; - var b04 = a01 * a13 - a03 * a11; - var b05 = a02 * a13 - a03 * a12; - var b06 = a20 * a31 - a21 * a30; - var b07 = a20 * a32 - a22 * a30; - var b08 = a20 * a33 - a23 * a30; - var b09 = a21 * a32 - a22 * a31; - var b10 = a21 * a33 - a23 * a31; - var b11 = a22 * a33 - a23 * a32; - return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; - } - function multiply(out, a2, b2) { - var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3]; - var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7]; - var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11]; - var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15]; - var b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3]; - out[0] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30; - out[1] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31; - out[2] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32; - out[3] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33; - b0 = b2[4]; - b1 = b2[5]; - b22 = b2[6]; - b3 = b2[7]; - out[4] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30; - out[5] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31; - out[6] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32; - out[7] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33; - b0 = b2[8]; - b1 = b2[9]; - b22 = b2[10]; - b3 = b2[11]; - out[8] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30; - out[9] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31; - out[10] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32; - out[11] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33; - b0 = b2[12]; - b1 = b2[13]; - b22 = b2[14]; - b3 = b2[15]; - out[12] = b0 * a00 + b1 * a10 + b22 * a20 + b3 * a30; - out[13] = b0 * a01 + b1 * a11 + b22 * a21 + b3 * a31; - out[14] = b0 * a02 + b1 * a12 + b22 * a22 + b3 * a32; - out[15] = b0 * a03 + b1 * a13 + b22 * a23 + b3 * a33; - return out; - } - function translate(out, a2, v2) { - var x2 = v2[0], y2 = v2[1], z = v2[2]; - var a00, a01, a02, a03; - var a10, a11, a12, a13; - var a20, a21, a22, a23; - if (a2 === out) { - out[12] = a2[0] * x2 + a2[4] * y2 + a2[8] * z + a2[12]; - out[13] = a2[1] * x2 + a2[5] * y2 + a2[9] * z + a2[13]; - out[14] = a2[2] * x2 + a2[6] * y2 + a2[10] * z + a2[14]; - out[15] = a2[3] * x2 + a2[7] * y2 + a2[11] * z + a2[15]; - } else { - a00 = a2[0]; - a01 = a2[1]; - a02 = a2[2]; - a03 = a2[3]; - a10 = a2[4]; - a11 = a2[5]; - a12 = a2[6]; - a13 = a2[7]; - a20 = a2[8]; - a21 = a2[9]; - a22 = a2[10]; - a23 = a2[11]; - out[0] = a00; - out[1] = a01; - out[2] = a02; - out[3] = a03; - out[4] = a10; - out[5] = a11; - out[6] = a12; - out[7] = a13; - out[8] = a20; - out[9] = a21; - out[10] = a22; - out[11] = a23; - out[12] = a00 * x2 + a10 * y2 + a20 * z + a2[12]; - out[13] = a01 * x2 + a11 * y2 + a21 * z + a2[13]; - out[14] = a02 * x2 + a12 * y2 + a22 * z + a2[14]; - out[15] = a03 * x2 + a13 * y2 + a23 * z + a2[15]; - } - return out; - } - function scale(out, a2, v2) { - var x2 = v2[0], y2 = v2[1], z = v2[2]; - out[0] = a2[0] * x2; - out[1] = a2[1] * x2; - out[2] = a2[2] * x2; - out[3] = a2[3] * x2; - out[4] = a2[4] * y2; - out[5] = a2[5] * y2; - out[6] = a2[6] * y2; - out[7] = a2[7] * y2; - out[8] = a2[8] * z; - out[9] = a2[9] * z; - out[10] = a2[10] * z; - out[11] = a2[11] * z; - out[12] = a2[12]; - out[13] = a2[13]; - out[14] = a2[14]; - out[15] = a2[15]; - return out; - } - function rotate(out, a2, rad, axis) { - var x2 = axis[0], y2 = axis[1], z = axis[2]; - var len = Math.hypot(x2, y2, z); - var s, c2, t2; - var a00, a01, a02, a03; - var a10, a11, a12, a13; - var a20, a21, a22, a23; - var b00, b01, b02; - var b10, b11, b12; - var b20, b21, b22; - if (len < EPSILON) { - return null; - } - len = 1 / len; - x2 *= len; - y2 *= len; - z *= len; - s = Math.sin(rad); - c2 = Math.cos(rad); - t2 = 1 - c2; - a00 = a2[0]; - a01 = a2[1]; - a02 = a2[2]; - a03 = a2[3]; - a10 = a2[4]; - a11 = a2[5]; - a12 = a2[6]; - a13 = a2[7]; - a20 = a2[8]; - a21 = a2[9]; - a22 = a2[10]; - a23 = a2[11]; - b00 = x2 * x2 * t2 + c2; - b01 = y2 * x2 * t2 + z * s; - b02 = z * x2 * t2 - y2 * s; - b10 = x2 * y2 * t2 - z * s; - b11 = y2 * y2 * t2 + c2; - b12 = z * y2 * t2 + x2 * s; - b20 = x2 * z * t2 + y2 * s; - b21 = y2 * z * t2 - x2 * s; - b22 = z * z * t2 + c2; - out[0] = a00 * b00 + a10 * b01 + a20 * b02; - out[1] = a01 * b00 + a11 * b01 + a21 * b02; - out[2] = a02 * b00 + a12 * b01 + a22 * b02; - out[3] = a03 * b00 + a13 * b01 + a23 * b02; - out[4] = a00 * b10 + a10 * b11 + a20 * b12; - out[5] = a01 * b10 + a11 * b11 + a21 * b12; - out[6] = a02 * b10 + a12 * b11 + a22 * b12; - out[7] = a03 * b10 + a13 * b11 + a23 * b12; - out[8] = a00 * b20 + a10 * b21 + a20 * b22; - out[9] = a01 * b20 + a11 * b21 + a21 * b22; - out[10] = a02 * b20 + a12 * b21 + a22 * b22; - out[11] = a03 * b20 + a13 * b21 + a23 * b22; - if (a2 !== out) { - out[12] = a2[12]; - out[13] = a2[13]; - out[14] = a2[14]; - out[15] = a2[15]; - } - return out; - } - function rotateX2(out, a2, rad) { - var s = Math.sin(rad); - var c2 = Math.cos(rad); - var a10 = a2[4]; - var a11 = a2[5]; - var a12 = a2[6]; - var a13 = a2[7]; - var a20 = a2[8]; - var a21 = a2[9]; - var a22 = a2[10]; - var a23 = a2[11]; - if (a2 !== out) { - out[0] = a2[0]; - out[1] = a2[1]; - out[2] = a2[2]; - out[3] = a2[3]; - out[12] = a2[12]; - out[13] = a2[13]; - out[14] = a2[14]; - out[15] = a2[15]; + // node_modules/@deck.gl/core/dist/esm/controllers/controller.js + var NO_TRANSITION_PROPS = { + transitionDuration: 0 + }; + var DEFAULT_INERTIA = 300; + var INERTIA_EASING = (t2) => 1 - (1 - t2) * (1 - t2); + var EVENT_TYPES = { + WHEEL: ["wheel"], + PAN: ["panstart", "panmove", "panend"], + PINCH: ["pinchstart", "pinchmove", "pinchend"], + TRIPLE_PAN: ["tripanstart", "tripanmove", "tripanend"], + DOUBLE_TAP: ["doubletap"], + KEYBOARD: ["keydown"] + }; + var pinchEventWorkaround = {}; + var Controller = class { + constructor(opts) { + _defineProperty(this, "props", void 0); + _defineProperty(this, "state", {}); + _defineProperty(this, "transitionManager", void 0); + _defineProperty(this, "eventManager", void 0); + _defineProperty(this, "onViewStateChange", void 0); + _defineProperty(this, "onStateChange", void 0); + _defineProperty(this, "makeViewport", void 0); + _defineProperty(this, "_controllerState", void 0); + _defineProperty(this, "_events", {}); + _defineProperty(this, "_interactionState", { + isDragging: false + }); + _defineProperty(this, "_customEvents", []); + _defineProperty(this, "_eventStartBlocked", null); + _defineProperty(this, "_panMove", false); + _defineProperty(this, "invertPan", false); + _defineProperty(this, "dragMode", "rotate"); + _defineProperty(this, "inertia", 0); + _defineProperty(this, "scrollZoom", true); + _defineProperty(this, "dragPan", true); + _defineProperty(this, "dragRotate", true); + _defineProperty(this, "doubleClickZoom", true); + _defineProperty(this, "touchZoom", true); + _defineProperty(this, "touchRotate", false); + _defineProperty(this, "keyboard", true); + this.transitionManager = new TransitionManager({ + ...opts, + getControllerState: (props) => new this.ControllerState(props), + onViewStateChange: this._onTransition.bind(this), + onStateChange: this._setInteractionState.bind(this) + }); + this.handleEvent = this.handleEvent.bind(this); + this.eventManager = opts.eventManager; + this.onViewStateChange = opts.onViewStateChange || (() => { + }); + this.onStateChange = opts.onStateChange || (() => { + }); + this.makeViewport = opts.makeViewport; } - out[4] = a10 * c2 + a20 * s; - out[5] = a11 * c2 + a21 * s; - out[6] = a12 * c2 + a22 * s; - out[7] = a13 * c2 + a23 * s; - out[8] = a20 * c2 - a10 * s; - out[9] = a21 * c2 - a11 * s; - out[10] = a22 * c2 - a12 * s; - out[11] = a23 * c2 - a13 * s; - return out; - } - function rotateY2(out, a2, rad) { - var s = Math.sin(rad); - var c2 = Math.cos(rad); - var a00 = a2[0]; - var a01 = a2[1]; - var a02 = a2[2]; - var a03 = a2[3]; - var a20 = a2[8]; - var a21 = a2[9]; - var a22 = a2[10]; - var a23 = a2[11]; - if (a2 !== out) { - out[4] = a2[4]; - out[5] = a2[5]; - out[6] = a2[6]; - out[7] = a2[7]; - out[12] = a2[12]; - out[13] = a2[13]; - out[14] = a2[14]; - out[15] = a2[15]; + set events(customEvents) { + this.toggleEvents(this._customEvents, false); + this.toggleEvents(customEvents, true); + this._customEvents = customEvents; + if (this.props) { + this.setProps(this.props); + } } - out[0] = a00 * c2 - a20 * s; - out[1] = a01 * c2 - a21 * s; - out[2] = a02 * c2 - a22 * s; - out[3] = a03 * c2 - a23 * s; - out[8] = a00 * s + a20 * c2; - out[9] = a01 * s + a21 * c2; - out[10] = a02 * s + a22 * c2; - out[11] = a03 * s + a23 * c2; - return out; - } - function rotateZ2(out, a2, rad) { - var s = Math.sin(rad); - var c2 = Math.cos(rad); - var a00 = a2[0]; - var a01 = a2[1]; - var a02 = a2[2]; - var a03 = a2[3]; - var a10 = a2[4]; - var a11 = a2[5]; - var a12 = a2[6]; - var a13 = a2[7]; - if (a2 !== out) { - out[8] = a2[8]; - out[9] = a2[9]; - out[10] = a2[10]; - out[11] = a2[11]; - out[12] = a2[12]; - out[13] = a2[13]; - out[14] = a2[14]; - out[15] = a2[15]; + finalize() { + for (const eventName in this._events) { + if (this._events[eventName]) { + var _this$eventManager; + (_this$eventManager = this.eventManager) === null || _this$eventManager === void 0 ? void 0 : _this$eventManager.off(eventName, this.handleEvent); + } + } + this.transitionManager.finalize(); } - out[0] = a00 * c2 + a10 * s; - out[1] = a01 * c2 + a11 * s; - out[2] = a02 * c2 + a12 * s; - out[3] = a03 * c2 + a13 * s; - out[4] = a10 * c2 - a00 * s; - out[5] = a11 * c2 - a01 * s; - out[6] = a12 * c2 - a02 * s; - out[7] = a13 * c2 - a03 * s; - return out; - } - function fromQuat(out, q) { - var x2 = q[0], y2 = q[1], z = q[2], w2 = q[3]; - var x22 = x2 + x2; - var y22 = y2 + y2; - var z2 = z + z; - var xx = x2 * x22; - var yx = y2 * x22; - var yy = y2 * y22; - var zx = z * x22; - var zy = z * y22; - var zz = z * z2; - var wx = w2 * x22; - var wy = w2 * y22; - var wz = w2 * z2; - out[0] = 1 - yy - zz; - out[1] = yx + wz; - out[2] = zx - wy; - out[3] = 0; - out[4] = yx - wz; - out[5] = 1 - xx - zz; - out[6] = zy + wx; - out[7] = 0; - out[8] = zx + wy; - out[9] = zy - wx; - out[10] = 1 - xx - yy; - out[11] = 0; - out[12] = 0; - out[13] = 0; - out[14] = 0; - out[15] = 1; - return out; - } - function frustum(out, left, right, bottom, top, near, far) { - var rl = 1 / (right - left); - var tb = 1 / (top - bottom); - var nf = 1 / (near - far); - out[0] = near * 2 * rl; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = near * 2 * tb; - out[6] = 0; - out[7] = 0; - out[8] = (right + left) * rl; - out[9] = (top + bottom) * tb; - out[10] = (far + near) * nf; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[14] = far * near * 2 * nf; - out[15] = 0; - return out; - } - function perspectiveNO(out, fovy, aspect, near, far) { - var f2 = 1 / Math.tan(fovy / 2), nf; - out[0] = f2 / aspect; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = f2; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[11] = -1; - out[12] = 0; - out[13] = 0; - out[15] = 0; - if (far != null && far !== Infinity) { - nf = 1 / (near - far); - out[10] = (far + near) * nf; - out[14] = 2 * far * near * nf; - } else { - out[10] = -1; - out[14] = -2 * near; + handleEvent(event) { + this._controllerState = void 0; + const eventStartBlocked = this._eventStartBlocked; + switch (event.type) { + case "panstart": + return eventStartBlocked ? false : this._onPanStart(event); + case "panmove": + return this._onPan(event); + case "panend": + return this._onPanEnd(event); + case "pinchstart": + return eventStartBlocked ? false : this._onPinchStart(event); + case "pinchmove": + return this._onPinch(event); + case "pinchend": + return this._onPinchEnd(event); + case "tripanstart": + return eventStartBlocked ? false : this._onTriplePanStart(event); + case "tripanmove": + return this._onTriplePan(event); + case "tripanend": + return this._onTriplePanEnd(event); + case "doubletap": + return this._onDoubleTap(event); + case "wheel": + return this._onWheel(event); + case "keydown": + return this._onKeyDown(event); + default: + return false; + } } - return out; - } - var perspective = perspectiveNO; - function orthoNO(out, left, right, bottom, top, near, far) { - var lr = 1 / (left - right); - var bt = 1 / (bottom - top); - var nf = 1 / (near - far); - out[0] = -2 * lr; - out[1] = 0; - out[2] = 0; - out[3] = 0; - out[4] = 0; - out[5] = -2 * bt; - out[6] = 0; - out[7] = 0; - out[8] = 0; - out[9] = 0; - out[10] = 2 * nf; - out[11] = 0; - out[12] = (left + right) * lr; - out[13] = (top + bottom) * bt; - out[14] = (far + near) * nf; - out[15] = 1; - return out; - } - var ortho = orthoNO; - function lookAt(out, eye, center, up) { - var x0, x1, x2, y0, y1, y2, z0, z1, z2, len; - var eyex = eye[0]; - var eyey = eye[1]; - var eyez = eye[2]; - var upx = up[0]; - var upy = up[1]; - var upz = up[2]; - var centerx = center[0]; - var centery = center[1]; - var centerz = center[2]; - if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) { - return identity(out); + get controllerState() { + this._controllerState = this._controllerState || new this.ControllerState({ + makeViewport: this.makeViewport, + ...this.props, + ...this.state + }); + return this._controllerState; } - z0 = eyex - centerx; - z1 = eyey - centery; - z2 = eyez - centerz; - len = 1 / Math.hypot(z0, z1, z2); - z0 *= len; - z1 *= len; - z2 *= len; - x0 = upy * z2 - upz * z1; - x1 = upz * z0 - upx * z2; - x2 = upx * z1 - upy * z0; - len = Math.hypot(x0, x1, x2); - if (!len) { - x0 = 0; - x1 = 0; - x2 = 0; - } else { - len = 1 / len; - x0 *= len; - x1 *= len; - x2 *= len; + getCenter(event) { + const { + x: x2, + y: y2 + } = this.props; + const { + offsetCenter + } = event; + return [offsetCenter.x - x2, offsetCenter.y - y2]; } - y0 = z1 * x2 - z2 * x1; - y1 = z2 * x0 - z0 * x2; - y2 = z0 * x1 - z1 * x0; - len = Math.hypot(y0, y1, y2); - if (!len) { - y0 = 0; - y1 = 0; - y2 = 0; - } else { - len = 1 / len; - y0 *= len; - y1 *= len; - y2 *= len; + isPointInBounds(pos, event) { + const { + width, + height + } = this.props; + if (event && event.handled) { + return false; + } + const inside = pos[0] >= 0 && pos[0] <= width && pos[1] >= 0 && pos[1] <= height; + if (inside && event) { + event.stopPropagation(); + } + return inside; } - out[0] = x0; - out[1] = y0; - out[2] = z0; - out[3] = 0; - out[4] = x1; - out[5] = y1; - out[6] = z1; - out[7] = 0; - out[8] = x2; - out[9] = y2; - out[10] = z2; - out[11] = 0; - out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); - out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); - out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); - out[15] = 1; - return out; - } - - // node_modules/gl-matrix/esm/vec4.js - function create3() { - var out = new ARRAY_TYPE(4); - if (ARRAY_TYPE != Float32Array) { - out[0] = 0; - out[1] = 0; - out[2] = 0; - out[3] = 0; + isFunctionKeyPressed(event) { + const { + srcEvent + } = event; + return Boolean(srcEvent.metaKey || srcEvent.altKey || srcEvent.ctrlKey || srcEvent.shiftKey); } - return out; - } - function scale2(out, a2, b2) { - out[0] = a2[0] * b2; - out[1] = a2[1] * b2; - out[2] = a2[2] * b2; - out[3] = a2[3] * b2; - return out; - } - function transformMat43(out, a2, m) { - var x2 = a2[0], y2 = a2[1], z = a2[2], w2 = a2[3]; - out[0] = m[0] * x2 + m[4] * y2 + m[8] * z + m[12] * w2; - out[1] = m[1] * x2 + m[5] * y2 + m[9] * z + m[13] * w2; - out[2] = m[2] * x2 + m[6] * y2 + m[10] * z + m[14] * w2; - out[3] = m[3] * x2 + m[7] * y2 + m[11] * z + m[15] * w2; - return out; - } - var forEach4 = function() { - var vec = create3(); - return function(a2, stride, offset, count2, fn, arg) { - var i2, l2; - if (!stride) { - stride = 4; + isDragging() { + return this._interactionState.isDragging || false; + } + blockEvents(timeout) { + const timer = setTimeout(() => { + if (this._eventStartBlocked === timer) { + this._eventStartBlocked = null; + } + }, timeout); + this._eventStartBlocked = timer; + } + setProps(props) { + if (props.dragMode) { + this.dragMode = props.dragMode; } - if (!offset) { - offset = 0; + this.props = props; + if (!("transitionInterpolator" in props)) { + props.transitionInterpolator = this._getTransitionProps().transitionInterpolator; } - if (count2) { - l2 = Math.min(count2 * stride + offset, a2.length); - } else { - l2 = a2.length; + this.transitionManager.processViewStateChange(props); + const { + inertia + } = props; + this.inertia = Number.isFinite(inertia) ? inertia : inertia === true ? DEFAULT_INERTIA : 0; + const { + scrollZoom = true, + dragPan = true, + dragRotate = true, + doubleClickZoom = true, + touchZoom = true, + touchRotate = false, + keyboard = true + } = props; + const isInteractive = Boolean(this.onViewStateChange); + this.toggleEvents(EVENT_TYPES.WHEEL, isInteractive && scrollZoom); + this.toggleEvents(EVENT_TYPES.PAN, isInteractive); + this.toggleEvents(EVENT_TYPES.PINCH, isInteractive && (touchZoom || touchRotate)); + this.toggleEvents(EVENT_TYPES.TRIPLE_PAN, isInteractive && touchRotate); + this.toggleEvents(EVENT_TYPES.DOUBLE_TAP, isInteractive && doubleClickZoom); + this.toggleEvents(EVENT_TYPES.KEYBOARD, isInteractive && keyboard); + this.scrollZoom = scrollZoom; + this.dragPan = dragPan; + this.dragRotate = dragRotate; + this.doubleClickZoom = doubleClickZoom; + this.touchZoom = touchZoom; + this.touchRotate = touchRotate; + this.keyboard = keyboard; + } + updateTransition() { + this.transitionManager.updateTransition(); + } + toggleEvents(eventNames, enabled) { + if (this.eventManager) { + eventNames.forEach((eventName) => { + if (this._events[eventName] !== enabled) { + this._events[eventName] = enabled; + if (enabled) { + this.eventManager.on(eventName, this.handleEvent); + } else { + this.eventManager.off(eventName, this.handleEvent); + } + } + }); } - for (i2 = offset; i2 < l2; i2 += stride) { - vec[0] = a2[i2]; - vec[1] = a2[i2 + 1]; - vec[2] = a2[i2 + 2]; - vec[3] = a2[i2 + 3]; - fn(vec, vec, arg); - a2[i2] = vec[0]; - a2[i2 + 1] = vec[1]; - a2[i2 + 2] = vec[2]; - a2[i2 + 3] = vec[3]; + } + updateViewport(newControllerState, extraProps = null, interactionState = {}) { + const viewState = { + ...newControllerState.getViewportProps(), + ...extraProps + }; + const changed = this.controllerState !== newControllerState; + this.state = newControllerState.getState(); + this._setInteractionState(interactionState); + if (changed) { + const oldViewState = this.controllerState && this.controllerState.getViewportProps(); + if (this.onViewStateChange) { + this.onViewStateChange({ + viewState, + interactionState: this._interactionState, + oldViewState + }); + } } - return a2; - }; - }(); - - // node_modules/@math.gl/core/dist/esm/classes/matrix4.js - var INDICES; - (function(INDICES2) { - INDICES2[INDICES2["COL0ROW0"] = 0] = "COL0ROW0"; - INDICES2[INDICES2["COL0ROW1"] = 1] = "COL0ROW1"; - INDICES2[INDICES2["COL0ROW2"] = 2] = "COL0ROW2"; - INDICES2[INDICES2["COL0ROW3"] = 3] = "COL0ROW3"; - INDICES2[INDICES2["COL1ROW0"] = 4] = "COL1ROW0"; - INDICES2[INDICES2["COL1ROW1"] = 5] = "COL1ROW1"; - INDICES2[INDICES2["COL1ROW2"] = 6] = "COL1ROW2"; - INDICES2[INDICES2["COL1ROW3"] = 7] = "COL1ROW3"; - INDICES2[INDICES2["COL2ROW0"] = 8] = "COL2ROW0"; - INDICES2[INDICES2["COL2ROW1"] = 9] = "COL2ROW1"; - INDICES2[INDICES2["COL2ROW2"] = 10] = "COL2ROW2"; - INDICES2[INDICES2["COL2ROW3"] = 11] = "COL2ROW3"; - INDICES2[INDICES2["COL3ROW0"] = 12] = "COL3ROW0"; - INDICES2[INDICES2["COL3ROW1"] = 13] = "COL3ROW1"; - INDICES2[INDICES2["COL3ROW2"] = 14] = "COL3ROW2"; - INDICES2[INDICES2["COL3ROW3"] = 15] = "COL3ROW3"; - })(INDICES || (INDICES = {})); - var DEFAULT_FOVY = 45 * Math.PI / 180; - var DEFAULT_ASPECT = 1; - var DEFAULT_NEAR = 0.1; - var DEFAULT_FAR = 500; - var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]); - var Matrix4 = class extends Matrix { - static get IDENTITY() { - return getIdentityMatrix(); } - static get ZERO() { - return getZeroMatrix(); + _onTransition(params) { + this.onViewStateChange({ + ...params, + interactionState: this._interactionState + }); } - get ELEMENTS() { - return 16; + _setInteractionState(newStates) { + Object.assign(this._interactionState, newStates); + this.onStateChange(this._interactionState); } - get RANK() { - return 4; + _onPanStart(event) { + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + let alternateMode = this.isFunctionKeyPressed(event) || event.rightButton || false; + if (this.invertPan || this.dragMode === "pan") { + alternateMode = !alternateMode; + } + const newControllerState = this.controllerState[alternateMode ? "panStart" : "rotateStart"]({ + pos + }); + this._panMove = alternateMode; + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true + }); + return true; } - get INDICES() { - return INDICES; + _onPan(event) { + if (!this.isDragging()) { + return false; + } + return this._panMove ? this._onPanMove(event) : this._onPanRotate(event); } - constructor(array) { - super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0); - if (arguments.length === 1 && Array.isArray(array)) { - this.copy(array); - } else { - this.identity(); + _onPanEnd(event) { + if (!this.isDragging()) { + return false; } + return this._panMove ? this._onPanMoveEnd(event) : this._onPanRotateEnd(event); } - copy(array) { - this[0] = array[0]; - this[1] = array[1]; - this[2] = array[2]; - this[3] = array[3]; - this[4] = array[4]; - this[5] = array[5]; - this[6] = array[6]; - this[7] = array[7]; - this[8] = array[8]; - this[9] = array[9]; - this[10] = array[10]; - this[11] = array[11]; - this[12] = array[12]; - this[13] = array[13]; - this[14] = array[14]; - this[15] = array[15]; - return this.check(); + _onPanMove(event) { + if (!this.dragPan) { + return false; + } + const pos = this.getCenter(event); + const newControllerState = this.controllerState.pan({ + pos + }); + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true, + isPanning: true + }); + return true; } - set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) { - this[0] = m00; - this[1] = m10; - this[2] = m20; - this[3] = m30; - this[4] = m01; - this[5] = m11; - this[6] = m21; - this[7] = m31; - this[8] = m02; - this[9] = m12; - this[10] = m22; - this[11] = m32; - this[12] = m03; - this[13] = m13; - this[14] = m23; - this[15] = m33; - return this.check(); + _onPanMoveEnd(event) { + const { + inertia + } = this; + if (this.dragPan && inertia && event.velocity) { + const pos = this.getCenter(event); + const endPos = [pos[0] + event.velocityX * inertia / 2, pos[1] + event.velocityY * inertia / 2]; + const newControllerState = this.controllerState.pan({ + pos: endPos + }).panEnd(); + this.updateViewport(newControllerState, { + ...this._getTransitionProps(), + transitionDuration: inertia, + transitionEasing: INERTIA_EASING + }, { + isDragging: false, + isPanning: true + }); + } else { + const newControllerState = this.controllerState.panEnd(); + this.updateViewport(newControllerState, null, { + isDragging: false, + isPanning: false + }); + } + return true; } - setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { - this[0] = m00; - this[1] = m10; - this[2] = m20; - this[3] = m30; - this[4] = m01; - this[5] = m11; - this[6] = m21; - this[7] = m31; - this[8] = m02; - this[9] = m12; - this[10] = m22; - this[11] = m32; - this[12] = m03; - this[13] = m13; - this[14] = m23; - this[15] = m33; - return this.check(); + _onPanRotate(event) { + if (!this.dragRotate) { + return false; + } + const pos = this.getCenter(event); + const newControllerState = this.controllerState.rotate({ + pos + }); + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true, + isRotating: true + }); + return true; } - toRowMajor(result) { - result[0] = this[0]; - result[1] = this[4]; - result[2] = this[8]; - result[3] = this[12]; - result[4] = this[1]; - result[5] = this[5]; - result[6] = this[9]; - result[7] = this[13]; - result[8] = this[2]; - result[9] = this[6]; - result[10] = this[10]; - result[11] = this[14]; - result[12] = this[3]; - result[13] = this[7]; - result[14] = this[11]; - result[15] = this[15]; - return result; + _onPanRotateEnd(event) { + const { + inertia + } = this; + if (this.dragRotate && inertia && event.velocity) { + const pos = this.getCenter(event); + const endPos = [pos[0] + event.velocityX * inertia / 2, pos[1] + event.velocityY * inertia / 2]; + const newControllerState = this.controllerState.rotate({ + pos: endPos + }).rotateEnd(); + this.updateViewport(newControllerState, { + ...this._getTransitionProps(), + transitionDuration: inertia, + transitionEasing: INERTIA_EASING + }, { + isDragging: false, + isRotating: true + }); + } else { + const newControllerState = this.controllerState.rotateEnd(); + this.updateViewport(newControllerState, null, { + isDragging: false, + isRotating: false + }); + } + return true; } - identity() { - return this.copy(IDENTITY_MATRIX); + _onWheel(event) { + if (!this.scrollZoom) { + return false; + } + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + event.srcEvent.preventDefault(); + const { + speed = 0.01, + smooth = false + } = this.scrollZoom === true ? {} : this.scrollZoom; + const { + delta + } = event; + let scale5 = 2 / (1 + Math.exp(-Math.abs(delta * speed))); + if (delta < 0 && scale5 !== 0) { + scale5 = 1 / scale5; + } + const newControllerState = this.controllerState.zoom({ + pos, + scale: scale5 + }); + this.updateViewport(newControllerState, { + ...this._getTransitionProps({ + around: pos + }), + transitionDuration: smooth ? 250 : 1 + }, { + isZooming: true, + isPanning: true + }); + return true; } - fromObject(object) { - return this.check(); + _onTriplePanStart(event) { + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + const newControllerState = this.controllerState.rotateStart({ + pos + }); + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true + }); + return true; } - fromQuaternion(quaternion) { - fromQuat(this, quaternion); - return this.check(); + _onTriplePan(event) { + if (!this.touchRotate) { + return false; + } + if (!this.isDragging()) { + return false; + } + const pos = this.getCenter(event); + pos[0] -= event.deltaX; + const newControllerState = this.controllerState.rotate({ + pos + }); + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true, + isRotating: true + }); + return true; } - frustum(view) { + _onTriplePanEnd(event) { + if (!this.isDragging()) { + return false; + } const { - left, - right, - bottom, - top, - near = DEFAULT_NEAR, - far = DEFAULT_FAR - } = view; - if (far === Infinity) { - computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near); + inertia + } = this; + if (this.touchRotate && inertia && event.velocityY) { + const pos = this.getCenter(event); + const endPos = [pos[0], pos[1] += event.velocityY * inertia / 2]; + const newControllerState = this.controllerState.rotate({ + pos: endPos + }); + this.updateViewport(newControllerState, { + ...this._getTransitionProps(), + transitionDuration: inertia, + transitionEasing: INERTIA_EASING + }, { + isDragging: false, + isRotating: true + }); + this.blockEvents(inertia); } else { - frustum(this, left, right, bottom, top, near, far); + const newControllerState = this.controllerState.rotateEnd(); + this.updateViewport(newControllerState, null, { + isDragging: false, + isRotating: false + }); } - return this.check(); + return true; } - lookAt(view) { - const { - eye, - center = [0, 0, 0], - up = [0, 1, 0] - } = view; - lookAt(this, eye, center, up); - return this.check(); + _onPinchStart(event) { + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + const newControllerState = this.controllerState.zoomStart({ + pos + }).rotateStart({ + pos + }); + pinchEventWorkaround._startPinchRotation = event.rotation; + pinchEventWorkaround._lastPinchEvent = event; + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true + }); + return true; } - ortho(view) { - const { - left, - right, - bottom, - top, - near = DEFAULT_NEAR, - far = DEFAULT_FAR - } = view; - ortho(this, left, right, bottom, top, near, far); - return this.check(); + _onPinch(event) { + if (!this.touchZoom && !this.touchRotate) { + return false; + } + if (!this.isDragging()) { + return false; + } + let newControllerState = this.controllerState; + if (this.touchZoom) { + const { + scale: scale5 + } = event; + const pos = this.getCenter(event); + newControllerState = newControllerState.zoom({ + pos, + scale: scale5 + }); + } + if (this.touchRotate) { + const { + rotation + } = event; + newControllerState = newControllerState.rotate({ + deltaAngleX: pinchEventWorkaround._startPinchRotation - rotation + }); + } + this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { + isDragging: true, + isPanning: this.touchZoom, + isZooming: this.touchZoom, + isRotating: this.touchRotate + }); + pinchEventWorkaround._lastPinchEvent = event; + return true; } - orthographic(view) { + _onPinchEnd(event) { + if (!this.isDragging()) { + return false; + } const { - fovy = DEFAULT_FOVY, - aspect = DEFAULT_ASPECT, - focalDistance = 1, - near = DEFAULT_NEAR, - far = DEFAULT_FAR - } = view; - checkRadians(fovy); - const halfY = fovy / 2; - const top = focalDistance * Math.tan(halfY); - const right = top * aspect; - return this.ortho({ - left: -right, - right, - bottom: -top, - top, - near, - far + inertia + } = this; + const { + _lastPinchEvent + } = pinchEventWorkaround; + if (this.touchZoom && inertia && _lastPinchEvent && event.scale !== _lastPinchEvent.scale) { + const pos = this.getCenter(event); + let newControllerState = this.controllerState.rotateEnd(); + const z = Math.log2(event.scale); + const velocityZ = (z - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime); + const endScale = Math.pow(2, z + velocityZ * inertia / 2); + newControllerState = newControllerState.zoom({ + pos, + scale: endScale + }).zoomEnd(); + this.updateViewport(newControllerState, { + ...this._getTransitionProps({ + around: pos + }), + transitionDuration: inertia, + transitionEasing: INERTIA_EASING + }, { + isDragging: false, + isPanning: this.touchZoom, + isZooming: this.touchZoom, + isRotating: false + }); + this.blockEvents(inertia); + } else { + const newControllerState = this.controllerState.zoomEnd().rotateEnd(); + this.updateViewport(newControllerState, null, { + isDragging: false, + isPanning: false, + isZooming: false, + isRotating: false + }); + } + pinchEventWorkaround._startPinchRotation = null; + pinchEventWorkaround._lastPinchEvent = null; + return true; + } + _onDoubleTap(event) { + if (!this.doubleClickZoom) { + return false; + } + const pos = this.getCenter(event); + if (!this.isPointInBounds(pos, event)) { + return false; + } + const isZoomOut = this.isFunctionKeyPressed(event); + const newControllerState = this.controllerState.zoom({ + pos, + scale: isZoomOut ? 0.5 : 2 + }); + this.updateViewport(newControllerState, this._getTransitionProps({ + around: pos + }), { + isZooming: true, + isPanning: true }); + this.blockEvents(100); + return true; } - perspective(view) { + _onKeyDown(event) { + if (!this.keyboard) { + return false; + } + const funcKey = this.isFunctionKeyPressed(event); const { - fovy = 45 * Math.PI / 180, - aspect = 1, - near = 0.1, - far = 500 - } = view; - checkRadians(fovy); - perspective(this, fovy, aspect, near, far); - return this.check(); - } - determinant() { - return determinant(this); + zoomSpeed, + moveSpeed, + rotateSpeedX, + rotateSpeedY + } = this.keyboard === true ? {} : this.keyboard; + const { + controllerState + } = this; + let newControllerState; + const interactionState = {}; + switch (event.srcEvent.code) { + case "Minus": + newControllerState = funcKey ? controllerState.zoomOut(zoomSpeed).zoomOut(zoomSpeed) : controllerState.zoomOut(zoomSpeed); + interactionState.isZooming = true; + break; + case "Equal": + newControllerState = funcKey ? controllerState.zoomIn(zoomSpeed).zoomIn(zoomSpeed) : controllerState.zoomIn(zoomSpeed); + interactionState.isZooming = true; + break; + case "ArrowLeft": + if (funcKey) { + newControllerState = controllerState.rotateLeft(rotateSpeedX); + interactionState.isRotating = true; + } else { + newControllerState = controllerState.moveLeft(moveSpeed); + interactionState.isPanning = true; + } + break; + case "ArrowRight": + if (funcKey) { + newControllerState = controllerState.rotateRight(rotateSpeedX); + interactionState.isRotating = true; + } else { + newControllerState = controllerState.moveRight(moveSpeed); + interactionState.isPanning = true; + } + break; + case "ArrowUp": + if (funcKey) { + newControllerState = controllerState.rotateUp(rotateSpeedY); + interactionState.isRotating = true; + } else { + newControllerState = controllerState.moveUp(moveSpeed); + interactionState.isPanning = true; + } + break; + case "ArrowDown": + if (funcKey) { + newControllerState = controllerState.rotateDown(rotateSpeedY); + interactionState.isRotating = true; + } else { + newControllerState = controllerState.moveDown(moveSpeed); + interactionState.isPanning = true; + } + break; + default: + return false; + } + this.updateViewport(newControllerState, this._getTransitionProps(), interactionState); + return true; } - getScale(result = [-0, -0, -0]) { - result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]); - result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]); - result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]); - return result; + _getTransitionProps(opts) { + const { + transition + } = this; + if (!transition || !transition.transitionInterpolator) { + return NO_TRANSITION_PROPS; + } + return opts ? { + ...transition, + transitionInterpolator: new LinearInterpolator({ + ...opts, + ...transition.transitionInterpolator.opts, + makeViewport: this.controllerState.makeViewport + }) + } : transition; } - getTranslation(result = [-0, -0, -0]) { - result[0] = this[12]; - result[1] = this[13]; - result[2] = this[14]; - return result; + }; + + // node_modules/@deck.gl/core/dist/esm/controllers/view-state.js + var ViewState = class { + constructor(props, state) { + _defineProperty(this, "_viewportProps", void 0); + _defineProperty(this, "_state", void 0); + this._viewportProps = this.applyConstraints(props); + this._state = state; } - getRotation(result, scaleResult) { - result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0]; - scaleResult = scaleResult || [-0, -0, -0]; - const scale3 = this.getScale(scaleResult); - const inverseScale0 = 1 / scale3[0]; - const inverseScale1 = 1 / scale3[1]; - const inverseScale2 = 1 / scale3[2]; - result[0] = this[0] * inverseScale0; - result[1] = this[1] * inverseScale1; - result[2] = this[2] * inverseScale2; - result[3] = 0; - result[4] = this[4] * inverseScale0; - result[5] = this[5] * inverseScale1; - result[6] = this[6] * inverseScale2; - result[7] = 0; - result[8] = this[8] * inverseScale0; - result[9] = this[9] * inverseScale1; - result[10] = this[10] * inverseScale2; - result[11] = 0; - result[12] = 0; - result[13] = 0; - result[14] = 0; - result[15] = 1; - return result; + getViewportProps() { + return this._viewportProps; } - getRotationMatrix3(result, scaleResult) { - result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0]; - scaleResult = scaleResult || [-0, -0, -0]; - const scale3 = this.getScale(scaleResult); - const inverseScale0 = 1 / scale3[0]; - const inverseScale1 = 1 / scale3[1]; - const inverseScale2 = 1 / scale3[2]; - result[0] = this[0] * inverseScale0; - result[1] = this[1] * inverseScale1; - result[2] = this[2] * inverseScale2; - result[3] = this[4] * inverseScale0; - result[4] = this[5] * inverseScale1; - result[5] = this[6] * inverseScale2; - result[6] = this[8] * inverseScale0; - result[7] = this[9] * inverseScale1; - result[8] = this[10] * inverseScale2; - return result; + getState() { + return this._state; } - transpose() { - transpose(this, this); - return this.check(); + }; + + // node_modules/@deck.gl/core/dist/esm/controllers/map-controller.js + var PITCH_MOUSE_THRESHOLD = 5; + var PITCH_ACCEL = 1.2; + var MapState = class extends ViewState { + constructor(options) { + const { + width, + height, + latitude, + longitude, + zoom, + bearing = 0, + pitch = 0, + altitude = 1.5, + position = [0, 0, 0], + maxZoom = 20, + minZoom = 0, + maxPitch = 60, + minPitch = 0, + startPanLngLat, + startZoomLngLat, + startRotatePos, + startBearing, + startPitch, + startZoom, + normalize: normalize5 = true + } = options; + assert10(Number.isFinite(longitude)); + assert10(Number.isFinite(latitude)); + assert10(Number.isFinite(zoom)); + super({ + width, + height, + latitude, + longitude, + zoom, + bearing, + pitch, + altitude, + maxZoom, + minZoom, + maxPitch, + minPitch, + normalize: normalize5, + position + }, { + startPanLngLat, + startZoomLngLat, + startRotatePos, + startBearing, + startPitch, + startZoom + }); + _defineProperty(this, "makeViewport", void 0); + this.makeViewport = options.makeViewport; } - invert() { - invert(this, this); - return this.check(); + panStart({ + pos + }) { + return this._getUpdatedState({ + startPanLngLat: this._unproject(pos) + }); } - multiplyLeft(a2) { - multiply(this, a2, this); - return this.check(); + pan({ + pos, + startPos + }) { + const startPanLngLat = this.getState().startPanLngLat || this._unproject(startPos); + if (!startPanLngLat) { + return this; + } + const viewport = this.makeViewport(this.getViewportProps()); + const newProps = viewport.panByPosition(startPanLngLat, pos); + return this._getUpdatedState(newProps); } - multiplyRight(a2) { - multiply(this, this, a2); - return this.check(); + panEnd() { + return this._getUpdatedState({ + startPanLngLat: null + }); } - rotateX(radians2) { - rotateX2(this, this, radians2); - return this.check(); + rotateStart({ + pos + }) { + return this._getUpdatedState({ + startRotatePos: pos, + startBearing: this.getViewportProps().bearing, + startPitch: this.getViewportProps().pitch + }); } - rotateY(radians2) { - rotateY2(this, this, radians2); - return this.check(); + rotate({ + pos, + deltaAngleX = 0, + deltaAngleY = 0 + }) { + const { + startRotatePos, + startBearing, + startPitch + } = this.getState(); + if (!startRotatePos || startBearing === void 0 || startPitch === void 0) { + return this; + } + let newRotation; + if (pos) { + newRotation = this._getNewRotation(pos, startRotatePos, startPitch, startBearing); + } else { + newRotation = { + bearing: startBearing + deltaAngleX, + pitch: startPitch + deltaAngleY + }; + } + return this._getUpdatedState(newRotation); } - rotateZ(radians2) { - rotateZ2(this, this, radians2); - return this.check(); + rotateEnd() { + return this._getUpdatedState({ + startBearing: null, + startPitch: null + }); } - rotateXYZ(angleXYZ) { - return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]); + zoomStart({ + pos + }) { + return this._getUpdatedState({ + startZoomLngLat: this._unproject(pos), + startZoom: this.getViewportProps().zoom + }); } - rotateAxis(radians2, axis) { - rotate(this, this, radians2, axis); - return this.check(); + zoom({ + pos, + startPos, + scale: scale5 + }) { + let { + startZoom, + startZoomLngLat + } = this.getState(); + if (!startZoomLngLat) { + startZoom = this.getViewportProps().zoom; + startZoomLngLat = this._unproject(startPos) || this._unproject(pos); + } + if (!startZoomLngLat) { + return this; + } + const { + maxZoom, + minZoom + } = this.getViewportProps(); + let zoom = startZoom + Math.log2(scale5); + zoom = clamp(zoom, minZoom, maxZoom); + const zoomedViewport = this.makeViewport({ + ...this.getViewportProps(), + zoom + }); + return this._getUpdatedState({ + zoom, + ...zoomedViewport.panByPosition(startZoomLngLat, pos) + }); } - scale(factor) { - scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]); - return this.check(); + zoomEnd() { + return this._getUpdatedState({ + startZoomLngLat: null, + startZoom: null + }); } - translate(vector) { - translate(this, this, vector); - return this.check(); + zoomIn(speed = 2) { + return this._zoomFromCenter(speed); } - transform(vector, result) { - if (vector.length === 4) { - result = transformMat43(result || [-0, -0, -0, -0], vector, this); - checkVector(result, 4); - return result; - } - return this.transformAsPoint(vector, result); + zoomOut(speed = 2) { + return this._zoomFromCenter(1 / speed); } - transformAsPoint(vector, result) { - const { - length - } = vector; - let out; - switch (length) { - case 2: - out = transformMat4(result || [-0, -0], vector, this); - break; - case 3: - out = transformMat42(result || [-0, -0, -0], vector, this); - break; - default: - throw new Error("Illegal vector"); - } - checkVector(out, vector.length); - return out; + moveLeft(speed = 100) { + return this._panFromCenter([speed, 0]); } - transformAsVector(vector, result) { - let out; - switch (vector.length) { - case 2: - out = vec2_transformMat4AsVector(result || [-0, -0], vector, this); - break; - case 3: - out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this); - break; - default: - throw new Error("Illegal vector"); - } - checkVector(out, vector.length); - return out; + moveRight(speed = 100) { + return this._panFromCenter([-speed, 0]); } - transformPoint(vector, result) { - return this.transformAsPoint(vector, result); + moveUp(speed = 100) { + return this._panFromCenter([0, speed]); } - transformVector(vector, result) { - return this.transformAsPoint(vector, result); + moveDown(speed = 100) { + return this._panFromCenter([0, -speed]); } - transformDirection(vector, result) { - return this.transformAsVector(vector, result); + rotateLeft(speed = 15) { + return this._getUpdatedState({ + bearing: this.getViewportProps().bearing - speed + }); } - makeRotationX(radians2) { - return this.identity().rotateX(radians2); + rotateRight(speed = 15) { + return this._getUpdatedState({ + bearing: this.getViewportProps().bearing + speed + }); } - makeTranslation(x2, y2, z) { - return this.identity().translate([x2, y2, z]); + rotateUp(speed = 10) { + return this._getUpdatedState({ + pitch: this.getViewportProps().pitch + speed + }); } - }; - var ZERO2; - var IDENTITY; - function getZeroMatrix() { - if (!ZERO2) { - ZERO2 = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); - Object.freeze(ZERO2); + rotateDown(speed = 10) { + return this._getUpdatedState({ + pitch: this.getViewportProps().pitch - speed + }); } - return ZERO2; - } - function getIdentityMatrix() { - if (!IDENTITY) { - IDENTITY = new Matrix4(); - Object.freeze(IDENTITY); + shortestPathFrom(viewState) { + const fromProps = viewState.getViewportProps(); + const props = { + ...this.getViewportProps() + }; + const { + bearing, + longitude + } = props; + if (Math.abs(bearing - fromProps.bearing) > 180) { + props.bearing = bearing < 0 ? bearing + 360 : bearing - 360; + } + if (Math.abs(longitude - fromProps.longitude) > 180) { + props.longitude = longitude < 0 ? longitude + 360 : longitude - 360; + } + return props; } - return IDENTITY; - } - function checkRadians(possiblyDegrees) { - if (possiblyDegrees > Math.PI * 2) { - throw Error("expected radians"); + applyConstraints(props) { + const { + maxZoom, + minZoom, + zoom + } = props; + props.zoom = clamp(zoom, minZoom, maxZoom); + const { + maxPitch, + minPitch, + pitch + } = props; + props.pitch = clamp(pitch, minPitch, maxPitch); + const { + normalize: normalize5 = true + } = props; + if (normalize5) { + Object.assign(props, normalizeViewportProps(props)); + } + return props; } - } - function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) { - const column0Row0 = 2 * near / (right - left); - const column1Row1 = 2 * near / (top - bottom); - const column2Row0 = (right + left) / (right - left); - const column2Row1 = (top + bottom) / (top - bottom); - const column2Row2 = -1; - const column2Row3 = -1; - const column3Row2 = -2 * near; - result[0] = column0Row0; - result[1] = 0; - result[2] = 0; - result[3] = 0; - result[4] = 0; - result[5] = column1Row1; - result[6] = 0; - result[7] = 0; - result[8] = column2Row0; - result[9] = column2Row1; - result[10] = column2Row2; - result[11] = column2Row3; - result[12] = 0; - result[13] = 0; - result[14] = column3Row2; - result[15] = 0; - return result; - } - - // node_modules/@luma.gl/shadertools/dist/esm/modules/lights/lights.glsl.js - var lights_glsl_default = "#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\n\nstruct AmbientLight {\n vec3 color;\n};\n\nstruct PointLight {\n vec3 color;\n vec3 position;\n vec3 attenuation;\n};\n\nstruct DirectionalLight {\n vec3 color;\n vec3 direction;\n};\n\nuniform AmbientLight lighting_uAmbientLight;\nuniform PointLight lighting_uPointLight[MAX_LIGHTS];\nuniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];\nuniform int lighting_uPointLightCount;\nuniform int lighting_uDirectionalLightCount;\n\nuniform bool lighting_uEnabled;\n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n return pointLight.attenuation.x\n + pointLight.attenuation.y * distance\n + pointLight.attenuation.z * distance * distance;\n}\n\n#endif\n"; - - // node_modules/@luma.gl/shadertools/dist/esm/modules/lights/lights.js - var INITIAL_MODULE_OPTIONS = { - lightSources: {} - }; - function convertColor() { - let { - color = [0, 0, 0], - intensity = 1 - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - return color.map((component) => component * intensity / 255); - } - function getLightSourceUniforms(_ref) { - let { - ambientLight, - pointLights = [], - directionalLights = [] - } = _ref; - const lightSourceUniforms = {}; - if (ambientLight) { - lightSourceUniforms["lighting_uAmbientLight.color"] = convertColor(ambientLight); - } else { - lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0]; + _zoomFromCenter(scale5) { + const { + width, + height + } = this.getViewportProps(); + return this.zoom({ + pos: [width / 2, height / 2], + scale: scale5 + }); } - pointLights.forEach((pointLight, index) => { - lightSourceUniforms["lighting_uPointLight[".concat(index, "].color")] = convertColor(pointLight); - lightSourceUniforms["lighting_uPointLight[".concat(index, "].position")] = pointLight.position; - lightSourceUniforms["lighting_uPointLight[".concat(index, "].attenuation")] = pointLight.attenuation || [1, 0, 0]; - }); - lightSourceUniforms.lighting_uPointLightCount = pointLights.length; - directionalLights.forEach((directionalLight, index) => { - lightSourceUniforms["lighting_uDirectionalLight[".concat(index, "].color")] = convertColor(directionalLight); - lightSourceUniforms["lighting_uDirectionalLight[".concat(index, "].direction")] = directionalLight.direction; - }); - lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length; - return lightSourceUniforms; - } - function getUniforms() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : INITIAL_MODULE_OPTIONS; - if ("lightSources" in opts) { + _panFromCenter(offset) { const { - ambientLight, - pointLights, - directionalLights - } = opts.lightSources || {}; - const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0; - if (!hasLights) { - return { - lighting_uEnabled: false - }; - } - return Object.assign({}, getLightSourceUniforms({ - ambientLight, - pointLights, - directionalLights - }), { - lighting_uEnabled: true + width, + height + } = this.getViewportProps(); + return this.pan({ + startPos: [width / 2, height / 2], + pos: [width / 2 + offset[0], height / 2 + offset[1]] }); } - if ("lights" in opts) { - const lightSources = { - pointLights: [], - directionalLights: [] - }; - for (const light of opts.lights || []) { - switch (light.type) { - case "ambient": - lightSources.ambientLight = light; - break; - case "directional": - lightSources.directionalLights.push(light); - break; - case "point": - lightSources.pointLights.push(light); - break; - default: + _getUpdatedState(newProps) { + return new this.constructor({ + makeViewport: this.makeViewport, + ...this.getViewportProps(), + ...this.getState(), + ...newProps + }); + } + _unproject(pos) { + const viewport = this.makeViewport(this.getViewportProps()); + return pos && viewport.unproject(pos); + } + _getNewRotation(pos, startPos, startPitch, startBearing) { + const deltaX = pos[0] - startPos[0]; + const deltaY = pos[1] - startPos[1]; + const centerY = pos[1]; + const startY = startPos[1]; + const { + width, + height + } = this.getViewportProps(); + const deltaScaleX = deltaX / width; + let deltaScaleY = 0; + if (deltaY > 0) { + if (Math.abs(height - startY) > PITCH_MOUSE_THRESHOLD) { + deltaScaleY = deltaY / (startY - height) * PITCH_ACCEL; + } + } else if (deltaY < 0) { + if (startY > PITCH_MOUSE_THRESHOLD) { + deltaScaleY = 1 - centerY / startY; } } - return getUniforms({ - lightSources + deltaScaleY = clamp(deltaScaleY, -1, 1); + const { + minPitch, + maxPitch + } = this.getViewportProps(); + const bearing = startBearing + 180 * deltaScaleX; + let pitch = startPitch; + if (deltaScaleY > 0) { + pitch = startPitch + deltaScaleY * (maxPitch - startPitch); + } else if (deltaScaleY < 0) { + pitch = startPitch - deltaScaleY * (minPitch - startPitch); + } + return { + pitch, + bearing + }; + } + }; + var MapController = class extends Controller { + constructor(...args) { + super(...args); + _defineProperty(this, "ControllerState", MapState); + _defineProperty(this, "transition", { + transitionDuration: 300, + transitionInterpolator: new LinearInterpolator({ + transitionProps: { + compare: ["longitude", "latitude", "zoom", "bearing", "pitch", "position"], + required: ["longitude", "latitude", "zoom"] + } + }) }); + _defineProperty(this, "dragMode", "pan"); } - return {}; - } - var lights = { - name: "lights", - vs: lights_glsl_default, - fs: lights_glsl_default, - getUniforms, - defines: { - MAX_LIGHTS: 3 + setProps(props) { + props.position = props.position || [0, 0, 0]; + const oldProps = this.props; + super.setProps(props); + const dimensionChanged = !oldProps || oldProps.height !== props.height; + if (dimensionChanged) { + this.updateViewport(new this.ControllerState({ + makeViewport: this.makeViewport, + ...props, + ...this.state + })); + } } }; - // node_modules/@luma.gl/shadertools/dist/esm/modules/picking/picking.js - var DEFAULT_HIGHLIGHT_COLOR = new Uint8Array([0, 255, 255, 255]); - var DEFAULT_MODULE_OPTIONS = { - pickingSelectedColor: null, - pickingHighlightColor: DEFAULT_HIGHLIGHT_COLOR, - pickingActive: false, - pickingAttribute: false + // node_modules/@deck.gl/core/dist/esm/views/map-view.js + var MapView = class extends View { + get ViewportType() { + return WebMercatorViewport2; + } + get ControllerType() { + return MapController; + } }; - function getUniforms2() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_MODULE_OPTIONS; - const uniforms = {}; - if (opts.pickingSelectedColor !== void 0) { - if (!opts.pickingSelectedColor) { - uniforms.picking_uSelectedColorValid = 0; - } else { - const selectedColor = opts.pickingSelectedColor.slice(0, 3); - uniforms.picking_uSelectedColorValid = 1; - uniforms.picking_uSelectedColor = selectedColor; + _defineProperty(MapView, "displayName", "MapView"); + + // node_modules/@deck.gl/core/dist/esm/lib/effect-manager.js + var DEFAULT_LIGHTING_EFFECT = new LightingEffect(); + function compareEffects(e1, e2) { + var _e1$order, _e2$order; + const o1 = (_e1$order = e1.order) !== null && _e1$order !== void 0 ? _e1$order : Infinity; + const o22 = (_e2$order = e2.order) !== null && _e2$order !== void 0 ? _e2$order : Infinity; + return o1 - o22; + } + var EffectManager = class { + constructor() { + _defineProperty(this, "effects", void 0); + _defineProperty(this, "_resolvedEffects", []); + _defineProperty(this, "_defaultEffects", []); + _defineProperty(this, "_needsRedraw", void 0); + this.effects = []; + this._needsRedraw = "Initial render"; + this._setEffects([]); + } + addDefaultEffect(effect) { + const defaultEffects = this._defaultEffects; + if (!defaultEffects.find((e2) => e2.id === effect.id)) { + const index = defaultEffects.findIndex((e2) => compareEffects(e2, effect) > 0); + if (index < 0) { + defaultEffects.push(effect); + } else { + defaultEffects.splice(index, 0, effect); + } + this._setEffects(this.effects); } } - if (opts.pickingHighlightColor) { - const color = Array.from(opts.pickingHighlightColor, (x2) => x2 / 255); - if (!Number.isFinite(color[3])) { - color[3] = 1; + setProps(props) { + if ("effects" in props) { + if (!deepEqual(props.effects, this.effects, 1)) { + this._setEffects(props.effects); + } } - uniforms.picking_uHighlightColor = color; } - if (opts.pickingActive !== void 0) { - uniforms.picking_uActive = Boolean(opts.pickingActive); - uniforms.picking_uAttribute = Boolean(opts.pickingAttribute); + needsRedraw(opts = { + clearRedrawFlags: false + }) { + const redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; + } + return redraw; } - return uniforms; - } - var vs = "uniform bool picking_uActive;\nuniform bool picking_uAttribute;\nuniform vec3 picking_uSelectedColor;\nuniform bool picking_uSelectedColorValid;\n\nout vec4 picking_vRGBcolor_Avalid;\n\nconst float COLOR_SCALE = 1. / 255.;\n\nbool picking_isColorValid(vec3 color) {\n return dot(color, vec3(1.0)) > 0.001;\n}\n\nbool isVertexPicked(vec3 vertexColor) {\n return\n picking_uSelectedColorValid &&\n !picking_isColorValid(abs(vertexColor - picking_uSelectedColor));\n}\n\nvoid picking_setPickingColor(vec3 pickingColor) {\n if (picking_uActive) {\n picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));\n\n if (!picking_uAttribute) {\n picking_vRGBcolor_Avalid.rgb = pickingColor * COLOR_SCALE;\n }\n } else {\n picking_vRGBcolor_Avalid.a = float(isVertexPicked(pickingColor));\n }\n}\n\nvoid picking_setPickingAttribute(float value) {\n if (picking_uAttribute) {\n picking_vRGBcolor_Avalid.r = value;\n }\n}\nvoid picking_setPickingAttribute(vec2 value) {\n if (picking_uAttribute) {\n picking_vRGBcolor_Avalid.rg = value;\n }\n}\nvoid picking_setPickingAttribute(vec3 value) {\n if (picking_uAttribute) {\n picking_vRGBcolor_Avalid.rgb = value;\n }\n}\n"; - var fs = "uniform bool picking_uActive;\nuniform vec3 picking_uSelectedColor;\nuniform vec4 picking_uHighlightColor;\n\nin vec4 picking_vRGBcolor_Avalid;\nvec4 picking_filterHighlightColor(vec4 color) {\n if (picking_uActive) {\n return color;\n }\n bool selected = bool(picking_vRGBcolor_Avalid.a);\n\n if (selected) {\n float highLightAlpha = picking_uHighlightColor.a;\n float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n float highLightRatio = highLightAlpha / blendedAlpha;\n\n vec3 blendedRGB = mix(color.rgb, picking_uHighlightColor.rgb, highLightRatio);\n return vec4(blendedRGB, blendedAlpha);\n } else {\n return color;\n }\n}\nvec4 picking_filterPickingColor(vec4 color) {\n if (picking_uActive) {\n if (picking_vRGBcolor_Avalid.a == 0.0) {\n discard;\n }\n return picking_vRGBcolor_Avalid;\n }\n return color;\n}\nvec4 picking_filterColor(vec4 color) {\n vec4 highightColor = picking_filterHighlightColor(color);\n return picking_filterPickingColor(highightColor);\n}\n\n"; - var picking = { - name: "picking", - vs, - fs, - getUniforms: getUniforms2 - }; - - // node_modules/@luma.gl/shadertools/dist/esm/modules/phong-lighting/phong-lighting.glsl.js - var phong_lighting_glsl_default = "\nuniform float lighting_uAmbient;\nuniform float lighting_uDiffuse;\nuniform float lighting_uShininess;\nuniform vec3 lighting_uSpecularColor;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n vec3 halfway_direction = normalize(light_direction + view_direction);\n float lambertian = dot(light_direction, normal_worldspace);\n float specular = 0.0;\n if (lambertian > 0.0) {\n float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n specular = pow(specular_angle, lighting_uShininess);\n }\n lambertian = max(lambertian, 0.0);\n return (lambertian * lighting_uDiffuse * surfaceColor + specular * lighting_uSpecularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n vec3 lightColor = surfaceColor;\n\n if (lighting_uEnabled) {\n vec3 view_direction = normalize(cameraPosition - position_worldspace);\n lightColor = lighting_uAmbient * surfaceColor * lighting_uAmbientLight.color;\n\n for (int i = 0; i < MAX_LIGHTS; i++) {\n if (i >= lighting_uPointLightCount) {\n break;\n }\n PointLight pointLight = lighting_uPointLight[i];\n vec3 light_position_worldspace = pointLight.position;\n vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n }\n\n for (int i = 0; i < MAX_LIGHTS; i++) {\n if (i >= lighting_uDirectionalLightCount) {\n break;\n }\n DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n }\n }\n return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n vec3 lightColor = vec3(0, 0, 0);\n vec3 surfaceColor = vec3(0, 0, 0);\n\n if (lighting_uEnabled) {\n vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n for (int i = 0; i < MAX_LIGHTS; i++) {\n if (i >= lighting_uPointLightCount) {\n break;\n }\n PointLight pointLight = lighting_uPointLight[i];\n vec3 light_position_worldspace = pointLight.position;\n vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n }\n\n for (int i = 0; i < MAX_LIGHTS; i++) {\n if (i >= lighting_uDirectionalLightCount) {\n break;\n }\n DirectionalLight directionalLight = lighting_uDirectionalLight[i];\n lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n }\n }\n return lightColor;\n}\n"; - - // node_modules/@luma.gl/shadertools/dist/esm/modules/phong-lighting/phong-lighting.js - var INITIAL_MODULE_OPTIONS2 = {}; - function getMaterialUniforms(material) { - const { - ambient = 0.35, - diffuse = 0.6, - shininess = 32, - specularColor = [30, 30, 30] - } = material; - return { - lighting_uAmbient: ambient, - lighting_uDiffuse: diffuse, - lighting_uShininess: shininess, - lighting_uSpecularColor: specularColor.map((x2) => x2 / 255) - }; - } - function getUniforms3() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : INITIAL_MODULE_OPTIONS2; - if (!("material" in opts)) { - return {}; + getEffects() { + return this._resolvedEffects; } - const { - material - } = opts; - if (!material) { - return { - lighting_uEnabled: false - }; + _setEffects(effects) { + const oldEffectsMap = {}; + for (const effect of this.effects) { + oldEffectsMap[effect.id] = effect; + } + const nextEffects = []; + for (const effect of effects) { + const oldEffect = oldEffectsMap[effect.id]; + if (oldEffect && oldEffect !== effect) { + if (oldEffect.setProps) { + oldEffect.setProps(effect.props); + nextEffects.push(oldEffect); + } else { + oldEffect.cleanup(); + nextEffects.push(effect); + } + } else { + nextEffects.push(effect); + } + delete oldEffectsMap[effect.id]; + } + for (const removedEffectId in oldEffectsMap) { + oldEffectsMap[removedEffectId].cleanup(); + } + this.effects = nextEffects; + this._resolvedEffects = nextEffects.concat(this._defaultEffects); + if (!effects.some((effect) => effect instanceof LightingEffect)) { + this._resolvedEffects.push(DEFAULT_LIGHTING_EFFECT); + } + this._needsRedraw = "effects changed"; + } + finalize() { + for (const effect of this._resolvedEffects) { + effect.cleanup(); + } + this.effects.length = 0; + this._resolvedEffects.length = 0; + this._defaultEffects.length = 0; } - return getMaterialUniforms(material); - } - var gouraudLighting = { - name: "gouraud-lighting", - dependencies: [lights], - vs: phong_lighting_glsl_default, - defines: { - LIGHTING_VERTEX: 1 - }, - getUniforms: getUniforms3 }; - // node_modules/@luma.gl/shadertools/dist/esm/modules/transform/transform.js - var vs2 = "attribute float transform_elementID;\nvec2 transform_getPixelSizeHalf(vec2 size) {\n return vec2(1.) / (2. * size);\n}\n\nvec2 transform_getPixelIndices(vec2 texSize, vec2 pixelSizeHalf) {\n float yIndex = floor((transform_elementID / texSize[0]) + pixelSizeHalf[1]);\n float xIndex = transform_elementID - (yIndex * texSize[0]);\n return vec2(xIndex, yIndex);\n}\nvec2 transform_getTexCoord(vec2 size) {\n vec2 pixelSizeHalf = transform_getPixelSizeHalf(size);\n vec2 indices = transform_getPixelIndices(size, pixelSizeHalf);\n vec2 coord = indices / size + pixelSizeHalf;\n return coord;\n}\nvec2 transform_getPos(vec2 size) {\n vec2 texCoord = transform_getTexCoord(size);\n vec2 pos = (texCoord * (2.0, 2.0)) - (1., 1.);\n return pos;\n}\nvec4 transform_getInput(sampler2D texSampler, vec2 size) {\n vec2 texCoord = transform_getTexCoord(size);\n vec4 textureColor = texture2D(texSampler, texCoord);\n return textureColor;\n}\n"; - var transform = { - name: "transform", - vs: vs2, - fs: null + // node_modules/@deck.gl/core/dist/esm/passes/draw-layers-pass.js + var DrawLayersPass = class extends LayersPass { + shouldDrawLayer(layer) { + const { + operation + } = layer.props; + return operation.includes("draw") || operation.includes("terrain"); + } }; - // node_modules/@luma.gl/engine/dist/esm/lib/program-manager.js - var ProgramManager = class _ProgramManager { - static getDefaultProgramManager(gl) { - gl.luma = gl.luma || {}; - gl.luma.defaultProgramManager = gl.luma.defaultProgramManager || new _ProgramManager(gl); - return gl.luma.defaultProgramManager; - } + // node_modules/@deck.gl/core/dist/esm/lib/deck-renderer.js + var TRACE_RENDER_LAYERS = "deckRenderer.renderLayers"; + var DeckRenderer = class { constructor(gl) { + _defineProperty(this, "gl", void 0); + _defineProperty(this, "layerFilter", void 0); + _defineProperty(this, "drawPickingColors", void 0); + _defineProperty(this, "drawLayersPass", void 0); + _defineProperty(this, "pickLayersPass", void 0); + _defineProperty(this, "renderCount", void 0); + _defineProperty(this, "_needsRedraw", void 0); + _defineProperty(this, "renderBuffers", void 0); + _defineProperty(this, "lastPostProcessEffect", void 0); this.gl = gl; - this._programCache = {}; - this._getUniforms = {}; - this._registeredModules = {}; - this._hookFunctions = []; - this._defaultModules = []; - this._hashes = {}; - this._hashCounter = 0; - this.stateHash = 0; - this._useCounts = {}; + this.layerFilter = null; + this.drawPickingColors = false; + this.drawLayersPass = new DrawLayersPass(gl); + this.pickLayersPass = new PickLayersPass(gl); + this.renderCount = 0; + this._needsRedraw = "Initial render"; + this.renderBuffers = []; + this.lastPostProcessEffect = null; } - addDefaultModule(module) { - if (!this._defaultModules.find((m) => m.name === module.name)) { - this._defaultModules.push(module); + setProps(props) { + if (this.layerFilter !== props.layerFilter) { + this.layerFilter = props.layerFilter; + this._needsRedraw = "layerFilter changed"; } - this.stateHash++; - } - removeDefaultModule(module) { - const moduleName = typeof module === "string" ? module : module.name; - this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName); - this.stateHash++; - } - addShaderHook(hook, opts) { - if (opts) { - hook = Object.assign(opts, { - hook - }); + if (this.drawPickingColors !== props.drawPickingColors) { + this.drawPickingColors = props.drawPickingColors; + this._needsRedraw = "drawPickingColors changed"; } - this._hookFunctions.push(hook); - this.stateHash++; } - get() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - vs: vs7 = "", - fs: fs4 = "", - defines: defines2 = {}, - inject = {}, - varyings = [], - bufferMode = 35981, - transpileToGLSL100 = false - } = props; - const modules = this._getModuleList(props.modules); - const vsHash = this._getHash(vs7); - const fsHash = this._getHash(fs4); - const moduleHashes = modules.map((m) => this._getHash(m.name)).sort(); - const varyingHashes = varyings.map((v2) => this._getHash(v2)); - const defineKeys = Object.keys(defines2).sort(); - const injectKeys = Object.keys(inject).sort(); - const defineHashes = []; - const injectHashes = []; - for (const key of defineKeys) { - defineHashes.push(this._getHash(key)); - defineHashes.push(this._getHash(defines2[key])); + renderLayers(opts) { + if (!opts.viewports.length) { + return; } - for (const key of injectKeys) { - injectHashes.push(this._getHash(key)); - injectHashes.push(this._getHash(inject[key])); + const layerPass = this.drawPickingColors ? this.pickLayersPass : this.drawLayersPass; + const renderOpts = { + layerFilter: this.layerFilter, + isPicking: this.drawPickingColors, + ...opts, + target: opts.target || Framebuffer.getDefaultFramebuffer(this.gl) + }; + if (renderOpts.effects) { + this._preRender(renderOpts.effects, renderOpts); } - const hash = "".concat(vsHash, "/").concat(fsHash, "D").concat(defineHashes.join("/"), "M").concat(moduleHashes.join("/"), "I").concat(injectHashes.join("/"), "V").concat(varyingHashes.join("/"), "H").concat(this.stateHash, "B").concat(bufferMode).concat(transpileToGLSL100 ? "T" : ""); - if (!this._programCache[hash]) { - const assembled = assembleShaders(this.gl, { - vs: vs7, - fs: fs4, - modules, - inject, - defines: defines2, - hookFunctions: this._hookFunctions, - transpileToGLSL100 - }); - this._programCache[hash] = new Program(this.gl, { - hash, - vs: assembled.vs, - fs: assembled.fs, - varyings, - bufferMode - }); - this._getUniforms[hash] = assembled.getUniforms || ((x2) => { - }); - this._useCounts[hash] = 0; + const outputBuffer = this.lastPostProcessEffect ? this.renderBuffers[0] : renderOpts.target; + const renderStats = layerPass.render({ + ...renderOpts, + target: outputBuffer + }); + if (renderOpts.effects) { + this._postRender(renderOpts.effects, renderOpts); } - this._useCounts[hash]++; - return this._programCache[hash]; + this.renderCount++; + debug(TRACE_RENDER_LAYERS, this, renderStats, opts); } - getUniforms(program) { - return this._getUniforms[program.hash] || null; + needsRedraw(opts = { + clearRedrawFlags: false + }) { + const redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; + } + return redraw; } - release(program) { - const hash = program.hash; - this._useCounts[hash]--; - if (this._useCounts[hash] === 0) { - this._programCache[hash].delete(); - delete this._programCache[hash]; - delete this._getUniforms[hash]; - delete this._useCounts[hash]; + finalize() { + const { + renderBuffers + } = this; + for (const buffer of renderBuffers) { + buffer.delete(); } + renderBuffers.length = 0; } - _getHash(key) { - if (this._hashes[key] === void 0) { - this._hashes[key] = this._hashCounter++; + _preRender(effects, opts) { + this.lastPostProcessEffect = null; + opts.preRenderStats = opts.preRenderStats || {}; + for (const effect of effects) { + opts.preRenderStats[effect.id] = effect.preRender(this.gl, opts); + if (effect.postRender) { + this.lastPostProcessEffect = effect.id; + } + } + if (this.lastPostProcessEffect) { + this._resizeRenderBuffers(); } - return this._hashes[key]; } - _getModuleList() { - let appModules = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []; - const modules = new Array(this._defaultModules.length + appModules.length); - const seen = {}; - let count2 = 0; - for (let i2 = 0, len = this._defaultModules.length; i2 < len; ++i2) { - const module = this._defaultModules[i2]; - const name = module.name; - modules[count2++] = module; - seen[name] = true; + _resizeRenderBuffers() { + const { + renderBuffers + } = this; + if (renderBuffers.length === 0) { + renderBuffers.push(new Framebuffer(this.gl), new Framebuffer(this.gl)); } - for (let i2 = 0, len = appModules.length; i2 < len; ++i2) { - const module = appModules[i2]; - const name = module.name; - if (!seen[name]) { - modules[count2++] = module; - seen[name] = true; + for (const buffer of renderBuffers) { + buffer.resize(); + } + } + _postRender(effects, opts) { + const { + renderBuffers + } = this; + const params = { + ...opts, + inputBuffer: renderBuffers[0], + swapBuffer: renderBuffers[1], + target: null + }; + for (const effect of effects) { + if (effect.postRender) { + if (effect.id === this.lastPostProcessEffect) { + params.target = opts.target; + effect.postRender(this.gl, params); + break; + } + const buffer = effect.postRender(this.gl, params); + params.inputBuffer = buffer; + params.swapBuffer = buffer === renderBuffers[0] ? renderBuffers[1] : renderBuffers[0]; } } - modules.length = count2; - return modules; } }; - // node_modules/@luma.gl/engine/dist/esm/lib/model-utils.js - var GLTF_TO_LUMA_ATTRIBUTE_MAP = { - POSITION: "positions", - NORMAL: "normals", - COLOR_0: "colors", - TEXCOORD_0: "texCoords", - TEXCOORD_1: "texCoords1", - TEXCOORD_2: "texCoords2" + // node_modules/@deck.gl/core/dist/esm/lib/picking/query-object.js + var NO_PICKED_OBJECT = { + pickedColor: null, + pickedObjectIndex: -1 }; - function getBuffersFromGeometry(gl, geometry, options) { - const buffers = {}; - let indices = geometry.indices; - for (const name in geometry.attributes) { - const attribute = geometry.attributes[name]; - const remappedName = mapAttributeName(name, options); - if (name === "indices") { - indices = attribute; - } else if (attribute.constant) { - buffers[remappedName] = attribute.value; + function getClosestObject({ + pickedColors, + decodePickingColor, + deviceX, + deviceY, + deviceRadius, + deviceRect + }) { + const { + x: x2, + y: y2, + width, + height + } = deviceRect; + let minSquareDistanceToCenter = deviceRadius * deviceRadius; + let closestPixelIndex = -1; + let i3 = 0; + for (let row = 0; row < height; row++) { + const dy = row + y2 - deviceY; + const dy2 = dy * dy; + if (dy2 > minSquareDistanceToCenter) { + i3 += 4 * width; } else { - const typedArray = attribute.value; - const accessor = { - ...attribute + for (let col = 0; col < width; col++) { + const pickedLayerIndex = pickedColors[i3 + 3] - 1; + if (pickedLayerIndex >= 0) { + const dx = col + x2 - deviceX; + const d2 = dx * dx + dy2; + if (d2 <= minSquareDistanceToCenter) { + minSquareDistanceToCenter = d2; + closestPixelIndex = i3; + } + } + i3 += 4; + } + } + } + if (closestPixelIndex >= 0) { + const pickedColor = pickedColors.slice(closestPixelIndex, closestPixelIndex + 4); + const pickedObject = decodePickingColor(pickedColor); + if (pickedObject) { + const dy = Math.floor(closestPixelIndex / 4 / width); + const dx = closestPixelIndex / 4 - dy * width; + return { + ...pickedObject, + pickedColor, + pickedX: x2 + dx, + pickedY: y2 + dy }; - delete accessor.value; - buffers[remappedName] = [new Buffer2(gl, typedArray), accessor]; - inferAttributeAccessor(name, accessor); } + log_default.error("Picked non-existent layer. Is picking buffer corrupt?")(); } - if (indices) { - const data = indices.value || indices; - assert6(data instanceof Uint16Array || data instanceof Uint32Array, 'attribute array for "indices" must be of integer type'); - const accessor = { - size: 1, - isIndexed: indices.isIndexed === void 0 ? true : indices.isIndexed - }; - buffers.indices = [new Buffer2(gl, { - data, - target: 34963 - }), accessor]; + return NO_PICKED_OBJECT; + } + function getUniqueObjects({ + pickedColors, + decodePickingColor + }) { + const uniqueColors = /* @__PURE__ */ new Map(); + if (pickedColors) { + for (let i3 = 0; i3 < pickedColors.length; i3 += 4) { + const pickedLayerIndex = pickedColors[i3 + 3] - 1; + if (pickedLayerIndex >= 0) { + const pickedColor = pickedColors.slice(i3, i3 + 4); + const colorKey = pickedColor.join(","); + if (!uniqueColors.has(colorKey)) { + const pickedObject = decodePickingColor(pickedColor); + if (pickedObject) { + uniqueColors.set(colorKey, { + ...pickedObject, + color: pickedColor + }); + } else { + log_default.error("Picked non-existent layer. Is picking buffer corrupt?")(); + } + } + } + } + } + return Array.from(uniqueColors.values()); + } + + // node_modules/@deck.gl/core/dist/esm/lib/picking/pick-info.js + function getEmptyPickingInfo({ + pickInfo, + viewports, + pixelRatio, + x: x2, + y: y2, + z + }) { + let pickedViewport = viewports[0]; + if (viewports.length > 1) { + pickedViewport = getViewportFromCoordinates((pickInfo === null || pickInfo === void 0 ? void 0 : pickInfo.pickedViewports) || viewports, { + x: x2, + y: y2 + }); + } + let coordinate; + if (pickedViewport) { + const point = [x2 - pickedViewport.x, y2 - pickedViewport.y]; + if (z !== void 0) { + point[2] = z; + } + coordinate = pickedViewport.unproject(point); + } + return { + color: null, + layer: null, + viewport: pickedViewport, + index: -1, + picked: false, + x: x2, + y: y2, + pixel: [x2, y2], + coordinate, + devicePixel: pickInfo && "pickedX" in pickInfo ? [pickInfo.pickedX, pickInfo.pickedY] : void 0, + pixelRatio + }; + } + function processPickInfo(opts) { + const { + pickInfo, + lastPickedInfo, + mode, + layers + } = opts; + const { + pickedColor, + pickedLayer, + pickedObjectIndex + } = pickInfo; + const affectedLayers = pickedLayer ? [pickedLayer] : []; + if (mode === "hover") { + const lastPickedPixelIndex = lastPickedInfo.index; + const lastPickedLayerId = lastPickedInfo.layerId; + const pickedLayerId = pickedLayer ? pickedLayer.props.id : null; + if (pickedLayerId !== lastPickedLayerId || pickedObjectIndex !== lastPickedPixelIndex) { + if (pickedLayerId !== lastPickedLayerId) { + const lastPickedLayer = layers.find((layer) => layer.props.id === lastPickedLayerId); + if (lastPickedLayer) { + affectedLayers.unshift(lastPickedLayer); + } + } + lastPickedInfo.layerId = pickedLayerId; + lastPickedInfo.index = pickedObjectIndex; + lastPickedInfo.info = null; + } } - return buffers; - } - function mapAttributeName(name, options) { - const { - attributeMap = GLTF_TO_LUMA_ATTRIBUTE_MAP - } = options || {}; - return attributeMap && attributeMap[name] || name; + const baseInfo = getEmptyPickingInfo(opts); + const infos = /* @__PURE__ */ new Map(); + infos.set(null, baseInfo); + affectedLayers.forEach((layer) => { + let info = { + ...baseInfo + }; + if (layer === pickedLayer) { + info.color = pickedColor; + info.index = pickedObjectIndex; + info.picked = true; + } + info = getLayerPickingInfo({ + layer, + info, + mode + }); + const rootLayer = info.layer; + if (layer === pickedLayer && mode === "hover") { + lastPickedInfo.info = info; + } + infos.set(rootLayer.id, info); + if (mode === "hover") { + rootLayer.updateAutoHighlight(info); + } + }); + return infos; } - function inferAttributeAccessor(attributeName, attribute) { - let category; - switch (attributeName) { - case "texCoords": - case "texCoord1": - case "texCoord2": - case "texCoord3": - category = "uvs"; - break; - case "vertices": - case "positions": - case "normals": - case "pickingColors": - category = "vectors"; - break; - default: + function getLayerPickingInfo({ + layer, + info, + mode + }) { + while (layer && info) { + const sourceLayer = info.layer || null; + info.sourceLayer = sourceLayer; + info.layer = layer; + info = layer.getPickingInfo({ + info, + mode, + sourceLayer + }); + layer = layer.parent; } - switch (category) { - case "vectors": - attribute.size = attribute.size || 3; - break; - case "uvs": - attribute.size = attribute.size || 2; - break; - default: + return info; + } + function getViewportFromCoordinates(viewports, pixel) { + for (let i3 = viewports.length - 1; i3 >= 0; i3--) { + const viewport = viewports[i3]; + if (viewport.containsPixel(pixel)) { + return viewport; + } } - assert6(Number.isFinite(attribute.size), "attribute ".concat(attributeName, " needs size")); + return viewports[0]; } - // node_modules/@luma.gl/engine/dist/esm/lib/model.js - var LOG_DRAW_PRIORITY = 2; - var LOG_DRAW_TIMEOUT = 1e4; - var ERR_MODEL_PARAMS = "Model needs drawMode and vertexCount"; - var NOOP2 = () => { - }; - var DRAW_PARAMS = {}; - var Model = class { + // node_modules/@deck.gl/core/dist/esm/lib/deck-picker.js + var DeckPicker = class { constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - const { - id = uid("model") - } = props; - assert6(isWebGL(gl)); - this.id = id; + _defineProperty(this, "gl", void 0); + _defineProperty(this, "pickingFBO", void 0); + _defineProperty(this, "depthFBO", void 0); + _defineProperty(this, "pickLayersPass", void 0); + _defineProperty(this, "layerFilter", void 0); + _defineProperty(this, "lastPickedInfo", void 0); + _defineProperty(this, "_pickable", true); this.gl = gl; - this.id = props.id || uid("Model"); - this.lastLogTime = 0; - this.animated = false; - this.initialize(props); - } - initialize(props) { - this.props = {}; - this.programManager = props.programManager || ProgramManager.getDefaultProgramManager(this.gl); - this._programManagerState = -1; - this._managedProgram = false; - const { - program = null, - vs: vs7, - fs: fs4, - modules, - defines: defines2, - inject, - varyings, - bufferMode, - transpileToGLSL100 - } = props; - this.programProps = { - program, - vs: vs7, - fs: fs4, - modules, - defines: defines2, - inject, - varyings, - bufferMode, - transpileToGLSL100 + this.pickLayersPass = new PickLayersPass(gl); + this.lastPickedInfo = { + index: -1, + layerId: null, + info: null }; - this.program = null; - this.vertexArray = null; - this._programDirty = true; - this.userData = {}; - this.needsRedraw = true; - this._attributes = {}; - this.attributes = {}; - this.uniforms = {}; - this.pickable = true; - this._checkProgram(); - this.setUniforms(Object.assign({}, this.getModuleUniforms(props.moduleSettings))); - this.drawMode = props.drawMode !== void 0 ? props.drawMode : 4; - this.vertexCount = props.vertexCount || 0; - this.geometryBuffers = {}; - this.isInstanced = props.isInstanced || props.instanced || props.instanceCount > 0; - this._setModelProps(props); - this.geometry = {}; - assert6(this.drawMode !== void 0 && Number.isFinite(this.vertexCount), ERR_MODEL_PARAMS); } setProps(props) { - this._setModelProps(props); - } - delete() { - for (const key in this._attributes) { - if (this._attributes[key] !== this.attributes[key]) { - this._attributes[key].delete(); - } + if ("layerFilter" in props) { + this.layerFilter = props.layerFilter; } - if (this._managedProgram) { - this.programManager.release(this.program); - this._managedProgram = false; + if ("_pickable" in props) { + this._pickable = props._pickable; } - this.vertexArray.delete(); - this._deleteGeometryBuffers(); - } - getDrawMode() { - return this.drawMode; - } - getVertexCount() { - return this.vertexCount; - } - getInstanceCount() { - return this.instanceCount; - } - getAttributes() { - return this.attributes; - } - getProgram() { - return this.program; - } - setProgram(props) { - const { - program, - vs: vs7, - fs: fs4, - modules, - defines: defines2, - inject, - varyings, - bufferMode, - transpileToGLSL100 - } = props; - this.programProps = { - program, - vs: vs7, - fs: fs4, - modules, - defines: defines2, - inject, - varyings, - bufferMode, - transpileToGLSL100 - }; - this._programDirty = true; - } - getUniforms() { - return this.uniforms; - } - setDrawMode(drawMode) { - this.drawMode = drawMode; - return this; - } - setVertexCount(vertexCount) { - assert6(Number.isFinite(vertexCount)); - this.vertexCount = vertexCount; - return this; - } - setInstanceCount(instanceCount) { - assert6(Number.isFinite(instanceCount)); - this.instanceCount = instanceCount; - return this; - } - setGeometry(geometry) { - this.drawMode = geometry.drawMode; - this.vertexCount = geometry.getVertexCount(); - this._deleteGeometryBuffers(); - this.geometryBuffers = getBuffersFromGeometry(this.gl, geometry); - this.vertexArray.setAttributes(this.geometryBuffers); - return this; } - setAttributes() { - let attributes = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if (isObjectEmpty2(attributes)) { - return this; + finalize() { + if (this.pickingFBO) { + this.pickingFBO.delete(); } - const normalizedAttributes = {}; - for (const name in attributes) { - const attribute = attributes[name]; - normalizedAttributes[name] = attribute.getValue ? attribute.getValue() : attribute; + if (this.depthFBO) { + this.depthFBO.color.delete(); + this.depthFBO.delete(); } - this.vertexArray.setAttributes(normalizedAttributes); - return this; - } - setUniforms() { - let uniforms = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - Object.assign(this.uniforms, uniforms); - return this; } - getModuleUniforms(opts) { - this._checkProgram(); - const getUniforms5 = this.programManager.getUniforms(this.program); - if (getUniforms5) { - return getUniforms5(opts); - } - return {}; + pickObject(opts) { + return this._pickClosestObject(opts); } - updateModuleSettings(opts) { - const uniforms = this.getModuleUniforms(opts || {}); - return this.setUniforms(uniforms); + pickObjects(opts) { + return this._pickVisibleObjects(opts); } - clear(opts) { - clear(this.program.gl, opts); - return this; + getLastPickedObject({ + x: x2, + y: y2, + layers, + viewports + }, lastPickedInfo = this.lastPickedInfo.info) { + const lastPickedLayerId = lastPickedInfo && lastPickedInfo.layer && lastPickedInfo.layer.id; + const lastPickedViewportId = lastPickedInfo && lastPickedInfo.viewport && lastPickedInfo.viewport.id; + const layer = lastPickedLayerId ? layers.find((l2) => l2.id === lastPickedLayerId) : null; + const viewport = lastPickedViewportId && viewports.find((v2) => v2.id === lastPickedViewportId) || viewports[0]; + const coordinate = viewport && viewport.unproject([x2 - viewport.x, y2 - viewport.y]); + const info = { + x: x2, + y: y2, + viewport, + coordinate, + layer + }; + return { + ...lastPickedInfo, + ...info + }; } - draw() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this._checkProgram(); - const { - moduleSettings = null, - framebuffer, - uniforms = {}, - attributes = {}, - transformFeedback = this.transformFeedback, - parameters = {}, - vertexArray = this.vertexArray - } = opts; - this.setAttributes(attributes); - this.updateModuleSettings(moduleSettings); - this.setUniforms(uniforms); - let logPriority; - if (log2.priority >= LOG_DRAW_PRIORITY) { - logPriority = this._logDrawCallStart(LOG_DRAW_PRIORITY); - } - const drawParams = this.vertexArray.getDrawParams(); - const { - isIndexed = drawParams.isIndexed, - indexType = drawParams.indexType, - indexOffset = drawParams.indexOffset, - vertexArrayInstanced = drawParams.isInstanced - } = this.props; - if (vertexArrayInstanced && !this.isInstanced) { - log2.warn("Found instanced attributes on non-instanced model", this.id)(); - } + _resizeBuffer() { + var _this$pickingFBO, _this$depthFBO; const { - isInstanced, - instanceCount + gl } = this; - const { - onBeforeRender = NOOP2, - onAfterRender = NOOP2 - } = this.props; - onBeforeRender(); - this.program.setUniforms(this.uniforms); - const didDraw = this.program.draw(Object.assign(DRAW_PARAMS, opts, { - logPriority, - uniforms: null, - framebuffer, - parameters, - drawMode: this.getDrawMode(), - vertexCount: this.getVertexCount(), - vertexArray, - transformFeedback, - isIndexed, - indexType, - isInstanced, - instanceCount, - offset: isIndexed ? indexOffset : 0 - })); - onAfterRender(); - if (log2.priority >= LOG_DRAW_PRIORITY) { - this._logDrawCallEnd(logPriority, vertexArray, framebuffer); + if (!this.pickingFBO) { + this.pickingFBO = new Framebuffer(gl); + if (Framebuffer.isSupported(gl, { + colorBufferFloat: true + })) { + const depthFBO = new Framebuffer(gl); + depthFBO.attach({ + [36064]: new Texture2D(gl, { + format: isWebGL2(gl) ? 34836 : 6408, + type: 5126 + }) + }); + this.depthFBO = depthFBO; + } } - return didDraw; + (_this$pickingFBO = this.pickingFBO) === null || _this$pickingFBO === void 0 ? void 0 : _this$pickingFBO.resize({ + width: gl.canvas.width, + height: gl.canvas.height + }); + (_this$depthFBO = this.depthFBO) === null || _this$depthFBO === void 0 ? void 0 : _this$depthFBO.resize({ + width: gl.canvas.width, + height: gl.canvas.height + }); } - transform() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - discard = true, - feedbackBuffers, - unbindModels = [] - } = opts; - let { - parameters - } = opts; - if (feedbackBuffers) { - this._setFeedbackBuffers(feedbackBuffers); + _getPickable(layers) { + if (this._pickable === false) { + return null; } - if (discard) { - parameters = Object.assign({}, parameters, { - [35977]: discard + const pickableLayers = layers.filter((layer) => this.pickLayersPass.shouldDrawLayer(layer) && !layer.isComposite); + return pickableLayers.length ? pickableLayers : null; + } + _pickClosestObject({ + layers, + views, + viewports, + x: x2, + y: y2, + radius = 0, + depth = 1, + mode = "query", + unproject3D, + onViewportActive, + effects + }) { + const pickableLayers = this._getPickable(layers); + const pixelRatio = cssToDeviceRatio(this.gl); + if (!pickableLayers) { + return { + result: [], + emptyInfo: getEmptyPickingInfo({ + viewports, + x: x2, + y: y2, + pixelRatio + }) + }; + } + this._resizeBuffer(); + const devicePixelRange = cssToDevicePixels(this.gl, [x2, y2], true); + const devicePixel = [devicePixelRange.x + Math.floor(devicePixelRange.width / 2), devicePixelRange.y + Math.floor(devicePixelRange.height / 2)]; + const deviceRadius = Math.round(radius * pixelRatio); + const { + width, + height + } = this.pickingFBO; + const deviceRect = this._getPickingRect({ + deviceX: devicePixel[0], + deviceY: devicePixel[1], + deviceRadius, + deviceWidth: width, + deviceHeight: height + }); + const cullRect = { + x: x2 - radius, + y: y2 - radius, + width: radius * 2 + 1, + height: radius * 2 + 1 + }; + let infos; + const result = []; + const affectedLayers = /* @__PURE__ */ new Set(); + for (let i3 = 0; i3 < depth; i3++) { + let pickInfo; + if (deviceRect) { + const pickedResult = this._drawAndSample({ + layers: pickableLayers, + views, + viewports, + onViewportActive, + deviceRect, + cullRect, + effects, + pass: "picking:".concat(mode) + }); + pickInfo = getClosestObject({ + ...pickedResult, + deviceX: devicePixel[0], + deviceY: devicePixel[1], + deviceRadius, + deviceRect + }); + } else { + pickInfo = { + pickedColor: null, + pickedObjectIndex: -1 + }; + } + let z; + if (pickInfo.pickedLayer && unproject3D && this.depthFBO) { + const { + pickedColors: pickedColors2 + } = this._drawAndSample({ + layers: [pickInfo.pickedLayer], + views, + viewports, + onViewportActive, + deviceRect: { + x: pickInfo.pickedX, + y: pickInfo.pickedY, + width: 1, + height: 1 + }, + cullRect, + effects, + pass: "picking:".concat(mode, ":z") + }, true); + if (pickedColors2[3]) { + z = pickedColors2[0]; + } + } + if (pickInfo.pickedLayer && i3 + 1 < depth) { + affectedLayers.add(pickInfo.pickedLayer); + pickInfo.pickedLayer.disablePickingIndex(pickInfo.pickedObjectIndex); + } + infos = processPickInfo({ + pickInfo, + lastPickedInfo: this.lastPickedInfo, + mode, + layers: pickableLayers, + viewports, + x: x2, + y: y2, + z, + pixelRatio }); + for (const info of infos.values()) { + if (info.layer) { + result.push(info); + } + } + if (!pickInfo.pickedColor) { + break; + } } - unbindModels.forEach((model) => model.vertexArray.unbindBuffers()); - try { - this.draw(Object.assign({}, opts, { - parameters - })); - } finally { - unbindModels.forEach((model) => model.vertexArray.bindBuffers()); + for (const layer of affectedLayers) { + layer.restorePickingColors(); } - return this; - } - render() { - let uniforms = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - log2.warn("Model.render() is deprecated. Use Model.setUniforms() and Model.draw()")(); - return this.setUniforms(uniforms).draw(); + return { + result, + emptyInfo: infos.get(null) + }; } - _setModelProps(props) { - Object.assign(this.props, props); - if ("uniforms" in props) { - this.setUniforms(props.uniforms); - } - if ("pickable" in props) { - this.pickable = props.pickable; + _pickVisibleObjects({ + layers, + views, + viewports, + x: x2, + y: y2, + width = 1, + height = 1, + mode = "query", + maxObjects = null, + onViewportActive, + effects + }) { + const pickableLayers = this._getPickable(layers); + if (!pickableLayers) { + return []; } - if ("instanceCount" in props) { - this.instanceCount = props.instanceCount; + this._resizeBuffer(); + const pixelRatio = cssToDeviceRatio(this.gl); + const leftTop = cssToDevicePixels(this.gl, [x2, y2], true); + const deviceLeft = leftTop.x; + const deviceTop = leftTop.y + leftTop.height; + const rightBottom = cssToDevicePixels(this.gl, [x2 + width, y2 + height], true); + const deviceRight = rightBottom.x + rightBottom.width; + const deviceBottom = rightBottom.y; + const deviceRect = { + x: deviceLeft, + y: deviceBottom, + width: deviceRight - deviceLeft, + height: deviceTop - deviceBottom + }; + const pickedResult = this._drawAndSample({ + layers: pickableLayers, + views, + viewports, + onViewportActive, + deviceRect, + cullRect: { + x: x2, + y: y2, + width, + height + }, + effects, + pass: "picking:".concat(mode) + }); + const pickInfos = getUniqueObjects(pickedResult); + const uniqueInfos = /* @__PURE__ */ new Map(); + const isMaxObjects = Number.isFinite(maxObjects); + for (let i3 = 0; i3 < pickInfos.length; i3++) { + var _info$object; + if (isMaxObjects && maxObjects && uniqueInfos.size >= maxObjects) { + break; + } + const pickInfo = pickInfos[i3]; + let info = { + color: pickInfo.pickedColor, + layer: null, + index: pickInfo.pickedObjectIndex, + picked: true, + x: x2, + y: y2, + pixelRatio + }; + info = getLayerPickingInfo({ + layer: pickInfo.pickedLayer, + info, + mode + }); + const pickedObjectKey = (_info$object = info.object) !== null && _info$object !== void 0 ? _info$object : "".concat(info.layer.id, "[").concat(info.index, "]"); + if (!uniqueInfos.has(pickedObjectKey)) { + uniqueInfos.set(pickedObjectKey, info); + } } - if ("geometry" in props) { - this.setGeometry(props.geometry); + return Array.from(uniqueInfos.values()); + } + _drawAndSample({ + layers, + views, + viewports, + onViewportActive, + deviceRect, + cullRect, + effects, + pass + }, pickZ = false) { + const pickingFBO = pickZ ? this.depthFBO : this.pickingFBO; + const opts = { + layers, + layerFilter: this.layerFilter, + views, + viewports, + onViewportActive, + pickingFBO, + deviceRect, + cullRect, + effects, + pass, + pickZ, + preRenderStats: {} + }; + for (const effect of effects) { + if (effect.useInPicking) { + opts.preRenderStats[effect.id] = effect.preRender(this.gl, opts); + } } - if ("attributes" in props) { - this.setAttributes(props.attributes); + const { + decodePickingColor + } = this.pickLayersPass.render(opts); + const { + x: x2, + y: y2, + width, + height + } = deviceRect; + const pickedColors = new (pickZ ? Float32Array : Uint8Array)(width * height * 4); + readPixelsToArray(pickingFBO, { + sourceX: x2, + sourceY: y2, + sourceWidth: width, + sourceHeight: height, + target: pickedColors + }); + return { + pickedColors, + decodePickingColor + }; + } + _getPickingRect({ + deviceX, + deviceY, + deviceRadius, + deviceWidth, + deviceHeight + }) { + const x2 = Math.max(0, deviceX - deviceRadius); + const y2 = Math.max(0, deviceY - deviceRadius); + const width = Math.min(deviceWidth, deviceX + deviceRadius + 1) - x2; + const height = Math.min(deviceHeight, deviceY + deviceRadius + 1) - y2; + if (width <= 0 || height <= 0) { + return null; } - if ("_feedbackBuffers" in props) { - this._setFeedbackBuffers(props._feedbackBuffers); + return { + x: x2, + y: y2, + width, + height + }; + } + }; + + // node_modules/@deck.gl/core/dist/esm/lib/tooltip.js + var defaultStyle = { + zIndex: "1", + position: "absolute", + pointerEvents: "none", + color: "#a0a7b4", + backgroundColor: "#29323c", + padding: "10px", + top: "0", + left: "0", + display: "none" + }; + var Tooltip = class { + constructor(canvas) { + _defineProperty(this, "el", null); + _defineProperty(this, "isVisible", false); + const canvasParent = canvas.parentElement; + if (canvasParent) { + this.el = document.createElement("div"); + this.el.className = "deck-tooltip"; + Object.assign(this.el.style, defaultStyle); + canvasParent.appendChild(this.el); } } - _checkProgram() { - const needsUpdate = this._programDirty || this.programManager.stateHash !== this._programManagerState; - if (!needsUpdate) { + setTooltip(displayInfo, x2, y2) { + const el = this.el; + if (!el) { return; } - let { - program - } = this.programProps; - if (program) { - this._managedProgram = false; - } else { - const { - vs: vs7, - fs: fs4, - modules, - inject, - defines: defines2, - varyings, - bufferMode, - transpileToGLSL100 - } = this.programProps; - program = this.programManager.get({ - vs: vs7, - fs: fs4, - modules, - inject, - defines: defines2, - varyings, - bufferMode, - transpileToGLSL100 - }); - if (this.program && this._managedProgram) { - this.programManager.release(this.program); - } - this._programManagerState = this.programManager.stateHash; - this._managedProgram = true; - } - assert6(program instanceof Program, "Model needs a program"); - this._programDirty = false; - if (program === this.program) { + if (typeof displayInfo === "string") { + el.innerText = displayInfo; + } else if (!displayInfo) { + this.isVisible = false; + el.style.display = "none"; return; - } - this.program = program; - if (this.vertexArray) { - this.vertexArray.setProps({ - program: this.program, - attributes: this.vertexArray.attributes - }); } else { - this.vertexArray = new VertexArray(this.gl, { - program: this.program - }); - } - this.setUniforms(Object.assign({}, this.getModuleUniforms())); - } - _deleteGeometryBuffers() { - for (const name in this.geometryBuffers) { - const buffer = this.geometryBuffers[name][0] || this.geometryBuffers[name]; - if (buffer instanceof Buffer2) { - buffer.delete(); + if (displayInfo.text) { + el.innerText = displayInfo.text; + } + if (displayInfo.html) { + el.innerHTML = displayInfo.html; + } + if (displayInfo.className) { + el.className = displayInfo.className; } } - } - _setAnimationProps(animationProps) { - if (this.animated) { - assert6(animationProps, "Model.draw(): animated uniforms but no animationProps"); + this.isVisible = true; + el.style.display = "block"; + el.style.transform = "translate(".concat(x2, "px, ").concat(y2, "px)"); + if (displayInfo && typeof displayInfo === "object" && "style" in displayInfo) { + Object.assign(el.style, displayInfo.style); } } - _setFeedbackBuffers() { - let feedbackBuffers = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if (isObjectEmpty2(feedbackBuffers)) { - return this; + remove() { + if (this.el) { + this.el.remove(); + this.el = null; } - const { - gl - } = this.program; - this.transformFeedback = this.transformFeedback || new TransformFeedback(gl, { - program: this.program - }); - this.transformFeedback.setBuffers(feedbackBuffers); - return this; } - _logDrawCallStart(logLevel) { - const logDrawTimeout = logLevel > 3 ? 0 : LOG_DRAW_TIMEOUT; - if (Date.now() - this.lastLogTime < logDrawTimeout) { - return void 0; + }; + + // node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js + var hammerjs = __toESM(require_hammer()); + + // node_modules/mjolnir.js/dist/esm/utils/hammer-overrides.js + var INPUT_START = 1; + var INPUT_MOVE = 2; + var INPUT_END = 4; + var MOUSE_INPUT_MAP = { + mousedown: INPUT_START, + mousemove: INPUT_MOVE, + mouseup: INPUT_END + }; + function some(array, predict) { + for (let i3 = 0; i3 < array.length; i3++) { + if (predict(array[i3])) { + return true; } - this.lastLogTime = Date.now(); - log2.group(LOG_DRAW_PRIORITY, ">>> DRAWING MODEL ".concat(this.id), { - collapsed: log2.level <= 2 - })(); - return logLevel; } - _logDrawCallEnd(logLevel, vertexArray, uniforms, framebuffer) { - if (logLevel === void 0) { - return; + return false; + } + function enhancePointerEventInput(PointerEventInput2) { + const oldHandler = PointerEventInput2.prototype.handler; + PointerEventInput2.prototype.handler = function handler(ev) { + const store = this.store; + if (ev.button > 0 && ev.type === "pointerdown") { + if (!some(store, (e2) => e2.pointerId === ev.pointerId)) { + store.push(ev); + } } - const attributeTable = getDebugTableForVertexArray({ - vertexArray, - header: "".concat(this.id, " attributes"), - attributes: this._attributes - }); - const { - table: uniformTable, - unusedTable, - unusedCount - } = getDebugTableForUniforms({ - header: "".concat(this.id, " uniforms"), - program: this.program, - uniforms: Object.assign({}, this.program.uniforms, uniforms) - }); - const { - table: missingTable, - count: missingCount - } = getDebugTableForUniforms({ - header: "".concat(this.id, " uniforms"), - program: this.program, - uniforms: Object.assign({}, this.program.uniforms, uniforms), - undefinedOnly: true - }); - if (missingCount > 0) { - log2.log("MISSING UNIFORMS", Object.keys(missingTable))(); + oldHandler.call(this, ev); + }; + } + function enhanceMouseInput(MouseInput2) { + MouseInput2.prototype.handler = function handler(ev) { + let eventType = MOUSE_INPUT_MAP[ev.type]; + if (eventType & INPUT_START && ev.button >= 0) { + this.pressed = true; } - if (unusedCount > 0) { - log2.log("UNUSED UNIFORMS", Object.keys(unusedTable))(); + if (eventType & INPUT_MOVE && ev.which === 0) { + eventType = INPUT_END; } - const configTable = getDebugTableForProgramConfiguration(this.vertexArray.configuration); - log2.table(logLevel, attributeTable)(); - log2.table(logLevel, uniformTable)(); - log2.table(logLevel + 1, configTable)(); - if (framebuffer) { - framebuffer.log({ - logLevel: LOG_DRAW_PRIORITY, - message: "Rendered to ".concat(framebuffer.id) - }); + if (!this.pressed) { + return; } - log2.groupEnd(LOG_DRAW_PRIORITY)(); + if (eventType & INPUT_END) { + this.pressed = false; + } + this.callback(this.manager, eventType, { + pointers: [ev], + changedPointers: [ev], + pointerType: "mouse", + srcEvent: ev + }); + }; + } + + // node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js + enhancePointerEventInput(hammerjs.PointerEventInput); + enhanceMouseInput(hammerjs.MouseInput); + var Manager2 = hammerjs.Manager; + var hammer_browser_default = hammerjs; + + // node_modules/mjolnir.js/dist/esm/inputs/input.js + var Input = class { + constructor(element, callback, options) { + this.element = element; + this.callback = callback; + this.options = { enable: true, ...options }; } }; - // node_modules/@luma.gl/engine/dist/esm/transform/buffer-transform.js - var BufferTransform = class { - constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - this.gl = gl; - this.currentIndex = 0; - this.feedbackMap = {}; - this.varyings = null; - this.bindings = []; - this.resources = {}; - this._initialize(props); - Object.seal(this); - } - setupResources(opts) { - for (const binding of this.bindings) { - this._setupTransformFeedback(binding, opts); + // node_modules/mjolnir.js/dist/esm/constants.js + var RECOGNIZERS = hammer_browser_default ? [ + [hammer_browser_default.Pan, { event: "tripan", pointers: 3, threshold: 0, enable: false }], + [hammer_browser_default.Rotate, { enable: false }], + [hammer_browser_default.Pinch, { enable: false }], + [hammer_browser_default.Swipe, { enable: false }], + [hammer_browser_default.Pan, { threshold: 0, enable: false }], + [hammer_browser_default.Press, { enable: false }], + [hammer_browser_default.Tap, { event: "doubletap", taps: 2, enable: false }], + // TODO - rename to 'tap' and 'singletap' in the next major release + [hammer_browser_default.Tap, { event: "anytap", enable: false }], + [hammer_browser_default.Tap, { enable: false }] + ] : null; + var RECOGNIZER_COMPATIBLE_MAP = { + tripan: ["rotate", "pinch", "pan"], + rotate: ["pinch"], + pinch: ["pan"], + pan: ["press", "doubletap", "anytap", "tap"], + doubletap: ["anytap"], + anytap: ["tap"] + }; + var RECOGNIZER_FALLBACK_MAP = { + doubletap: ["tap"] + }; + var BASIC_EVENT_ALIASES = { + pointerdown: "pointerdown", + pointermove: "pointermove", + pointerup: "pointerup", + touchstart: "pointerdown", + touchmove: "pointermove", + touchend: "pointerup", + mousedown: "pointerdown", + mousemove: "pointermove", + mouseup: "pointerup" + }; + var INPUT_EVENT_TYPES = { + KEY_EVENTS: ["keydown", "keyup"], + MOUSE_EVENTS: ["mousedown", "mousemove", "mouseup", "mouseover", "mouseout", "mouseleave"], + WHEEL_EVENTS: [ + // Chrome, Safari + "wheel", + // IE + "mousewheel" + ] + }; + var EVENT_RECOGNIZER_MAP = { + tap: "tap", + anytap: "anytap", + doubletap: "doubletap", + press: "press", + pinch: "pinch", + pinchin: "pinch", + pinchout: "pinch", + pinchstart: "pinch", + pinchmove: "pinch", + pinchend: "pinch", + pinchcancel: "pinch", + rotate: "rotate", + rotatestart: "rotate", + rotatemove: "rotate", + rotateend: "rotate", + rotatecancel: "rotate", + tripan: "tripan", + tripanstart: "tripan", + tripanmove: "tripan", + tripanup: "tripan", + tripandown: "tripan", + tripanleft: "tripan", + tripanright: "tripan", + tripanend: "tripan", + tripancancel: "tripan", + pan: "pan", + panstart: "pan", + panmove: "pan", + panup: "pan", + pandown: "pan", + panleft: "pan", + panright: "pan", + panend: "pan", + pancancel: "pan", + swipe: "swipe", + swipeleft: "swipe", + swiperight: "swipe", + swipeup: "swipe", + swipedown: "swipe" + }; + var GESTURE_EVENT_ALIASES = { + click: "tap", + anyclick: "anytap", + dblclick: "doubletap", + mousedown: "pointerdown", + mousemove: "pointermove", + mouseup: "pointerup", + mouseover: "pointerover", + mouseout: "pointerout", + mouseleave: "pointerleave" + }; + + // node_modules/mjolnir.js/dist/esm/utils/globals.js + var userAgent = typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent.toLowerCase() : ""; + var window_5 = typeof window !== "undefined" ? window : global; + var passiveSupported = false; + try { + const options = { + // This function will be called when the browser + // attempts to access the passive property. + get passive() { + passiveSupported = true; + return true; } - } - updateModelProps() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - varyings - } = this; - if (varyings.length > 0) { - props = Object.assign({}, props, { - varyings + }; + window_5.addEventListener("test", null, options); + window_5.removeEventListener("test", null); + } catch (err3) { + passiveSupported = false; + } + + // node_modules/mjolnir.js/dist/esm/inputs/wheel-input.js + var firefox = userAgent.indexOf("firefox") !== -1; + var { WHEEL_EVENTS } = INPUT_EVENT_TYPES; + var EVENT_TYPE = "wheel"; + var WHEEL_DELTA_MAGIC_SCALER = 4.000244140625; + var WHEEL_DELTA_PER_LINE = 40; + var SHIFT_MULTIPLIER = 0.25; + var WheelInput = class extends Input { + constructor(element, callback, options) { + super(element, callback, options); + this.handleEvent = (event) => { + if (!this.options.enable) { + return; + } + let value = event.deltaY; + if (window_5.WheelEvent) { + if (firefox && event.deltaMode === window_5.WheelEvent.DOM_DELTA_PIXEL) { + value /= window_5.devicePixelRatio; + } + if (event.deltaMode === window_5.WheelEvent.DOM_DELTA_LINE) { + value *= WHEEL_DELTA_PER_LINE; + } + } + if (value !== 0 && value % WHEEL_DELTA_MAGIC_SCALER === 0) { + value = Math.floor(value / WHEEL_DELTA_MAGIC_SCALER); + } + if (event.shiftKey && value) { + value = value * SHIFT_MULTIPLIER; + } + this.callback({ + type: EVENT_TYPE, + center: { + x: event.clientX, + y: event.clientY + }, + delta: -value, + srcEvent: event, + pointerType: "mouse", + target: event.target }); - } - return props; - } - getDrawOptions() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const binding = this.bindings[this.currentIndex]; - const { - sourceBuffers, - transformFeedback - } = binding; - const attributes = Object.assign({}, sourceBuffers, opts.attributes); - return { - attributes, - transformFeedback }; + this.events = (this.options.events || []).concat(WHEEL_EVENTS); + this.events.forEach((event) => element.addEventListener(event, this.handleEvent, passiveSupported ? { passive: false } : false)); } - swap() { - if (this.feedbackMap) { - this.currentIndex = this._getNextIndex(); - return true; + destroy() { + this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); + } + /** + * Enable this input (begin processing events) + * if the specified event type is among those handled by this input. + */ + enableEventType(eventType, enabled) { + if (eventType === EVENT_TYPE) { + this.options.enable = enabled; } - return false; } - update() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this._setupBuffers(opts); + }; + + // node_modules/mjolnir.js/dist/esm/inputs/move-input.js + var { MOUSE_EVENTS } = INPUT_EVENT_TYPES; + var MOVE_EVENT_TYPE = "pointermove"; + var OVER_EVENT_TYPE = "pointerover"; + var OUT_EVENT_TYPE = "pointerout"; + var ENTER_EVENT_TYPE = "pointerenter"; + var LEAVE_EVENT_TYPE = "pointerleave"; + var MoveInput = class extends Input { + constructor(element, callback, options) { + super(element, callback, options); + this.handleEvent = (event) => { + this.handleOverEvent(event); + this.handleOutEvent(event); + this.handleEnterEvent(event); + this.handleLeaveEvent(event); + this.handleMoveEvent(event); + }; + this.pressed = false; + const { enable: enable2 } = this.options; + this.enableMoveEvent = enable2; + this.enableLeaveEvent = enable2; + this.enableEnterEvent = enable2; + this.enableOutEvent = enable2; + this.enableOverEvent = enable2; + this.events = (this.options.events || []).concat(MOUSE_EVENTS); + this.events.forEach((event) => element.addEventListener(event, this.handleEvent)); } - getBuffer(varyingName) { - const { - feedbackBuffers - } = this.bindings[this.currentIndex]; - const bufferOrParams = varyingName ? feedbackBuffers[varyingName] : null; - if (!bufferOrParams) { - return null; - } - return bufferOrParams instanceof Buffer2 ? bufferOrParams : bufferOrParams.buffer; + destroy() { + this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); } - getData() { - let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - varyingName - } = options; - const buffer = this.getBuffer(varyingName); - if (buffer) { - return buffer.getData(); + /** + * Enable this input (begin processing events) + * if the specified event type is among those handled by this input. + */ + enableEventType(eventType, enabled) { + if (eventType === MOVE_EVENT_TYPE) { + this.enableMoveEvent = enabled; } - return null; - } - delete() { - for (const name in this.resources) { - this.resources[name].delete(); + if (eventType === OVER_EVENT_TYPE) { + this.enableOverEvent = enabled; } - } - _initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this._setupBuffers(props); - this.varyings = props.varyings || Object.keys(this.bindings[this.currentIndex].feedbackBuffers); - if (this.varyings.length > 0) { - assert6(isWebGL2(this.gl)); + if (eventType === OUT_EVENT_TYPE) { + this.enableOutEvent = enabled; } - } - _getFeedbackBuffers(props) { - const { - sourceBuffers = {} - } = props; - const feedbackBuffers = {}; - if (this.bindings[this.currentIndex]) { - Object.assign(feedbackBuffers, this.bindings[this.currentIndex].feedbackBuffers); + if (eventType === ENTER_EVENT_TYPE) { + this.enableEnterEvent = enabled; } - if (this.feedbackMap) { - for (const sourceName in this.feedbackMap) { - const feedbackName = this.feedbackMap[sourceName]; - if (sourceName in sourceBuffers) { - feedbackBuffers[feedbackName] = sourceName; - } - } + if (eventType === LEAVE_EVENT_TYPE) { + this.enableLeaveEvent = enabled; } - Object.assign(feedbackBuffers, props.feedbackBuffers); - for (const bufferName in feedbackBuffers) { - const bufferOrRef = feedbackBuffers[bufferName]; - if (typeof bufferOrRef === "string") { - const sourceBuffer = sourceBuffers[bufferOrRef]; - const { - byteLength, - usage, - accessor - } = sourceBuffer; - feedbackBuffers[bufferName] = this._createNewBuffer(bufferName, { - byteLength, - usage, - accessor - }); + } + handleOverEvent(event) { + if (this.enableOverEvent) { + if (event.type === "mouseover") { + this._emit(OVER_EVENT_TYPE, event); } } - return feedbackBuffers; - } - _setupBuffers() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - sourceBuffers = null - } = props; - Object.assign(this.feedbackMap, props.feedbackMap); - const feedbackBuffers = this._getFeedbackBuffers(props); - this._updateBindings({ - sourceBuffers, - feedbackBuffers - }); - } - _setupTransformFeedback(binding, _ref) { - let { - model - } = _ref; - const { - program - } = model; - binding.transformFeedback = new TransformFeedback(this.gl, { - program, - buffers: binding.feedbackBuffers - }); } - _updateBindings(opts) { - this.bindings[this.currentIndex] = this._updateBinding(this.bindings[this.currentIndex], opts); - if (this.feedbackMap) { - const { - sourceBuffers, - feedbackBuffers - } = this._swapBuffers(this.bindings[this.currentIndex]); - const nextIndex = this._getNextIndex(); - this.bindings[nextIndex] = this._updateBinding(this.bindings[nextIndex], { - sourceBuffers, - feedbackBuffers - }); + handleOutEvent(event) { + if (this.enableOutEvent) { + if (event.type === "mouseout") { + this._emit(OUT_EVENT_TYPE, event); + } } } - _updateBinding(binding, opts) { - if (!binding) { - return { - sourceBuffers: Object.assign({}, opts.sourceBuffers), - feedbackBuffers: Object.assign({}, opts.feedbackBuffers) - }; - } - Object.assign(binding.sourceBuffers, opts.sourceBuffers); - Object.assign(binding.feedbackBuffers, opts.feedbackBuffers); - if (binding.transformFeedback) { - binding.transformFeedback.setBuffers(binding.feedbackBuffers); + handleEnterEvent(event) { + if (this.enableEnterEvent) { + if (event.type === "mouseenter") { + this._emit(ENTER_EVENT_TYPE, event); + } } - return binding; } - _swapBuffers(opts) { - if (!this.feedbackMap) { - return null; - } - const sourceBuffers = Object.assign({}, opts.sourceBuffers); - const feedbackBuffers = Object.assign({}, opts.feedbackBuffers); - for (const srcName in this.feedbackMap) { - const dstName = this.feedbackMap[srcName]; - sourceBuffers[srcName] = opts.feedbackBuffers[dstName]; - feedbackBuffers[dstName] = opts.sourceBuffers[srcName]; - assert6(feedbackBuffers[dstName] instanceof Buffer2); + handleLeaveEvent(event) { + if (this.enableLeaveEvent) { + if (event.type === "mouseleave") { + this._emit(LEAVE_EVENT_TYPE, event); + } } - return { - sourceBuffers, - feedbackBuffers - }; } - _createNewBuffer(name, opts) { - const buffer = new Buffer2(this.gl, opts); - if (this.resources[name]) { - this.resources[name].delete(); + handleMoveEvent(event) { + if (this.enableMoveEvent) { + switch (event.type) { + case "mousedown": + if (event.button >= 0) { + this.pressed = true; + } + break; + case "mousemove": + if (event.which === 0) { + this.pressed = false; + } + if (!this.pressed) { + this._emit(MOVE_EVENT_TYPE, event); + } + break; + case "mouseup": + this.pressed = false; + break; + default: + } } - this.resources[name] = buffer; - return buffer; } - _getNextIndex() { - return (this.currentIndex + 1) % 2; + _emit(type, event) { + this.callback({ + type, + center: { + x: event.clientX, + y: event.clientY + }, + srcEvent: event, + pointerType: "mouse", + target: event.target + }); } }; - // node_modules/@luma.gl/engine/dist/esm/transform/transform-shader-utils.js - var SAMPLER_UNIFORM_PREFIX = "transform_uSampler_"; - var SIZE_UNIFORM_PREFIX = "transform_uSize_"; - var VS_POS_VARIABLE = "transform_position"; - function updateForTextures(_ref) { - let { - vs: vs7, - sourceTextureMap, - targetTextureVarying, - targetTexture - } = _ref; - const texAttributeNames = Object.keys(sourceTextureMap); - let sourceCount = texAttributeNames.length; - let targetTextureType = null; - const samplerTextureMap = {}; - let updatedVs = vs7; - let finalInject = {}; - if (sourceCount > 0 || targetTextureVarying) { - const vsLines = updatedVs.split("\n"); - const updateVsLines = vsLines.slice(); - vsLines.forEach((line, index, lines) => { - if (sourceCount > 0) { - const updated = processAttributeDefinition(line, sourceTextureMap); - if (updated) { - const { - updatedLine, - inject - } = updated; - updateVsLines[index] = updatedLine; - finalInject = combineInjects([finalInject, inject]); - Object.assign(samplerTextureMap, updated.samplerTextureMap); - sourceCount--; - } - } - if (targetTextureVarying && !targetTextureType) { - targetTextureType = getVaryingType(line, targetTextureVarying); + // node_modules/mjolnir.js/dist/esm/inputs/key-input.js + var { KEY_EVENTS } = INPUT_EVENT_TYPES; + var DOWN_EVENT_TYPE = "keydown"; + var UP_EVENT_TYPE = "keyup"; + var KeyInput = class extends Input { + constructor(element, callback, options) { + super(element, callback, options); + this.handleEvent = (event) => { + const targetElement = event.target || event.srcElement; + if (targetElement.tagName === "INPUT" && targetElement.type === "text" || targetElement.tagName === "TEXTAREA") { + return; } - }); - if (targetTextureVarying) { - assert6(targetTexture); - const sizeName = "".concat(SIZE_UNIFORM_PREFIX).concat(targetTextureVarying); - const uniformDeclaration = "uniform vec2 ".concat(sizeName, ";\n"); - const posInstructions = " vec2 ".concat(VS_POS_VARIABLE, " = transform_getPos(").concat(sizeName, ");\n gl_Position = vec4(").concat(VS_POS_VARIABLE, ", 0, 1.);\n"); - const inject = { - "vs:#decl": uniformDeclaration, - "vs:#main-start": posInstructions - }; - finalInject = combineInjects([finalInject, inject]); - } - updatedVs = updateVsLines.join("\n"); - } - return { - vs: updatedVs, - targetTextureType, - inject: finalInject, - samplerTextureMap - }; - } - function getSizeUniforms(_ref2) { - let { - sourceTextureMap, - targetTextureVarying, - targetTexture - } = _ref2; - const uniforms = {}; - let width; - let height; - if (targetTextureVarying) { - ({ - width, - height - } = targetTexture); - uniforms["".concat(SIZE_UNIFORM_PREFIX).concat(targetTextureVarying)] = [width, height]; - } - for (const textureName in sourceTextureMap) { - ({ - width, - height - } = sourceTextureMap[textureName]); - uniforms["".concat(SIZE_UNIFORM_PREFIX).concat(textureName)] = [width, height]; - } - return uniforms; - } - function getAttributeDefinition(line) { - return getQualifierDetails(line, ["attribute", "in"]); - } - function getSamplerDeclerations(textureName) { - const samplerName = "".concat(SAMPLER_UNIFORM_PREFIX).concat(textureName); - const sizeName = "".concat(SIZE_UNIFORM_PREFIX).concat(textureName); - const uniformDeclerations = " uniform sampler2D ".concat(samplerName, ";\n uniform vec2 ").concat(sizeName, ";"); - return { - samplerName, - sizeName, - uniformDeclerations - }; - } - function getVaryingType(line, varying) { - const qualaiferDetails = getQualifierDetails(line, ["varying", "out"]); - if (!qualaiferDetails) { - return null; - } - return qualaiferDetails.name === varying ? qualaiferDetails.type : null; - } - function processAttributeDefinition(line, textureMap) { - const samplerTextureMap = {}; - const attributeData = getAttributeDefinition(line); - if (!attributeData) { - return null; - } - const { - type, - name - } = attributeData; - if (name && textureMap[name]) { - const updatedLine = "// ".concat(line, " => Replaced by Transform with a sampler"); - const { - samplerName, - sizeName, - uniformDeclerations - } = getSamplerDeclerations(name); - const channels = typeToChannelSuffix(type); - const sampleInstruction = " ".concat(type, " ").concat(name, " = transform_getInput(").concat(samplerName, ", ").concat(sizeName, ").").concat(channels, ";\n"); - samplerTextureMap[samplerName] = name; - const inject = { - "vs:#decl": uniformDeclerations, - "vs:#main-start": sampleInstruction - }; - return { - updatedLine, - inject, - samplerTextureMap - }; - } - return null; - } - - // node_modules/@luma.gl/engine/dist/esm/transform/texture-transform.js - var SRC_TEX_PARAMETER_OVERRIDES = { - [10241]: 9728, - [10240]: 9728, - [10242]: 33071, - [10243]: 33071 - }; - var FS_OUTPUT_VARIABLE = "transform_output"; - var TextureTransform = class { - constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - this.gl = gl; - this.id = this.currentIndex = 0; - this._swapTexture = null; - this.targetTextureVarying = null; - this.targetTextureType = null; - this.samplerTextureMap = null; - this.bindings = []; - this.resources = {}; - this._initialize(props); - Object.seal(this); + if (this.enableDownEvent && event.type === "keydown") { + this.callback({ + type: DOWN_EVENT_TYPE, + srcEvent: event, + key: event.key, + target: event.target + }); + } + if (this.enableUpEvent && event.type === "keyup") { + this.callback({ + type: UP_EVENT_TYPE, + srcEvent: event, + key: event.key, + target: event.target + }); + } + }; + this.enableDownEvent = this.options.enable; + this.enableUpEvent = this.options.enable; + this.events = (this.options.events || []).concat(KEY_EVENTS); + element.tabIndex = this.options.tabIndex || 0; + element.style.outline = "none"; + this.events.forEach((event) => element.addEventListener(event, this.handleEvent)); } - updateModelProps() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const updatedModelProps = this._processVertexShader(props); - return Object.assign({}, props, updatedModelProps); + destroy() { + this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); } - getDrawOptions() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - sourceBuffers, - sourceTextures, - framebuffer, - targetTexture - } = this.bindings[this.currentIndex]; - const attributes = Object.assign({}, sourceBuffers, opts.attributes); - const uniforms = Object.assign({}, opts.uniforms); - const parameters = Object.assign({}, opts.parameters); - let discard = opts.discard; - if (this.hasSourceTextures || this.hasTargetTexture) { - attributes.transform_elementID = this.elementIDBuffer; - for (const sampler in this.samplerTextureMap) { - const textureName = this.samplerTextureMap[sampler]; - uniforms[sampler] = sourceTextures[textureName]; - } - this._setSourceTextureParameters(); - const sizeUniforms = getSizeUniforms({ - sourceTextureMap: sourceTextures, - targetTextureVarying: this.targetTextureVarying, - targetTexture - }); - Object.assign(uniforms, sizeUniforms); + /** + * Enable this input (begin processing events) + * if the specified event type is among those handled by this input. + */ + enableEventType(eventType, enabled) { + if (eventType === DOWN_EVENT_TYPE) { + this.enableDownEvent = enabled; } - if (this.hasTargetTexture) { - discard = false; - parameters.viewport = [0, 0, framebuffer.width, framebuffer.height]; + if (eventType === UP_EVENT_TYPE) { + this.enableUpEvent = enabled; } - return { - attributes, - framebuffer, - uniforms, - discard, - parameters + } + }; + + // node_modules/mjolnir.js/dist/esm/inputs/contextmenu-input.js + var EVENT_TYPE2 = "contextmenu"; + var ContextmenuInput = class extends Input { + constructor(element, callback, options) { + super(element, callback, options); + this.handleEvent = (event) => { + if (!this.options.enable) { + return; + } + this.callback({ + type: EVENT_TYPE2, + center: { + x: event.clientX, + y: event.clientY + }, + srcEvent: event, + pointerType: "mouse", + target: event.target + }); }; + element.addEventListener("contextmenu", this.handleEvent); } - swap() { - if (this._swapTexture) { - this.currentIndex = this._getNextIndex(); - return true; + destroy() { + this.element.removeEventListener("contextmenu", this.handleEvent); + } + /** + * Enable this input (begin processing events) + * if the specified event type is among those handled by this input. + */ + enableEventType(eventType, enabled) { + if (eventType === EVENT_TYPE2) { + this.options.enable = enabled; } - return false; } - update() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - this._setupTextures(opts); + }; + + // node_modules/mjolnir.js/dist/esm/utils/event-utils.js + var DOWN_EVENT = 1; + var MOVE_EVENT = 2; + var UP_EVENT = 4; + var MOUSE_EVENTS2 = { + pointerdown: DOWN_EVENT, + pointermove: MOVE_EVENT, + pointerup: UP_EVENT, + mousedown: DOWN_EVENT, + mousemove: MOVE_EVENT, + mouseup: UP_EVENT + }; + var MOUSE_EVENT_WHICH_LEFT = 1; + var MOUSE_EVENT_WHICH_MIDDLE = 2; + var MOUSE_EVENT_WHICH_RIGHT = 3; + var MOUSE_EVENT_BUTTON_LEFT = 0; + var MOUSE_EVENT_BUTTON_MIDDLE = 1; + var MOUSE_EVENT_BUTTON_RIGHT = 2; + var MOUSE_EVENT_BUTTONS_LEFT_MASK = 1; + var MOUSE_EVENT_BUTTONS_RIGHT_MASK = 2; + var MOUSE_EVENT_BUTTONS_MIDDLE_MASK = 4; + function whichButtons(event) { + const eventType = MOUSE_EVENTS2[event.srcEvent.type]; + if (!eventType) { + return null; } - getTargetTexture() { - const { - targetTexture - } = this.bindings[this.currentIndex]; - return targetTexture; + const { buttons, button, which } = event.srcEvent; + let leftButton = false; + let middleButton = false; + let rightButton = false; + if ( + // button is up, need to find out which one was pressed before + eventType === UP_EVENT || // moving but does not support `buttons` API + eventType === MOVE_EVENT && !Number.isFinite(buttons) + ) { + leftButton = which === MOUSE_EVENT_WHICH_LEFT; + middleButton = which === MOUSE_EVENT_WHICH_MIDDLE; + rightButton = which === MOUSE_EVENT_WHICH_RIGHT; + } else if (eventType === MOVE_EVENT) { + leftButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_LEFT_MASK); + middleButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_MIDDLE_MASK); + rightButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_RIGHT_MASK); + } else if (eventType === DOWN_EVENT) { + leftButton = button === MOUSE_EVENT_BUTTON_LEFT; + middleButton = button === MOUSE_EVENT_BUTTON_MIDDLE; + rightButton = button === MOUSE_EVENT_BUTTON_RIGHT; } - getData() { - let { - packed = false - } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - framebuffer - } = this.bindings[this.currentIndex]; - const pixels = readPixelsToArray(framebuffer); - if (!packed) { - return pixels; - } - const ArrayType = pixels.constructor; - const channelCount = typeToChannelCount(this.targetTextureType); - const packedPixels = new ArrayType(pixels.length * channelCount / 4); - let packCount = 0; - for (let i2 = 0; i2 < pixels.length; i2 += 4) { - for (let j = 0; j < channelCount; j++) { - packedPixels[packCount++] = pixels[i2 + j]; + return { leftButton, middleButton, rightButton }; + } + function getOffsetPosition(event, rootElement) { + const center = event.center; + if (!center) { + return null; + } + const rect = rootElement.getBoundingClientRect(); + const scaleX2 = rect.width / rootElement.offsetWidth || 1; + const scaleY2 = rect.height / rootElement.offsetHeight || 1; + const offsetCenter = { + x: (center.x - rect.left - rootElement.clientLeft) / scaleX2, + y: (center.y - rect.top - rootElement.clientTop) / scaleY2 + }; + return { center, offsetCenter }; + } + + // node_modules/mjolnir.js/dist/esm/utils/event-registrar.js + var DEFAULT_OPTIONS = { + srcElement: "root", + priority: 0 + }; + var EventRegistrar = class { + constructor(eventManager) { + this.handleEvent = (event) => { + if (this.isEmpty()) { + return; } - } - return packedPixels; + const mjolnirEvent = this._normalizeEvent(event); + let target = event.srcEvent.target; + while (target && target !== mjolnirEvent.rootElement) { + this._emit(mjolnirEvent, target); + if (mjolnirEvent.handled) { + return; + } + target = target.parentNode; + } + this._emit(mjolnirEvent, "root"); + }; + this.eventManager = eventManager; + this.handlers = []; + this.handlersByElement = /* @__PURE__ */ new Map(); + this._active = false; } - getFramebuffer() { - const currentResources = this.bindings[this.currentIndex]; - return currentResources.framebuffer; + // Returns true if there are no non-passive handlers + isEmpty() { + return !this._active; } - delete() { - if (this.ownTexture) { - this.ownTexture.delete(); + add(type, handler, options, once = false, passive = false) { + const { handlers, handlersByElement } = this; + let opts = DEFAULT_OPTIONS; + if (typeof options === "string" || options && options.addEventListener) { + opts = { ...DEFAULT_OPTIONS, srcElement: options }; + } else if (options) { + opts = { ...DEFAULT_OPTIONS, ...options }; } - if (this.elementIDBuffer) { - this.elementIDBuffer.delete(); + let entries = handlersByElement.get(opts.srcElement); + if (!entries) { + entries = []; + handlersByElement.set(opts.srcElement, entries); } - } - _initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - _targetTextureVarying, - _swapTexture - } = props; - this._swapTexture = _swapTexture; - this.targetTextureVarying = _targetTextureVarying; - this.hasTargetTexture = _targetTextureVarying; - this._setupTextures(props); - } - _createTargetTexture(props) { - const { - sourceTextures, - textureOrReference - } = props; - if (textureOrReference instanceof Texture2D) { - return textureOrReference; + const entry = { + type, + handler, + srcElement: opts.srcElement, + priority: opts.priority + }; + if (once) { + entry.once = true; } - const refTexture = sourceTextures[textureOrReference]; - if (!refTexture) { - return null; + if (passive) { + entry.passive = true; } - this._targetRefTexName = textureOrReference; - return this._createNewTexture(refTexture); - } - _setupTextures() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - sourceBuffers, - _sourceTextures = {}, - _targetTexture - } = props; - const targetTexture = this._createTargetTexture({ - sourceTextures: _sourceTextures, - textureOrReference: _targetTexture - }); - this.hasSourceTextures = this.hasSourceTextures || _sourceTextures && Object.keys(_sourceTextures).length > 0; - this._updateBindings({ - sourceBuffers, - sourceTextures: _sourceTextures, - targetTexture - }); - if ("elementCount" in props) { - this._updateElementIDBuffer(props.elementCount); + handlers.push(entry); + this._active = this._active || !entry.passive; + let insertPosition = entries.length - 1; + while (insertPosition >= 0) { + if (entries[insertPosition].priority >= entry.priority) { + break; + } + insertPosition--; } + entries.splice(insertPosition + 1, 0, entry); } - _updateElementIDBuffer(elementCount) { - if (typeof elementCount !== "number" || this.elementCount >= elementCount) { - return; - } - const elementIds = new Float32Array(elementCount); - elementIds.forEach((_2, index, array) => { - array[index] = index; - }); - if (!this.elementIDBuffer) { - this.elementIDBuffer = new Buffer2(this.gl, { - data: elementIds, - accessor: { - size: 1 + remove(type, handler) { + const { handlers, handlersByElement } = this; + for (let i3 = handlers.length - 1; i3 >= 0; i3--) { + const entry = handlers[i3]; + if (entry.type === type && entry.handler === handler) { + handlers.splice(i3, 1); + const entries = handlersByElement.get(entry.srcElement); + entries.splice(entries.indexOf(entry), 1); + if (entries.length === 0) { + handlersByElement.delete(entry.srcElement); } - }); - } else { - this.elementIDBuffer.setData({ - data: elementIds - }); - } - this.elementCount = elementCount; - } - _updateBindings(opts) { - this.bindings[this.currentIndex] = this._updateBinding(this.bindings[this.currentIndex], opts); - if (this._swapTexture) { - const { - sourceTextures, - targetTexture - } = this._swapTextures(this.bindings[this.currentIndex]); - const nextIndex = this._getNextIndex(); - this.bindings[nextIndex] = this._updateBinding(this.bindings[nextIndex], { - sourceTextures, - targetTexture - }); + } } + this._active = handlers.some((entry) => !entry.passive); } - _updateBinding(binding, opts) { - const { - sourceBuffers, - sourceTextures, - targetTexture - } = opts; - if (!binding) { - binding = { - sourceBuffers: {}, - sourceTextures: {}, - targetTexture: null + /** + * Invoke handlers on a particular element + */ + _emit(event, srcElement) { + const entries = this.handlersByElement.get(srcElement); + if (entries) { + let immediatePropagationStopped = false; + const stopPropagation = () => { + event.handled = true; }; - } - Object.assign(binding.sourceTextures, sourceTextures); - Object.assign(binding.sourceBuffers, sourceBuffers); - if (targetTexture) { - binding.targetTexture = targetTexture; - const { - width, - height - } = targetTexture; - const { - framebuffer - } = binding; - if (framebuffer) { - framebuffer.update({ - attachments: { - [36064]: targetTexture - }, - resizeAttachments: false - }); - framebuffer.resize({ - width, - height - }); - } else { - binding.framebuffer = new Framebuffer(this.gl, { - id: "transform-framebuffer", - width, - height, - attachments: { - [36064]: targetTexture - } + const stopImmediatePropagation = () => { + event.handled = true; + immediatePropagationStopped = true; + }; + const entriesToRemove = []; + for (let i3 = 0; i3 < entries.length; i3++) { + const { type, handler, once } = entries[i3]; + handler({ + ...event, + // @ts-ignore + type, + stopPropagation, + stopImmediatePropagation }); + if (once) { + entriesToRemove.push(entries[i3]); + } + if (immediatePropagationStopped) { + break; + } } - } - return binding; - } - _setSourceTextureParameters() { - const index = this.currentIndex; - const { - sourceTextures - } = this.bindings[index]; - for (const name in sourceTextures) { - sourceTextures[name].setParameters(SRC_TEX_PARAMETER_OVERRIDES); - } - } - _swapTextures(opts) { - if (!this._swapTexture) { - return null; - } - const sourceTextures = Object.assign({}, opts.sourceTextures); - sourceTextures[this._swapTexture] = opts.targetTexture; - const targetTexture = opts.sourceTextures[this._swapTexture]; - return { - sourceTextures, - targetTexture - }; - } - _createNewTexture(refTexture) { - const texture = cloneTextureFrom(refTexture, { - parameters: { - [10241]: 9728, - [10240]: 9728, - [10242]: 33071, - [10243]: 33071 - }, - pixelStore: { - [37440]: false + for (let i3 = 0; i3 < entriesToRemove.length; i3++) { + const { type, handler } = entriesToRemove[i3]; + this.remove(type, handler); } - }); - if (this.ownTexture) { - this.ownTexture.delete(); } - this.ownTexture = texture; - return texture; - } - _getNextIndex() { - return (this.currentIndex + 1) % 2; } - _processVertexShader() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - sourceTextures, - targetTexture - } = this.bindings[this.currentIndex]; - const { - vs: vs7, - uniforms, - targetTextureType, - inject, - samplerTextureMap - } = updateForTextures({ - vs: props.vs, - sourceTextureMap: sourceTextures, - targetTextureVarying: this.targetTextureVarying, - targetTexture - }); - const combinedInject = combineInjects([props.inject || {}, inject]); - this.targetTextureType = targetTextureType; - this.samplerTextureMap = samplerTextureMap; - const fs4 = props._fs || getPassthroughFS({ - version: getShaderVersion(vs7), - input: this.targetTextureVarying, - inputType: targetTextureType, - output: FS_OUTPUT_VARIABLE - }); - const modules = this.hasSourceTextures || this.targetTextureVarying ? [transform].concat(props.modules || []) : props.modules; + /** + * Normalizes hammerjs and custom events to have predictable fields. + */ + _normalizeEvent(event) { + const rootElement = this.eventManager.getElement(); return { - vs: vs7, - fs: fs4, - modules, - uniforms, - inject: combinedInject + ...event, + ...whichButtons(event), + ...getOffsetPosition(event, rootElement), + preventDefault: () => { + event.srcEvent.preventDefault(); + }, + stopImmediatePropagation: null, + stopPropagation: null, + handled: false, + rootElement }; } }; - - // node_modules/@luma.gl/engine/dist/esm/transform/transform.js - var Transform = class { - static isSupported(gl) { - return isWebGL2(gl); + + // node_modules/mjolnir.js/dist/esm/event-manager.js + var DEFAULT_OPTIONS2 = { + // event handlers + events: null, + // custom recognizers + recognizers: null, + recognizerOptions: {}, + // Manager class + Manager: Manager2, + // allow browser default touch action + // https://github.com/uber/react-map-gl/issues/506 + touchAction: "none", + tabIndex: 0 + }; + var EventManager = class { + constructor(element = null, options) { + this._onBasicInput = (event) => { + const { srcEvent } = event; + const alias = BASIC_EVENT_ALIASES[srcEvent.type]; + if (alias) { + this.manager.emit(alias, event); + } + }; + this._onOtherEvent = (event) => { + this.manager.emit(event.type, event); + }; + this.options = { ...DEFAULT_OPTIONS2, ...options }; + this.events = /* @__PURE__ */ new Map(); + this.setElement(element); + const { events } = this.options; + if (events) { + this.on(events); + } } - constructor(gl) { - let props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; - this.gl = gl; - this.model = null; - this.elementCount = 0; - this.bufferTransform = null; - this.textureTransform = null; - this.elementIDBuffer = null; - this._initialize(props); - Object.seal(this); + getElement() { + return this.element; } - delete() { - const { - model, - bufferTransform, - textureTransform - } = this; - if (model) { - model.delete(); - } - if (bufferTransform) { - bufferTransform.delete(); + setElement(element) { + if (this.element) { + this.destroy(); } - if (textureTransform) { - textureTransform.delete(); + this.element = element; + if (!element) { + return; } - } - run() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - clearRenderTarget = true - } = opts; - const updatedOpts = this._updateDrawOptions(opts); - if (clearRenderTarget && updatedOpts.framebuffer) { - updatedOpts.framebuffer.clear({ - color: true + const { options } = this; + const ManagerClass = options.Manager; + this.manager = new ManagerClass(element, { + touchAction: options.touchAction, + recognizers: options.recognizers || RECOGNIZERS + }).on("hammer.input", this._onBasicInput); + if (!options.recognizers) { + Object.keys(RECOGNIZER_COMPATIBLE_MAP).forEach((name) => { + const recognizer = this.manager.get(name); + if (recognizer) { + RECOGNIZER_COMPATIBLE_MAP[name].forEach((otherName) => { + recognizer.recognizeWith(otherName); + }); + } }); } - this.model.transform(updatedOpts); + for (const recognizerName in options.recognizerOptions) { + const recognizer = this.manager.get(recognizerName); + if (recognizer) { + const recognizerOption = options.recognizerOptions[recognizerName]; + delete recognizerOption.enable; + recognizer.set(recognizerOption); + } + } + this.wheelInput = new WheelInput(element, this._onOtherEvent, { + enable: false + }); + this.moveInput = new MoveInput(element, this._onOtherEvent, { + enable: false + }); + this.keyInput = new KeyInput(element, this._onOtherEvent, { + enable: false, + tabIndex: options.tabIndex + }); + this.contextmenuInput = new ContextmenuInput(element, this._onOtherEvent, { + enable: false + }); + for (const [eventAlias, eventRegistrar] of this.events) { + if (!eventRegistrar.isEmpty()) { + this._toggleRecognizer(eventRegistrar.recognizerName, true); + this.manager.on(eventAlias, eventRegistrar.handleEvent); + } + } } - swap() { - let swapped = false; - const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); - for (const resourceTransform of resourceTransforms) { - swapped = swapped || resourceTransform.swap(); + // Tear down internal event management implementations. + destroy() { + if (this.element) { + this.wheelInput.destroy(); + this.moveInput.destroy(); + this.keyInput.destroy(); + this.contextmenuInput.destroy(); + this.manager.destroy(); + this.wheelInput = null; + this.moveInput = null; + this.keyInput = null; + this.contextmenuInput = null; + this.manager = null; + this.element = null; } - assert6(swapped, "Nothing to swap"); } - getBuffer() { - let varyingName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null; - return this.bufferTransform && this.bufferTransform.getBuffer(varyingName); + /** Register an event handler function to be called on `event` */ + on(event, handler, opts) { + this._addEventHandler(event, handler, opts, false); } - getData() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); - for (const resourceTransform of resourceTransforms) { - const data = resourceTransform.getData(opts); - if (data) { - return data; - } - } - return null; + once(event, handler, opts) { + this._addEventHandler(event, handler, opts, true); } - getFramebuffer() { - return this.textureTransform && this.textureTransform.getFramebuffer(); + watch(event, handler, opts) { + this._addEventHandler(event, handler, opts, false, true); } - update() { - let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - if ("elementCount" in opts) { - this.model.setVertexCount(opts.elementCount); + off(event, handler) { + this._removeEventHandler(event, handler); + } + /* + * Enable/disable recognizer for the given event + */ + _toggleRecognizer(name, enabled) { + const { manager } = this; + if (!manager) { + return; } - const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); - for (const resourceTransform of resourceTransforms) { - resourceTransform.update(opts); + const recognizer = manager.get(name); + if (recognizer && recognizer.options.enable !== enabled) { + recognizer.set({ enable: enabled }); + const fallbackRecognizers = RECOGNIZER_FALLBACK_MAP[name]; + if (fallbackRecognizers && !this.options.recognizers) { + fallbackRecognizers.forEach((otherName) => { + const otherRecognizer = manager.get(otherName); + if (enabled) { + otherRecognizer.requireFailure(name); + recognizer.dropRequireFailure(otherName); + } else { + otherRecognizer.dropRequireFailure(name); + } + }); + } } + this.wheelInput.enableEventType(name, enabled); + this.moveInput.enableEventType(name, enabled); + this.keyInput.enableEventType(name, enabled); + this.contextmenuInput.enableEventType(name, enabled); } - _initialize() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - gl - } = this; - this._buildResourceTransforms(gl, props); - props = this._updateModelProps(props); - this.model = new Model(gl, Object.assign({}, props, { - fs: props.fs || getPassthroughFS({ - version: getShaderVersion(props.vs) - }), - id: props.id || "transform-model", - drawMode: props.drawMode || 0, - vertexCount: props.elementCount - })); - this.bufferTransform && this.bufferTransform.setupResources({ - model: this.model - }); - } - _updateModelProps(props) { - let updatedProps = Object.assign({}, props); - const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); - for (const resourceTransform of resourceTransforms) { - updatedProps = resourceTransform.updateModelProps(updatedProps); + /** + * Process the event registration for a single event + handler. + */ + _addEventHandler(event, handler, opts, once, passive) { + if (typeof event !== "string") { + opts = handler; + for (const eventName in event) { + this._addEventHandler(eventName, event[eventName], opts, once, passive); + } + return; } - return updatedProps; - } - _buildResourceTransforms(gl, props) { - if (canCreateBufferTransform(props)) { - this.bufferTransform = new BufferTransform(gl, props); + const { manager, events } = this; + const eventAlias = GESTURE_EVENT_ALIASES[event] || event; + let eventRegistrar = events.get(eventAlias); + if (!eventRegistrar) { + eventRegistrar = new EventRegistrar(this); + events.set(eventAlias, eventRegistrar); + eventRegistrar.recognizerName = EVENT_RECOGNIZER_MAP[eventAlias] || eventAlias; + if (manager) { + manager.on(eventAlias, eventRegistrar.handleEvent); + } } - if (canCreateTextureTransform(props)) { - this.textureTransform = new TextureTransform(gl, props); + eventRegistrar.add(event, handler, opts, once, passive); + if (!eventRegistrar.isEmpty()) { + this._toggleRecognizer(eventRegistrar.recognizerName, true); } - assert6(this.bufferTransform || this.textureTransform, "must provide source/feedback buffers or source/target textures"); } - _updateDrawOptions(opts) { - let updatedOpts = Object.assign({}, opts); - const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean); - for (const resourceTransform of resourceTransforms) { - updatedOpts = Object.assign(updatedOpts, resourceTransform.getDrawOptions(updatedOpts)); + /** + * Process the event deregistration for a single event + handler. + */ + _removeEventHandler(event, handler) { + if (typeof event !== "string") { + for (const eventName in event) { + this._removeEventHandler(eventName, event[eventName]); + } + return; + } + const { events } = this; + const eventAlias = GESTURE_EVENT_ALIASES[event] || event; + const eventRegistrar = events.get(eventAlias); + if (!eventRegistrar) { + return; + } + eventRegistrar.remove(event, handler); + if (eventRegistrar.isEmpty()) { + const { recognizerName } = eventRegistrar; + let isRecognizerUsed = false; + for (const eh of events.values()) { + if (eh.recognizerName === recognizerName && !eh.isEmpty()) { + isRecognizerUsed = true; + break; + } + } + if (!isRecognizerUsed) { + this._toggleRecognizer(recognizerName, false); + } } - return updatedOpts; } }; - function canCreateBufferTransform(props) { - if (!isObjectEmpty2(props.feedbackBuffers) || !isObjectEmpty2(props.feedbackMap) || props.varyings && props.varyings.length > 0) { - return true; - } - return false; - } - function canCreateTextureTransform(props) { - if (!isObjectEmpty2(props._sourceTextures) || props._targetTexture || props._targetTextureVarying) { - return true; - } - return false; - } - // node_modules/@luma.gl/engine/dist/esm/geometry/geometry.js - var DRAW_MODE = { - POINTS: 0, - LINES: 1, - LINE_LOOP: 2, - LINE_STRIP: 3, - TRIANGLES: 4, - TRIANGLE_STRIP: 5, - TRIANGLE_FAN: 6 + // node_modules/@deck.gl/core/dist/esm/lib/deck.js + function noop4() { + } + var getCursor = ({ + isDragging + }) => isDragging ? "grabbing" : "grab"; + var defaultProps = { + id: "", + width: "100%", + height: "100%", + style: null, + viewState: null, + initialViewState: null, + pickingRadius: 0, + layerFilter: null, + glOptions: {}, + parameters: {}, + parent: null, + gl: null, + canvas: null, + layers: [], + effects: [], + views: null, + controller: null, + useDevicePixels: true, + touchAction: "none", + eventRecognizerOptions: {}, + _framebuffer: null, + _animate: false, + _pickable: true, + _typedArrayManagerProps: {}, + _customRender: null, + onWebGLInitialized: noop4, + onResize: noop4, + onViewStateChange: noop4, + onInteractionStateChange: noop4, + onBeforeRender: noop4, + onAfterRender: noop4, + onLoad: noop4, + onError: (error2) => log_default.error(error2.message, error2.cause)(), + onHover: null, + onClick: null, + onDragStart: null, + onDrag: null, + onDragEnd: null, + _onMetrics: null, + getCursor, + getTooltip: null, + debug: false, + drawPickingColors: false }; - var Geometry = class { - static get DRAW_MODE() { - return DRAW_MODE; - } - constructor() { - let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; - const { - id = uid("geometry"), - drawMode = DRAW_MODE.TRIANGLES, - attributes = {}, - indices = null, - vertexCount = null - } = props; - this.id = id; - this.drawMode = drawMode | 0; - this.attributes = {}; - this.userData = {}; - this._setAttributes(attributes, indices); - this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices); - } - get mode() { - return this.drawMode; - } - getVertexCount() { - return this.vertexCount; - } - getAttributes() { - return this.indices ? { - indices: this.indices, - ...this.attributes - } : this.attributes; - } - _print(attributeName) { - return "Geometry ".concat(this.id, " attribute ").concat(attributeName); - } - _setAttributes(attributes, indices) { - if (indices) { - this.indices = ArrayBuffer.isView(indices) ? { - value: indices, - size: 1 - } : indices; - } - for (const attributeName in attributes) { - let attribute = attributes[attributeName]; - attribute = ArrayBuffer.isView(attribute) ? { - value: attribute - } : attribute; - assert6(ArrayBuffer.isView(attribute.value), "".concat(this._print(attributeName), ": must be typed array or object with value as typed array")); - if ((attributeName === "POSITION" || attributeName === "positions") && !attribute.size) { - attribute.size = 3; - } - if (attributeName === "indices") { - assert6(!this.indices); - this.indices = attribute; + var Deck = class { + constructor(props) { + _defineProperty(this, "props", void 0); + _defineProperty(this, "width", 0); + _defineProperty(this, "height", 0); + _defineProperty(this, "userData", {}); + _defineProperty(this, "canvas", null); + _defineProperty(this, "viewManager", null); + _defineProperty(this, "layerManager", null); + _defineProperty(this, "effectManager", null); + _defineProperty(this, "deckRenderer", null); + _defineProperty(this, "deckPicker", null); + _defineProperty(this, "eventManager", null); + _defineProperty(this, "tooltip", null); + _defineProperty(this, "metrics", void 0); + _defineProperty(this, "animationLoop", void 0); + _defineProperty(this, "stats", void 0); + _defineProperty(this, "viewState", void 0); + _defineProperty(this, "cursorState", void 0); + _defineProperty(this, "_needsRedraw", void 0); + _defineProperty(this, "_pickRequest", void 0); + _defineProperty(this, "_lastPointerDownInfo", null); + _defineProperty(this, "_metricsCounter", void 0); + _defineProperty(this, "_onPointerMove", (event) => { + const { + _pickRequest + } = this; + if (event.type === "pointerleave") { + _pickRequest.x = -1; + _pickRequest.y = -1; + _pickRequest.radius = 0; + } else if (event.leftButton || event.rightButton) { + return; } else { - this.attributes[attributeName] = attribute; + const pos = event.offsetCenter; + if (!pos) { + return; + } + _pickRequest.x = pos.x; + _pickRequest.y = pos.y; + _pickRequest.radius = this.props.pickingRadius; } + if (this.layerManager) { + this.layerManager.context.mousePosition = { + x: _pickRequest.x, + y: _pickRequest.y + }; + } + _pickRequest.event = event; + }); + _defineProperty(this, "_onEvent", (event) => { + const eventOptions = EVENTS[event.type]; + const pos = event.offsetCenter; + if (!eventOptions || !pos || !this.layerManager) { + return; + } + const layers = this.layerManager.getLayers(); + const info = this.deckPicker.getLastPickedObject({ + x: pos.x, + y: pos.y, + layers, + viewports: this.getViewports(pos) + }, this._lastPointerDownInfo); + const { + layer + } = info; + const layerHandler = layer && (layer[eventOptions.handler] || layer.props[eventOptions.handler]); + const rootHandler = this.props[eventOptions.handler]; + let handled = false; + if (layerHandler) { + handled = layerHandler.call(layer, info, event); + } + if (!handled && rootHandler) { + rootHandler(info, event); + } + }); + _defineProperty(this, "_onPointerDown", (event) => { + const pos = event.offsetCenter; + const pickedInfo = this._pick("pickObject", "pickObject Time", { + x: pos.x, + y: pos.y, + radius: this.props.pickingRadius + }); + this._lastPointerDownInfo = pickedInfo.result[0] || pickedInfo.emptyInfo; + }); + this.props = { + ...defaultProps, + ...props + }; + props = this.props; + this._needsRedraw = "Initial render"; + this._pickRequest = { + mode: "hover", + x: -1, + y: -1, + radius: 0, + event: null + }; + this.cursorState = { + isHovering: false, + isDragging: false + }; + if (props.viewState && props.initialViewState) { + log_default.warn("View state tracking is disabled. Use either `initialViewState` for auto update or `viewState` for manual update.")(); } - if (this.indices && this.indices.isIndexed !== void 0) { - this.indices = Object.assign({}, this.indices); - delete this.indices.isIndexed; - } - return this; - } - _calculateVertexCount(attributes, indices) { - if (indices) { - return indices.value.length; + if (getBrowser() === "IE") { + log_default.warn("IE 11 is not supported")(); } - let vertexCount = Infinity; - for (const attributeName in attributes) { - const attribute = attributes[attributeName]; - const { - value, - size, - constant - } = attribute; - if (!constant && value && size >= 1) { - vertexCount = Math.min(vertexCount, value.length / size); + this.viewState = props.initialViewState; + if (!props.gl) { + if (typeof document !== "undefined") { + this.canvas = this._createCanvas(props); } } - assert6(Number.isFinite(vertexCount)); - return vertexCount; - } - }; - - // node_modules/@luma.gl/engine/dist/esm/animation/timeline.js - var channelHandles = 1; - var animationHandles = 1; - var Timeline = class { - constructor() { - this.time = 0; - this.channels = /* @__PURE__ */ new Map(); - this.animations = /* @__PURE__ */ new Map(); - this.playing = false; - this.lastEngineTime = -1; - } - addChannel(props) { - const { - delay: delay2 = 0, - duration = Number.POSITIVE_INFINITY, - rate = 1, - repeat = 1 - } = props; - const handle = channelHandles++; - const channel = { - time: 0, - delay: delay2, - duration, - rate, - repeat + this.animationLoop = this._createAnimationLoop(props); + this.stats = new Stats2({ + id: "deck.gl" + }); + this.metrics = { + fps: 0, + setPropsTime: 0, + updateAttributesTime: 0, + framesRedrawn: 0, + pickTime: 0, + pickCount: 0, + gpuTime: 0, + gpuTimePerFrame: 0, + cpuTime: 0, + cpuTimePerFrame: 0, + bufferMemory: 0, + textureMemory: 0, + renderbufferMemory: 0, + gpuMemory: 0 }; - this._setChannelTime(channel, this.time); - this.channels.set(handle, channel); - return handle; + this._metricsCounter = 0; + this.setProps(props); + if (props._typedArrayManagerProps) { + typed_array_manager_default.setOptions(props._typedArrayManagerProps); + } + this.animationLoop.start(); } - removeChannel(handle) { - this.channels.delete(handle); - for (const [animationHandle, animation] of this.animations) { - if (animation.channel === handle) { - this.detachAnimation(animationHandle); - } + finalize() { + var _this$animationLoop, _this$layerManager, _this$viewManager, _this$effectManager, _this$deckRenderer, _this$deckPicker, _this$eventManager, _this$tooltip; + (_this$animationLoop = this.animationLoop) === null || _this$animationLoop === void 0 ? void 0 : _this$animationLoop.stop(); + this.animationLoop = null; + this._lastPointerDownInfo = null; + (_this$layerManager = this.layerManager) === null || _this$layerManager === void 0 ? void 0 : _this$layerManager.finalize(); + this.layerManager = null; + (_this$viewManager = this.viewManager) === null || _this$viewManager === void 0 ? void 0 : _this$viewManager.finalize(); + this.viewManager = null; + (_this$effectManager = this.effectManager) === null || _this$effectManager === void 0 ? void 0 : _this$effectManager.finalize(); + this.effectManager = null; + (_this$deckRenderer = this.deckRenderer) === null || _this$deckRenderer === void 0 ? void 0 : _this$deckRenderer.finalize(); + this.deckRenderer = null; + (_this$deckPicker = this.deckPicker) === null || _this$deckPicker === void 0 ? void 0 : _this$deckPicker.finalize(); + this.deckPicker = null; + (_this$eventManager = this.eventManager) === null || _this$eventManager === void 0 ? void 0 : _this$eventManager.destroy(); + this.eventManager = null; + (_this$tooltip = this.tooltip) === null || _this$tooltip === void 0 ? void 0 : _this$tooltip.remove(); + this.tooltip = null; + if (!this.props.canvas && !this.props.gl && this.canvas) { + var _this$canvas$parentEl; + (_this$canvas$parentEl = this.canvas.parentElement) === null || _this$canvas$parentEl === void 0 ? void 0 : _this$canvas$parentEl.removeChild(this.canvas); + this.canvas = null; } } - isFinished(handle) { - const channel = this.channels.get(handle); - if (channel === void 0) { - return false; + setProps(props) { + this.stats.get("setProps Time").timeStart(); + if ("onLayerHover" in props) { + log_default.removed("onLayerHover", "onHover")(); } - return this.time >= channel.delay + channel.duration * channel.repeat; + if ("onLayerClick" in props) { + log_default.removed("onLayerClick", "onClick")(); + } + if (props.initialViewState && !deepEqual(this.props.initialViewState, props.initialViewState, 3)) { + this.viewState = props.initialViewState; + } + Object.assign(this.props, props); + this._setCanvasSize(this.props); + const resolvedProps = Object.create(this.props); + Object.assign(resolvedProps, { + views: this._getViews(), + width: this.width, + height: this.height, + viewState: this._getViewState() + }); + this.animationLoop.setProps(resolvedProps); + if (this.layerManager) { + this.viewManager.setProps(resolvedProps); + this.layerManager.activateViewport(this.getViewports()[0]); + this.layerManager.setProps(resolvedProps); + this.effectManager.setProps(resolvedProps); + this.deckRenderer.setProps(resolvedProps); + this.deckPicker.setProps(resolvedProps); + } + this.stats.get("setProps Time").timeEnd(); } - getTime(handle) { - if (handle === void 0) { - return this.time; + needsRedraw(opts = { + clearRedrawFlags: false + }) { + if (!this.layerManager) { + return false; } - const channel = this.channels.get(handle); - if (channel === void 0) { - return -1; + if (this.props._animate) { + return "Deck._animate"; } - return channel.time; + let redraw = this._needsRedraw; + if (opts.clearRedrawFlags) { + this._needsRedraw = false; + } + const viewManagerNeedsRedraw = this.viewManager.needsRedraw(opts); + const layerManagerNeedsRedraw = this.layerManager.needsRedraw(opts); + const effectManagerNeedsRedraw = this.effectManager.needsRedraw(opts); + const deckRendererNeedsRedraw = this.deckRenderer.needsRedraw(opts); + redraw = redraw || viewManagerNeedsRedraw || layerManagerNeedsRedraw || effectManagerNeedsRedraw || deckRendererNeedsRedraw; + return redraw; } - setTime(time) { - this.time = Math.max(0, time); - const channels = this.channels.values(); - for (const channel of channels) { - this._setChannelTime(channel, this.time); + redraw(reason) { + if (!this.layerManager) { + return; } - const animations = this.animations.values(); - for (const animationData of animations) { - const { - animation, - channel - } = animationData; - animation.setTime(this.getTime(channel)); + let redrawReason = this.needsRedraw({ + clearRedrawFlags: true + }); + redrawReason = reason || redrawReason; + if (!redrawReason) { + return; + } + this.stats.get("Redraw Count").incrementCount(); + if (this.props._customRender) { + this.props._customRender(redrawReason); + } else { + this._drawLayers(redrawReason); } } - play() { - this.playing = true; + get isInitialized() { + return this.viewManager !== null; } - pause() { - this.playing = false; - this.lastEngineTime = -1; + getViews() { + assert10(this.viewManager); + return this.viewManager.views; } - reset() { - this.setTime(0); + getViewports(rect) { + assert10(this.viewManager); + return this.viewManager.getViewports(rect); } - attachAnimation(animation, channelHandle) { - const animationHandle = animationHandles++; - this.animations.set(animationHandle, { - animation, - channel: channelHandle - }); - animation.setTime(this.getTime(channelHandle)); - return animationHandle; + getCanvas() { + return this.canvas; } - detachAnimation(handle) { - this.animations.delete(handle); + pickObject(opts) { + const infos = this._pick("pickObject", "pickObject Time", opts).result; + return infos.length ? infos[0] : null; } - update(engineTime) { - if (this.playing) { - if (this.lastEngineTime === -1) { - this.lastEngineTime = engineTime; - } - this.setTime(this.time + (engineTime - this.lastEngineTime)); - this.lastEngineTime = engineTime; + pickMultipleObjects(opts) { + opts.depth = opts.depth || 10; + return this._pick("pickObject", "pickMultipleObjects Time", opts).result; + } + pickObjects(opts) { + return this._pick("pickObjects", "pickObjects Time", opts); + } + _addResources(resources, forceUpdate = false) { + for (const id in resources) { + this.layerManager.resourceManager.add({ + resourceId: id, + data: resources[id], + forceUpdate + }); } } - _setChannelTime(channel, time) { - const offsetTime = time - channel.delay; - const totalDuration = channel.duration * channel.repeat; - if (offsetTime >= totalDuration) { - channel.time = channel.duration * channel.rate; - } else { - channel.time = Math.max(0, offsetTime) % channel.duration; - channel.time *= channel.rate; + _removeResources(resourceIds) { + for (const id of resourceIds) { + this.layerManager.resourceManager.remove(id); } } - }; - - // node_modules/@deck.gl/core/dist/esm/effects/lighting/ambient-light.js - var DEFAULT_LIGHT_COLOR = [255, 255, 255]; - var DEFAULT_LIGHT_INTENSITY = 1; - var idCount = 0; - var AmbientLight = class { - constructor(props = {}) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "color", void 0); - _defineProperty(this, "intensity", void 0); - _defineProperty(this, "type", "ambient"); - const { - color = DEFAULT_LIGHT_COLOR - } = props; - const { - intensity = DEFAULT_LIGHT_INTENSITY - } = props; - this.id = props.id || "ambient-".concat(idCount++); - this.color = color; - this.intensity = intensity; + _addDefaultEffect(effect) { + this.effectManager.addDefaultEffect(effect); } - }; - - // node_modules/@deck.gl/core/dist/esm/effects/lighting/directional-light.js - var DEFAULT_LIGHT_COLOR2 = [255, 255, 255]; - var DEFAULT_LIGHT_INTENSITY2 = 1; - var DEFAULT_LIGHT_DIRECTION = [0, 0, -1]; - var idCount2 = 0; - var DirectionalLight = class { - constructor(props = {}) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "color", void 0); - _defineProperty(this, "intensity", void 0); - _defineProperty(this, "type", "directional"); - _defineProperty(this, "direction", void 0); - _defineProperty(this, "shadow", void 0); - const { - color = DEFAULT_LIGHT_COLOR2 - } = props; - const { - intensity = DEFAULT_LIGHT_INTENSITY2 - } = props; - const { - direction = DEFAULT_LIGHT_DIRECTION - } = props; + _pick(method, statKey, opts) { + assert10(this.deckPicker); const { - _shadow = false - } = props; - this.id = props.id || "directional-".concat(idCount2++); - this.color = color; - this.intensity = intensity; - this.type = "directional"; - this.direction = new Vector3(direction).normalize().toArray(); - this.shadow = _shadow; + stats + } = this; + stats.get("Pick Count").incrementCount(); + stats.get(statKey).timeStart(); + const infos = this.deckPicker[method]({ + layers: this.layerManager.getLayers(opts), + views: this.viewManager.getViews(), + viewports: this.getViewports(opts), + onViewportActive: this.layerManager.activateViewport, + effects: this.effectManager.getEffects(), + ...opts + }); + stats.get(statKey).timeEnd(); + return infos; } - getProjectedLight(opts) { - return this; + _createCanvas(props) { + let canvas = props.canvas; + if (typeof canvas === "string") { + canvas = document.getElementById(canvas); + assert10(canvas); + } + if (!canvas) { + canvas = document.createElement("canvas"); + canvas.id = props.id || "deckgl-overlay"; + const parent = props.parent || document.body; + parent.appendChild(canvas); + } + Object.assign(canvas.style, props.style); + return canvas; } - }; - - // node_modules/@deck.gl/core/dist/esm/passes/pass.js - var Pass = class { - constructor(gl, props = { - id: "pass" - }) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "gl", void 0); - _defineProperty(this, "props", void 0); + _setCanvasSize(props) { + if (!this.canvas) { + return; + } const { - id + width, + height } = props; - this.id = id; - this.gl = gl; - this.props = { - ...props - }; - } - setProps(props) { - Object.assign(this.props, props); + if (width || width === 0) { + const cssWidth = Number.isFinite(width) ? "".concat(width, "px") : width; + this.canvas.style.width = cssWidth; + } + if (height || height === 0) { + var _props$style; + const cssHeight = Number.isFinite(height) ? "".concat(height, "px") : height; + this.canvas.style.position = ((_props$style = props.style) === null || _props$style === void 0 ? void 0 : _props$style.position) || "absolute"; + this.canvas.style.height = cssHeight; + } } - render(params) { + _updateCanvasSize() { + var _canvas$clientWidth, _canvas$clientHeight; + const { + canvas + } = this; + if (!canvas) { + return; + } + const newWidth = (_canvas$clientWidth = canvas.clientWidth) !== null && _canvas$clientWidth !== void 0 ? _canvas$clientWidth : canvas.width; + const newHeight = (_canvas$clientHeight = canvas.clientHeight) !== null && _canvas$clientHeight !== void 0 ? _canvas$clientHeight : canvas.height; + if (newWidth !== this.width || newHeight !== this.height) { + var _this$viewManager2, _this$layerManager2; + this.width = newWidth; + this.height = newHeight; + (_this$viewManager2 = this.viewManager) === null || _this$viewManager2 === void 0 ? void 0 : _this$viewManager2.setProps({ + width: newWidth, + height: newHeight + }); + (_this$layerManager2 = this.layerManager) === null || _this$layerManager2 === void 0 ? void 0 : _this$layerManager2.activateViewport(this.getViewports()[0]); + this.props.onResize({ + width: newWidth, + height: newHeight + }); + } } - cleanup() { + _createAnimationLoop(props) { + const { + width, + height, + gl, + glOptions, + debug: debug2, + onError, + onBeforeRender, + onAfterRender, + useDevicePixels + } = props; + return new AnimationLoop({ + width, + height, + useDevicePixels, + autoResizeDrawingBuffer: !gl, + autoResizeViewport: false, + gl, + onCreateContext: (opts) => createGLContext({ + ...glOptions, + ...opts, + canvas: this.canvas, + debug: debug2, + onContextLost: () => this._onContextLost() + }), + onInitialize: (context) => this._setGLContext(context.gl), + onRender: this._onRenderFrame.bind(this), + onBeforeRender, + onAfterRender, + onError + }); } - }; - - // node_modules/@deck.gl/core/dist/esm/passes/layers-pass.js - var LayersPass = class extends Pass { - constructor(...args) { - super(...args); - _defineProperty(this, "_lastRenderIndex", -1); + _getViewState() { + return this.props.viewState || this.viewState; } - render(options) { - const gl = this.gl; - setParameters(gl, { - framebuffer: options.target - }); - return this._drawLayers(options); + _getViews() { + let views = this.props.views || [new MapView({ + id: "default-view" + })]; + views = Array.isArray(views) ? views : [views]; + if (views.length && this.props.controller) { + views[0].props.controller = this.props.controller; + } + return views; } - _drawLayers(options) { + _onContextLost() { const { - target, - moduleParameters, - viewports, - views, - onViewportActive, - clearStack = true, - clearCanvas = true - } = options; - options.pass = options.pass || "unknown"; - const gl = this.gl; - if (clearCanvas) { - clearGLCanvas(gl, target); - } - if (clearStack) { - this._lastRenderIndex = -1; + onError + } = this.props; + if (this.animationLoop && onError) { + onError(new Error("WebGL context is lost")); } - const renderStats = []; - for (const viewport of viewports) { - const view = views && views[viewport.id]; - onViewportActive === null || onViewportActive === void 0 ? void 0 : onViewportActive(viewport); - const drawLayerParams = this._getDrawLayerParams(viewport, options); - const subViewports = viewport.subViewports || [viewport]; - for (const subViewport of subViewports) { - const stats = this._drawLayersInViewport(gl, { - target, - moduleParameters, - viewport: subViewport, - view, - pass: options.pass, - layers: options.layers - }, drawLayerParams); - renderStats.push(stats); + } + _pickAndCallback() { + const { + _pickRequest + } = this; + if (_pickRequest.event) { + const { + result, + emptyInfo + } = this._pick("pickObject", "pickObject Time", _pickRequest); + this.cursorState.isHovering = result.length > 0; + let pickedInfo = emptyInfo; + let handled = false; + for (const info of result) { + var _info$layer; + pickedInfo = info; + handled = ((_info$layer = info.layer) === null || _info$layer === void 0 ? void 0 : _info$layer.onHover(info, _pickRequest.event)) || handled; + } + if (!handled && this.props.onHover) { + this.props.onHover(pickedInfo, _pickRequest.event); + } + if (this.props.getTooltip && this.tooltip) { + const displayInfo = this.props.getTooltip(pickedInfo); + this.tooltip.setTooltip(displayInfo, pickedInfo.x, pickedInfo.y); } + _pickRequest.event = null; } - return renderStats; } - _getDrawLayerParams(viewport, { - layers, - pass, - isPicking = false, - layerFilter, - cullRect, - effects, - moduleParameters - }, evaluateShouldDrawOnly = false) { - const drawLayerParams = []; - const indexResolver = layerIndexResolver(this._lastRenderIndex + 1); - const drawContext = { - layer: layers[0], - viewport, - isPicking, - renderPass: pass, - cullRect - }; - const layerFilterCache = {}; - for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) { - const layer = layers[layerIndex]; - const shouldDrawLayer = this._shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache); - const layerParam = { - shouldDrawLayer - }; - if (shouldDrawLayer && !evaluateShouldDrawOnly) { - layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer); - layerParam.moduleParameters = this._getModuleParameters(layer, effects, pass, moduleParameters); - layerParam.layerParameters = this.getLayerParameters(layer, layerIndex, viewport); - } - drawLayerParams[layerIndex] = layerParam; + _updateCursor() { + const container = this.props.parent || this.canvas; + if (container) { + container.style.cursor = this.props.getCursor(this.cursorState); } - return drawLayerParams; } - _drawLayersInViewport(gl, { - layers, - moduleParameters: globalModuleParameters, - pass, - target, - viewport, - view - }, drawLayerParams) { - const glViewport = getGLViewport(gl, { - moduleParameters: globalModuleParameters, - target, - viewport - }); - if (view && view.props.clear) { - const clearOpts = view.props.clear === true ? { - color: true, - depth: true - } : view.props.clear; - withParameters(gl, { - scissorTest: true, - scissor: glViewport - }, () => clear(gl, clearOpts)); + _setGLContext(gl) { + if (this.layerManager) { + return; } - const renderStatus = { - totalCount: layers.length, - visibleCount: 0, - compositeCount: 0, - pickableCount: 0 - }; + if (!this.canvas) { + this.canvas = gl.canvas; + instrumentGLContext(gl, { + enable: true, + copyState: true + }); + } + this.tooltip = new Tooltip(this.canvas); setParameters(gl, { - viewport: glViewport + blend: true, + blendFunc: [770, 771, 1, 771], + polygonOffsetFill: true, + depthTest: true, + depthFunc: 515 }); - for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) { - const layer = layers[layerIndex]; - const { - shouldDrawLayer, - layerRenderIndex, - moduleParameters, - layerParameters - } = drawLayerParams[layerIndex]; - if (shouldDrawLayer && layer.props.pickable) { - renderStatus.pickableCount++; + this.props.onWebGLInitialized(gl); + const timeline = new Timeline(); + timeline.play(); + this.animationLoop.attachTimeline(timeline); + this.eventManager = new EventManager(this.props.parent || gl.canvas, { + touchAction: this.props.touchAction, + recognizerOptions: this.props.eventRecognizerOptions, + events: { + pointerdown: this._onPointerDown, + pointermove: this._onPointerMove, + pointerleave: this._onPointerMove } - if (layer.isComposite) { - renderStatus.compositeCount++; - } else if (shouldDrawLayer) { - renderStatus.visibleCount++; - this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex); - moduleParameters.viewport = viewport; - try { - layer._drawLayer({ - moduleParameters, - uniforms: { - layerIndex: layerRenderIndex - }, - parameters: layerParameters + }); + for (const eventType in EVENTS) { + this.eventManager.on(eventType, this._onEvent); + } + this.viewManager = new ViewManager({ + timeline, + eventManager: this.eventManager, + onViewStateChange: this._onViewStateChange.bind(this), + onInteractionStateChange: this._onInteractionStateChange.bind(this), + views: this._getViews(), + viewState: this._getViewState(), + width: this.width, + height: this.height + }); + const viewport = this.viewManager.getViewports()[0]; + this.layerManager = new LayerManager(gl, { + deck: this, + stats: this.stats, + viewport, + timeline + }); + this.effectManager = new EffectManager(); + this.deckRenderer = new DeckRenderer(gl); + this.deckPicker = new DeckPicker(gl); + this.setProps(this.props); + this._updateCanvasSize(); + this.props.onLoad(); + } + _drawLayers(redrawReason, renderOptions) { + const { + gl + } = this.layerManager.context; + setParameters(gl, this.props.parameters); + this.props.onBeforeRender({ + gl + }); + this.deckRenderer.renderLayers({ + target: this.props._framebuffer, + layers: this.layerManager.getLayers(), + viewports: this.viewManager.getViewports(), + onViewportActive: this.layerManager.activateViewport, + views: this.viewManager.getViews(), + pass: "screen", + effects: this.effectManager.getEffects(), + ...renderOptions + }); + this.props.onAfterRender({ + gl + }); + } + _onRenderFrame(animationProps) { + this._getFrameStats(); + if (this._metricsCounter++ % 60 === 0) { + this._getMetrics(); + this.stats.reset(); + log_default.table(4, this.metrics)(); + if (this.props._onMetrics) { + this.props._onMetrics(this.metrics); + } + } + this._updateCanvasSize(); + this._updateCursor(); + if (this.tooltip.isVisible && this.viewManager.needsRedraw()) { + this.tooltip.setTooltip(null); + } + this.layerManager.updateLayers(); + this._pickAndCallback(); + this.redraw(); + if (this.viewManager) { + this.viewManager.updateViewStates(); + } + } + _onViewStateChange(params) { + const viewState = this.props.onViewStateChange(params) || params.viewState; + if (this.viewState) { + this.viewState = { + ...this.viewState, + [params.viewId]: viewState + }; + if (!this.props.viewState) { + if (this.viewManager) { + this.viewManager.setProps({ + viewState: this.viewState }); - } catch (err) { - layer.raiseError(err, "drawing ".concat(layer, " to ").concat(pass)); } } } - return renderStatus; } - shouldDrawLayer(layer) { - return true; + _onInteractionStateChange(interactionState) { + this.cursorState.isDragging = interactionState.isDragging || false; + this.props.onInteractionStateChange(interactionState); } - getModuleParameters(layer, effects) { - return null; + _getFrameStats() { + const { + stats + } = this; + stats.get("frameRate").timeEnd(); + stats.get("frameRate").timeStart(); + const animationLoopStats = this.animationLoop.stats; + stats.get("GPU Time").addTime(animationLoopStats.get("GPU Time").lastTiming); + stats.get("CPU Time").addTime(animationLoopStats.get("CPU Time").lastTiming); } - getLayerParameters(layer, layerIndex, viewport) { - return layer.props.parameters; + _getMetrics() { + const { + metrics, + stats + } = this; + metrics.fps = stats.get("frameRate").getHz(); + metrics.setPropsTime = stats.get("setProps Time").time; + metrics.updateAttributesTime = stats.get("Update Attributes").time; + metrics.framesRedrawn = stats.get("Redraw Count").count; + metrics.pickTime = stats.get("pickObject Time").time + stats.get("pickMultipleObjects Time").time + stats.get("pickObjects Time").time; + metrics.pickCount = stats.get("Pick Count").count; + metrics.gpuTime = stats.get("GPU Time").time; + metrics.cpuTime = stats.get("CPU Time").time; + metrics.gpuTimePerFrame = stats.get("GPU Time").getAverageTime(); + metrics.cpuTimePerFrame = stats.get("CPU Time").getAverageTime(); + const memoryStats = lumaStats.get("Memory Usage"); + metrics.bufferMemory = memoryStats.get("Buffer Memory").count; + metrics.textureMemory = memoryStats.get("Texture Memory").count; + metrics.renderbufferMemory = memoryStats.get("Renderbuffer Memory").count; + metrics.gpuMemory = memoryStats.get("GPU Memory").count; } - _shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache) { - const shouldDrawLayer = layer.props.visible && this.shouldDrawLayer(layer); - if (!shouldDrawLayer) { - return false; - } - drawContext.layer = layer; - let parent = layer.parent; - while (parent) { - if (!parent.props.visible || !parent.filterSubLayer(drawContext)) { - return false; - } - drawContext.layer = parent; - parent = parent.parent; + }; + _defineProperty(Deck, "defaultProps", defaultProps); + _defineProperty(Deck, "VERSION", VERSION5); + + // node_modules/@deck.gl/core/dist/esm/lib/attribute/shader-attribute.js + var ShaderAttribute = class { + constructor(dataColumn, opts) { + _defineProperty(this, "opts", void 0); + _defineProperty(this, "source", void 0); + this.opts = opts; + this.source = dataColumn; + } + get value() { + return this.source.value; + } + getValue() { + const buffer = this.source.getBuffer(); + const accessor = this.getAccessor(); + if (buffer) { + return [buffer, accessor]; } - if (layerFilter) { - const rootLayerId = drawContext.layer.id; - if (!(rootLayerId in layerFilterCache)) { - layerFilterCache[rootLayerId] = layerFilter(drawContext); - } - if (!layerFilterCache[rootLayerId]) { - return false; + const { + value + } = this.source; + const { + size + } = accessor; + let constantValue = value; + if (value && value.length !== size) { + constantValue = new Float32Array(size); + const index = accessor.elementOffset || 0; + for (let i3 = 0; i3 < size; ++i3) { + constantValue[i3] = value[index + i3]; } } - layer.activateViewport(drawContext.viewport); - return true; + return constantValue; } - _getModuleParameters(layer, effects, pass, overrides) { - var _layer$internalState; - const moduleParameters = Object.assign(Object.create(((_layer$internalState = layer.internalState) === null || _layer$internalState === void 0 ? void 0 : _layer$internalState.propsInTransition) || layer.props), { - autoWrapLongitude: layer.wrapLongitude, - viewport: layer.context.viewport, - mousePosition: layer.context.mousePosition, - pickingActive: 0, - devicePixelRatio: cssToDeviceRatio(this.gl) - }); - if (effects) { - for (const effect of effects) { - var _effect$getModulePara; - Object.assign(moduleParameters, (_effect$getModulePara = effect.getModuleParameters) === null || _effect$getModulePara === void 0 ? void 0 : _effect$getModulePara.call(effect, layer)); - } - } - return Object.assign(moduleParameters, this.getModuleParameters(layer, effects), overrides); + getAccessor() { + return { + ...this.source.getAccessor(), + ...this.opts + }; } }; - function layerIndexResolver(startIndex = 0, layerIndices = {}) { - const resolvers = {}; - const resolveLayerIndex = (layer, isDrawn) => { - const indexOverride = layer.props._offset; - const layerId = layer.id; - const parentId = layer.parent && layer.parent.id; - let index; - if (parentId && !(parentId in layerIndices)) { - resolveLayerIndex(layer.parent, false); + + // node_modules/@deck.gl/core/dist/esm/lib/attribute/gl-utils.js + function glArrayFromType(glType) { + switch (glType) { + case 5126: + return Float32Array; + case 5130: + return Float64Array; + case 5123: + case 33635: + case 32819: + case 32820: + return Uint16Array; + case 5125: + return Uint32Array; + case 5121: + return Uint8ClampedArray; + case 5120: + return Int8Array; + case 5122: + return Int16Array; + case 5124: + return Int32Array; + default: + throw new Error("Unknown GL type"); + } + } + + // node_modules/@deck.gl/core/dist/esm/lib/attribute/data-column.js + function getStride(accessor) { + return accessor.stride || accessor.size * accessor.bytesPerElement; + } + function resolveShaderAttribute(baseAccessor, shaderAttributeOptions) { + if (shaderAttributeOptions.offset) { + log_default.removed("shaderAttribute.offset", "vertexOffset, elementOffset")(); + } + const stride = getStride(baseAccessor); + const vertexOffset = shaderAttributeOptions.vertexOffset !== void 0 ? shaderAttributeOptions.vertexOffset : baseAccessor.vertexOffset || 0; + const elementOffset = shaderAttributeOptions.elementOffset || 0; + const offset = vertexOffset * stride + elementOffset * baseAccessor.bytesPerElement + (baseAccessor.offset || 0); + return { + ...shaderAttributeOptions, + offset, + stride + }; + } + function resolveDoublePrecisionShaderAttributes(baseAccessor, shaderAttributeOptions) { + const resolvedOptions = resolveShaderAttribute(baseAccessor, shaderAttributeOptions); + return { + high: resolvedOptions, + low: { + ...resolvedOptions, + offset: resolvedOptions.offset + baseAccessor.size * 4 } - if (parentId in resolvers) { - const resolver = resolvers[parentId] = resolvers[parentId] || layerIndexResolver(layerIndices[parentId], layerIndices); - index = resolver(layer, isDrawn); - resolvers[layerId] = resolver; - } else if (Number.isFinite(indexOverride)) { - index = indexOverride + (layerIndices[parentId] || 0); - resolvers[layerId] = null; + }; + } + var DataColumn = class { + constructor(gl, opts, state) { + _defineProperty(this, "gl", void 0); + _defineProperty(this, "id", void 0); + _defineProperty(this, "size", void 0); + _defineProperty(this, "settings", void 0); + _defineProperty(this, "value", void 0); + _defineProperty(this, "doublePrecision", void 0); + _defineProperty(this, "_buffer", void 0); + _defineProperty(this, "state", void 0); + this.gl = gl; + this.id = opts.id || ""; + this.size = opts.size || 1; + const logicalType = opts.logicalType || opts.type; + const doublePrecision = logicalType === 5130; + let { + defaultValue + } = opts; + defaultValue = Number.isFinite(defaultValue) ? [defaultValue] : defaultValue || new Array(this.size).fill(0); + let bufferType; + if (doublePrecision) { + bufferType = 5126; + } else if (!logicalType && opts.isIndexed) { + bufferType = gl && hasFeature(gl, FEATURES.ELEMENT_INDEX_UINT32) ? 5125 : 5123; } else { - index = startIndex; + bufferType = logicalType || 5126; } - if (isDrawn && index >= startIndex) { - startIndex = index + 1; + let defaultType = glArrayFromType(logicalType || bufferType || 5126); + this.doublePrecision = doublePrecision; + if (doublePrecision && opts.fp64 === false) { + defaultType = Float32Array; } - layerIndices[layerId] = index; - return index; - }; - return resolveLayerIndex; - } - function getGLViewport(gl, { - moduleParameters, - target, - viewport - }) { - const useTarget = target && target.id !== "default-framebuffer"; - const pixelRatio = moduleParameters && moduleParameters.devicePixelRatio || cssToDeviceRatio(gl); - const height = useTarget ? target.height : gl.drawingBufferHeight; - const dimensions = viewport; - return [dimensions.x * pixelRatio, height - (dimensions.y + dimensions.height) * pixelRatio, dimensions.width * pixelRatio, dimensions.height * pixelRatio]; - } - function clearGLCanvas(gl, targetFramebuffer) { - const width = targetFramebuffer ? targetFramebuffer.width : gl.drawingBufferWidth; - const height = targetFramebuffer ? targetFramebuffer.height : gl.drawingBufferHeight; - setParameters(gl, { - viewport: [0, 0, width, height] - }); - gl.clear(16384 | 256); - } - - // node_modules/@deck.gl/core/dist/esm/passes/shadow-pass.js - var ShadowPass = class extends LayersPass { - constructor(gl, props) { - super(gl, props); - _defineProperty(this, "shadowMap", void 0); - _defineProperty(this, "depthBuffer", void 0); - _defineProperty(this, "fbo", void 0); - this.shadowMap = new Texture2D(gl, { - width: 1, - height: 1, - parameters: { - [10241]: 9729, - [10240]: 9729, - [10242]: 33071, - [10243]: 33071 - } - }); - this.depthBuffer = new Renderbuffer(gl, { - format: 33189, - width: 1, - height: 1 - }); - this.fbo = new Framebuffer(gl, { - id: "shadowmap", - width: 1, - height: 1, - attachments: { - [36064]: this.shadowMap, - [36096]: this.depthBuffer - } - }); - } - render(params) { - const target = this.fbo; - withParameters(this.gl, { - depthRange: [0, 1], - depthTest: true, - blend: false, - clearColor: [1, 1, 1, 1] - }, () => { - const viewport = params.viewports[0]; - const pixelRatio = cssToDeviceRatio(this.gl); - const width = viewport.width * pixelRatio; - const height = viewport.height * pixelRatio; - if (width !== target.width || height !== target.height) { - target.resize({ - width, - height - }); - } - super.render({ - ...params, - target, - pass: "shadow" + this.value = null; + this.settings = { + ...opts, + defaultType, + defaultValue, + logicalType, + type: bufferType, + size: this.size, + bytesPerElement: defaultType.BYTES_PER_ELEMENT + }; + this.state = { + ...state, + externalBuffer: null, + bufferAccessor: this.settings, + allocatedValue: null, + numInstances: 0, + bounds: null, + constant: false + }; + this._buffer = null; + } + get isConstant() { + return this.state.constant; + } + get buffer() { + if (!this._buffer) { + const { + isIndexed, + type + } = this.settings; + this._buffer = new Buffer2(this.gl, { + id: this.id, + target: isIndexed ? 34963 : 34962, + accessor: { + type + } }); - }); + } + return this._buffer; } - shouldDrawLayer(layer) { - return layer.props.shadowEnabled !== false; + get byteOffset() { + const accessor = this.getAccessor(); + if (accessor.vertexOffset) { + return accessor.vertexOffset * getStride(accessor); + } + return 0; } - getModuleParameters() { - return { - drawToShadowMap: true - }; + get numInstances() { + return this.state.numInstances; + } + set numInstances(n2) { + this.state.numInstances = n2; } delete() { - if (this.fbo) { - this.fbo.delete(); - this.fbo = null; + if (this._buffer) { + this._buffer.delete(); + this._buffer = null; } - if (this.shadowMap) { - this.shadowMap.delete(); - this.shadowMap = null; + typed_array_manager_default.release(this.state.allocatedValue); + } + getShaderAttributes(id, options) { + if (this.doublePrecision) { + const shaderAttributes = {}; + const isBuffer64Bit = this.value instanceof Float64Array; + const doubleShaderAttributeDefs = resolveDoublePrecisionShaderAttributes(this.getAccessor(), options || {}); + shaderAttributes[id] = new ShaderAttribute(this, doubleShaderAttributeDefs.high); + shaderAttributes["".concat(id, "64Low")] = isBuffer64Bit ? new ShaderAttribute(this, doubleShaderAttributeDefs.low) : new Float32Array(this.size); + return shaderAttributes; } - if (this.depthBuffer) { - this.depthBuffer.delete(); - this.depthBuffer = null; + if (options) { + const shaderAttributeDef = resolveShaderAttribute(this.getAccessor(), options); + return { + [id]: new ShaderAttribute(this, shaderAttributeDef) + }; } + return { + [id]: this + }; } - }; - - // node_modules/@deck.gl/core/dist/esm/shaderlib/misc/geometry.js - var defines = "#define SMOOTH_EDGE_RADIUS 0.5"; - var vs3 = "\n".concat(defines, "\n\nstruct VertexGeometry {\n vec4 position;\n vec3 worldPosition;\n vec3 worldPositionAlt;\n vec3 normal;\n vec2 uv;\n vec3 pickingColor;\n} geometry = VertexGeometry(\n vec4(0.0, 0.0, 1.0, 0.0),\n vec3(0.0),\n vec3(0.0),\n vec3(0.0),\n vec2(0.0),\n vec3(0.0)\n);\n"); - var fs2 = "\n".concat(defines, "\n\nstruct FragmentGeometry {\n vec2 uv;\n} geometry;\n\nfloat smoothedge(float edge, float x) {\n return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n"); - var geometry_default = { - name: "geometry", - vs: vs3, - fs: fs2 - }; - - // node_modules/@deck.gl/core/dist/esm/shaderlib/project/project.glsl.js - var COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => "const int COORDINATE_SYSTEM_".concat(key, " = ").concat(COORDINATE_SYSTEM[key], ";")).join(""); - var PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => "const int PROJECTION_MODE_".concat(key, " = ").concat(PROJECTION_MODE[key], ";")).join(""); - var UNIT_GLSL_CONSTANTS = Object.keys(UNIT).map((key) => "const int UNIT_".concat(key.toUpperCase(), " = ").concat(UNIT[key], ";")).join(""); - var project_glsl_default = "".concat(COORDINATE_SYSTEM_GLSL_CONSTANTS, "\n").concat(PROJECTION_MODE_GLSL_CONSTANTS, "\n").concat(UNIT_GLSL_CONSTANTS, "\n\nuniform int project_uCoordinateSystem;\nuniform int project_uProjectionMode;\nuniform float project_uScale;\nuniform bool project_uWrapLongitude;\nuniform vec3 project_uCommonUnitsPerMeter;\nuniform vec3 project_uCommonUnitsPerWorldUnit;\nuniform vec3 project_uCommonUnitsPerWorldUnit2;\nuniform vec4 project_uCenter;\nuniform mat4 project_uModelMatrix;\nuniform mat4 project_uViewProjectionMatrix;\nuniform vec2 project_uViewportSize;\nuniform float project_uDevicePixelRatio;\nuniform float project_uFocalDistance;\nuniform vec3 project_uCameraPosition;\nuniform vec3 project_uCoordinateOrigin;\nuniform vec3 project_uCommonOrigin;\nuniform bool project_uPseudoMeters;\n\nconst float TILE_SIZE = 512.0;\nconst float PI = 3.1415926536;\nconst float WORLD_SCALE = TILE_SIZE / (PI * 2.0);\nconst vec3 ZERO_64_LOW = vec3(0.0);\nconst float EARTH_RADIUS = 6370972.0;\nconst float GLOBE_RADIUS = 256.0;\nfloat project_size_at_latitude(float lat) {\n float y = clamp(lat, -89.9, 89.9);\n return 1.0 / cos(radians(y));\n}\n\nfloat project_size() {\n if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR &&\n project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT &&\n project_uPseudoMeters == false) {\n \n if (geometry.position.w == 0.0) {\n return project_size_at_latitude(geometry.worldPosition.y);\n }\n \n float y = geometry.position.y / TILE_SIZE * 2.0 - 1.0;\n float y2 = y * y;\n float y4 = y2 * y2;\n float y6 = y4 * y2;\n return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;\n }\n return 1.0;\n}\n\nfloat project_size_at_latitude(float meters, float lat) {\n return meters * project_uCommonUnitsPerMeter.z * project_size_at_latitude(lat);\n}\nfloat project_size(float meters) {\n return meters * project_uCommonUnitsPerMeter.z * project_size();\n}\n\nvec2 project_size(vec2 meters) {\n return meters * project_uCommonUnitsPerMeter.xy * project_size();\n}\n\nvec3 project_size(vec3 meters) {\n return meters * project_uCommonUnitsPerMeter * project_size();\n}\n\nvec4 project_size(vec4 meters) {\n return vec4(meters.xyz * project_uCommonUnitsPerMeter, meters.w);\n}\nmat3 project_get_orientation_matrix(vec3 up) {\n vec3 uz = normalize(up);\n vec3 ux = abs(uz.z) == 1.0 ? vec3(1.0, 0.0, 0.0) : normalize(vec3(uz.y, -uz.x, 0));\n vec3 uy = cross(uz, ux);\n return mat3(ux, uy, uz);\n}\n\nbool project_needs_rotation(vec3 commonPosition, out mat3 transform) {\n if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {\n transform = project_get_orientation_matrix(commonPosition);\n return true;\n }\n return false;\n}\nvec3 project_normal(vec3 vector) {\n vec4 normal_modelspace = project_uModelMatrix * vec4(vector, 0.0);\n vec3 n = normalize(normal_modelspace.xyz * project_uCommonUnitsPerMeter);\n mat3 rotation;\n if (project_needs_rotation(geometry.position.xyz, rotation)) {\n n = rotation * n;\n }\n return n;\n}\n\nvec4 project_offset_(vec4 offset) {\n float dy = offset.y;\n vec3 commonUnitsPerWorldUnit = project_uCommonUnitsPerWorldUnit + project_uCommonUnitsPerWorldUnit2 * dy;\n return vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w);\n}\nvec2 project_mercator_(vec2 lnglat) {\n float x = lnglat.x;\n if (project_uWrapLongitude) {\n x = mod(x + 180., 360.0) - 180.;\n }\n float y = clamp(lnglat.y, -89.9, 89.9);\n return vec2(\n radians(x) + PI,\n PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))\n ) * WORLD_SCALE;\n}\n\nvec3 project_globe_(vec3 lnglatz) {\n float lambda = radians(lnglatz.x);\n float phi = radians(lnglatz.y);\n float cosPhi = cos(phi);\n float D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;\n\n return vec3(\n sin(lambda) * cosPhi,\n -cos(lambda) * cosPhi,\n sin(phi)\n ) * D;\n}\nvec4 project_position(vec4 position, vec3 position64Low) {\n vec4 position_world = project_uModelMatrix * position;\n if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR) {\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n return vec4(\n project_mercator_(position_world.xy),\n project_size_at_latitude(position_world.z, position_world.y),\n position_world.w\n );\n }\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {\n position_world.xyz += project_uCoordinateOrigin;\n }\n }\n if (project_uProjectionMode == PROJECTION_MODE_GLOBE) {\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n return vec4(\n project_globe_(position_world.xyz),\n position_world.w\n );\n }\n }\n if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT) {\n if (abs(position_world.y - project_uCoordinateOrigin.y) > 0.25) {\n return vec4(\n project_mercator_(position_world.xy) - project_uCommonOrigin.xy,\n project_size(position_world.z),\n position_world.w\n );\n }\n }\n }\n if (project_uProjectionMode == PROJECTION_MODE_IDENTITY ||\n (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&\n (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||\n project_uCoordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {\n position_world.xyz -= project_uCoordinateOrigin;\n }\n return project_offset_(position_world + project_uModelMatrix * vec4(position64Low, 0.0));\n}\n\nvec4 project_position(vec4 position) {\n return project_position(position, ZERO_64_LOW);\n}\n\nvec3 project_position(vec3 position, vec3 position64Low) {\n vec4 projected_position = project_position(vec4(position, 1.0), position64Low);\n return projected_position.xyz;\n}\n\nvec3 project_position(vec3 position) {\n vec4 projected_position = project_position(vec4(position, 1.0), ZERO_64_LOW);\n return projected_position.xyz;\n}\n\nvec2 project_position(vec2 position) {\n vec4 projected_position = project_position(vec4(position, 0.0, 1.0), ZERO_64_LOW);\n return projected_position.xy;\n}\n\nvec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) {\n return viewProjectionMatrix * position + center;\n}\nvec4 project_common_position_to_clipspace(vec4 position) {\n return project_common_position_to_clipspace(position, project_uViewProjectionMatrix, project_uCenter);\n}\nvec2 project_pixel_size_to_clipspace(vec2 pixels) {\n vec2 offset = pixels / project_uViewportSize * project_uDevicePixelRatio * 2.0;\n return offset * project_uFocalDistance;\n}\n\nfloat project_size_to_pixel(float meters) {\n return project_size(meters) * project_uScale;\n}\nfloat project_size_to_pixel(float size, int unit) {\n if (unit == UNIT_METERS) return project_size_to_pixel(size);\n if (unit == UNIT_COMMON) return size * project_uScale;\n return size;\n}\nfloat project_pixel_size(float pixels) {\n return pixels / project_uScale;\n}\nvec2 project_pixel_size(vec2 pixels) {\n return pixels / project_uScale;\n}\n"); - - // node_modules/@deck.gl/core/dist/esm/utils/memoize.js - function isEqual(a2, b2) { - if (a2 === b2) { - return true; + getBuffer() { + if (this.state.constant) { + return null; + } + return this.state.externalBuffer || this._buffer; } - if (Array.isArray(a2)) { - const len = a2.length; - if (!b2 || b2.length !== len) { - return false; + getValue() { + if (this.state.constant) { + return this.value; } - for (let i2 = 0; i2 < len; i2++) { - if (a2[i2] !== b2[i2]) { - return false; + return [this.getBuffer(), this.getAccessor()]; + } + getAccessor() { + return this.state.bufferAccessor; + } + getBounds() { + if (this.state.bounds) { + return this.state.bounds; + } + let result = null; + if (this.state.constant && this.value) { + const min = Array.from(this.value); + result = [min, min]; + } else { + const { + value, + numInstances, + size + } = this; + const len2 = numInstances * size; + if (value && len2 && value.length >= len2) { + const min = new Array(size).fill(Infinity); + const max = new Array(size).fill(-Infinity); + for (let i3 = 0; i3 < len2; ) { + for (let j = 0; j < size; j++) { + const v2 = value[i3++]; + if (v2 < min[j]) + min[j] = v2; + if (v2 > max[j]) + max[j] = v2; + } + } + result = [min, max]; } } - return true; + this.state.bounds = result; + return result; } - return false; - } - function memoize(compute) { - let cachedArgs = {}; - let cachedResult; - return (args) => { - for (const key in args) { - if (!isEqual(args[key], cachedArgs[key])) { - cachedResult = compute(args); - cachedArgs = args; - break; + setData(data) { + const { + state + } = this; + let opts; + if (ArrayBuffer.isView(data)) { + opts = { + value: data + }; + } else if (data instanceof Buffer2) { + opts = { + buffer: data + }; + } else { + opts = data; + } + const accessor = { + ...this.settings, + ...opts + }; + state.bufferAccessor = accessor; + state.bounds = null; + if (opts.constant) { + let value = opts.value; + value = this._normalizeValue(value, [], 0); + if (this.settings.normalized) { + value = this.normalizeConstant(value); + } + const hasChanged = !state.constant || !this._areValuesEqual(value, this.value); + if (!hasChanged) { + return false; + } + state.externalBuffer = null; + state.constant = true; + this.value = value; + } else if (opts.buffer) { + const buffer = opts.buffer; + state.externalBuffer = buffer; + state.constant = false; + this.value = opts.value || null; + const isBuffer64Bit = opts.value instanceof Float64Array; + accessor.type = opts.type || buffer.accessor.type; + accessor.bytesPerElement = buffer.accessor.BYTES_PER_ELEMENT * (isBuffer64Bit ? 2 : 1); + accessor.stride = getStride(accessor); + } else if (opts.value) { + this._checkExternalBuffer(opts); + let value = opts.value; + state.externalBuffer = null; + state.constant = false; + this.value = value; + accessor.bytesPerElement = value.BYTES_PER_ELEMENT; + accessor.stride = getStride(accessor); + const { + buffer, + byteOffset + } = this; + if (this.doublePrecision && value instanceof Float64Array) { + value = toDoublePrecisionArray(value, accessor); + } + const requiredBufferSize = value.byteLength + byteOffset + accessor.stride * 2; + if (buffer.byteLength < requiredBufferSize) { + buffer.reallocate(requiredBufferSize); } + buffer.setAccessor(null); + buffer.subData({ + data: value, + offset: byteOffset + }); + accessor.type = opts.type || buffer.accessor.type; } - return cachedResult; - }; - } - - // node_modules/@deck.gl/core/dist/esm/shaderlib/project/viewport-uniforms.js - var ZERO_VECTOR = [0, 0, 0, 0]; - var VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]; - var IDENTITY_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; - var DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0]; - var DEFAULT_COORDINATE_ORIGIN = [0, 0, 0]; - var getMemoizedViewportUniforms = memoize(calculateViewportUniforms); - function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN) { - if (coordinateOrigin.length < 3) { - coordinateOrigin = [coordinateOrigin[0], coordinateOrigin[1], 0]; + return true; } - let shaderCoordinateOrigin = coordinateOrigin; - let geospatialOrigin; - let offsetMode = true; - if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS || coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) { - geospatialOrigin = coordinateOrigin; - } else { - geospatialOrigin = viewport.isGeospatial ? [Math.fround(viewport.longitude), Math.fround(viewport.latitude), 0] : null; + updateSubBuffer(opts = {}) { + this.state.bounds = null; + const value = this.value; + const { + startOffset = 0, + endOffset + } = opts; + this.buffer.subData({ + data: this.doublePrecision && value instanceof Float64Array ? toDoublePrecisionArray(value, { + size: this.size, + startIndex: startOffset, + endIndex: endOffset + }) : value.subarray(startOffset, endOffset), + offset: startOffset * value.BYTES_PER_ELEMENT + this.byteOffset + }); } - switch (viewport.projectionMode) { - case PROJECTION_MODE.WEB_MERCATOR: - if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) { - geospatialOrigin = [0, 0, 0]; - offsetMode = false; - } - break; - case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET: - if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) { - shaderCoordinateOrigin = geospatialOrigin; - } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) { - shaderCoordinateOrigin = [Math.fround(viewport.center[0]), Math.fround(viewport.center[1]), 0]; - geospatialOrigin = viewport.unprojectPosition(shaderCoordinateOrigin); - shaderCoordinateOrigin[0] -= coordinateOrigin[0]; - shaderCoordinateOrigin[1] -= coordinateOrigin[1]; - shaderCoordinateOrigin[2] -= coordinateOrigin[2]; + allocate(numInstances, copy3 = false) { + const { + state + } = this; + const oldValue = state.allocatedValue; + const value = typed_array_manager_default.allocate(oldValue, numInstances + 1, { + size: this.size, + type: this.settings.defaultType, + copy: copy3 + }); + this.value = value; + const { + buffer, + byteOffset + } = this; + if (buffer.byteLength < value.byteLength + byteOffset) { + buffer.reallocate(value.byteLength + byteOffset); + if (copy3 && oldValue) { + buffer.subData({ + data: oldValue instanceof Float64Array ? toDoublePrecisionArray(oldValue, this) : oldValue, + offset: byteOffset + }); } - break; - case PROJECTION_MODE.IDENTITY: - shaderCoordinateOrigin = viewport.position.map(Math.fround); - shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0; - break; - case PROJECTION_MODE.GLOBE: - offsetMode = false; - geospatialOrigin = null; - break; - default: - offsetMode = false; + } + state.allocatedValue = value; + state.constant = false; + state.externalBuffer = null; + state.bufferAccessor = this.settings; + return true; } - return { - geospatialOrigin, - shaderCoordinateOrigin, - offsetMode - }; - } - function calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin) { - const { - viewMatrixUncentered, - projectionMatrix - } = viewport; - let { - viewMatrix, - viewProjectionMatrix - } = viewport; - let projectionCenter = ZERO_VECTOR; - let originCommon = ZERO_VECTOR; - let cameraPosCommon = viewport.cameraPosition; - const { - geospatialOrigin, - shaderCoordinateOrigin, - offsetMode - } = getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin); - if (offsetMode) { - originCommon = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin); - cameraPosCommon = [cameraPosCommon[0] - originCommon[0], cameraPosCommon[1] - originCommon[1], cameraPosCommon[2] - originCommon[2]]; - originCommon[3] = 1; - projectionCenter = transformMat43([], originCommon, viewProjectionMatrix); - viewMatrix = viewMatrixUncentered || viewMatrix; - viewProjectionMatrix = multiply([], projectionMatrix, viewMatrix); - viewProjectionMatrix = multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX); + _checkExternalBuffer(opts) { + const { + value + } = opts; + if (!ArrayBuffer.isView(value)) { + throw new Error("Attribute ".concat(this.id, " value is not TypedArray")); + } + const ArrayType = this.settings.defaultType; + let illegalArrayType = false; + if (this.doublePrecision) { + illegalArrayType = value.BYTES_PER_ELEMENT < 4; + } + if (illegalArrayType) { + throw new Error("Attribute ".concat(this.id, " does not support ").concat(value.constructor.name)); + } + if (!(value instanceof ArrayType) && this.settings.normalized && !("normalized" in opts)) { + log_default.warn("Attribute ".concat(this.id, " is normalized"))(); + } } - return { - viewMatrix, - viewProjectionMatrix, - projectionCenter, - originCommon, - cameraPosCommon, - shaderCoordinateOrigin, - geospatialOrigin - }; - } - function getUniformsFromViewport({ - viewport, - devicePixelRatio = 1, - modelMatrix = null, - coordinateSystem = COORDINATE_SYSTEM.DEFAULT, - coordinateOrigin = DEFAULT_COORDINATE_ORIGIN, - autoWrapLongitude = false - }) { - if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { - coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN; + normalizeConstant(value) { + switch (this.settings.type) { + case 5120: + return new Float32Array(value).map((x2) => (x2 + 128) / 255 * 2 - 1); + case 5122: + return new Float32Array(value).map((x2) => (x2 + 32768) / 65535 * 2 - 1); + case 5121: + return new Float32Array(value).map((x2) => x2 / 255); + case 5123: + return new Float32Array(value).map((x2) => x2 / 65535); + default: + return value; + } } - const uniforms = getMemoizedViewportUniforms({ - viewport, - devicePixelRatio, - coordinateSystem, - coordinateOrigin - }); - uniforms.project_uWrapLongitude = autoWrapLongitude; - uniforms.project_uModelMatrix = modelMatrix || IDENTITY_MATRIX2; - return uniforms; - } - function calculateViewportUniforms({ - viewport, - devicePixelRatio, - coordinateSystem, - coordinateOrigin - }) { - const { - projectionCenter, - viewProjectionMatrix, - originCommon, - cameraPosCommon, - shaderCoordinateOrigin, - geospatialOrigin - } = calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin); - const distanceScales = viewport.getDistanceScales(); - const viewportSize = [viewport.width * devicePixelRatio, viewport.height * devicePixelRatio]; - const focalDistance = transformMat43([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1; - const uniforms = { - project_uCoordinateSystem: coordinateSystem, - project_uProjectionMode: viewport.projectionMode, - project_uCoordinateOrigin: shaderCoordinateOrigin, - project_uCommonOrigin: originCommon.slice(0, 3), - project_uCenter: projectionCenter, - project_uPseudoMeters: Boolean(viewport._pseudoMeters), - project_uViewportSize: viewportSize, - project_uDevicePixelRatio: devicePixelRatio, - project_uFocalDistance: focalDistance, - project_uCommonUnitsPerMeter: distanceScales.unitsPerMeter, - project_uCommonUnitsPerWorldUnit: distanceScales.unitsPerMeter, - project_uCommonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2, - project_uScale: viewport.scale, - project_uWrapLongitude: false, - project_uViewProjectionMatrix: viewProjectionMatrix, - project_uModelMatrix: IDENTITY_MATRIX2, - project_uCameraPosition: cameraPosCommon - }; - if (geospatialOrigin) { - const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin); - switch (coordinateSystem) { - case COORDINATE_SYSTEM.METER_OFFSETS: - uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter; - uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2; - break; - case COORDINATE_SYSTEM.LNGLAT: - case COORDINATE_SYSTEM.LNGLAT_OFFSETS: - if (!viewport._pseudoMeters) { - uniforms.project_uCommonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter; - } - uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree; - uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2; - break; - case COORDINATE_SYSTEM.CARTESIAN: - uniforms.project_uCommonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]]; - uniforms.project_uCommonUnitsPerWorldUnit2 = [0, 0, distanceScalesAtOrigin.unitsPerMeter2[2]]; + _normalizeValue(value, out, start) { + const { + defaultValue, + size + } = this.settings; + if (Number.isFinite(value)) { + out[start] = value; + return out; + } + if (!value) { + let i3 = size; + while (--i3 >= 0) { + out[start + i3] = defaultValue[i3]; + } + return out; + } + switch (size) { + case 4: + out[start + 3] = Number.isFinite(value[3]) ? value[3] : defaultValue[3]; + case 3: + out[start + 2] = Number.isFinite(value[2]) ? value[2] : defaultValue[2]; + case 2: + out[start + 1] = Number.isFinite(value[1]) ? value[1] : defaultValue[1]; + case 1: + out[start + 0] = Number.isFinite(value[0]) ? value[0] : defaultValue[0]; break; default: - break; + let i3 = size; + while (--i3 >= 0) { + out[start + i3] = Number.isFinite(value[i3]) ? value[i3] : defaultValue[i3]; + } } + return out; } - return uniforms; - } - - // node_modules/@deck.gl/core/dist/esm/shaderlib/project/project.js - var INITIAL_MODULE_OPTIONS3 = {}; - function getUniforms4(opts = INITIAL_MODULE_OPTIONS3) { - if ("viewport" in opts) { - return getUniformsFromViewport(opts); - } - return {}; - } - var project_default = { - name: "project", - dependencies: [fp32, geometry_default], - vs: project_glsl_default, - getUniforms: getUniforms4 - }; - - // node_modules/@math.gl/web-mercator/dist/esm/math-utils.js - function createMat4() { - return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; - } - function transformVector(matrix, vector) { - const result = transformMat43([], vector, matrix); - scale2(result, result, 1 / result[3]); - return result; - } - function mod(value, divisor) { - const modulus = value % divisor; - return modulus < 0 ? divisor + modulus : modulus; - } - function clamp2(x2, min, max) { - return x2 < min ? min : x2 > max ? max : x2; - } - function ieLog2(x2) { - return Math.log(x2) * Math.LOG2E; - } - var log22 = Math.log2 || ieLog2; - - // node_modules/@math.gl/web-mercator/dist/esm/assert.js - function assert9(condition, message) { - if (!condition) { - throw new Error(message || "@math.gl/web-mercator: assertion failed."); - } - } + _areValuesEqual(value1, value2) { + if (!value1 || !value2) { + return false; + } + const { + size + } = this; + for (let i3 = 0; i3 < size; i3++) { + if (value1[i3] !== value2[i3]) { + return false; + } + } + return true; + } + }; - // node_modules/@math.gl/web-mercator/dist/esm/web-mercator-utils.js - var PI = Math.PI; - var PI_4 = PI / 4; - var DEGREES_TO_RADIANS2 = PI / 180; - var RADIANS_TO_DEGREES2 = 180 / PI; - var TILE_SIZE = 512; - var EARTH_CIRCUMFERENCE = 4003e4; - var MAX_LATITUDE = 85.051129; - var DEFAULT_ALTITUDE = 1.5; - function scaleToZoom(scale3) { - return log22(scale3); - } - function lngLatToWorld(lngLat) { - const [lng, lat] = lngLat; - assert9(Number.isFinite(lng)); - assert9(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude"); - const lambda2 = lng * DEGREES_TO_RADIANS2; - const phi2 = lat * DEGREES_TO_RADIANS2; - const x2 = TILE_SIZE * (lambda2 + PI) / (2 * PI); - const y2 = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI); - return [x2, y2]; - } - function worldToLngLat(xy) { - const [x2, y2] = xy; - const lambda2 = x2 / TILE_SIZE * (2 * PI) - PI; - const phi2 = 2 * (Math.atan(Math.exp(y2 / TILE_SIZE * (2 * PI) - PI)) - PI_4); - return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2]; - } - function getMeterZoom(options) { - const { - latitude - } = options; - assert9(Number.isFinite(latitude)); - const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); - return scaleToZoom(EARTH_CIRCUMFERENCE * latCosine) - 9; - } - function unitsPerMeter(latitude) { - const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); - return TILE_SIZE / EARTH_CIRCUMFERENCE / latCosine; - } - function getDistanceScales(options) { - const { - latitude, - longitude, - highPrecision = false - } = options; - assert9(Number.isFinite(latitude) && Number.isFinite(longitude)); - const worldSize = TILE_SIZE; - const latCosine = Math.cos(latitude * DEGREES_TO_RADIANS2); - const unitsPerDegreeX = worldSize / 360; - const unitsPerDegreeY = unitsPerDegreeX / latCosine; - const altUnitsPerMeter = worldSize / EARTH_CIRCUMFERENCE / latCosine; - const result = { - unitsPerMeter: [altUnitsPerMeter, altUnitsPerMeter, altUnitsPerMeter], - metersPerUnit: [1 / altUnitsPerMeter, 1 / altUnitsPerMeter, 1 / altUnitsPerMeter], - unitsPerDegree: [unitsPerDegreeX, unitsPerDegreeY, altUnitsPerMeter], - degreesPerUnit: [1 / unitsPerDegreeX, 1 / unitsPerDegreeY, 1 / altUnitsPerMeter] + // node_modules/@deck.gl/core/dist/esm/utils/iterable-utils.js + var EMPTY_ARRAY = []; + var placeholderArray = []; + function createIterable(data, startRow = 0, endRow = Infinity) { + let iterable = EMPTY_ARRAY; + const objectInfo = { + index: -1, + data, + target: [] }; - if (highPrecision) { - const latCosine2 = DEGREES_TO_RADIANS2 * Math.tan(latitude * DEGREES_TO_RADIANS2) / latCosine; - const unitsPerDegreeY2 = unitsPerDegreeX * latCosine2 / 2; - const altUnitsPerDegree2 = worldSize / EARTH_CIRCUMFERENCE * latCosine2; - const altUnitsPerMeter2 = altUnitsPerDegree2 / unitsPerDegreeY * altUnitsPerMeter; - result.unitsPerDegree2 = [0, unitsPerDegreeY2, altUnitsPerDegree2]; - result.unitsPerMeter2 = [altUnitsPerMeter2, 0, altUnitsPerMeter2]; + if (!data) { + iterable = EMPTY_ARRAY; + } else if (typeof data[Symbol.iterator] === "function") { + iterable = data; + } else if (data.length > 0) { + placeholderArray.length = data.length; + iterable = placeholderArray; } - return result; + if (startRow > 0 || Number.isFinite(endRow)) { + iterable = (Array.isArray(iterable) ? iterable : Array.from(iterable)).slice(startRow, endRow); + objectInfo.index = startRow - 1; + } + return { + iterable, + objectInfo + }; } - function addMetersToLngLat(lngLatZ, xyz) { - const [longitude, latitude, z0] = lngLatZ; - const [x2, y2, z] = xyz; - const { - unitsPerMeter: unitsPerMeter2, - unitsPerMeter2: unitsPerMeter22 - } = getDistanceScales({ - longitude, - latitude, - highPrecision: true - }); - const worldspace = lngLatToWorld(lngLatZ); - worldspace[0] += x2 * (unitsPerMeter2[0] + unitsPerMeter22[0] * y2); - worldspace[1] += y2 * (unitsPerMeter2[1] + unitsPerMeter22[1] * y2); - const newLngLat = worldToLngLat(worldspace); - const newZ = (z0 || 0) + (z || 0); - return Number.isFinite(z0) || Number.isFinite(z) ? [newLngLat[0], newLngLat[1], newZ] : newLngLat; + function isAsyncIterable2(data) { + return data && data[Symbol.asyncIterator]; } - function getViewMatrix(options) { + function getAccessorFromBuffer(typedArray, options) { const { - height, - pitch, - bearing, - altitude, - scale: scale3, - center + size, + stride, + offset, + startIndices, + nested } = options; - const vm = createMat4(); - translate(vm, vm, [0, 0, -altitude]); - rotateX2(vm, vm, -pitch * DEGREES_TO_RADIANS2); - rotateZ2(vm, vm, bearing * DEGREES_TO_RADIANS2); - const relativeScale = scale3 / height; - scale(vm, vm, [relativeScale, relativeScale, relativeScale]); - if (center) { - translate(vm, vm, negate2([], center)); + const bytesPerElement = typedArray.BYTES_PER_ELEMENT; + const elementStride = stride ? stride / bytesPerElement : size; + const elementOffset = offset ? offset / bytesPerElement : 0; + const vertexCount = Math.floor((typedArray.length - elementOffset) / elementStride); + return (_2, { + index, + target + }) => { + if (!startIndices) { + const sourceIndex = index * elementStride + elementOffset; + for (let j = 0; j < size; j++) { + target[j] = typedArray[sourceIndex + j]; + } + return target; + } + const startIndex = startIndices[index]; + const endIndex = startIndices[index + 1] || vertexCount; + let result; + if (nested) { + result = new Array(endIndex - startIndex); + for (let i3 = startIndex; i3 < endIndex; i3++) { + const sourceIndex = i3 * elementStride + elementOffset; + target = new Array(size); + for (let j = 0; j < size; j++) { + target[j] = typedArray[sourceIndex + j]; + } + result[i3 - startIndex] = target; + } + } else if (elementStride === size) { + result = typedArray.subarray(startIndex * size + elementOffset, endIndex * size + elementOffset); + } else { + result = new typedArray.constructor((endIndex - startIndex) * size); + let targetIndex = 0; + for (let i3 = startIndex; i3 < endIndex; i3++) { + const sourceIndex = i3 * elementStride + elementOffset; + for (let j = 0; j < size; j++) { + result[targetIndex++] = typedArray[sourceIndex + j]; + } + } + } + return result; + }; + } + + // node_modules/@deck.gl/core/dist/esm/utils/range.js + var EMPTY = []; + var FULL = [[0, Infinity]]; + function add4(rangeList, range2) { + if (rangeList === FULL) { + return rangeList; } - return vm; + if (range2[0] < 0) { + range2[0] = 0; + } + if (range2[0] >= range2[1]) { + return rangeList; + } + const newRangeList = []; + const len2 = rangeList.length; + let insertPosition = 0; + for (let i3 = 0; i3 < len2; i3++) { + const range0 = rangeList[i3]; + if (range0[1] < range2[0]) { + newRangeList.push(range0); + insertPosition = i3 + 1; + } else if (range0[0] > range2[1]) { + newRangeList.push(range0); + } else { + range2 = [Math.min(range0[0], range2[0]), Math.max(range0[1], range2[1])]; + } + } + newRangeList.splice(insertPosition, 0, range2); + return newRangeList; } - function getProjectionParameters(options) { + + // node_modules/@deck.gl/core/dist/esm/utils/array-utils.js + function padArrayChunk(options) { const { - width, - height, - altitude, - pitch = 0, - offset, - center, - scale: scale3, - nearZMultiplier = 1, - farZMultiplier = 1 - } = options; - let { - fovy = altitudeToFovy(DEFAULT_ALTITUDE) + source, + target, + start = 0, + size, + getData } = options; - if (altitude !== void 0) { - fovy = altitudeToFovy(altitude); + const end = options.end || target.length; + const sourceLength = source.length; + const targetLength = end - start; + if (sourceLength > targetLength) { + target.set(source.subarray(0, targetLength), start); + return; } - const fovRadians = fovy * DEGREES_TO_RADIANS2; - const pitchRadians = pitch * DEGREES_TO_RADIANS2; - const focalDistance = fovyToAltitude(fovy); - let cameraToSeaLevelDistance = focalDistance; - if (center) { - cameraToSeaLevelDistance += center[2] * scale3 / Math.cos(pitchRadians) / height; + target.set(source, start); + if (!getData) { + return; + } + let i3 = sourceLength; + while (i3 < targetLength) { + const datum = getData(i3, source); + for (let j = 0; j < size; j++) { + target[start + i3] = datum[j] || 0; + i3++; + } } - const fovAboveCenter = fovRadians * (0.5 + (offset ? offset[1] : 0) / height); - const topHalfSurfaceDistance = Math.sin(fovAboveCenter) * cameraToSeaLevelDistance / Math.sin(clamp2(Math.PI / 2 - pitchRadians - fovAboveCenter, 0.01, Math.PI - 0.01)); - const furthestDistance = Math.sin(pitchRadians) * topHalfSurfaceDistance + cameraToSeaLevelDistance; - const horizonDistance = cameraToSeaLevelDistance * 10; - const farZ = Math.min(furthestDistance * farZMultiplier, horizonDistance); - return { - fov: fovRadians, - aspect: width / height, - focalDistance, - near: nearZMultiplier, - far: farZ - }; - } - function altitudeToFovy(altitude) { - return 2 * Math.atan(0.5 / altitude) * RADIANS_TO_DEGREES2; - } - function fovyToAltitude(fovy) { - return 0.5 / Math.tan(0.5 * fovy * DEGREES_TO_RADIANS2); - } - function worldToPixels(xyz, pixelProjectionMatrix) { - const [x2, y2, z = 0] = xyz; - assert9(Number.isFinite(x2) && Number.isFinite(y2) && Number.isFinite(z)); - return transformVector(pixelProjectionMatrix, [x2, y2, z, 1]); } - function pixelsToWorld(xyz, pixelUnprojectionMatrix, targetZ = 0) { - const [x2, y2, z] = xyz; - assert9(Number.isFinite(x2) && Number.isFinite(y2), "invalid pixel coordinate"); - if (Number.isFinite(z)) { - const coord = transformVector(pixelUnprojectionMatrix, [x2, y2, z, 1]); - return coord; + function padArray({ + source, + target, + size, + getData, + sourceStartIndices, + targetStartIndices + }) { + if (!Array.isArray(targetStartIndices)) { + padArrayChunk({ + source, + target, + size, + getData + }); + return target; } - const coord0 = transformVector(pixelUnprojectionMatrix, [x2, y2, 0, 1]); - const coord1 = transformVector(pixelUnprojectionMatrix, [x2, y2, 1, 1]); - const z0 = coord0[2]; - const z1 = coord1[2]; - const t2 = z0 === z1 ? 0 : ((targetZ || 0) - z0) / (z1 - z0); - return lerp2([], coord0, coord1, t2); + let sourceIndex = 0; + let targetIndex = 0; + const getChunkData = getData && ((i3, chunk) => getData(i3 + targetIndex, chunk)); + const n2 = Math.min(sourceStartIndices.length, targetStartIndices.length); + for (let i3 = 1; i3 < n2; i3++) { + const nextSourceIndex = sourceStartIndices[i3] * size; + const nextTargetIndex = targetStartIndices[i3] * size; + padArrayChunk({ + source: source.subarray(sourceIndex, nextSourceIndex), + target, + start: targetIndex, + end: nextTargetIndex, + size, + getData: getChunkData + }); + sourceIndex = nextSourceIndex; + targetIndex = nextTargetIndex; + } + if (targetIndex < target.length) { + padArrayChunk({ + source: [], + target, + start: targetIndex, + size, + getData: getChunkData + }); + } + return target; } - // node_modules/@math.gl/web-mercator/dist/esm/fit-bounds.js - function fitBounds(options) { - const { - width, - height, - bounds, - minExtent = 0, - maxZoom = 24, - offset = [0, 0] - } = options; - const [[west, south], [east, north]] = bounds; - const padding = getPaddingObject(options.padding); - const nw = lngLatToWorld([west, clamp2(north, -MAX_LATITUDE, MAX_LATITUDE)]); - const se = lngLatToWorld([east, clamp2(south, -MAX_LATITUDE, MAX_LATITUDE)]); - const size = [Math.max(Math.abs(se[0] - nw[0]), minExtent), Math.max(Math.abs(se[1] - nw[1]), minExtent)]; - const targetSize = [width - padding.left - padding.right - Math.abs(offset[0]) * 2, height - padding.top - padding.bottom - Math.abs(offset[1]) * 2]; - assert9(targetSize[0] > 0 && targetSize[1] > 0); - const scaleX2 = targetSize[0] / size[0]; - const scaleY2 = targetSize[1] / size[1]; - const offsetX = (padding.right - padding.left) / 2 / scaleX2; - const offsetY = (padding.top - padding.bottom) / 2 / scaleY2; - const center = [(se[0] + nw[0]) / 2 + offsetX, (se[1] + nw[1]) / 2 + offsetY]; - const centerLngLat = worldToLngLat(center); - const zoom = Math.min(maxZoom, log22(Math.abs(Math.min(scaleX2, scaleY2)))); - assert9(Number.isFinite(zoom)); + // node_modules/@deck.gl/core/dist/esm/lib/attribute/attribute-transition-utils.js + var DEFAULT_TRANSITION_SETTINGS = { + interpolation: { + duration: 0, + easing: (t2) => t2 + }, + spring: { + stiffness: 0.05, + damping: 0.5 + } + }; + function normalizeTransitionSettings(userSettings, layerSettings) { + if (!userSettings) { + return null; + } + if (Number.isFinite(userSettings)) { + userSettings = { + type: "interpolation", + duration: userSettings + }; + } + const type = userSettings.type || "interpolation"; return { - longitude: centerLngLat[0], - latitude: centerLngLat[1], - zoom + ...DEFAULT_TRANSITION_SETTINGS[type], + ...layerSettings, + ...userSettings, + type }; } - function getPaddingObject(padding = 0) { - if (typeof padding === "number") { - return { - top: padding, - bottom: padding, - left: padding, - right: padding - }; + function getSourceBufferAttribute(gl, attribute) { + const buffer = attribute.getBuffer(); + if (buffer) { + return [buffer, { + divisor: 0, + size: attribute.size, + normalized: attribute.settings.normalized + }]; } - assert9(Number.isFinite(padding.top) && Number.isFinite(padding.bottom) && Number.isFinite(padding.left) && Number.isFinite(padding.right)); - return padding; + return attribute.value; } - - // node_modules/@math.gl/web-mercator/dist/esm/get-bounds.js - var DEGREES_TO_RADIANS3 = Math.PI / 180; - function getBounds(viewport, z = 0) { - const { - width, - height, - unproject - } = viewport; - const unprojectOps = { - targetZ: z - }; - const bottomLeft = unproject([0, height], unprojectOps); - const bottomRight = unproject([width, height], unprojectOps); - let topLeft; - let topRight; - const halfFov = viewport.fovy ? 0.5 * viewport.fovy * DEGREES_TO_RADIANS3 : Math.atan(0.5 / viewport.altitude); - const angleToGround = (90 - viewport.pitch) * DEGREES_TO_RADIANS3; - if (halfFov > angleToGround - 0.01) { - topLeft = unprojectOnFarPlane(viewport, 0, z); - topRight = unprojectOnFarPlane(viewport, width, z); - } else { - topLeft = unproject([0, 0], unprojectOps); - topRight = unproject([width, 0], unprojectOps); + function getAttributeTypeFromSize(size) { + switch (size) { + case 1: + return "float"; + case 2: + return "vec2"; + case 3: + return "vec3"; + case 4: + return "vec4"; + default: + throw new Error('No defined attribute type for size "'.concat(size, '"')); } - return [bottomLeft, bottomRight, topRight, topLeft]; } - function unprojectOnFarPlane(viewport, x2, targetZ) { + function cycleBuffers(buffers) { + buffers.push(buffers.shift()); + } + function getAttributeBufferLength(attribute, numInstances) { const { - pixelUnprojectionMatrix - } = viewport; - const coord0 = transformVector(pixelUnprojectionMatrix, [x2, 0, 1, 1]); - const coord1 = transformVector(pixelUnprojectionMatrix, [x2, viewport.height, 1, 1]); - const z = targetZ * viewport.distanceScales.unitsPerMeter[2]; - const t2 = (z - coord0[2]) / (coord1[2] - coord0[2]); - const coord = lerp2([], coord0, coord1, t2); - const result = worldToLngLat(coord); - result.push(targetZ); - return result; + doublePrecision, + settings, + value, + size + } = attribute; + const multiplier = doublePrecision && value instanceof Float64Array ? 2 : 1; + return (settings.noAlloc ? value.length : numInstances * size) * multiplier; + } + function padBuffer({ + buffer, + numInstances, + attribute, + fromLength, + fromStartIndices, + getData = (x2) => x2 + }) { + const precisionMultiplier = attribute.doublePrecision && attribute.value instanceof Float64Array ? 2 : 1; + const size = attribute.size * precisionMultiplier; + const byteOffset = attribute.byteOffset; + const toStartIndices = attribute.startIndices; + const hasStartIndices = fromStartIndices && toStartIndices; + const toLength = getAttributeBufferLength(attribute, numInstances); + const isConstant = attribute.isConstant; + if (!hasStartIndices && fromLength >= toLength) { + return; + } + const toData = isConstant ? attribute.value : attribute.getBuffer().getData({ + srcByteOffset: byteOffset + }); + if (attribute.settings.normalized && !isConstant) { + const getter = getData; + getData = (value, chunk) => attribute.normalizeConstant(getter(value, chunk)); + } + const getMissingData = isConstant ? (i3, chunk) => getData(toData, chunk) : (i3, chunk) => getData(toData.subarray(i3, i3 + size), chunk); + const source = buffer.getData({ + length: fromLength + }); + const data = new Float32Array(toLength); + padArray({ + source, + target: data, + sourceStartIndices: fromStartIndices, + targetStartIndices: toStartIndices, + size, + getData: getMissingData + }); + if (buffer.byteLength < data.byteLength + byteOffset) { + buffer.reallocate(data.byteLength + byteOffset); + } + buffer.subData({ + data, + offset: byteOffset + }); } - // node_modules/@math.gl/web-mercator/dist/esm/normalize-viewport-props.js - var TILE_SIZE2 = 512; - function normalizeViewportProps(props) { - const { - width, - height, - pitch = 0 - } = props; - let { - longitude, - latitude, - zoom, - bearing = 0 - } = props; - if (longitude < -180 || longitude > 180) { - longitude = mod(longitude + 180, 360) - 180; + // node_modules/@deck.gl/core/dist/esm/lib/attribute/attribute.js + var Attribute = class extends DataColumn { + constructor(gl, opts) { + super(gl, opts, { + startIndices: null, + lastExternalBuffer: null, + binaryValue: null, + binaryAccessor: null, + needsUpdate: true, + needsRedraw: false, + updateRanges: FULL + }); + _defineProperty(this, "constant", false); + this.settings.update = opts.update || (opts.accessor ? this._autoUpdater : void 0); + Object.seal(this.settings); + Object.seal(this.state); + this._validateAttributeUpdaters(); } - if (bearing < -180 || bearing > 180) { - bearing = mod(bearing + 180, 360) - 180; + get startIndices() { + return this.state.startIndices; } - const minZoom = log22(height / TILE_SIZE2); - if (zoom <= minZoom) { - zoom = minZoom; - latitude = 0; - } else { - const halfHeightPixels = height / 2 / Math.pow(2, zoom); - const minLatitude = worldToLngLat([0, halfHeightPixels])[1]; - if (latitude < minLatitude) { - latitude = minLatitude; - } else { - const maxLatitude = worldToLngLat([0, TILE_SIZE2 - halfHeightPixels])[1]; - if (latitude > maxLatitude) { - latitude = maxLatitude; - } - } + set startIndices(layout) { + this.state.startIndices = layout; } - return { - width, - height, - longitude, - latitude, - zoom, - pitch, - bearing - }; - } - - // node_modules/@deck.gl/core/dist/esm/shaderlib/shadow/shadow.js - var vs4 = "\nconst int max_lights = 2;\nuniform mat4 shadow_uViewProjectionMatrices[max_lights];\nuniform vec4 shadow_uProjectCenters[max_lights];\nuniform bool shadow_uDrawShadowMap;\nuniform bool shadow_uUseShadowMap;\nuniform int shadow_uLightId;\nuniform float shadow_uLightCount;\n\nvarying vec3 shadow_vPosition[max_lights];\n\nvec4 shadow_setVertexPosition(vec4 position_commonspace) {\n if (shadow_uDrawShadowMap) {\n return project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[shadow_uLightId], shadow_uProjectCenters[shadow_uLightId]);\n }\n if (shadow_uUseShadowMap) {\n for (int i = 0; i < max_lights; i++) {\n if(i < int(shadow_uLightCount)) {\n vec4 shadowMap_position = project_common_position_to_clipspace(position_commonspace, shadow_uViewProjectionMatrices[i], shadow_uProjectCenters[i]);\n shadow_vPosition[i] = (shadowMap_position.xyz / shadowMap_position.w + 1.0) / 2.0;\n }\n }\n }\n return gl_Position;\n}\n"; - var fs3 = "\nconst int max_lights = 2;\nuniform bool shadow_uDrawShadowMap;\nuniform bool shadow_uUseShadowMap;\nuniform sampler2D shadow_uShadowMap0;\nuniform sampler2D shadow_uShadowMap1;\nuniform vec4 shadow_uColor;\nuniform float shadow_uLightCount;\n\nvarying vec3 shadow_vPosition[max_lights];\n\nconst vec4 bitPackShift = vec4(1.0, 255.0, 65025.0, 16581375.0);\nconst vec4 bitUnpackShift = 1.0 / bitPackShift;\nconst vec4 bitMask = vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0);\n\nfloat shadow_getShadowWeight(vec3 position, sampler2D shadowMap) {\n vec4 rgbaDepth = texture2D(shadowMap, position.xy);\n\n float z = dot(rgbaDepth, bitUnpackShift);\n return smoothstep(0.001, 0.01, position.z - z);\n}\n\nvec4 shadow_filterShadowColor(vec4 color) {\n if (shadow_uDrawShadowMap) {\n vec4 rgbaDepth = fract(gl_FragCoord.z * bitPackShift);\n rgbaDepth -= rgbaDepth.gbaa * bitMask;\n return rgbaDepth;\n }\n if (shadow_uUseShadowMap) {\n float shadowAlpha = 0.0;\n shadowAlpha += shadow_getShadowWeight(shadow_vPosition[0], shadow_uShadowMap0);\n if(shadow_uLightCount > 1.0) {\n shadowAlpha += shadow_getShadowWeight(shadow_vPosition[1], shadow_uShadowMap1);\n }\n shadowAlpha *= shadow_uColor.a / shadow_uLightCount;\n float blendedAlpha = shadowAlpha + color.a * (1.0 - shadowAlpha);\n\n return vec4(\n mix(color.rgb, shadow_uColor.rgb, shadowAlpha / blendedAlpha),\n blendedAlpha\n );\n }\n return color;\n}\n"; - var getMemoizedViewportCenterPosition = memoize(getViewportCenterPosition); - var getMemoizedViewProjectionMatrices = memoize(getViewProjectionMatrices); - var DEFAULT_SHADOW_COLOR = [0, 0, 0, 1]; - var VECTOR_TO_POINT_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]; - function screenToCommonSpace(xyz, pixelUnprojectionMatrix) { - const [x2, y2, z] = xyz; - const coord = pixelsToWorld([x2, y2, z], pixelUnprojectionMatrix); - if (Number.isFinite(z)) { - return coord; + needsUpdate() { + return this.state.needsUpdate; } - return [coord[0], coord[1], 0]; - } - function getViewportCenterPosition({ - viewport, - center - }) { - return new Matrix4(viewport.viewProjectionMatrix).invert().transform(center); - } - function getViewProjectionMatrices({ - viewport, - shadowMatrices - }) { - const projectionMatrices = []; - const pixelUnprojectionMatrix = viewport.pixelUnprojectionMatrix; - const farZ = viewport.isGeospatial ? void 0 : 1; - const corners = [[0, 0, farZ], [viewport.width, 0, farZ], [0, viewport.height, farZ], [viewport.width, viewport.height, farZ], [0, 0, -1], [viewport.width, 0, -1], [0, viewport.height, -1], [viewport.width, viewport.height, -1]].map((pixel) => screenToCommonSpace(pixel, pixelUnprojectionMatrix)); - for (const shadowMatrix of shadowMatrices) { - const viewMatrix = shadowMatrix.clone().translate(new Vector3(viewport.center).negate()); - const positions = corners.map((corner) => viewMatrix.transform(corner)); - const projectionMatrix = new Matrix4().ortho({ - left: Math.min(...positions.map((position) => position[0])), - right: Math.max(...positions.map((position) => position[0])), - bottom: Math.min(...positions.map((position) => position[1])), - top: Math.max(...positions.map((position) => position[1])), - near: Math.min(...positions.map((position) => -position[2])), - far: Math.max(...positions.map((position) => -position[2])) - }); - projectionMatrices.push(projectionMatrix.multiplyRight(shadowMatrix)); + needsRedraw({ + clearChangedFlags = false + } = {}) { + const needsRedraw = this.state.needsRedraw; + this.state.needsRedraw = needsRedraw && !clearChangedFlags; + return needsRedraw; } - return projectionMatrices; - } - function createShadowUniforms(opts, context) { - const { - shadowEnabled = true - } = opts; - if (!shadowEnabled || !opts.shadowMatrices || !opts.shadowMatrices.length) { - return { - shadow_uDrawShadowMap: false, - shadow_uUseShadowMap: false - }; + getUpdateTriggers() { + const { + accessor + } = this.settings; + return [this.id].concat(typeof accessor !== "function" && accessor || []); } - const uniforms = { - shadow_uDrawShadowMap: Boolean(opts.drawToShadowMap), - shadow_uUseShadowMap: opts.shadowMaps ? opts.shadowMaps.length > 0 : false, - shadow_uColor: opts.shadowColor || DEFAULT_SHADOW_COLOR, - shadow_uLightId: opts.shadowLightId || 0, - shadow_uLightCount: opts.shadowMatrices.length - }; - const center = getMemoizedViewportCenterPosition({ - viewport: opts.viewport, - center: context.project_uCenter - }); - const projectCenters = []; - const viewProjectionMatrices = getMemoizedViewProjectionMatrices({ - shadowMatrices: opts.shadowMatrices, - viewport: opts.viewport - }).slice(); - for (let i2 = 0; i2 < opts.shadowMatrices.length; i2++) { - const viewProjectionMatrix = viewProjectionMatrices[i2]; - const viewProjectionMatrixCentered = viewProjectionMatrix.clone().translate(new Vector3(opts.viewport.center).negate()); - if (context.project_uCoordinateSystem === COORDINATE_SYSTEM.LNGLAT && context.project_uProjectionMode === PROJECTION_MODE.WEB_MERCATOR) { - viewProjectionMatrices[i2] = viewProjectionMatrixCentered; - projectCenters[i2] = center; + supportsTransition() { + return Boolean(this.settings.transition); + } + getTransitionSetting(opts) { + if (!opts || !this.supportsTransition()) { + return null; + } + const { + accessor + } = this.settings; + const layerSettings = this.settings.transition; + const userSettings = Array.isArray(accessor) ? opts[accessor.find((a2) => opts[a2])] : opts[accessor]; + return normalizeTransitionSettings(userSettings, layerSettings); + } + setNeedsUpdate(reason = this.id, dataRange) { + this.state.needsUpdate = this.state.needsUpdate || reason; + this.setNeedsRedraw(reason); + if (dataRange) { + const { + startRow = 0, + endRow = Infinity + } = dataRange; + this.state.updateRanges = add4(this.state.updateRanges, [startRow, endRow]); } else { - viewProjectionMatrices[i2] = viewProjectionMatrix.clone().multiplyRight(VECTOR_TO_POINT_MATRIX2); - projectCenters[i2] = viewProjectionMatrixCentered.transform(center); + this.state.updateRanges = FULL; } } - for (let i2 = 0; i2 < viewProjectionMatrices.length; i2++) { - uniforms["shadow_uViewProjectionMatrices[".concat(i2, "]")] = viewProjectionMatrices[i2]; - uniforms["shadow_uProjectCenters[".concat(i2, "]")] = projectCenters[i2]; - if (opts.shadowMaps && opts.shadowMaps.length > 0) { - uniforms["shadow_uShadowMap".concat(i2)] = opts.shadowMaps[i2]; + clearNeedsUpdate() { + this.state.needsUpdate = false; + this.state.updateRanges = EMPTY; + } + setNeedsRedraw(reason = this.id) { + this.state.needsRedraw = this.state.needsRedraw || reason; + } + allocate(numInstances) { + const { + state, + settings + } = this; + if (settings.noAlloc) { + return false; + } + if (settings.update) { + super.allocate(numInstances, state.updateRanges !== FULL); + return true; + } + return false; + } + updateBuffer({ + numInstances, + data, + props, + context + }) { + if (!this.needsUpdate()) { + return false; + } + const { + state: { + updateRanges + }, + settings: { + update, + noAlloc + } + } = this; + let updated = true; + if (update) { + for (const [startRow, endRow] of updateRanges) { + update.call(context, this, { + data, + startRow, + endRow, + props, + numInstances + }); + } + if (!this.value) { + } else if (this.constant || this.buffer.byteLength < this.value.byteLength + this.byteOffset) { + this.setData({ + value: this.value, + constant: this.constant + }); + this.constant = false; + } else { + for (const [startRow, endRow] of updateRanges) { + const startOffset = Number.isFinite(startRow) ? this.getVertexOffset(startRow) : 0; + const endOffset = Number.isFinite(endRow) ? this.getVertexOffset(endRow) : noAlloc || !Number.isFinite(numInstances) ? this.value.length : numInstances * this.size; + super.updateSubBuffer({ + startOffset, + endOffset + }); + } + } + this._checkAttributeArray(); } else { - uniforms["shadow_uShadowMap".concat(i2)] = opts.dummyShadowMap; + updated = false; } + this.clearNeedsUpdate(); + this.setNeedsRedraw(); + return updated; } - return uniforms; - } - var shadow_default = { - name: "shadow", - dependencies: [project_default], - vs: vs4, - fs: fs3, - inject: { - "vs:DECKGL_FILTER_GL_POSITION": "\n position = shadow_setVertexPosition(geometry.position);\n ", - "fs:DECKGL_FILTER_COLOR": "\n color = shadow_filterShadowColor(color);\n " - }, - getUniforms: (opts = {}, context = {}) => { - if ("viewport" in opts && (opts.drawToShadowMap || opts.shadowMaps && opts.shadowMaps.length > 0)) { - return createShadowUniforms(opts, context); + setConstantValue(value) { + if (value === void 0 || typeof value === "function") { + return false; } - return {}; + const hasChanged = this.setData({ + constant: true, + value + }); + if (hasChanged) { + this.setNeedsRedraw(); + } + this.clearNeedsUpdate(); + return true; } - }; - - // node_modules/@deck.gl/core/dist/esm/effects/lighting/lighting-effect.js - var DEFAULT_AMBIENT_LIGHT_PROPS = { - color: [255, 255, 255], - intensity: 1 - }; - var DEFAULT_DIRECTIONAL_LIGHT_PROPS = [{ - color: [255, 255, 255], - intensity: 1, - direction: [-1, 3, -1] - }, { - color: [255, 255, 255], - intensity: 0.9, - direction: [1, -8, -2.5] - }]; - var DEFAULT_SHADOW_COLOR2 = [0, 0, 0, 200 / 255]; - var LightingEffect = class { - constructor(props = {}) { - _defineProperty(this, "id", "lighting-effect"); - _defineProperty(this, "props", void 0); - _defineProperty(this, "shadowColor", DEFAULT_SHADOW_COLOR2); - _defineProperty(this, "shadow", void 0); - _defineProperty(this, "ambientLight", void 0); - _defineProperty(this, "directionalLights", void 0); - _defineProperty(this, "pointLights", void 0); - _defineProperty(this, "shadowPasses", []); - _defineProperty(this, "shadowMaps", []); - _defineProperty(this, "dummyShadowMap", null); - _defineProperty(this, "programManager", void 0); - _defineProperty(this, "shadowMatrices", void 0); - this.setProps(props); + setExternalBuffer(buffer) { + const { + state + } = this; + if (!buffer) { + state.lastExternalBuffer = null; + return false; + } + this.clearNeedsUpdate(); + if (state.lastExternalBuffer === buffer) { + return true; + } + state.lastExternalBuffer = buffer; + this.setNeedsRedraw(); + this.setData(buffer); + return true; } - setProps(props) { - this.ambientLight = null; - this.directionalLights = []; - this.pointLights = []; - for (const key in props) { - const lightSource = props[key]; - switch (lightSource.type) { - case "ambient": - this.ambientLight = lightSource; - break; - case "directional": - this.directionalLights.push(lightSource); - break; - case "point": - this.pointLights.push(lightSource); - break; - default: + setBinaryValue(buffer, startIndices = null) { + const { + state, + settings + } = this; + if (!buffer) { + state.binaryValue = null; + state.binaryAccessor = null; + return false; + } + if (settings.noAlloc) { + return false; + } + if (state.binaryValue === buffer) { + this.clearNeedsUpdate(); + return true; + } + state.binaryValue = buffer; + this.setNeedsRedraw(); + const needsUpdate = settings.transform || startIndices !== this.startIndices; + if (needsUpdate) { + if (ArrayBuffer.isView(buffer)) { + buffer = { + value: buffer + }; } + const binaryValue = buffer; + assert10(ArrayBuffer.isView(binaryValue.value), "invalid ".concat(settings.accessor)); + const needsNormalize = Boolean(binaryValue.size) && binaryValue.size !== this.size; + state.binaryAccessor = getAccessorFromBuffer(binaryValue.value, { + size: binaryValue.size || this.size, + stride: binaryValue.stride, + offset: binaryValue.offset, + startIndices, + nested: needsNormalize + }); + return false; } - this._applyDefaultLights(); - this.shadow = this.directionalLights.some((light) => light.shadow); - this.props = props; + this.clearNeedsUpdate(); + this.setData(buffer); + return true; } - preRender(gl, { - layers, - layerFilter, - viewports, - onViewportActive, - views + getVertexOffset(row) { + const { + startIndices + } = this; + const vertexIndex = startIndices ? row < startIndices.length ? startIndices[row] : this.numInstances : row; + return vertexIndex * this.size; + } + getShaderAttributes() { + const shaderAttributeDefs = this.settings.shaderAttributes || { + [this.id]: null + }; + const shaderAttributes = {}; + for (const shaderAttributeName in shaderAttributeDefs) { + Object.assign(shaderAttributes, super.getShaderAttributes(shaderAttributeName, shaderAttributeDefs[shaderAttributeName])); + } + return shaderAttributes; + } + _autoUpdater(attribute, { + data, + startRow, + endRow, + props, + numInstances }) { - if (!this.shadow) + if (attribute.constant) { return; - this.shadowMatrices = this._calculateMatrices(); - if (this.shadowPasses.length === 0) { - this._createShadowPasses(gl); } - if (!this.programManager) { - this.programManager = ProgramManager.getDefaultProgramManager(gl); - if (shadow_default) { - this.programManager.addDefaultModule(shadow_default); + const { + settings, + state, + value, + size, + startIndices + } = attribute; + const { + accessor, + transform: transform2 + } = settings; + const accessorFunc = state.binaryAccessor || (typeof accessor === "function" ? accessor : props[accessor]); + assert10(typeof accessorFunc === "function", 'accessor "'.concat(accessor, '" is not a function')); + let i3 = attribute.getVertexOffset(startRow); + const { + iterable, + objectInfo + } = createIterable(data, startRow, endRow); + for (const object of iterable) { + objectInfo.index++; + let objectValue = accessorFunc(object, objectInfo); + if (transform2) { + objectValue = transform2.call(this, objectValue); + } + if (startIndices) { + const numVertices = (objectInfo.index < startIndices.length - 1 ? startIndices[objectInfo.index + 1] : numInstances) - startIndices[objectInfo.index]; + if (objectValue && Array.isArray(objectValue[0])) { + let startIndex = i3; + for (const item of objectValue) { + attribute._normalizeValue(item, value, startIndex); + startIndex += size; + } + } else if (objectValue && objectValue.length > size) { + value.set(objectValue, i3); + } else { + attribute._normalizeValue(objectValue, objectInfo.target, 0); + fillArray2({ + target: value, + source: objectInfo.target, + start: i3, + count: numVertices + }); + } + i3 += numVertices * size; + } else { + attribute._normalizeValue(objectValue, value, i3); + i3 += size; } } - if (!this.dummyShadowMap) { - this.dummyShadowMap = new Texture2D(gl, { - width: 1, - height: 1 - }); + } + _validateAttributeUpdaters() { + const { + settings + } = this; + const hasUpdater = settings.noAlloc || typeof settings.update === "function"; + if (!hasUpdater) { + throw new Error("Attribute ".concat(this.id, " missing update or accessor")); } - for (let i2 = 0; i2 < this.shadowPasses.length; i2++) { - const shadowPass = this.shadowPasses[i2]; - shadowPass.render({ - layers, - layerFilter, - viewports, - onViewportActive, - views, - moduleParameters: { - shadowLightId: i2, - dummyShadowMap: this.dummyShadowMap, - shadowMatrices: this.shadowMatrices - } - }); + } + _checkAttributeArray() { + const { + value + } = this; + const limit = Math.min(4, this.size); + if (value && value.length >= limit) { + let valid = true; + switch (limit) { + case 4: + valid = valid && Number.isFinite(value[3]); + case 3: + valid = valid && Number.isFinite(value[2]); + case 2: + valid = valid && Number.isFinite(value[1]); + case 1: + valid = valid && Number.isFinite(value[0]); + break; + default: + valid = false; + } + if (!valid) { + throw new Error("Illegal attribute generated for ".concat(this.id)); + } } } - getModuleParameters(layer) { - const parameters = this.shadow ? { - shadowMaps: this.shadowMaps, - dummyShadowMap: this.dummyShadowMap, - shadowColor: this.shadowColor, - shadowMatrices: this.shadowMatrices - } : {}; - parameters.lightSources = { - ambientLight: this.ambientLight, - directionalLights: this.directionalLights.map((directionalLight) => directionalLight.getProjectedLight({ - layer - })), - pointLights: this.pointLights.map((pointLight) => pointLight.getProjectedLight({ - layer - })) + }; + + // node_modules/@deck.gl/core/dist/esm/transitions/gpu-interpolation-transition.js + var GPUInterpolationTransition = class { + constructor({ + gl, + attribute, + timeline + }) { + _defineProperty(this, "gl", void 0); + _defineProperty(this, "type", "interpolation"); + _defineProperty(this, "attributeInTransition", void 0); + _defineProperty(this, "settings", void 0); + _defineProperty(this, "attribute", void 0); + _defineProperty(this, "transition", void 0); + _defineProperty(this, "currentStartIndices", void 0); + _defineProperty(this, "currentLength", void 0); + _defineProperty(this, "transform", void 0); + _defineProperty(this, "buffers", void 0); + this.gl = gl; + this.transition = new Transition(timeline); + this.attribute = attribute; + this.attributeInTransition = new Attribute(gl, attribute.settings); + this.currentStartIndices = attribute.startIndices; + this.currentLength = 0; + this.transform = getTransform(gl, attribute); + const bufferOpts = { + byteLength: 0, + usage: 35050 }; - return parameters; + this.buffers = [new Buffer2(gl, bufferOpts), new Buffer2(gl, bufferOpts)]; } - cleanup() { - for (const shadowPass of this.shadowPasses) { - shadowPass.delete(); - } - this.shadowPasses.length = 0; - this.shadowMaps.length = 0; - if (this.dummyShadowMap) { - this.dummyShadowMap.delete(); - this.dummyShadowMap = null; - } - if (this.shadow && this.programManager) { - this.programManager.removeDefaultModule(shadow_default); - this.programManager = null; - } + get inProgress() { + return this.transition.inProgress; } - _calculateMatrices() { - const lightMatrices = []; - for (const light of this.directionalLights) { - const viewMatrix = new Matrix4().lookAt({ - eye: new Vector3(light.direction).negate() + start(transitionSettings, numInstances) { + if (transitionSettings.duration <= 0) { + this.transition.cancel(); + return; + } + this.settings = transitionSettings; + const { + gl, + buffers, + attribute + } = this; + cycleBuffers(buffers); + const padBufferOpts = { + numInstances, + attribute, + fromLength: this.currentLength, + fromStartIndices: this.currentStartIndices, + getData: transitionSettings.enter + }; + for (const buffer of buffers) { + padBuffer({ + buffer, + ...padBufferOpts }); - lightMatrices.push(viewMatrix); } - return lightMatrices; + this.currentStartIndices = attribute.startIndices; + this.currentLength = getAttributeBufferLength(attribute, numInstances); + this.attributeInTransition.setData({ + buffer: buffers[1], + value: attribute.value + }); + this.transition.start(transitionSettings); + this.transform.update({ + elementCount: Math.floor(this.currentLength / attribute.size), + sourceBuffers: { + aFrom: buffers[0], + aTo: getSourceBufferAttribute(gl, attribute) + }, + feedbackBuffers: { + vCurrent: buffers[1] + } + }); } - _createShadowPasses(gl) { - for (let i2 = 0; i2 < this.directionalLights.length; i2++) { - const shadowPass = new ShadowPass(gl); - this.shadowPasses[i2] = shadowPass; - this.shadowMaps[i2] = shadowPass.shadowMap; + update() { + const updated = this.transition.update(); + if (updated) { + const { + duration, + easing + } = this.settings; + const { + time + } = this.transition; + let t2 = time / duration; + if (easing) { + t2 = easing(t2); + } + this.transform.run({ + uniforms: { + time: t2 + } + }); } + return updated; } - _applyDefaultLights() { - const { - ambientLight, - pointLights, - directionalLights - } = this; - if (!ambientLight && pointLights.length === 0 && directionalLights.length === 0) { - this.ambientLight = new AmbientLight(DEFAULT_AMBIENT_LIGHT_PROPS); - this.directionalLights.push(new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[0]), new DirectionalLight(DEFAULT_DIRECTIONAL_LIGHT_PROPS[1])); + cancel() { + this.transition.cancel(); + this.transform.delete(); + for (const buffer of this.buffers) { + buffer.delete(); } + this.buffers.length = 0; } }; + var vs6 = "\n#define SHADER_NAME interpolation-transition-vertex-shader\n\nuniform float time;\nattribute ATTRIBUTE_TYPE aFrom;\nattribute ATTRIBUTE_TYPE aTo;\nvarying ATTRIBUTE_TYPE vCurrent;\n\nvoid main(void) {\n vCurrent = mix(aFrom, aTo, time);\n gl_Position = vec4(0.0);\n}\n"; + function getTransform(gl, attribute) { + const attributeType = getAttributeTypeFromSize(attribute.size); + return new Transform(gl, { + vs: vs6, + defines: { + ATTRIBUTE_TYPE: attributeType + }, + varyings: ["vCurrent"] + }); + } - // node_modules/@deck.gl/core/dist/esm/utils/typed-array-manager.js - var TypedArrayManager = class { - constructor(options = {}) { - _defineProperty(this, "_pool", []); - _defineProperty(this, "opts", { - overAlloc: 2, - poolSize: 100 + // node_modules/@deck.gl/core/dist/esm/transitions/gpu-spring-transition.js + var GPUSpringTransition = class { + constructor({ + gl, + attribute, + timeline + }) { + _defineProperty(this, "gl", void 0); + _defineProperty(this, "type", "spring"); + _defineProperty(this, "attributeInTransition", void 0); + _defineProperty(this, "settings", void 0); + _defineProperty(this, "attribute", void 0); + _defineProperty(this, "transition", void 0); + _defineProperty(this, "currentStartIndices", void 0); + _defineProperty(this, "currentLength", void 0); + _defineProperty(this, "texture", void 0); + _defineProperty(this, "framebuffer", void 0); + _defineProperty(this, "transform", void 0); + _defineProperty(this, "buffers", void 0); + this.gl = gl; + this.type = "spring"; + this.transition = new Transition(timeline); + this.attribute = attribute; + this.attributeInTransition = new Attribute(gl, { + ...attribute.settings, + normalized: false }); - this.setOptions(options); + this.currentStartIndices = attribute.startIndices; + this.currentLength = 0; + this.texture = getTexture(gl); + this.framebuffer = getFramebuffer2(gl, this.texture); + this.transform = getTransform2(gl, attribute, this.framebuffer); + const bufferOpts = { + byteLength: 0, + usage: 35050 + }; + this.buffers = [new Buffer2(gl, bufferOpts), new Buffer2(gl, bufferOpts), new Buffer2(gl, bufferOpts)]; } - setOptions(options) { - Object.assign(this.opts, options); + get inProgress() { + return this.transition.inProgress; } - allocate(typedArray, count2, { - size = 1, - type, - padding = 0, - copy = false, - initialize = false, - maxCount - }) { - const Type = type || typedArray && typedArray.constructor || Float32Array; - const newSize = count2 * size + padding; - if (ArrayBuffer.isView(typedArray)) { - if (newSize <= typedArray.length) { - return typedArray; - } - if (newSize * typedArray.BYTES_PER_ELEMENT <= typedArray.buffer.byteLength) { - return new Type(typedArray.buffer, 0, newSize); - } - } - let maxSize = Infinity; - if (maxCount) { - maxSize = maxCount * size + padding; - } - const newArray = this._allocate(Type, newSize, initialize, maxSize); - if (typedArray && copy) { - newArray.set(typedArray); - } else if (!initialize) { - newArray.fill(0, 0, 4); + start(transitionSettings, numInstances) { + const { + gl, + buffers, + attribute + } = this; + const padBufferOpts = { + numInstances, + attribute, + fromLength: this.currentLength, + fromStartIndices: this.currentStartIndices, + getData: transitionSettings.enter + }; + for (const buffer of buffers) { + padBuffer({ + buffer, + ...padBufferOpts + }); } - this._release(typedArray); - return newArray; - } - release(typedArray) { - this._release(typedArray); + this.settings = transitionSettings; + this.currentStartIndices = attribute.startIndices; + this.currentLength = getAttributeBufferLength(attribute, numInstances); + this.attributeInTransition.setData({ + buffer: buffers[1], + value: attribute.value + }); + this.transition.start({ + ...transitionSettings, + duration: Infinity + }); + this.transform.update({ + elementCount: Math.floor(this.currentLength / attribute.size), + sourceBuffers: { + aTo: getSourceBufferAttribute(gl, attribute) + } + }); } - _allocate(Type, size, initialize, maxSize) { - let sizeToAllocate = Math.max(Math.ceil(size * this.opts.overAlloc), 1); - if (sizeToAllocate > maxSize) { - sizeToAllocate = maxSize; + update() { + const { + buffers, + transform: transform2, + framebuffer, + transition + } = this; + const updated = transition.update(); + if (!updated) { + return false; } - const pool = this._pool; - const byteLength = Type.BYTES_PER_ELEMENT * sizeToAllocate; - const i2 = pool.findIndex((b2) => b2.byteLength >= byteLength); - if (i2 >= 0) { - const array = new Type(pool.splice(i2, 1)[0], 0, sizeToAllocate); - if (initialize) { - array.fill(0); + const settings = this.settings; + transform2.update({ + sourceBuffers: { + aPrev: buffers[0], + aCur: buffers[1] + }, + feedbackBuffers: { + vNext: buffers[2] } - return array; + }); + transform2.run({ + framebuffer, + discard: false, + clearRenderTarget: true, + uniforms: { + stiffness: settings.stiffness, + damping: settings.damping + }, + parameters: { + depthTest: false, + blend: true, + viewport: [0, 0, 1, 1], + blendFunc: [1, 1], + blendEquation: [32776, 32776] + } + }); + cycleBuffers(buffers); + this.attributeInTransition.setData({ + buffer: buffers[1], + value: this.attribute.value + }); + const isTransitioning = readPixelsToArray(framebuffer)[0] > 0; + if (!isTransitioning) { + transition.end(); } - return new Type(sizeToAllocate); + return true; } - _release(typedArray) { - if (!ArrayBuffer.isView(typedArray)) { - return; - } - const pool = this._pool; - const { - buffer - } = typedArray; - const { - byteLength - } = buffer; - const i2 = pool.findIndex((b2) => b2.byteLength >= byteLength); - if (i2 < 0) { - pool.push(buffer); - } else if (i2 > 0 || pool.length < this.opts.poolSize) { - pool.splice(i2, 0, buffer); - } - if (pool.length > this.opts.poolSize) { - pool.shift(); + cancel() { + this.transition.cancel(); + this.transform.delete(); + for (const buffer of this.buffers) { + buffer.delete(); } + this.buffers.length = 0; + this.texture.delete(); + this.framebuffer.delete(); } }; - var typed_array_manager_default = new TypedArrayManager(); - - // node_modules/@deck.gl/core/dist/esm/utils/math-utils.js - function createMat42() { - return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; - } - function mod2(value, divisor) { - const modulus = value % divisor; - return modulus < 0 ? divisor + modulus : modulus; - } - function getCameraPosition(viewMatrixInverse) { - return [viewMatrixInverse[12], viewMatrixInverse[13], viewMatrixInverse[14]]; - } - function getFrustumPlanes(viewProjectionMatrix) { - return { - left: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[0], viewProjectionMatrix[7] + viewProjectionMatrix[4], viewProjectionMatrix[11] + viewProjectionMatrix[8], viewProjectionMatrix[15] + viewProjectionMatrix[12]), - right: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[0], viewProjectionMatrix[7] - viewProjectionMatrix[4], viewProjectionMatrix[11] - viewProjectionMatrix[8], viewProjectionMatrix[15] - viewProjectionMatrix[12]), - bottom: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[1], viewProjectionMatrix[7] + viewProjectionMatrix[5], viewProjectionMatrix[11] + viewProjectionMatrix[9], viewProjectionMatrix[15] + viewProjectionMatrix[13]), - top: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[1], viewProjectionMatrix[7] - viewProjectionMatrix[5], viewProjectionMatrix[11] - viewProjectionMatrix[9], viewProjectionMatrix[15] - viewProjectionMatrix[13]), - near: getFrustumPlane(viewProjectionMatrix[3] + viewProjectionMatrix[2], viewProjectionMatrix[7] + viewProjectionMatrix[6], viewProjectionMatrix[11] + viewProjectionMatrix[10], viewProjectionMatrix[15] + viewProjectionMatrix[14]), - far: getFrustumPlane(viewProjectionMatrix[3] - viewProjectionMatrix[2], viewProjectionMatrix[7] - viewProjectionMatrix[6], viewProjectionMatrix[11] - viewProjectionMatrix[10], viewProjectionMatrix[15] - viewProjectionMatrix[14]) - }; - } - var scratchVector = new Vector3(); - function getFrustumPlane(a2, b2, c2, d2) { - scratchVector.set(a2, b2, c2); - const L = scratchVector.len(); - return { - distance: d2 / L, - normal: new Vector3(-a2 / L, -b2 / L, -c2 / L) - }; - } - function fp64LowPart(x2) { - return x2 - Math.fround(x2); + function getTransform2(gl, attribute, framebuffer) { + const attributeType = getAttributeTypeFromSize(attribute.size); + return new Transform(gl, { + framebuffer, + vs: "\n#define SHADER_NAME spring-transition-vertex-shader\n\n#define EPSILON 0.00001\n\nuniform float stiffness;\nuniform float damping;\nattribute ATTRIBUTE_TYPE aPrev;\nattribute ATTRIBUTE_TYPE aCur;\nattribute ATTRIBUTE_TYPE aTo;\nvarying ATTRIBUTE_TYPE vNext;\nvarying float vIsTransitioningFlag;\n\nATTRIBUTE_TYPE getNextValue(ATTRIBUTE_TYPE cur, ATTRIBUTE_TYPE prev, ATTRIBUTE_TYPE dest) {\n ATTRIBUTE_TYPE velocity = cur - prev;\n ATTRIBUTE_TYPE delta = dest - cur;\n ATTRIBUTE_TYPE spring = delta * stiffness;\n ATTRIBUTE_TYPE damper = velocity * -1.0 * damping;\n return spring + damper + velocity + cur;\n}\n\nvoid main(void) {\n bool isTransitioning = length(aCur - aPrev) > EPSILON || length(aTo - aCur) > EPSILON;\n vIsTransitioningFlag = isTransitioning ? 1.0 : 0.0;\n\n vNext = getNextValue(aCur, aPrev, aTo);\n gl_Position = vec4(0, 0, 0, 1);\n gl_PointSize = 100.0;\n}\n", + fs: "\n#define SHADER_NAME spring-transition-is-transitioning-fragment-shader\n\nvarying float vIsTransitioningFlag;\n\nvoid main(void) {\n if (vIsTransitioningFlag == 0.0) {\n discard;\n }\n gl_FragColor = vec4(1.0);\n}", + defines: { + ATTRIBUTE_TYPE: attributeType + }, + varyings: ["vNext"] + }); } - var scratchArray; - function toDoublePrecisionArray(typedArray, options) { - const { - size = 1, - startIndex = 0 - } = options; - const endIndex = options.endIndex !== void 0 ? options.endIndex : typedArray.length; - const count2 = (endIndex - startIndex) / size; - scratchArray = typed_array_manager_default.allocate(scratchArray, count2, { - type: Float32Array, - size: size * 2 + function getTexture(gl) { + return new Texture2D(gl, { + data: new Uint8Array(4), + format: 6408, + type: 5121, + border: 0, + mipmaps: false, + dataFormat: 6408, + width: 1, + height: 1 }); - let sourceIndex = startIndex; - let targetIndex = 0; - while (sourceIndex < endIndex) { - for (let j = 0; j < size; j++) { - const value = typedArray[sourceIndex++]; - scratchArray[targetIndex + j] = value; - scratchArray[targetIndex + j + size] = fp64LowPart(value); - } - targetIndex += size * 2; - } - return scratchArray.subarray(0, count2 * size * 2); } - function mergeBounds(boundsList) { - let mergedBounds = null; - let isMerged = false; - for (const bounds of boundsList) { - if (!bounds) - continue; - if (!mergedBounds) { - mergedBounds = bounds; - } else { - if (!isMerged) { - mergedBounds = [[mergedBounds[0][0], mergedBounds[0][1]], [mergedBounds[1][0], mergedBounds[1][1]]]; - isMerged = true; - } - mergedBounds[0][0] = Math.min(mergedBounds[0][0], bounds[0][0]); - mergedBounds[0][1] = Math.min(mergedBounds[0][1], bounds[0][1]); - mergedBounds[1][0] = Math.max(mergedBounds[1][0], bounds[1][0]); - mergedBounds[1][1] = Math.max(mergedBounds[1][1], bounds[1][1]); + function getFramebuffer2(gl, texture) { + return new Framebuffer(gl, { + id: "spring-transition-is-transitioning-framebuffer", + width: 1, + height: 1, + attachments: { + [36064]: texture } - } - return mergedBounds; + }); } - // node_modules/@deck.gl/core/dist/esm/viewports/viewport.js - var DEGREES_TO_RADIANS4 = Math.PI / 180; - var IDENTITY2 = createMat42(); - var ZERO_VECTOR2 = [0, 0, 0]; - var DEFAULT_DISTANCE_SCALES = { - unitsPerMeter: [1, 1, 1], - metersPerUnit: [1, 1, 1] + // node_modules/@deck.gl/core/dist/esm/lib/attribute/attribute-transition-manager.js + var TRANSITION_TYPES = { + interpolation: GPUInterpolationTransition, + spring: GPUSpringTransition }; - function createProjectionMatrix({ - width, - height, - orthographic, - fovyRadians, - focalDistance, - padding, - near, - far - }) { - const aspect = width / height; - const matrix = orthographic ? new Matrix4().orthographic({ - fovy: fovyRadians, - aspect, - focalDistance, - near, - far - }) : new Matrix4().perspective({ - fovy: fovyRadians, - aspect, - near, - far - }); - if (padding) { - const { - left = 0, - right = 0, - top = 0, - bottom = 0 - } = padding; - const offsetX = clamp((left + width - right) / 2, 0, width) - width / 2; - const offsetY = clamp((top + height - bottom) / 2, 0, height) - height / 2; - matrix[8] -= offsetX * 2 / width; - matrix[9] += offsetY * 2 / height; - } - return matrix; - } - var Viewport = class _Viewport { - constructor(opts = {}) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "x", void 0); - _defineProperty(this, "y", void 0); - _defineProperty(this, "width", void 0); - _defineProperty(this, "height", void 0); - _defineProperty(this, "padding", void 0); - _defineProperty(this, "isGeospatial", void 0); - _defineProperty(this, "zoom", void 0); - _defineProperty(this, "focalDistance", void 0); - _defineProperty(this, "position", void 0); - _defineProperty(this, "modelMatrix", void 0); - _defineProperty(this, "distanceScales", void 0); - _defineProperty(this, "scale", void 0); - _defineProperty(this, "center", void 0); - _defineProperty(this, "cameraPosition", void 0); - _defineProperty(this, "projectionMatrix", void 0); - _defineProperty(this, "viewMatrix", void 0); - _defineProperty(this, "viewMatrixUncentered", void 0); - _defineProperty(this, "viewMatrixInverse", void 0); - _defineProperty(this, "viewProjectionMatrix", void 0); - _defineProperty(this, "pixelProjectionMatrix", void 0); - _defineProperty(this, "pixelUnprojectionMatrix", void 0); - _defineProperty(this, "resolution", void 0); - _defineProperty(this, "_frustumPlanes", {}); - this.id = opts.id || this.constructor.displayName || "viewport"; - this.x = opts.x || 0; - this.y = opts.y || 0; - this.width = opts.width || 1; - this.height = opts.height || 1; - this.zoom = opts.zoom || 0; - this.padding = opts.padding; - this.distanceScales = opts.distanceScales || DEFAULT_DISTANCE_SCALES; - this.focalDistance = opts.focalDistance || 1; - this.position = opts.position || ZERO_VECTOR2; - this.modelMatrix = opts.modelMatrix || null; - const { - longitude, - latitude - } = opts; - this.isGeospatial = Number.isFinite(latitude) && Number.isFinite(longitude); - this._initProps(opts); - this._initMatrices(opts); - this.equals = this.equals.bind(this); - this.project = this.project.bind(this); - this.unproject = this.unproject.bind(this); - this.projectPosition = this.projectPosition.bind(this); - this.unprojectPosition = this.unprojectPosition.bind(this); - this.projectFlat = this.projectFlat.bind(this); - this.unprojectFlat = this.unprojectFlat.bind(this); + var AttributeTransitionManager = class { + constructor(gl, { + id, + timeline + }) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "isSupported", void 0); + _defineProperty(this, "gl", void 0); + _defineProperty(this, "timeline", void 0); + _defineProperty(this, "transitions", void 0); + _defineProperty(this, "needsRedraw", void 0); + _defineProperty(this, "numInstances", void 0); + this.id = id; + this.gl = gl; + this.timeline = timeline; + this.transitions = {}; + this.needsRedraw = false; + this.numInstances = 1; + this.isSupported = Transform.isSupported(gl); } - get subViewports() { - return null; + finalize() { + for (const attributeName in this.transitions) { + this._removeTransition(attributeName); + } } - get metersPerPixel() { - return this.distanceScales.metersPerUnit[2] / this.scale; + update({ + attributes, + transitions, + numInstances + }) { + this.numInstances = numInstances || 1; + for (const attributeName in attributes) { + const attribute = attributes[attributeName]; + const settings = attribute.getTransitionSetting(transitions); + if (!settings) + continue; + this._updateAttribute(attributeName, attribute, settings); + } + for (const attributeName in this.transitions) { + const attribute = attributes[attributeName]; + if (!attribute || !attribute.getTransitionSetting(transitions)) { + this._removeTransition(attributeName); + } + } } - get projectionMode() { - if (this.isGeospatial) { - return this.zoom < 12 ? PROJECTION_MODE.WEB_MERCATOR : PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET; + hasAttribute(attributeName) { + const transition = this.transitions[attributeName]; + return transition && transition.inProgress; + } + getAttributes() { + const animatedAttributes = {}; + for (const attributeName in this.transitions) { + const transition = this.transitions[attributeName]; + if (transition.inProgress) { + animatedAttributes[attributeName] = transition.attributeInTransition; + } } - return PROJECTION_MODE.IDENTITY; + return animatedAttributes; } - equals(viewport) { - if (!(viewport instanceof _Viewport)) { + run() { + if (!this.isSupported || this.numInstances === 0) { return false; } - if (this === viewport) { - return true; + for (const attributeName in this.transitions) { + const updated = this.transitions[attributeName].update(); + if (updated) { + this.needsRedraw = true; + } } - return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix); + const needsRedraw = this.needsRedraw; + this.needsRedraw = false; + return needsRedraw; } - project(xyz, { - topLeft = true - } = {}) { - const worldPosition = this.projectPosition(xyz); - const coord = worldToPixels(worldPosition, this.pixelProjectionMatrix); - const [x2, y2] = coord; - const y22 = topLeft ? y2 : this.height - y2; - return xyz.length === 2 ? [x2, y22] : [x2, y22, coord[2]]; + _removeTransition(attributeName) { + this.transitions[attributeName].cancel(); + delete this.transitions[attributeName]; } - unproject(xyz, { - topLeft = true, - targetZ + _updateAttribute(attributeName, attribute, settings) { + const transition = this.transitions[attributeName]; + let isNew = !transition || transition.type !== settings.type; + if (isNew) { + if (!this.isSupported) { + log_default.warn("WebGL2 not supported by this browser. Transition for ".concat(attributeName, " is disabled."))(); + return; + } + if (transition) { + this._removeTransition(attributeName); + } + const TransitionType = TRANSITION_TYPES[settings.type]; + if (TransitionType) { + this.transitions[attributeName] = new TransitionType({ + attribute, + timeline: this.timeline, + gl: this.gl + }); + } else { + log_default.error("unsupported transition type '".concat(settings.type, "'"))(); + isNew = false; + } + } + if (isNew || attribute.needsRedraw()) { + this.needsRedraw = true; + this.transitions[attributeName].start(settings, this.numInstances); + } + } + }; + + // node_modules/@deck.gl/core/dist/esm/lib/attribute/attribute-manager.js + var TRACE_INVALIDATE = "attributeManager.invalidate"; + var TRACE_UPDATE_START = "attributeManager.updateStart"; + var TRACE_UPDATE_END = "attributeManager.updateEnd"; + var TRACE_ATTRIBUTE_UPDATE_START = "attribute.updateStart"; + var TRACE_ATTRIBUTE_ALLOCATE = "attribute.allocate"; + var TRACE_ATTRIBUTE_UPDATE_END = "attribute.updateEnd"; + var AttributeManager = class { + constructor(gl, { + id = "attribute-manager", + stats, + timeline } = {}) { - const [x2, y2, z] = xyz; - const y22 = topLeft ? y2 : this.height - y2; - const targetZWorld = targetZ && targetZ * this.distanceScales.unitsPerMeter[2]; - const coord = pixelsToWorld([x2, y22, z], this.pixelUnprojectionMatrix, targetZWorld); - const [X, Y, Z] = this.unprojectPosition(coord); - if (Number.isFinite(z)) { - return [X, Y, Z]; + _defineProperty(this, "id", void 0); + _defineProperty(this, "gl", void 0); + _defineProperty(this, "attributes", void 0); + _defineProperty(this, "updateTriggers", void 0); + _defineProperty(this, "needsRedraw", void 0); + _defineProperty(this, "userData", void 0); + _defineProperty(this, "stats", void 0); + _defineProperty(this, "attributeTransitionManager", void 0); + _defineProperty(this, "mergeBoundsMemoized", memoize(mergeBounds)); + this.id = id; + this.gl = gl; + this.attributes = {}; + this.updateTriggers = {}; + this.needsRedraw = true; + this.userData = {}; + this.stats = stats; + this.attributeTransitionManager = new AttributeTransitionManager(gl, { + id: "".concat(id, "-transitions"), + timeline + }); + Object.seal(this); + } + finalize() { + for (const attributeName in this.attributes) { + this.attributes[attributeName].delete(); } - return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y]; + this.attributeTransitionManager.finalize(); } - projectPosition(xyz) { - const [X, Y] = this.projectFlat(xyz); - const Z = (xyz[2] || 0) * this.distanceScales.unitsPerMeter[2]; - return [X, Y, Z]; + getNeedsRedraw(opts = { + clearRedrawFlags: false + }) { + const redraw = this.needsRedraw; + this.needsRedraw = this.needsRedraw && !opts.clearRedrawFlags; + return redraw && this.id; } - unprojectPosition(xyz) { - const [X, Y] = this.unprojectFlat(xyz); - const Z = (xyz[2] || 0) * this.distanceScales.metersPerUnit[2]; - return [X, Y, Z]; + setNeedsRedraw() { + this.needsRedraw = true; } - projectFlat(xyz) { - if (this.isGeospatial) { - const result = lngLatToWorld(xyz); - result[1] = clamp(result[1], -318, 830); - return result; - } - return xyz; + add(attributes) { + this._add(attributes); } - unprojectFlat(xyz) { - if (this.isGeospatial) { - return worldToLngLat(xyz); + addInstanced(attributes) { + this._add(attributes, { + instanced: 1 + }); + } + remove(attributeNameArray) { + for (const name of attributeNameArray) { + if (this.attributes[name] !== void 0) { + this.attributes[name].delete(); + delete this.attributes[name]; + } } - return xyz; } - getBounds(options = {}) { - const unprojectOption = { - targetZ: options.z || 0 - }; - const topLeft = this.unproject([0, 0], unprojectOption); - const topRight = this.unproject([this.width, 0], unprojectOption); - const bottomLeft = this.unproject([0, this.height], unprojectOption); - const bottomRight = this.unproject([this.width, this.height], unprojectOption); - return [Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]), Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1])]; + invalidate(triggerName, dataRange) { + const invalidatedAttributes = this._invalidateTrigger(triggerName, dataRange); + debug(TRACE_INVALIDATE, this, triggerName, invalidatedAttributes); } - getDistanceScales(coordinateOrigin) { - if (coordinateOrigin) { - return getDistanceScales({ - longitude: coordinateOrigin[0], - latitude: coordinateOrigin[1], - highPrecision: true - }); + invalidateAll(dataRange) { + for (const attributeName in this.attributes) { + this.attributes[attributeName].setNeedsUpdate(attributeName, dataRange); } - return this.distanceScales; + debug(TRACE_INVALIDATE, this, "all"); } - containsPixel({ - x: x2, - y: y2, - width = 1, - height = 1 + update({ + data, + numInstances, + startIndices = null, + transitions, + props = {}, + buffers = {}, + context = {} }) { - return x2 < this.x + this.width && this.x < x2 + width && y2 < this.y + this.height && this.y < y2 + height; - } - getFrustumPlanes() { - if (this._frustumPlanes.near) { - return this._frustumPlanes; + let updated = false; + debug(TRACE_UPDATE_START, this); + if (this.stats) { + this.stats.get("Update Attributes").timeStart(); } - Object.assign(this._frustumPlanes, getFrustumPlanes(this.viewProjectionMatrix)); - return this._frustumPlanes; - } - panByPosition(coords, pixel) { - return null; - } - _initProps(opts) { - const longitude = opts.longitude; - const latitude = opts.latitude; - if (this.isGeospatial) { - if (!Number.isFinite(opts.zoom)) { - this.zoom = getMeterZoom({ - latitude - }) + Math.log2(this.focalDistance); + for (const attributeName in this.attributes) { + const attribute = this.attributes[attributeName]; + const accessorName = attribute.settings.accessor; + attribute.startIndices = startIndices; + attribute.numInstances = numInstances; + if (props[attributeName]) { + log_default.removed("props.".concat(attributeName), "data.attributes.".concat(attributeName))(); } - this.distanceScales = opts.distanceScales || getDistanceScales({ - latitude, - longitude - }); + if (attribute.setExternalBuffer(buffers[attributeName])) { + } else if (attribute.setBinaryValue(typeof accessorName === "string" ? buffers[accessorName] : void 0, data.startIndices)) { + } else if (typeof accessorName === "string" && !buffers[accessorName] && attribute.setConstantValue(props[accessorName])) { + } else if (attribute.needsUpdate()) { + updated = true; + this._updateAttribute({ + attribute, + numInstances, + data, + props, + context + }); + } + this.needsRedraw = this.needsRedraw || attribute.needsRedraw(); } - const scale3 = Math.pow(2, this.zoom); - this.scale = scale3; - const { - position, - modelMatrix - } = opts; - let meterOffset = ZERO_VECTOR2; - if (position) { - meterOffset = modelMatrix ? new Matrix4(modelMatrix).transformAsVector(position, []) : position; + if (updated) { + debug(TRACE_UPDATE_END, this, numInstances); } - if (this.isGeospatial) { - const center = this.projectPosition([longitude, latitude, 0]); - this.center = new Vector3(meterOffset).scale(this.distanceScales.unitsPerMeter).add(center); - } else { - this.center = this.projectPosition(meterOffset); + if (this.stats) { + this.stats.get("Update Attributes").timeEnd(); } + this.attributeTransitionManager.update({ + attributes: this.attributes, + numInstances, + transitions + }); } - _initMatrices(opts) { + updateTransition() { const { - viewMatrix = IDENTITY2, - projectionMatrix = null, - orthographic = false, - fovyRadians, - fovy = 75, - near = 0.1, - far = 1e3, - padding = null, - focalDistance = 1 - } = opts; - this.viewMatrixUncentered = viewMatrix; - this.viewMatrix = new Matrix4().multiplyRight(viewMatrix).translate(new Vector3(this.center).negate()); - this.projectionMatrix = projectionMatrix || createProjectionMatrix({ - width: this.width, - height: this.height, - orthographic, - fovyRadians: fovyRadians || fovy * DEGREES_TO_RADIANS4, - focalDistance, - padding, - near, - far + attributeTransitionManager + } = this; + const transitionUpdated = attributeTransitionManager.run(); + this.needsRedraw = this.needsRedraw || transitionUpdated; + return transitionUpdated; + } + getAttributes() { + return this.attributes; + } + getBounds(attributeNames) { + const bounds = attributeNames.map((attributeName) => { + var _this$attributes$attr; + return (_this$attributes$attr = this.attributes[attributeName]) === null || _this$attributes$attr === void 0 ? void 0 : _this$attributes$attr.getBounds(); }); - const vpm = createMat42(); - multiply(vpm, vpm, this.projectionMatrix); - multiply(vpm, vpm, this.viewMatrix); - this.viewProjectionMatrix = vpm; - this.viewMatrixInverse = invert([], this.viewMatrix) || this.viewMatrix; - this.cameraPosition = getCameraPosition(this.viewMatrixInverse); - const viewportMatrix = createMat42(); - const pixelProjectionMatrix = createMat42(); - scale(viewportMatrix, viewportMatrix, [this.width / 2, -this.height / 2, 1]); - translate(viewportMatrix, viewportMatrix, [1, -1, 0]); - multiply(pixelProjectionMatrix, viewportMatrix, this.viewProjectionMatrix); - this.pixelProjectionMatrix = pixelProjectionMatrix; - this.pixelUnprojectionMatrix = invert(createMat42(), this.pixelProjectionMatrix); - if (!this.pixelUnprojectionMatrix) { - log_default.warn("Pixel project matrix not invertible")(); - } + return this.mergeBoundsMemoized(bounds); } - }; - _defineProperty(Viewport, "displayName", "Viewport"); - - // node_modules/@deck.gl/core/dist/esm/viewports/web-mercator-viewport.js - var WebMercatorViewport2 = class _WebMercatorViewport extends Viewport { - constructor(opts = {}) { + getChangedAttributes(opts = { + clearChangedFlags: false + }) { const { - latitude = 0, - longitude = 0, - zoom = 0, - pitch = 0, - bearing = 0, - nearZMultiplier = 0.1, - farZMultiplier = 1.01, - nearZ, - farZ, - orthographic = false, - projectionMatrix, - repeat = false, - worldOffset = 0, - position, - padding, - legacyMeterSizes = false - } = opts; - let { - width, - height, - altitude = 1.5 - } = opts; - const scale3 = Math.pow(2, zoom); - width = width || 1; - height = height || 1; - let fovy; - let projectionParameters = null; - if (projectionMatrix) { - altitude = projectionMatrix[5] / 2; - fovy = altitudeToFovy(altitude); - } else { - if (opts.fovy) { - fovy = opts.fovy; - altitude = fovyToAltitude(fovy); - } else { - fovy = altitudeToFovy(altitude); - } - let offset; - if (padding) { - const { - top = 0, - bottom = 0 - } = padding; - offset = [0, clamp((top + height - bottom) / 2, 0, height) - height / 2]; - } - projectionParameters = getProjectionParameters({ - width, - height, - scale: scale3, - center: position && [0, 0, position[2] * unitsPerMeter(latitude)], - offset, - pitch, - fovy, - nearZMultiplier, - farZMultiplier - }); - if (Number.isFinite(nearZ)) { - projectionParameters.near = nearZ; + attributes, + attributeTransitionManager + } = this; + const changedAttributes = { + ...attributeTransitionManager.getAttributes() + }; + for (const attributeName in attributes) { + const attribute = attributes[attributeName]; + if (attribute.needsRedraw(opts) && !attributeTransitionManager.hasAttribute(attributeName)) { + changedAttributes[attributeName] = attribute; } - if (Number.isFinite(farZ)) { - projectionParameters.far = farZ; + } + return changedAttributes; + } + getShaderAttributes(attributes, excludeAttributes = {}) { + if (!attributes) { + attributes = this.getAttributes(); + } + const shaderAttributes = {}; + for (const attributeName in attributes) { + if (!excludeAttributes[attributeName]) { + Object.assign(shaderAttributes, attributes[attributeName].getShaderAttributes()); } } - let viewMatrixUncentered = getViewMatrix({ - height, - pitch, - bearing, - scale: scale3, - altitude - }); - if (worldOffset) { - const viewOffset = new Matrix4().translate([512 * worldOffset, 0, 0]); - viewMatrixUncentered = viewOffset.multiplyLeft(viewMatrixUncentered); + return shaderAttributes; + } + _add(attributes, extraProps = {}) { + for (const attributeName in attributes) { + const attribute = attributes[attributeName]; + this.attributes[attributeName] = this._createAttribute(attributeName, attribute, extraProps); } - super({ - ...opts, - width, - height, - viewMatrix: viewMatrixUncentered, - longitude, - latitude, - zoom, - ...projectionParameters, - fovy, - focalDistance: altitude - }); - _defineProperty(this, "longitude", void 0); - _defineProperty(this, "latitude", void 0); - _defineProperty(this, "pitch", void 0); - _defineProperty(this, "bearing", void 0); - _defineProperty(this, "altitude", void 0); - _defineProperty(this, "fovy", void 0); - _defineProperty(this, "orthographic", void 0); - _defineProperty(this, "_subViewports", void 0); - _defineProperty(this, "_pseudoMeters", void 0); - this.latitude = latitude; - this.longitude = longitude; - this.zoom = zoom; - this.pitch = pitch; - this.bearing = bearing; - this.altitude = altitude; - this.fovy = fovy; - this.orthographic = orthographic; - this._subViewports = repeat ? [] : null; - this._pseudoMeters = legacyMeterSizes; - Object.freeze(this); + this._mapUpdateTriggersToAttributes(); } - get subViewports() { - if (this._subViewports && !this._subViewports.length) { - const bounds = this.getBounds(); - const minOffset = Math.floor((bounds[0] + 180) / 360); - const maxOffset = Math.ceil((bounds[2] - 180) / 360); - for (let x2 = minOffset; x2 <= maxOffset; x2++) { - const offsetViewport = x2 ? new _WebMercatorViewport({ - ...this, - worldOffset: x2 - }) : this; - this._subViewports.push(offsetViewport); - } + _createAttribute(name, attribute, extraProps) { + const props = { + ...attribute, + id: name, + size: attribute.isIndexed && 1 || attribute.size || 1, + divisor: extraProps.instanced ? 1 : attribute.divisor || 0 + }; + return new Attribute(this.gl, props); + } + _mapUpdateTriggersToAttributes() { + const triggers = {}; + for (const attributeName in this.attributes) { + const attribute = this.attributes[attributeName]; + attribute.getUpdateTriggers().forEach((triggerName) => { + if (!triggers[triggerName]) { + triggers[triggerName] = []; + } + triggers[triggerName].push(attributeName); + }); } - return this._subViewports; + this.updateTriggers = triggers; } - projectPosition(xyz) { - if (this._pseudoMeters) { - return super.projectPosition(xyz); + _invalidateTrigger(triggerName, dataRange) { + const { + attributes, + updateTriggers + } = this; + const invalidatedAttributes = updateTriggers[triggerName]; + if (invalidatedAttributes) { + invalidatedAttributes.forEach((name) => { + const attribute = attributes[name]; + if (attribute) { + attribute.setNeedsUpdate(attribute.id, dataRange); + } + }); } - const [X, Y] = this.projectFlat(xyz); - const Z = (xyz[2] || 0) * unitsPerMeter(xyz[1]); - return [X, Y, Z]; + return invalidatedAttributes; } - unprojectPosition(xyz) { - if (this._pseudoMeters) { - return super.unprojectPosition(xyz); + _updateAttribute(opts) { + const { + attribute, + numInstances + } = opts; + debug(TRACE_ATTRIBUTE_UPDATE_START, attribute); + if (attribute.constant) { + attribute.setConstantValue(attribute.value); + return; + } + if (attribute.allocate(numInstances)) { + debug(TRACE_ATTRIBUTE_ALLOCATE, attribute, numInstances); + } + const updated = attribute.updateBuffer(opts); + if (updated) { + this.needsRedraw = true; + debug(TRACE_ATTRIBUTE_UPDATE_END, attribute, numInstances); } - const [X, Y] = this.unprojectFlat(xyz); - const Z = (xyz[2] || 0) / unitsPerMeter(Y); - return [X, Y, Z]; - } - addMetersToLngLat(lngLatZ, xyz) { - return addMetersToLngLat(lngLatZ, xyz); - } - panByPosition(coords, pixel) { - const fromLocation = pixelsToWorld(pixel, this.pixelUnprojectionMatrix); - const toLocation = this.projectFlat(coords); - const translate2 = add([], toLocation, negate([], fromLocation)); - const newCenter = add([], this.center, translate2); - const [longitude, latitude] = this.unprojectFlat(newCenter); - return { - longitude, - latitude - }; } - getBounds(options = {}) { - const corners = getBounds(this, options.z || 0); - return [Math.min(corners[0][0], corners[1][0], corners[2][0], corners[3][0]), Math.min(corners[0][1], corners[1][1], corners[2][1], corners[3][1]), Math.max(corners[0][0], corners[1][0], corners[2][0], corners[3][0]), Math.max(corners[0][1], corners[1][1], corners[2][1], corners[3][1])]; + }; + + // node_modules/@deck.gl/core/dist/esm/transitions/cpu-interpolation-transition.js + var CPUInterpolationTransition = class extends Transition { + get value() { + return this._value; } - fitBounds(bounds, options = {}) { + _onUpdate() { const { - width, - height + time, + settings: { + fromValue, + toValue, + duration, + easing + } } = this; - const { - longitude, - latitude, - zoom - } = fitBounds({ - width, - height, - bounds, - ...options - }); - return new _WebMercatorViewport({ - width, - height, - longitude, - latitude, - zoom - }); + const t2 = easing(time / duration); + this._value = lerp(fromValue, toValue, t2); } }; - _defineProperty(WebMercatorViewport2, "displayName", "WebMercatorViewport"); - // node_modules/@deck.gl/core/dist/esm/shaderlib/project/project-functions.js - var DEFAULT_COORDINATE_ORIGIN2 = [0, 0, 0]; - function lngLatZToWorldPosition(lngLatZ, viewport, offsetMode = false) { - const p2 = viewport.projectPosition(lngLatZ); - if (offsetMode && viewport instanceof WebMercatorViewport2) { - const [longitude, latitude, z = 0] = lngLatZ; - const distanceScales = viewport.getDistanceScales([longitude, latitude]); - p2[2] = z * distanceScales.unitsPerMeter[2]; - } - return p2; + // node_modules/@deck.gl/core/dist/esm/transitions/cpu-spring-transition.js + var EPSILON2 = 1e-5; + function updateSpringElement(prev, cur, dest, damping, stiffness) { + const velocity = cur - prev; + const delta = dest - cur; + const spring2 = delta * stiffness; + const damper = -velocity * damping; + return spring2 + damper + velocity + cur; } - function normalizeParameters(opts) { - const { - viewport, - modelMatrix, - coordinateOrigin - } = opts; - let { - coordinateSystem, - fromCoordinateSystem, - fromCoordinateOrigin - } = opts; - if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { - coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN; - } - if (fromCoordinateSystem === void 0) { - fromCoordinateSystem = coordinateSystem; - } - if (fromCoordinateOrigin === void 0) { - fromCoordinateOrigin = coordinateOrigin; + function updateSpring(prev, cur, dest, damping, stiffness) { + if (Array.isArray(dest)) { + const next = []; + for (let i3 = 0; i3 < dest.length; i3++) { + next[i3] = updateSpringElement(prev[i3], cur[i3], dest[i3], damping, stiffness); + } + return next; } - return { - viewport, - coordinateSystem, - coordinateOrigin, - modelMatrix, - fromCoordinateSystem, - fromCoordinateOrigin - }; + return updateSpringElement(prev, cur, dest, damping, stiffness); } - function getWorldPosition(position, { - viewport, - modelMatrix, - coordinateSystem, - coordinateOrigin, - offsetMode - }) { - let [x2, y2, z = 0] = position; - if (modelMatrix) { - [x2, y2, z] = transformMat43([], [x2, y2, z, 1], modelMatrix); - } - switch (coordinateSystem) { - case COORDINATE_SYSTEM.LNGLAT: - return lngLatZToWorldPosition([x2, y2, z], viewport, offsetMode); - case COORDINATE_SYSTEM.LNGLAT_OFFSETS: - return lngLatZToWorldPosition([x2 + coordinateOrigin[0], y2 + coordinateOrigin[1], z + (coordinateOrigin[2] || 0)], viewport, offsetMode); - case COORDINATE_SYSTEM.METER_OFFSETS: - return lngLatZToWorldPosition(addMetersToLngLat(coordinateOrigin, [x2, y2, z]), viewport, offsetMode); - case COORDINATE_SYSTEM.CARTESIAN: - default: - return viewport.isGeospatial ? [x2 + coordinateOrigin[0], y2 + coordinateOrigin[1], z + coordinateOrigin[2]] : viewport.projectPosition([x2, y2, z]); + function distance(value1, value2) { + if (Array.isArray(value1)) { + let distanceSquare = 0; + for (let i3 = 0; i3 < value1.length; i3++) { + const d2 = value1[i3] - value2[i3]; + distanceSquare += d2 * d2; + } + return Math.sqrt(distanceSquare); } + return Math.abs(value1 - value2); } - function projectPosition(position, params) { - const { - viewport, - coordinateSystem, - coordinateOrigin, - modelMatrix, - fromCoordinateSystem, - fromCoordinateOrigin - } = normalizeParameters(params); - const { - autoOffset = true - } = params; - const { - geospatialOrigin = DEFAULT_COORDINATE_ORIGIN2, - shaderCoordinateOrigin = DEFAULT_COORDINATE_ORIGIN2, - offsetMode = false - } = autoOffset ? getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin) : {}; - const worldPosition = getWorldPosition(position, { - viewport, - modelMatrix, - coordinateSystem: fromCoordinateSystem, - coordinateOrigin: fromCoordinateOrigin, - offsetMode - }); - if (offsetMode) { - const positionCommonSpace = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin); - sub(worldPosition, worldPosition, positionCommonSpace); + var CPUSpringTransition = class extends Transition { + get value() { + return this._currValue; } - return worldPosition; - } + _onUpdate() { + const { + fromValue, + toValue, + damping, + stiffness + } = this.settings; + const { + _prevValue = fromValue, + _currValue = fromValue + } = this; + let nextValue = updateSpring(_prevValue, _currValue, toValue, damping, stiffness); + const delta = distance(nextValue, toValue); + const velocity = distance(nextValue, _currValue); + if (delta < EPSILON2 && velocity < EPSILON2) { + nextValue = toValue; + this.end(); + } + this._prevValue = _currValue; + this._currValue = nextValue; + } + }; - // node_modules/@deck.gl/core/dist/esm/passes/pick-layers-pass.js - var PICKING_PARAMETERS = { - blendFunc: [1, 0, 32771, 0], - blendEquation: 32774 + // node_modules/@deck.gl/core/dist/esm/lib/uniform-transition-manager.js + var TRANSITION_TYPES2 = { + interpolation: CPUInterpolationTransition, + spring: CPUSpringTransition }; - var PickLayersPass = class extends LayersPass { - constructor(...args) { - super(...args); - _defineProperty(this, "pickZ", void 0); - _defineProperty(this, "_colorEncoderState", null); - } - render(props) { - if ("pickingFBO" in props) { - return this._drawPickingBuffer(props); - } - return super.render(props); + var UniformTransitionManager = class { + constructor(timeline) { + this.transitions = /* @__PURE__ */ new Map(); + this.timeline = timeline; } - _drawPickingBuffer({ - layers, - layerFilter, - views, - viewports, - onViewportActive, - pickingFBO, - deviceRect: { - x: x2, - y: y2, - width, - height - }, - cullRect, - effects, - pass = "picking", - pickZ, - moduleParameters - }) { - const gl = this.gl; - this.pickZ = pickZ; - const colorEncoderState = this._resetColorEncoder(pickZ); - const renderStatus = withParameters(gl, { - scissorTest: true, - scissor: [x2, y2, width, height], - clearColor: [0, 0, 0, 0], - depthMask: true, - depthTest: true, - depthRange: [0, 1], - colorMask: [true, true, true, true], - ...PICKING_PARAMETERS, - blend: !pickZ - }, () => super.render({ - target: pickingFBO, - layers, - layerFilter, - views, - viewports, - onViewportActive, - cullRect, - effects: effects === null || effects === void 0 ? void 0 : effects.filter((e2) => e2.useInPicking), - pass, - isPicking: true, - moduleParameters - })); - this._colorEncoderState = null; - const decodePickingColor = colorEncoderState && decodeColor.bind(null, colorEncoderState); - return { - decodePickingColor, - stats: renderStatus - }; + get active() { + return this.transitions.size > 0; } - shouldDrawLayer(layer) { + add(key, fromValue, toValue, settings) { const { - pickable, - operation - } = layer.props; - return pickable && operation.includes("draw") || operation.includes("terrain") || operation.includes("mask"); - } - getModuleParameters() { - return { - pickingActive: 1, - pickingAttribute: this.pickZ, - lightSources: {} - }; + transitions + } = this; + if (transitions.has(key)) { + const transition2 = transitions.get(key); + const { + value = transition2.settings.fromValue + } = transition2; + fromValue = value; + this.remove(key); + } + settings = normalizeTransitionSettings(settings); + if (!settings) { + return; + } + const TransitionType = TRANSITION_TYPES2[settings.type]; + if (!TransitionType) { + log_default.error("unsupported transition type '".concat(settings.type, "'"))(); + return; + } + const transition = new TransitionType(this.timeline); + transition.start({ + ...settings, + fromValue, + toValue + }); + transitions.set(key, transition); } - getLayerParameters(layer, layerIndex, viewport) { - const pickParameters = { - ...layer.props.parameters - }; + remove(key) { const { - pickable, - operation - } = layer.props; - if (!this._colorEncoderState) { - pickParameters.blend = false; - } else if (pickable && operation.includes("draw")) { - Object.assign(pickParameters, PICKING_PARAMETERS); - pickParameters.blend = true; - pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport); + transitions + } = this; + if (transitions.has(key)) { + transitions.get(key).cancel(); + transitions.delete(key); } - if (operation.includes("terrain")) { - pickParameters.blend = false; + } + update() { + const propsInTransition = {}; + for (const [key, transition] of this.transitions) { + transition.update(); + propsInTransition[key] = transition.value; + if (!transition.inProgress) { + this.remove(key); + } } - return pickParameters; + return propsInTransition; } - _resetColorEncoder(pickZ) { - this._colorEncoderState = pickZ ? null : { - byLayer: /* @__PURE__ */ new Map(), - byAlpha: [] - }; - return this._colorEncoderState; + clear() { + for (const key of this.transitions.keys()) { + this.remove(key); + } } }; - function encodeColor(encoded, layer, viewport) { - const { - byLayer, - byAlpha - } = encoded; - let a2; - let entry = byLayer.get(layer); - if (entry) { - entry.viewports.push(viewport); - a2 = entry.a; - } else { - a2 = byLayer.size + 1; - if (a2 <= 255) { - entry = { - a: a2, - layer, - viewports: [viewport] - }; - byLayer.set(layer, entry); - byAlpha[a2] = entry; - } else { - log_default.warn("Too many pickable layers, only picking the first 255")(); - a2 = 0; + + // node_modules/@deck.gl/core/dist/esm/lifecycle/props.js + function validateProps(props) { + const propTypes = props[PROP_TYPES_SYMBOL]; + for (const propName in propTypes) { + const propType = propTypes[propName]; + const { + validate: validate2 + } = propType; + if (validate2 && !validate2(props[propName], propType)) { + throw new Error("Invalid prop ".concat(propName, ": ").concat(props[propName])); } } - return [0, 0, 0, a2 / 255]; } - function decodeColor(encoded, pickedColor) { - const entry = encoded.byAlpha[pickedColor[3]]; - return entry && { - pickedLayer: entry.layer, - pickedViewports: entry.viewports, - pickedObjectIndex: entry.layer.decodePickingColor(pickedColor) + function diffProps(props, oldProps) { + const propsChangedReason = compareProps({ + newProps: props, + oldProps, + propTypes: props[PROP_TYPES_SYMBOL], + ignoreProps: { + data: null, + updateTriggers: null, + extensions: null, + transitions: null + } + }); + const dataChangedReason = diffDataProps(props, oldProps); + let updateTriggersChangedReason = false; + if (!dataChangedReason) { + updateTriggersChangedReason = diffUpdateTriggers(props, oldProps); + } + return { + dataChanged: dataChangedReason, + propsChanged: propsChangedReason, + updateTriggersChanged: updateTriggersChangedReason, + extensionsChanged: diffExtensions(props, oldProps), + transitionsChanged: diffTransitions(props, oldProps) }; } - - // node_modules/@deck.gl/core/dist/esm/lifecycle/constants.js - var LIFECYCLE = { - NO_STATE: "Awaiting state", - MATCHED: "Matched. State transferred from previous layer", - INITIALIZED: "Initialized", - AWAITING_GC: "Discarded. Awaiting garbage collection", - AWAITING_FINALIZATION: "No longer matched. Awaiting garbage collection", - FINALIZED: "Finalized! Awaiting garbage collection" - }; - var COMPONENT_SYMBOL = Symbol.for("component"); - var PROP_TYPES_SYMBOL = Symbol.for("propTypes"); - var DEPRECATED_PROPS_SYMBOL = Symbol.for("deprecatedProps"); - var ASYNC_DEFAULTS_SYMBOL = Symbol.for("asyncPropDefaults"); - var ASYNC_ORIGINAL_SYMBOL = Symbol.for("asyncPropOriginal"); - var ASYNC_RESOLVED_SYMBOL = Symbol.for("asyncPropResolved"); - - // node_modules/@deck.gl/core/dist/esm/utils/flatten.js - function flatten(array, filter = () => true) { - if (!Array.isArray(array)) { - return filter(array) ? [array] : []; + function diffTransitions(props, oldProps) { + if (!props.transitions) { + return false; + } + const result = {}; + const propTypes = props[PROP_TYPES_SYMBOL]; + let changed = false; + for (const key in props.transitions) { + const propType = propTypes[key]; + const type = propType && propType.type; + const isTransitionable = type === "number" || type === "color" || type === "array"; + if (isTransitionable && comparePropValues(props[key], oldProps[key], propType)) { + result[key] = true; + changed = true; + } + } + return changed ? result : false; + } + function compareProps({ + newProps, + oldProps, + ignoreProps = {}, + propTypes = {}, + triggerName = "props" + }) { + if (oldProps === newProps) { + return false; + } + if (typeof newProps !== "object" || newProps === null) { + return "".concat(triggerName, " changed shallowly"); + } + if (typeof oldProps !== "object" || oldProps === null) { + return "".concat(triggerName, " changed shallowly"); + } + for (const key of Object.keys(newProps)) { + if (!(key in ignoreProps)) { + if (!(key in oldProps)) { + return "".concat(triggerName, ".").concat(key, " added"); + } + const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]); + if (changed) { + return "".concat(triggerName, ".").concat(key, " ").concat(changed); + } + } } - return flattenArray(array, filter, []); - } - function flattenArray(array, filter, result) { - let index = -1; - while (++index < array.length) { - const value = array[index]; - if (Array.isArray(value)) { - flattenArray(value, filter, result); - } else if (filter(value)) { - result.push(value); + for (const key of Object.keys(oldProps)) { + if (!(key in ignoreProps)) { + if (!(key in newProps)) { + return "".concat(triggerName, ".").concat(key, " dropped"); + } + if (!Object.hasOwnProperty.call(newProps, key)) { + const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]); + if (changed) { + return "".concat(triggerName, ".").concat(key, " ").concat(changed); + } + } } } - return result; + return false; } - function fillArray2({ - target, - source, - start = 0, - count: count2 = 1 - }) { - const length = source.length; - const total = count2 * length; - let copied = 0; - for (let i2 = start; copied < length; copied++) { - target[i2++] = source[copied]; + function comparePropValues(newProp, oldProp, propType) { + let equal = propType && propType.equal; + if (equal && !equal(newProp, oldProp, propType)) { + return "changed deeply"; } - while (copied < total) { - if (copied < total - copied) { - target.copyWithin(start + copied, start, start + copied); - copied *= 2; - } else { - target.copyWithin(start + copied, start, start + total - copied); - copied = total; + if (!equal) { + equal = newProp && oldProp && newProp.equals; + if (equal && !equal.call(newProp, oldProp)) { + return "changed deeply"; } } - return target; - } - - // node_modules/@deck.gl/core/dist/esm/lib/resource/resource.js - var Resource2 = class { - constructor(id, data, context) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "context", void 0); - _defineProperty(this, "isLoaded", void 0); - _defineProperty(this, "persistent", void 0); - _defineProperty(this, "_loadCount", 0); - _defineProperty(this, "_subscribers", /* @__PURE__ */ new Set()); - _defineProperty(this, "_data", void 0); - _defineProperty(this, "_loader", void 0); - _defineProperty(this, "_error", void 0); - _defineProperty(this, "_content", void 0); - this.id = id; - this.context = context; - this.setData(data); - } - subscribe(consumer) { - this._subscribers.add(consumer); + if (!equal && oldProp !== newProp) { + return "changed shallowly"; } - unsubscribe(consumer) { - this._subscribers.delete(consumer); + return null; + } + function diffDataProps(props, oldProps) { + if (oldProps === null) { + return "oldProps is null, initial diff"; } - inUse() { - return this._subscribers.size > 0; + let dataChanged = false; + const { + dataComparator, + _dataDiff + } = props; + if (dataComparator) { + if (!dataComparator(props.data, oldProps.data)) { + dataChanged = "Data comparator detected a change"; + } + } else if (props.data !== oldProps.data) { + dataChanged = "A new data container was supplied"; } - delete() { + if (dataChanged && _dataDiff) { + dataChanged = _dataDiff(props.data, oldProps.data) || dataChanged; } - getData() { - return this.isLoaded ? this._error ? Promise.reject(this._error) : this._content : this._loader.then(() => this.getData()); + return dataChanged; + } + function diffUpdateTriggers(props, oldProps) { + if (oldProps === null) { + return { + all: true + }; } - setData(data, forceUpdate) { - if (data === this._data && !forceUpdate) { - return; - } - this._data = data; - const loadCount = ++this._loadCount; - let loader = data; - if (typeof data === "string") { - loader = load(data); - } - if (loader instanceof Promise) { - this.isLoaded = false; - this._loader = loader.then((result) => { - if (this._loadCount === loadCount) { - this.isLoaded = true; - this._error = void 0; - this._content = result; - } - }).catch((error2) => { - if (this._loadCount === loadCount) { - this.isLoaded = true; - this._error = error2 || true; - } - }); - } else { - this.isLoaded = true; - this._error = void 0; - this._content = data; + if ("all" in props.updateTriggers) { + const diffReason = diffUpdateTrigger(props, oldProps, "all"); + if (diffReason) { + return { + all: true + }; } - for (const subscriber of this._subscribers) { - subscriber.onChange(this.getData()); + } + const reason = {}; + let changed = false; + for (const triggerName in props.updateTriggers) { + if (triggerName !== "all") { + const diffReason = diffUpdateTrigger(props, oldProps, triggerName); + if (diffReason) { + reason[triggerName] = true; + changed = true; + } } } - }; - - // node_modules/@deck.gl/core/dist/esm/lib/resource/resource-manager.js - var ResourceManager = class { - constructor({ - gl, - protocol - }) { - _defineProperty(this, "protocol", void 0); - _defineProperty(this, "_context", void 0); - _defineProperty(this, "_resources", void 0); - _defineProperty(this, "_consumers", void 0); - _defineProperty(this, "_pruneRequest", void 0); - this.protocol = protocol || "resource://"; - this._context = { - gl, - resourceManager: this - }; - this._resources = {}; - this._consumers = {}; - this._pruneRequest = null; + return changed ? reason : false; + } + function diffExtensions(props, oldProps) { + if (oldProps === null) { + return true; } - contains(resourceId) { - if (resourceId.startsWith(this.protocol)) { + const oldExtensions = oldProps.extensions; + const { + extensions + } = props; + if (extensions === oldExtensions) { + return false; + } + if (!oldExtensions || !extensions) { + return true; + } + if (extensions.length !== oldExtensions.length) { + return true; + } + for (let i3 = 0; i3 < extensions.length; i3++) { + if (!extensions[i3].equals(oldExtensions[i3])) { return true; } - return resourceId in this._resources; } - add({ - resourceId, - data, - forceUpdate = false, - persistent = true - }) { - let res = this._resources[resourceId]; - if (res) { - res.setData(data, forceUpdate); - } else { - res = new Resource2(resourceId, data, this._context); - this._resources[resourceId] = res; - } - res.persistent = persistent; + return false; + } + function diffUpdateTrigger(props, oldProps, triggerName) { + let newTriggers = props.updateTriggers[triggerName]; + newTriggers = newTriggers === void 0 || newTriggers === null ? {} : newTriggers; + let oldTriggers = oldProps.updateTriggers[triggerName]; + oldTriggers = oldTriggers === void 0 || oldTriggers === null ? {} : oldTriggers; + const diffReason = compareProps({ + oldProps: oldTriggers, + newProps: newTriggers, + triggerName + }); + return diffReason; + } + + // node_modules/@deck.gl/core/dist/esm/utils/count.js + var ERR_NOT_OBJECT = "count(): argument not an object"; + var ERR_NOT_CONTAINER = "count(): argument not a container"; + function count(container) { + if (!isObject2(container)) { + throw new Error(ERR_NOT_OBJECT); } - remove(resourceId) { - const res = this._resources[resourceId]; - if (res) { - res.delete(); - delete this._resources[resourceId]; - } + if (typeof container.count === "function") { + return container.count(); } - unsubscribe({ - consumerId - }) { - const consumer = this._consumers[consumerId]; - if (consumer) { - for (const requestId in consumer) { - const request = consumer[requestId]; - const resource = this._resources[request.resourceId]; - if (resource) { - resource.unsubscribe(request); - } - } - delete this._consumers[consumerId]; - this.prune(); - } + if (Number.isFinite(container.size)) { + return container.size; } - subscribe({ - resourceId, - onChange, - consumerId, - requestId = "default" - }) { - const { - _resources: resources, - protocol - } = this; - if (resourceId.startsWith(protocol)) { - resourceId = resourceId.replace(protocol, ""); - if (!resources[resourceId]) { - this.add({ - resourceId, - data: null, - persistent: false - }); - } - } - const res = resources[resourceId]; - this._track(consumerId, requestId, res, onChange); - if (res) { - return res.getData(); - } - return void 0; + if (Number.isFinite(container.length)) { + return container.length; } - prune() { - if (!this._pruneRequest) { - this._pruneRequest = setTimeout(() => this._prune(), 0); - } + if (isPlainObject(container)) { + return Object.keys(container).length; } - finalize() { - for (const key in this._resources) { - this._resources[key].delete(); - } + throw new Error(ERR_NOT_CONTAINER); + } + function isPlainObject(value) { + return value !== null && typeof value === "object" && value.constructor === Object; + } + function isObject2(value) { + return value !== null && typeof value === "object"; + } + + // node_modules/@deck.gl/core/dist/esm/utils/shader.js + function mergeShaders(target, source) { + if (!source) { + return target; } - _track(consumerId, requestId, resource, onChange) { - const consumers = this._consumers; - const consumer = consumers[consumerId] = consumers[consumerId] || {}; - const request = consumer[requestId] || {}; - const oldResource = request.resourceId && this._resources[request.resourceId]; - if (oldResource) { - oldResource.unsubscribe(request); - this.prune(); - } - if (resource) { - consumer[requestId] = request; - request.onChange = onChange; - request.resourceId = resource.id; - resource.subscribe(request); + const result = { + ...target, + ...source + }; + if ("defines" in source) { + result.defines = { + ...target.defines, + ...source.defines + }; + } + if ("modules" in source) { + result.modules = (target.modules || []).concat(source.modules); + if (source.modules.some((module) => module.name === "project64")) { + const index = result.modules.findIndex((module) => module.name === "project32"); + if (index >= 0) { + result.modules.splice(index, 1); + } } } - _prune() { - this._pruneRequest = null; - for (const key of Object.keys(this._resources)) { - const res = this._resources[key]; - if (!res.persistent && !res.inUse()) { - res.delete(); - delete this._resources[key]; + if ("inject" in source) { + if (!target.inject) { + result.inject = source.inject; + } else { + const mergedInjection = { + ...target.inject + }; + for (const key in source.inject) { + mergedInjection[key] = (mergedInjection[key] || "") + source.inject[key]; } + result.inject = mergedInjection; } } - }; + return result; + } - // node_modules/@deck.gl/core/dist/esm/shaderlib/project32/project32.js - var vs5 = "\nvec4 project_position_to_clipspace(\n vec3 position, vec3 position64Low, vec3 offset, out vec4 commonPosition\n) {\n vec3 projectedPosition = project_position(position, position64Low);\n mat3 rotation;\n if (project_needs_rotation(projectedPosition, rotation)) {\n // offset is specified as ENU\n // when in globe projection, rotate offset so that the ground alighs with the surface of the globe\n offset = rotation * offset;\n }\n commonPosition = vec4(projectedPosition + offset, 1.0);\n return project_common_position_to_clipspace(commonPosition);\n}\n\nvec4 project_position_to_clipspace(\n vec3 position, vec3 position64Low, vec3 offset\n) {\n vec4 commonPosition;\n return project_position_to_clipspace(position, position64Low, offset, commonPosition);\n}\n"; - var project32_default = { - name: "project32", - dependencies: [project_default], - vs: vs5 + // node_modules/@deck.gl/core/dist/esm/utils/texture.js + var DEFAULT_TEXTURE_PARAMETERS = { + [10241]: 9987, + [10240]: 9729, + [10242]: 33071, + [10243]: 33071 }; - - // node_modules/@deck.gl/core/dist/esm/shaderlib/picking/picking.js - var picking_default = { - inject: { - "vs:DECKGL_FILTER_GL_POSITION": "\n // for picking depth values\n picking_setPickingAttribute(position.z / position.w);\n ", - "vs:DECKGL_FILTER_COLOR": "\n picking_setPickingColor(geometry.pickingColor);\n ", - "fs:#decl": "\nuniform bool picking_uAttribute;\n ", - "fs:DECKGL_FILTER_COLOR": { - order: 99, - injection: "\n // use highlight color if this fragment belongs to the selected object.\n color = picking_filterHighlightColor(color);\n\n // use picking color if rendering to picking FBO.\n color = picking_filterPickingColor(color);\n " + var internalTextures = {}; + function createTexture(owner, gl, image, parameters) { + if (image instanceof Texture2D) { + return image; + } else if (image.constructor && image.constructor.name !== "Object") { + image = { + data: image + }; + } + let specialTextureParameters = null; + if (image.compressed) { + specialTextureParameters = { + [10241]: image.data.length > 1 ? 9985 : 9729 + }; + } + const texture = new Texture2D(gl, { + ...image, + parameters: { + ...DEFAULT_TEXTURE_PARAMETERS, + ...specialTextureParameters, + ...parameters } - }, - ...picking - }; - - // node_modules/@deck.gl/core/dist/esm/shaderlib/index.js - var DEFAULT_MODULES = [project_default]; - var SHADER_HOOKS = ["vs:DECKGL_FILTER_SIZE(inout vec3 size, VertexGeometry geometry)", "vs:DECKGL_FILTER_GL_POSITION(inout vec4 position, VertexGeometry geometry)", "vs:DECKGL_FILTER_COLOR(inout vec4 color, VertexGeometry geometry)", "fs:DECKGL_FILTER_COLOR(inout vec4 color, FragmentGeometry geometry)"]; - function createProgramManager(gl) { - const programManager = ProgramManager.getDefaultProgramManager(gl); - for (const shaderModule of DEFAULT_MODULES) { - programManager.addDefaultModule(shaderModule); + }); + internalTextures[texture.id] = owner; + return texture; + } + function destroyTexture(owner, texture) { + if (!texture || !(texture instanceof Texture2D)) { + return; } - for (const shaderHook of SHADER_HOOKS) { - programManager.addShaderHook(shaderHook); + if (internalTextures[texture.id] === owner) { + texture.delete(); + delete internalTextures[texture.id]; } - return programManager; } - // node_modules/@deck.gl/core/dist/esm/lib/layer-manager.js - var TRACE_SET_LAYERS = "layerManager.setLayers"; - var TRACE_ACTIVATE_VIEWPORT = "layerManager.activateViewport"; - var LayerManager = class { - constructor(gl, { - deck, - stats, - viewport: _viewport, - timeline - } = {}) { - _defineProperty(this, "layers", void 0); - _defineProperty(this, "context", void 0); - _defineProperty(this, "resourceManager", void 0); - _defineProperty(this, "_lastRenderedLayers", []); - _defineProperty(this, "_needsRedraw", false); - _defineProperty(this, "_needsUpdate", false); - _defineProperty(this, "_nextLayers", null); - _defineProperty(this, "_debug", false); - _defineProperty(this, "activateViewport", (viewport) => { - debug(TRACE_ACTIVATE_VIEWPORT, this, viewport); - if (viewport) { - this.context.viewport = viewport; - } - }); - this.layers = []; - this.resourceManager = new ResourceManager({ - gl, - protocol: "deck://" - }); - this.context = { - mousePosition: null, - userData: {}, - layerManager: this, - gl, - deck, - programManager: gl && createProgramManager(gl), - stats: stats || new Stats({ - id: "deck.gl" - }), - viewport: _viewport || new Viewport({ - id: "DEFAULT-INITIAL-VIEWPORT" - }), - timeline: timeline || new Timeline(), - resourceManager: this.resourceManager, - onError: void 0 - }; - Object.seal(this); - } - finalize() { - this.resourceManager.finalize(); - for (const layer of this.layers) { - this._finalizeLayer(layer); + // node_modules/@deck.gl/core/dist/esm/lifecycle/prop-types.js + var TYPE_DEFINITIONS2 = { + boolean: { + validate(value, propType) { + return true; + }, + equal(value1, value2, propType) { + return Boolean(value1) === Boolean(value2); } - } - needsRedraw(opts = { - clearRedrawFlags: false - }) { - let redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; + }, + number: { + validate(value, propType) { + return Number.isFinite(value) && (!("max" in propType) || value <= propType.max) && (!("min" in propType) || value >= propType.min); } - for (const layer of this.layers) { - const layerNeedsRedraw = layer.getNeedsRedraw(opts); - redraw = redraw || layerNeedsRedraw; + }, + color: { + validate(value, propType) { + return propType.optional && !value || isArray3(value) && (value.length === 3 || value.length === 4); + }, + equal(value1, value2, propType) { + return deepEqual(value1, value2, 1); + } + }, + accessor: { + validate(value, propType) { + const valueType = getTypeOf2(value); + return valueType === "function" || valueType === getTypeOf2(propType.value); + }, + equal(value1, value2, propType) { + if (typeof value2 === "function") { + return true; + } + return deepEqual(value1, value2, 1); } - return redraw; - } - needsUpdate() { - if (this._nextLayers && this._nextLayers !== this._lastRenderedLayers) { - return "layers changed"; + }, + array: { + validate(value, propType) { + return propType.optional && !value || isArray3(value); + }, + equal(value1, value2, propType) { + const { + compare + } = propType; + const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0; + return compare ? deepEqual(value1, value2, depth) : value1 === value2; } - return this._needsUpdate; - } - setNeedsRedraw(reason) { - this._needsRedraw = this._needsRedraw || reason; - } - setNeedsUpdate(reason) { - this._needsUpdate = this._needsUpdate || reason; - } - getLayers({ - layerIds - } = {}) { - return layerIds ? this.layers.filter((layer) => layerIds.find((layerId) => layer.id.indexOf(layerId) === 0)) : this.layers; - } - setProps(props) { - if ("debug" in props) { - this._debug = props.debug; + }, + object: { + equal(value1, value2, propType) { + if (propType.ignore) { + return true; + } + const { + compare + } = propType; + const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0; + return compare ? deepEqual(value1, value2, depth) : value1 === value2; } - if ("userData" in props) { - this.context.userData = props.userData; + }, + function: { + validate(value, propType) { + return propType.optional && !value || typeof value === "function"; + }, + equal(value1, value2, propType) { + const shouldIgnore = !propType.compare && propType.ignore !== false; + return shouldIgnore || value1 === value2; } - if ("layers" in props) { - this._nextLayers = props.layers; + }, + data: { + transform: (value, propType, component) => { + const { + dataTransform + } = component.props; + return dataTransform && value ? dataTransform(value) : value; } - if ("onError" in props) { - this.context.onError = props.onError; + }, + image: { + transform: (value, propType, component) => { + const context = component.context; + if (!context || !context.gl) { + return null; + } + return createTexture(component.id, context.gl, value, { + ...propType.parameters, + ...component.props.textureParameters + }); + }, + release: (value, propType, component) => { + destroyTexture(component.id, value); } } - setLayers(newLayers, reason) { - debug(TRACE_SET_LAYERS, this, reason, newLayers); - this._lastRenderedLayers = newLayers; - const flatLayers = flatten(newLayers, Boolean); - for (const layer of flatLayers) { - layer.context = this.context; + }; + function parsePropTypes2(propDefs) { + const propTypes = {}; + const defaultProps18 = {}; + const deprecatedProps = {}; + for (const [propName, propDef] of Object.entries(propDefs)) { + const deprecated = propDef === null || propDef === void 0 ? void 0 : propDef.deprecatedFor; + if (deprecated) { + deprecatedProps[propName] = Array.isArray(deprecated) ? deprecated : [deprecated]; + } else { + const propType = parsePropType2(propName, propDef); + propTypes[propName] = propType; + defaultProps18[propName] = propType.value; } - this._updateLayers(this.layers, flatLayers); } - updateLayers() { - const reason = this.needsUpdate(); - if (reason) { - this.setNeedsRedraw("updating layers: ".concat(reason)); - this.setLayers(this._nextLayers || this._lastRenderedLayers, reason); + return { + propTypes, + defaultProps: defaultProps18, + deprecatedProps + }; + } + function parsePropType2(name, propDef) { + switch (getTypeOf2(propDef)) { + case "object": + return normalizePropDefinition(name, propDef); + case "array": + return normalizePropDefinition(name, { + type: "array", + value: propDef, + compare: false + }); + case "boolean": + return normalizePropDefinition(name, { + type: "boolean", + value: propDef + }); + case "number": + return normalizePropDefinition(name, { + type: "number", + value: propDef + }); + case "function": + return normalizePropDefinition(name, { + type: "function", + value: propDef, + compare: true + }); + default: + return { + name, + type: "unknown", + value: propDef + }; + } + } + function normalizePropDefinition(name, propDef) { + if (!("type" in propDef)) { + if (!("value" in propDef)) { + return { + name, + type: "object", + value: propDef + }; } - this._nextLayers = null; + return { + name, + type: getTypeOf2(propDef.value), + ...propDef + }; } - _handleError(stage, error2, layer) { - layer.raiseError(error2, "".concat(stage, " of ").concat(layer)); + return { + name, + ...TYPE_DEFINITIONS2[propDef.type], + ...propDef + }; + } + function isArray3(value) { + return Array.isArray(value) || ArrayBuffer.isView(value); + } + function getTypeOf2(value) { + if (isArray3(value)) { + return "array"; } - _updateLayers(oldLayers, newLayers) { - const oldLayerMap = {}; - for (const oldLayer of oldLayers) { - if (oldLayerMap[oldLayer.id]) { - log_default.warn("Multiple old layers with same id ".concat(oldLayer.id))(); - } else { - oldLayerMap[oldLayer.id] = oldLayer; - } - } - const generatedLayers = []; - this._updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers); - this._finalizeOldLayers(oldLayerMap); - let needsUpdate = false; - for (const layer of generatedLayers) { - if (layer.hasUniformTransition()) { - needsUpdate = "Uniform transition in ".concat(layer); - break; - } - } - this._needsUpdate = needsUpdate; - this.layers = generatedLayers; + if (value === null) { + return "null"; } - _updateSublayersRecursively(newLayers, oldLayerMap, generatedLayers) { - for (const newLayer of newLayers) { - newLayer.context = this.context; - const oldLayer = oldLayerMap[newLayer.id]; - if (oldLayer === null) { - log_default.warn("Multiple new layers with same id ".concat(newLayer.id))(); - } - oldLayerMap[newLayer.id] = null; - let sublayers = null; - try { - if (this._debug && oldLayer !== newLayer) { - newLayer.validateProps(); - } - if (!oldLayer) { - this._initializeLayer(newLayer); - } else { - this._transferLayerState(oldLayer, newLayer); - this._updateLayer(newLayer); - } - generatedLayers.push(newLayer); - sublayers = newLayer.isComposite ? newLayer.getSubLayers() : null; - } catch (err) { - this._handleError("matching", err, newLayer); - } - if (sublayers) { - this._updateSublayersRecursively(sublayers, oldLayerMap, generatedLayers); - } + return typeof value; + } + + // node_modules/@deck.gl/core/dist/esm/lifecycle/create-props.js + function createProps(component, propObjects) { + let extensions; + for (let i3 = propObjects.length - 1; i3 >= 0; i3--) { + const props = propObjects[i3]; + if ("extensions" in props) { + extensions = props.extensions; } } - _finalizeOldLayers(oldLayerMap) { - for (const layerId in oldLayerMap) { - const layer = oldLayerMap[layerId]; - if (layer) { - this._finalizeLayer(layer); - } + const propsPrototype = getPropsPrototype(component.constructor, extensions); + const propsInstance = Object.create(propsPrototype); + propsInstance[COMPONENT_SYMBOL] = component; + propsInstance[ASYNC_ORIGINAL_SYMBOL] = {}; + propsInstance[ASYNC_RESOLVED_SYMBOL] = {}; + for (let i3 = 0; i3 < propObjects.length; ++i3) { + const props = propObjects[i3]; + for (const key in props) { + propsInstance[key] = props[key]; } } - _initializeLayer(layer) { - try { - layer._initialize(); - layer.lifecycle = LIFECYCLE.INITIALIZED; - } catch (err) { - this._handleError("initialization", err, layer); + Object.freeze(propsInstance); + return propsInstance; + } + var MergedDefaultPropsCacheKey = "_mergedDefaultProps"; + function getPropsPrototype(componentClass, extensions) { + let cacheKey = MergedDefaultPropsCacheKey; + if (extensions) { + for (const extension of extensions) { + const ExtensionClass = extension.constructor; + if (ExtensionClass) { + cacheKey += ":".concat(ExtensionClass.extensionName || ExtensionClass.name); + } } } - _transferLayerState(oldLayer, newLayer) { - newLayer._transferState(oldLayer); - newLayer.lifecycle = LIFECYCLE.MATCHED; - if (newLayer !== oldLayer) { - oldLayer.lifecycle = LIFECYCLE.AWAITING_GC; - } + const defaultProps18 = getOwnProperty(componentClass, cacheKey); + if (!defaultProps18) { + return componentClass[cacheKey] = createPropsPrototypeAndTypes(componentClass, extensions || []); } - _updateLayer(layer) { - try { - layer._update(); - } catch (err) { - this._handleError("update", err, layer); - } + return defaultProps18; + } + function createPropsPrototypeAndTypes(componentClass, extensions) { + const parent = componentClass.prototype; + if (!parent) { + return null; } - _finalizeLayer(layer) { - this._needsRedraw = this._needsRedraw || "finalized ".concat(layer); - layer.lifecycle = LIFECYCLE.AWAITING_FINALIZATION; - try { - layer._finalize(); - layer.lifecycle = LIFECYCLE.FINALIZED; - } catch (err) { - this._handleError("finalization", err, layer); + const parentClass = Object.getPrototypeOf(componentClass); + const parentDefaultProps = getPropsPrototype(parentClass); + const componentDefaultProps = getOwnProperty(componentClass, "defaultProps") || {}; + const componentPropDefs = parsePropTypes2(componentDefaultProps); + const defaultProps18 = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps, componentPropDefs.defaultProps); + const propTypes = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps === null || parentDefaultProps === void 0 ? void 0 : parentDefaultProps[PROP_TYPES_SYMBOL], componentPropDefs.propTypes); + const deprecatedProps = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps === null || parentDefaultProps === void 0 ? void 0 : parentDefaultProps[DEPRECATED_PROPS_SYMBOL], componentPropDefs.deprecatedProps); + for (const extension of extensions) { + const extensionDefaultProps = getPropsPrototype(extension.constructor); + if (extensionDefaultProps) { + Object.assign(defaultProps18, extensionDefaultProps); + Object.assign(propTypes, extensionDefaultProps[PROP_TYPES_SYMBOL]); + Object.assign(deprecatedProps, extensionDefaultProps[DEPRECATED_PROPS_SYMBOL]); } } - }; - - // node_modules/@deck.gl/core/dist/esm/utils/deep-equal.js - function deepEqual(a2, b2, depth) { - if (a2 === b2) { - return true; - } - if (!depth || !a2 || !b2) { - return false; + createPropsPrototype(defaultProps18, componentClass); + addAsyncPropsToPropPrototype(defaultProps18, propTypes); + addDeprecatedPropsToPropPrototype(defaultProps18, deprecatedProps); + defaultProps18[PROP_TYPES_SYMBOL] = propTypes; + defaultProps18[DEPRECATED_PROPS_SYMBOL] = deprecatedProps; + if (extensions.length === 0 && !hasOwnProperty(componentClass, "_propTypes")) { + componentClass._propTypes = propTypes; } - if (Array.isArray(a2)) { - if (!Array.isArray(b2) || a2.length !== b2.length) { - return false; + return defaultProps18; + } + function createPropsPrototype(defaultProps18, componentClass) { + const id = getComponentName(componentClass); + Object.defineProperties(defaultProps18, { + id: { + writable: true, + value: id } - for (let i2 = 0; i2 < a2.length; i2++) { - if (!deepEqual(a2[i2], b2[i2], depth - 1)) { - return false; + }); + } + function addDeprecatedPropsToPropPrototype(defaultProps18, deprecatedProps) { + for (const propName in deprecatedProps) { + Object.defineProperty(defaultProps18, propName, { + enumerable: false, + set(newValue) { + const nameStr = "".concat(this.id, ": ").concat(propName); + for (const newPropName of deprecatedProps[propName]) { + if (!hasOwnProperty(this, newPropName)) { + this[newPropName] = newValue; + } + } + log_default.deprecated(nameStr, deprecatedProps[propName].join("/"))(); } - } - return true; - } - if (Array.isArray(b2)) { - return false; + }); } - if (typeof a2 === "object" && typeof b2 === "object") { - const aKeys = Object.keys(a2); - const bKeys = Object.keys(b2); - if (aKeys.length !== bKeys.length) { - return false; + } + function addAsyncPropsToPropPrototype(defaultProps18, propTypes) { + const defaultValues = {}; + const descriptors = {}; + for (const propName in propTypes) { + const propType = propTypes[propName]; + const { + name, + value + } = propType; + if (propType.async) { + defaultValues[name] = value; + descriptors[name] = getDescriptorForAsyncProp(name); } - for (const key of aKeys) { - if (!b2.hasOwnProperty(key)) { - return false; + } + defaultProps18[ASYNC_DEFAULTS_SYMBOL] = defaultValues; + defaultProps18[ASYNC_ORIGINAL_SYMBOL] = {}; + Object.defineProperties(defaultProps18, descriptors); + } + function getDescriptorForAsyncProp(name) { + return { + enumerable: true, + set(newValue) { + if (typeof newValue === "string" || newValue instanceof Promise || isAsyncIterable2(newValue)) { + this[ASYNC_ORIGINAL_SYMBOL][name] = newValue; + } else { + this[ASYNC_RESOLVED_SYMBOL][name] = newValue; } - if (!deepEqual(a2[key], b2[key], depth - 1)) { - return false; + }, + get() { + if (this[ASYNC_RESOLVED_SYMBOL]) { + if (name in this[ASYNC_RESOLVED_SYMBOL]) { + const value = this[ASYNC_RESOLVED_SYMBOL][name]; + return value || this[ASYNC_DEFAULTS_SYMBOL][name]; + } + if (name in this[ASYNC_ORIGINAL_SYMBOL]) { + const state = this[COMPONENT_SYMBOL] && this[COMPONENT_SYMBOL].internalState; + if (state && state.hasAsyncProp(name)) { + return state.getAsyncProp(name) || this[ASYNC_DEFAULTS_SYMBOL][name]; + } + } } + return this[ASYNC_DEFAULTS_SYMBOL][name]; } - return true; + }; + } + function hasOwnProperty(object, prop) { + return Object.prototype.hasOwnProperty.call(object, prop); + } + function getOwnProperty(object, prop) { + return hasOwnProperty(object, prop) && object[prop]; + } + function getComponentName(componentClass) { + const componentName = componentClass.componentName; + if (!componentName) { + log_default.warn("".concat(componentClass.name, ".componentName not specified"))(); } - return false; + return componentName || componentClass.name; } - // node_modules/@deck.gl/core/dist/esm/lib/view-manager.js - var ViewManager = class { - constructor(props) { - _defineProperty(this, "width", void 0); - _defineProperty(this, "height", void 0); - _defineProperty(this, "views", void 0); - _defineProperty(this, "viewState", void 0); - _defineProperty(this, "controllers", void 0); - _defineProperty(this, "timeline", void 0); - _defineProperty(this, "_viewports", void 0); - _defineProperty(this, "_viewportMap", void 0); - _defineProperty(this, "_isUpdating", void 0); - _defineProperty(this, "_needsRedraw", void 0); - _defineProperty(this, "_needsUpdate", void 0); - _defineProperty(this, "_eventManager", void 0); - _defineProperty(this, "_eventCallbacks", void 0); - this.views = []; - this.width = 100; - this.height = 100; - this.viewState = {}; - this.controllers = {}; - this.timeline = props.timeline; - this._viewports = []; - this._viewportMap = {}; - this._isUpdating = false; - this._needsRedraw = "First render"; - this._needsUpdate = "Initialize"; - this._eventManager = props.eventManager; - this._eventCallbacks = { - onViewStateChange: props.onViewStateChange, - onInteractionStateChange: props.onInteractionStateChange - }; - Object.seal(this); - this.setProps(props); + // node_modules/@deck.gl/core/dist/esm/lifecycle/component.js + var counter = 0; + var Component = class { + constructor(...propObjects) { + _defineProperty(this, "id", void 0); + _defineProperty(this, "props", void 0); + _defineProperty(this, "count", void 0); + this.props = createProps(this, propObjects); + this.id = this.props.id; + this.count = counter++; } - finalize() { - for (const key in this.controllers) { - const controller = this.controllers[key]; - if (controller) { - controller.finalize(); + clone(newProps) { + const { + props + } = this; + const asyncProps = {}; + for (const key in props[ASYNC_DEFAULTS_SYMBOL]) { + if (key in props[ASYNC_RESOLVED_SYMBOL]) { + asyncProps[key] = props[ASYNC_RESOLVED_SYMBOL][key]; + } else if (key in props[ASYNC_ORIGINAL_SYMBOL]) { + asyncProps[key] = props[ASYNC_ORIGINAL_SYMBOL][key]; } } - this.controllers = {}; - } - needsRedraw(opts = { - clearRedrawFlags: false - }) { - const redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; - } - return redraw; + return new this.constructor({ + ...props, + ...asyncProps, + ...newProps + }); } - setNeedsUpdate(reason) { - this._needsUpdate = this._needsUpdate || reason; - this._needsRedraw = this._needsRedraw || reason; + }; + _defineProperty(Component, "componentName", "Component"); + _defineProperty(Component, "defaultProps", {}); + + // node_modules/@deck.gl/core/dist/esm/lifecycle/component-state.js + var EMPTY_PROPS = Object.freeze({}); + var ComponentState = class { + constructor(component) { + _defineProperty(this, "component", void 0); + _defineProperty(this, "onAsyncPropUpdated", void 0); + _defineProperty(this, "asyncProps", void 0); + _defineProperty(this, "oldProps", void 0); + _defineProperty(this, "oldAsyncProps", void 0); + this.component = component; + this.asyncProps = {}; + this.onAsyncPropUpdated = () => { + }; + this.oldProps = null; + this.oldAsyncProps = null; } - updateViewStates() { - for (const viewId in this.controllers) { - const controller = this.controllers[viewId]; - if (controller) { - controller.updateTransition(); + finalize() { + for (const propName in this.asyncProps) { + const asyncProp = this.asyncProps[propName]; + if (asyncProp && asyncProp.type && asyncProp.type.release) { + asyncProp.type.release(asyncProp.resolvedValue, asyncProp.type, this.component); } } + this.asyncProps = {}; + this.component = null; + this.resetOldProps(); } - getViewports(rect) { - if (rect) { - return this._viewports.filter((viewport) => viewport.containsPixel(rect)); - } - return this._viewports; - } - getViews() { - const viewMap = {}; - this.views.forEach((view) => { - viewMap[view.id] = view; - }); - return viewMap; + getOldProps() { + return this.oldAsyncProps || this.oldProps || EMPTY_PROPS; } - getView(viewId) { - return this.views.find((view) => view.id === viewId); + resetOldProps() { + this.oldAsyncProps = null; + this.oldProps = this.component ? this.component.props : null; } - getViewState(viewOrViewId) { - const view = typeof viewOrViewId === "string" ? this.getView(viewOrViewId) : viewOrViewId; - const viewState = view && this.viewState[view.getViewStateId()] || this.viewState; - return view ? view.filterViewState(viewState) : viewState; + hasAsyncProp(propName) { + return propName in this.asyncProps; } - getViewport(viewId) { - return this._viewportMap[viewId]; + getAsyncProp(propName) { + const asyncProp = this.asyncProps[propName]; + return asyncProp && asyncProp.resolvedValue; } - unproject(xyz, opts) { - const viewports = this.getViewports(); - const pixel = { - x: xyz[0], - y: xyz[1] - }; - for (let i2 = viewports.length - 1; i2 >= 0; --i2) { - const viewport = viewports[i2]; - if (viewport.containsPixel(pixel)) { - const p2 = xyz.slice(); - p2[0] -= viewport.x; - p2[1] -= viewport.y; - return viewport.unproject(p2, opts); + isAsyncPropLoading(propName) { + if (propName) { + const asyncProp = this.asyncProps[propName]; + return Boolean(asyncProp && asyncProp.pendingLoadCount > 0 && asyncProp.pendingLoadCount !== asyncProp.resolvedLoadCount); + } + for (const key in this.asyncProps) { + if (this.isAsyncPropLoading(key)) { + return true; } } + return false; + } + reloadAsyncProp(propName, value) { + this._watchPromise(propName, Promise.resolve(value)); + } + setAsyncProps(props) { + this.component = props[COMPONENT_SYMBOL] || this.component; + const resolvedValues = props[ASYNC_RESOLVED_SYMBOL] || {}; + const originalValues = props[ASYNC_ORIGINAL_SYMBOL] || props; + const defaultValues = props[ASYNC_DEFAULTS_SYMBOL] || {}; + for (const propName in resolvedValues) { + const value = resolvedValues[propName]; + this._createAsyncPropData(propName, defaultValues[propName]); + this._updateAsyncProp(propName, value); + resolvedValues[propName] = this.getAsyncProp(propName); + } + for (const propName in originalValues) { + const value = originalValues[propName]; + this._createAsyncPropData(propName, defaultValues[propName]); + this._updateAsyncProp(propName, value); + } + } + _fetch(propName, url) { return null; } - setProps(props) { - if (props.views) { - this._setViews(props.views); + _onResolve(propName, value) { + } + _onError(propName, error2) { + } + _updateAsyncProp(propName, value) { + if (!this._didAsyncInputValueChange(propName, value)) { + return; } - if (props.viewState) { - this._setViewState(props.viewState); + if (typeof value === "string") { + value = this._fetch(propName, value); } - if ("width" in props || "height" in props) { - this._setSize(props.width, props.height); + if (value instanceof Promise) { + this._watchPromise(propName, value); + return; } - if (!this._isUpdating) { - this._update(); + if (isAsyncIterable2(value)) { + this._resolveAsyncIterable(propName, value); + return; } + this._setPropValue(propName, value); } - _update() { - this._isUpdating = true; - if (this._needsUpdate) { - this._needsUpdate = false; - this._rebuildViewports(); - } - if (this._needsUpdate) { - this._needsUpdate = false; - this._rebuildViewports(); + _freezeAsyncOldProps() { + if (!this.oldAsyncProps && this.oldProps) { + this.oldAsyncProps = Object.create(this.oldProps); + for (const propName in this.asyncProps) { + Object.defineProperty(this.oldAsyncProps, propName, { + enumerable: true, + value: this.oldProps[propName] + }); + } } - this._isUpdating = false; } - _setSize(width, height) { - if (width !== this.width || height !== this.height) { - this.width = width; - this.height = height; - this.setNeedsUpdate("Size changed"); + _didAsyncInputValueChange(propName, value) { + const asyncProp = this.asyncProps[propName]; + if (value === asyncProp.resolvedValue || value === asyncProp.lastValue) { + return false; } + asyncProp.lastValue = value; + return true; } - _setViews(views) { - views = flatten(views, Boolean); - const viewsChanged = this._diffViews(views, this.views); - if (viewsChanged) { - this.setNeedsUpdate("views changed"); + _setPropValue(propName, value) { + this._freezeAsyncOldProps(); + const asyncProp = this.asyncProps[propName]; + if (asyncProp) { + value = this._postProcessValue(asyncProp, value); + asyncProp.resolvedValue = value; + asyncProp.pendingLoadCount++; + asyncProp.resolvedLoadCount = asyncProp.pendingLoadCount; } - this.views = views; } - _setViewState(viewState) { - if (viewState) { - const viewStateChanged = !deepEqual(viewState, this.viewState, 3); - if (viewStateChanged) { - this.setNeedsUpdate("viewState changed"); - } - this.viewState = viewState; - } else { - log_default.warn("missing `viewState` or `initialViewState`")(); + _setAsyncPropValue(propName, value, loadCount) { + const asyncProp = this.asyncProps[propName]; + if (asyncProp && loadCount >= asyncProp.resolvedLoadCount && value !== void 0) { + this._freezeAsyncOldProps(); + asyncProp.resolvedValue = value; + asyncProp.resolvedLoadCount = loadCount; + this.onAsyncPropUpdated(propName, value); } } - _onViewStateChange(viewId, event) { - if (this._eventCallbacks.onViewStateChange) { - this._eventCallbacks.onViewStateChange({ - ...event, - viewId + _watchPromise(propName, promise) { + const asyncProp = this.asyncProps[propName]; + if (asyncProp) { + asyncProp.pendingLoadCount++; + const loadCount = asyncProp.pendingLoadCount; + promise.then((data) => { + if (!this.component) { + return; + } + data = this._postProcessValue(asyncProp, data); + this._setAsyncPropValue(propName, data, loadCount); + this._onResolve(propName, data); + }).catch((error2) => { + this._onError(propName, error2); }); } } - _createController(view, props) { - const Controller2 = props.type; - const controller = new Controller2({ - timeline: this.timeline, - eventManager: this._eventManager, - onViewStateChange: this._onViewStateChange.bind(this, props.id), - onStateChange: this._eventCallbacks.onInteractionStateChange, - makeViewport: (viewState) => { - var _this$getView; - return (_this$getView = this.getView(view.id)) === null || _this$getView === void 0 ? void 0 : _this$getView.makeViewport({ - viewState, - width: this.width, - height: this.height - }); + async _resolveAsyncIterable(propName, iterable) { + if (propName !== "data") { + this._setPropValue(propName, iterable); + return; + } + const asyncProp = this.asyncProps[propName]; + if (!asyncProp) { + return; + } + asyncProp.pendingLoadCount++; + const loadCount = asyncProp.pendingLoadCount; + let data = []; + let count2 = 0; + for await (const chunk of iterable) { + if (!this.component) { + return; } - }); - return controller; + const { + dataTransform + } = this.component.props; + if (dataTransform) { + data = dataTransform(chunk, data); + } else { + data = data.concat(chunk); + } + Object.defineProperty(data, "__diff", { + enumerable: false, + value: [{ + startRow: count2, + endRow: data.length + }] + }); + count2 = data.length; + this._setAsyncPropValue(propName, data, loadCount); + } + this._onResolve(propName, data); } - _updateController(view, viewState, viewport, controller) { - const controllerProps = view.controller; - if (controllerProps && viewport) { - const resolvedProps = { - ...viewState, - ...controllerProps, - id: view.id, - x: viewport.x, - y: viewport.y, - width: viewport.width, - height: viewport.height - }; - if (!controller || controller.constructor !== controllerProps.type) { - controller = this._createController(view, resolvedProps); + _postProcessValue(asyncProp, value) { + const propType = asyncProp.type; + if (propType && this.component) { + if (propType.release) { + propType.release(asyncProp.resolvedValue, propType, this.component); } - if (controller) { - controller.setProps(resolvedProps); + if (propType.transform) { + return propType.transform(value, propType, this.component); } - return controller; } - return null; + return value; } - _rebuildViewports() { - const { - views - } = this; - const oldControllers = this.controllers; - this._viewports = []; - this.controllers = {}; - let invalidateControllers = false; - for (let i2 = views.length; i2--; ) { - const view = views[i2]; - const viewState = this.getViewState(view); - const viewport = view.makeViewport({ - viewState, - width: this.width, - height: this.height + _createAsyncPropData(propName, defaultValue) { + const asyncProp = this.asyncProps[propName]; + if (!asyncProp) { + const propTypes = this.component && this.component.props[PROP_TYPES_SYMBOL]; + this.asyncProps[propName] = { + type: propTypes && propTypes[propName], + lastValue: null, + resolvedValue: defaultValue, + pendingLoadCount: 0, + resolvedLoadCount: 0 + }; + } + } + }; + + // node_modules/@deck.gl/core/dist/esm/lib/layer-state.js + var LayerState = class extends ComponentState { + constructor({ + attributeManager, + layer + }) { + super(layer); + _defineProperty(this, "attributeManager", void 0); + _defineProperty(this, "needsRedraw", void 0); + _defineProperty(this, "needsUpdate", void 0); + _defineProperty(this, "subLayers", void 0); + _defineProperty(this, "usesPickingColorCache", void 0); + _defineProperty(this, "hasPickingBuffer", void 0); + _defineProperty(this, "changeFlags", void 0); + _defineProperty(this, "viewport", void 0); + _defineProperty(this, "uniformTransitions", void 0); + _defineProperty(this, "propsInTransition", void 0); + this.attributeManager = attributeManager; + this.needsRedraw = true; + this.needsUpdate = true; + this.subLayers = null; + this.usesPickingColorCache = false; + } + get layer() { + return this.component; + } + _fetch(propName, url) { + const layer = this.layer; + const fetch2 = layer === null || layer === void 0 ? void 0 : layer.props.fetch; + if (fetch2) { + return fetch2(url, { + propName, + layer }); - let oldController = oldControllers[view.id]; - const hasController = Boolean(view.controller); - if (hasController && !oldController) { - invalidateControllers = true; - } - if ((invalidateControllers || !hasController) && oldController) { - oldController.finalize(); - oldController = null; - } - this.controllers[view.id] = this._updateController(view, viewState, viewport, oldController); - if (viewport) { - this._viewports.unshift(viewport); - } } - for (const id in oldControllers) { - const oldController = oldControllers[id]; - if (oldController && !this.controllers[id]) { - oldController.finalize(); + return super._fetch(propName, url); + } + _onResolve(propName, value) { + const layer = this.layer; + if (layer) { + const onDataLoad = layer.props.onDataLoad; + if (propName === "data" && onDataLoad) { + onDataLoad(value, { + propName, + layer + }); } } - this._buildViewportMap(); } - _buildViewportMap() { - this._viewportMap = {}; - this._viewports.forEach((viewport) => { - if (viewport.id) { - this._viewportMap[viewport.id] = this._viewportMap[viewport.id] || viewport; - } - }); + _onError(propName, error2) { + const layer = this.layer; + if (layer) { + layer.raiseError(error2, "loading ".concat(propName, " of ").concat(this.layer)); + } } - _diffViews(newViews, oldViews) { - if (newViews.length !== oldViews.length) { - return true; + }; + + // node_modules/@deck.gl/core/dist/esm/lib/layer.js + var TRACE_CHANGE_FLAG = "layer.changeFlag"; + var TRACE_INITIALIZE = "layer.initialize"; + var TRACE_UPDATE = "layer.update"; + var TRACE_FINALIZE = "layer.finalize"; + var TRACE_MATCHED = "layer.matched"; + var MAX_PICKING_COLOR_CACHE_SIZE = 2 ** 24 - 1; + var EMPTY_ARRAY2 = Object.freeze([]); + var areViewportsEqual = memoize(({ + oldViewport, + viewport + }) => { + return oldViewport.equals(viewport); + }); + var pickingColorCache = new Uint8ClampedArray(0); + var defaultProps2 = { + data: { + type: "data", + value: EMPTY_ARRAY2, + async: true + }, + dataComparator: { + type: "function", + value: null, + optional: true + }, + _dataDiff: { + type: "function", + value: (data) => data && data.__diff, + optional: true + }, + dataTransform: { + type: "function", + value: null, + optional: true + }, + onDataLoad: { + type: "function", + value: null, + optional: true + }, + onError: { + type: "function", + value: null, + optional: true + }, + fetch: { + type: "function", + value: (url, { + propName, + layer, + loaders, + loadOptions, + signal + }) => { + const { + resourceManager + } = layer.context; + loadOptions = loadOptions || layer.getLoadOptions(); + loaders = loaders || layer.props.loaders; + if (signal) { + var _loadOptions; + loadOptions = { + ...loadOptions, + fetch: { + ...(_loadOptions = loadOptions) === null || _loadOptions === void 0 ? void 0 : _loadOptions.fetch, + signal + } + }; + } + let inResourceManager = resourceManager.contains(url); + if (!inResourceManager && !loadOptions) { + resourceManager.add({ + resourceId: url, + data: load(url, loaders), + persistent: false + }); + inResourceManager = true; + } + if (inResourceManager) { + return resourceManager.subscribe({ + resourceId: url, + onChange: (data) => { + var _layer$internalState; + return (_layer$internalState = layer.internalState) === null || _layer$internalState === void 0 ? void 0 : _layer$internalState.reloadAsyncProp(propName, data); + }, + consumerId: layer.id, + requestId: propName + }); + } + return load(url, loaders, loadOptions); } - return newViews.some((_2, i2) => !newViews[i2].equals(oldViews[i2])); + }, + updateTriggers: {}, + visible: true, + pickable: false, + opacity: { + type: "number", + min: 0, + max: 1, + value: 1 + }, + operation: "draw", + onHover: { + type: "function", + value: null, + optional: true + }, + onClick: { + type: "function", + value: null, + optional: true + }, + onDragStart: { + type: "function", + value: null, + optional: true + }, + onDrag: { + type: "function", + value: null, + optional: true + }, + onDragEnd: { + type: "function", + value: null, + optional: true + }, + coordinateSystem: COORDINATE_SYSTEM.DEFAULT, + coordinateOrigin: { + type: "array", + value: [0, 0, 0], + compare: true + }, + modelMatrix: { + type: "array", + value: null, + compare: true, + optional: true + }, + wrapLongitude: false, + positionFormat: "XYZ", + colorFormat: "RGBA", + parameters: { + type: "object", + value: {}, + optional: true, + compare: 2 + }, + loadOptions: { + type: "object", + value: null, + optional: true, + ignore: true + }, + transitions: null, + extensions: [], + loaders: { + type: "array", + value: [], + optional: true, + ignore: true + }, + getPolygonOffset: { + type: "function", + value: ({ + layerIndex + }) => [0, -layerIndex * 100] + }, + highlightedObjectIndex: null, + autoHighlight: false, + highlightColor: { + type: "accessor", + value: [0, 0, 128, 128] } }; - - // node_modules/@deck.gl/core/dist/esm/utils/positions.js - var PERCENT_OR_PIXELS_REGEX = /([0-9]+\.?[0-9]*)(%|px)/; - function parsePosition(value) { - switch (typeof value) { - case "number": - return { - position: value, - relative: false - }; - case "string": - const match = PERCENT_OR_PIXELS_REGEX.exec(value); - if (match && match.length >= 3) { - const relative = match[2] === "%"; - const position = parseFloat(match[1]); - return { - position: relative ? position / 100 : position, - relative - }; - } - default: - throw new Error("Could not parse position string ".concat(value)); - } - } - function getPosition(position, extent) { - return position.relative ? Math.round(position.position * extent) : position.position; - } - - // node_modules/@deck.gl/core/dist/esm/utils/assert.js - function assert10(condition, message) { - if (!condition) { - throw new Error(message || "deck.gl: assertion failed."); + var Layer = class extends Component { + constructor(...args) { + super(...args); + _defineProperty(this, "internalState", null); + _defineProperty(this, "lifecycle", LIFECYCLE.NO_STATE); + _defineProperty(this, "context", void 0); + _defineProperty(this, "state", void 0); + _defineProperty(this, "parent", null); } - } - - // node_modules/@deck.gl/core/dist/esm/views/view.js - var View = class { - constructor(props) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "viewportInstance", void 0); - _defineProperty(this, "_x", void 0); - _defineProperty(this, "_y", void 0); - _defineProperty(this, "_width", void 0); - _defineProperty(this, "_height", void 0); - _defineProperty(this, "_padding", void 0); - _defineProperty(this, "props", void 0); - const { - id, - x: x2 = 0, - y: y2 = 0, - width = "100%", - height = "100%", - padding = null, - viewportInstance - } = props || {}; - assert10(!viewportInstance || viewportInstance instanceof Viewport); - this.viewportInstance = viewportInstance; - this.id = id || this.constructor.displayName || "view"; - this.props = { - ...props, - id: this.id - }; - this._x = parsePosition(x2); - this._y = parsePosition(y2); - this._width = parsePosition(width); - this._height = parsePosition(height); - this._padding = padding && { - left: parsePosition(padding.left || 0), - right: parsePosition(padding.right || 0), - top: parsePosition(padding.top || 0), - bottom: parsePosition(padding.bottom || 0) - }; - this.equals = this.equals.bind(this); - Object.seal(this); + static get componentName() { + return Object.prototype.hasOwnProperty.call(this, "layerName") ? this.layerName : ""; } - equals(view) { - if (this === view) { - return true; - } - if (this.viewportInstance) { - return view.viewportInstance ? this.viewportInstance.equals(view.viewportInstance) : false; + get root() { + let layer = this; + while (layer.parent) { + layer = layer.parent; } - return this.ViewportType === view.ViewportType && deepEqual(this.props, view.props, 2); + return layer; } - makeViewport({ - width, - height, - viewState - }) { - if (this.viewportInstance) { - return this.viewportInstance; - } - viewState = this.filterViewState(viewState); - const viewportDimensions = this.getDimensions({ - width, - height + toString() { + const className = this.constructor.layerName || this.constructor.name; + return "".concat(className, "({id: '").concat(this.props.id, "'})"); + } + project(xyz) { + assert10(this.internalState); + const viewport = this.internalState.viewport || this.context.viewport; + const worldPosition = getWorldPosition(xyz, { + viewport, + modelMatrix: this.props.modelMatrix, + coordinateOrigin: this.props.coordinateOrigin, + coordinateSystem: this.props.coordinateSystem }); - if (!viewportDimensions.height || !viewportDimensions.width) { - return null; - } - return new this.ViewportType({ - ...viewState, - ...this.props, - ...viewportDimensions + const [x2, y2, z] = worldToPixels(worldPosition, viewport.pixelProjectionMatrix); + return xyz.length === 2 ? [x2, y2] : [x2, y2, z]; + } + unproject(xy) { + assert10(this.internalState); + const viewport = this.internalState.viewport || this.context.viewport; + return viewport.unproject(xy); + } + projectPosition(xyz, params) { + assert10(this.internalState); + const viewport = this.internalState.viewport || this.context.viewport; + return projectPosition(xyz, { + viewport, + modelMatrix: this.props.modelMatrix, + coordinateOrigin: this.props.coordinateOrigin, + coordinateSystem: this.props.coordinateSystem, + ...params }); } - getViewStateId() { - const { - viewState - } = this.props; - if (typeof viewState === "string") { - return viewState; - } - return (viewState === null || viewState === void 0 ? void 0 : viewState.id) || this.id; + get isComposite() { + return false; } - filterViewState(viewState) { - if (this.props.viewState && typeof this.props.viewState === "object") { - if (!this.props.viewState.id) { - return this.props.viewState; - } - const newViewState = { - ...viewState - }; - for (const key in this.props.viewState) { - if (key !== "id") { - newViewState[key] = this.props.viewState[key]; - } - } - return newViewState; - } - return viewState; + setState(partialState) { + this.setChangeFlags({ + stateChanged: true + }); + Object.assign(this.state, partialState); + this.setNeedsRedraw(); } - getDimensions({ - width, - height - }) { - const dimensions = { - x: getPosition(this._x, width), - y: getPosition(this._y, height), - width: getPosition(this._width, width), - height: getPosition(this._height, height) - }; - if (this._padding) { - dimensions.padding = { - left: getPosition(this._padding.left, width), - top: getPosition(this._padding.top, height), - right: getPosition(this._padding.right, width), - bottom: getPosition(this._padding.bottom, height) - }; + setNeedsRedraw() { + if (this.internalState) { + this.internalState.needsRedraw = true; } - return dimensions; } - get controller() { - const opts = this.props.controller; - if (!opts) { - return null; - } - if (opts === true) { - return { - type: this.ControllerType - }; - } - if (typeof opts === "function") { - return { - type: opts - }; + setNeedsUpdate() { + if (this.internalState) { + this.context.layerManager.setNeedsUpdate(String(this)); + this.internalState.needsUpdate = true; } - return { - type: this.ControllerType, - ...opts - }; - } - }; - - // node_modules/@deck.gl/core/dist/esm/transitions/transition.js - var Transition = class { - constructor(timeline) { - _defineProperty(this, "_inProgress", void 0); - _defineProperty(this, "_handle", void 0); - _defineProperty(this, "_timeline", void 0); - _defineProperty(this, "time", void 0); - _defineProperty(this, "settings", void 0); - this._inProgress = false; - this._handle = null; - this._timeline = timeline; - this.time = 0; - this.settings = { - duration: 0 - }; } - get inProgress() { - return this._inProgress; + get isLoaded() { + return this.internalState ? !this.internalState.isAsyncPropLoading() : false; } - start(settings) { - var _this$settings$onStar, _this$settings; - this.cancel(); - this.settings = settings; - this._inProgress = true; - (_this$settings$onStar = (_this$settings = this.settings).onStart) === null || _this$settings$onStar === void 0 ? void 0 : _this$settings$onStar.call(_this$settings, this); + get wrapLongitude() { + return this.props.wrapLongitude; } - end() { - if (this._inProgress) { - var _this$settings$onEnd, _this$settings2; - this._timeline.removeChannel(this._handle); - this._handle = null; - this._inProgress = false; - (_this$settings$onEnd = (_this$settings2 = this.settings).onEnd) === null || _this$settings$onEnd === void 0 ? void 0 : _this$settings$onEnd.call(_this$settings2, this); - } + isPickable() { + return this.props.pickable && this.props.visible; } - cancel() { - if (this._inProgress) { - var _this$settings$onInte, _this$settings3; - (_this$settings$onInte = (_this$settings3 = this.settings).onInterrupt) === null || _this$settings$onInte === void 0 ? void 0 : _this$settings$onInte.call(_this$settings3, this); - this._timeline.removeChannel(this._handle); - this._handle = null; - this._inProgress = false; - } + getModels() { + return this.state && (this.state.models || this.state.model && [this.state.model]) || []; } - update() { - var _this$settings$onUpda, _this$settings4; - if (!this._inProgress) { - return false; - } - if (this._handle === null) { - const { - _timeline: timeline, - settings - } = this; - this._handle = timeline.addChannel({ - delay: timeline.getTime(), - duration: settings.duration - }); - } - this.time = this._timeline.getTime(this._handle); - this._onUpdate(); - (_this$settings$onUpda = (_this$settings4 = this.settings).onUpdate) === null || _this$settings$onUpda === void 0 ? void 0 : _this$settings$onUpda.call(_this$settings4, this); - if (this._timeline.isFinished(this._handle)) { - this.end(); + setModuleParameters(moduleParameters) { + for (const model of this.getModels()) { + model.updateModuleSettings(moduleParameters); } - return true; - } - _onUpdate() { - } - }; - - // node_modules/@deck.gl/core/dist/esm/controllers/transition-manager.js - var noop3 = () => { - }; - var TRANSITION_EVENTS = { - BREAK: 1, - SNAP_TO_END: 2, - IGNORE: 3 - }; - var DEFAULT_EASING = (t2) => t2; - var DEFAULT_INTERRUPTION = TRANSITION_EVENTS.BREAK; - var TransitionManager = class { - constructor(opts) { - _defineProperty(this, "getControllerState", void 0); - _defineProperty(this, "props", void 0); - _defineProperty(this, "propsInTransition", void 0); - _defineProperty(this, "transition", void 0); - _defineProperty(this, "onViewStateChange", void 0); - _defineProperty(this, "onStateChange", void 0); - _defineProperty(this, "_onTransitionUpdate", (transition) => { - const { - time, - settings: { - interpolator, - startProps, - endProps, - duration, - easing - } - } = transition; - const t2 = easing(time / duration); - const viewport = interpolator.interpolateProps(startProps, endProps, t2); - this.propsInTransition = this.getControllerState({ - ...this.props, - ...viewport - }).getViewportProps(); - this.onViewStateChange({ - viewState: this.propsInTransition, - oldViewState: this.props - }); - }); - this.getControllerState = opts.getControllerState; - this.propsInTransition = null; - this.transition = new Transition(opts.timeline); - this.onViewStateChange = opts.onViewStateChange || noop3; - this.onStateChange = opts.onStateChange || noop3; - } - finalize() { - this.transition.cancel(); } - getViewportInTransition() { - return this.propsInTransition; + getAttributeManager() { + return this.internalState && this.internalState.attributeManager; } - processViewStateChange(nextProps) { - let transitionTriggered = false; - const currentProps = this.props; - this.props = nextProps; - if (!currentProps || this._shouldIgnoreViewportChange(currentProps, nextProps)) { - return false; - } - if (this._isTransitionEnabled(nextProps)) { - let startProps = currentProps; - if (this.transition.inProgress) { - const { - interruption, - endProps - } = this.transition.settings; - startProps = { - ...currentProps, - ...interruption === TRANSITION_EVENTS.SNAP_TO_END ? endProps : this.propsInTransition || currentProps - }; - } - this._triggerTransition(startProps, nextProps); - transitionTriggered = true; - } else { - this.transition.cancel(); - } - return transitionTriggered; + getCurrentLayer() { + return this.internalState && this.internalState.layer; } - updateTransition() { - this.transition.update(); + getLoadOptions() { + return this.props.loadOptions; } - _isTransitionEnabled(props) { + use64bitPositions() { const { - transitionDuration, - transitionInterpolator - } = props; - return (transitionDuration > 0 || transitionDuration === "auto") && Boolean(transitionInterpolator); + coordinateSystem + } = this.props; + return coordinateSystem === COORDINATE_SYSTEM.DEFAULT || coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN; } - _isUpdateDueToCurrentTransition(props) { - if (this.transition.inProgress && this.propsInTransition) { - return this.transition.settings.interpolator.arePropsEqual(props, this.propsInTransition); + onHover(info, pickingEvent) { + if (this.props.onHover) { + return this.props.onHover(info, pickingEvent) || false; } return false; } - _shouldIgnoreViewportChange(currentProps, nextProps) { - if (this.transition.inProgress) { - return this.transition.settings.interruption === TRANSITION_EVENTS.IGNORE || this._isUpdateDueToCurrentTransition(nextProps); - } - if (this._isTransitionEnabled(nextProps)) { - return nextProps.transitionInterpolator.arePropsEqual(currentProps, nextProps); + onClick(info, pickingEvent) { + if (this.props.onClick) { + return this.props.onClick(info, pickingEvent) || false; } - return true; + return false; } - _triggerTransition(startProps, endProps) { - const startViewstate = this.getControllerState(startProps); - const endViewStateProps = this.getControllerState(endProps).shortestPathFrom(startViewstate); - const transitionInterpolator = endProps.transitionInterpolator; - const duration = transitionInterpolator.getDuration ? transitionInterpolator.getDuration(startProps, endProps) : endProps.transitionDuration; - if (duration === 0) { - return; - } - const initialProps = transitionInterpolator.initializeProps(startProps, endViewStateProps); - this.propsInTransition = {}; - const transitionSettings = { - duration, - easing: endProps.transitionEasing || DEFAULT_EASING, - interpolator: transitionInterpolator, - interruption: endProps.transitionInterruption || DEFAULT_INTERRUPTION, - startProps: initialProps.start, - endProps: initialProps.end, - onStart: endProps.onTransitionStart, - onUpdate: this._onTransitionUpdate, - onInterrupt: this._onTransitionEnd(endProps.onTransitionInterrupt), - onEnd: this._onTransitionEnd(endProps.onTransitionEnd) - }; - this.transition.start(transitionSettings); - this.onStateChange({ - inTransition: true - }); - this.updateTransition(); + nullPickingColor() { + return [0, 0, 0]; } - _onTransitionEnd(callback) { - return (transition) => { - this.propsInTransition = null; - this.onStateChange({ - inTransition: false, - isZooming: false, - isPanning: false, - isRotating: false - }); - callback === null || callback === void 0 ? void 0 : callback(transition); - }; + encodePickingColor(i3, target = []) { + target[0] = i3 + 1 & 255; + target[1] = i3 + 1 >> 8 & 255; + target[2] = i3 + 1 >> 8 >> 8 & 255; + return target; } - }; - - // node_modules/@deck.gl/core/dist/esm/transitions/transition-interpolator.js - var TransitionInterpolator = class { - constructor(opts) { - _defineProperty(this, "_propsToCompare", void 0); - _defineProperty(this, "_propsToExtract", void 0); - _defineProperty(this, "_requiredProps", void 0); - const { - compare, - extract, - required - } = opts; - this._propsToCompare = compare; - this._propsToExtract = extract || compare; - this._requiredProps = required; + decodePickingColor(color) { + assert10(color instanceof Uint8Array); + const [i1, i22, i3] = color; + const index = i1 + i22 * 256 + i3 * 65536 - 1; + return index; } - arePropsEqual(currentProps, nextProps) { - for (const key of this._propsToCompare) { - if (!(key in currentProps) || !(key in nextProps) || !equals(currentProps[key], nextProps[key])) { - return false; - } + getNumInstances() { + if (Number.isFinite(this.props.numInstances)) { + return this.props.numInstances; } - return true; + if (this.state && this.state.numInstances !== void 0) { + return this.state.numInstances; + } + return count(this.props.data); } - initializeProps(startProps, endProps) { - const startViewStateProps = {}; - const endViewStateProps = {}; - for (const key of this._propsToExtract) { - if (key in startProps || key in endProps) { - startViewStateProps[key] = startProps[key]; - endViewStateProps[key] = endProps[key]; - } + getStartIndices() { + if (this.props.startIndices) { + return this.props.startIndices; } - this._checkRequiredProps(startViewStateProps); - this._checkRequiredProps(endViewStateProps); - return { - start: startViewStateProps, - end: endViewStateProps - }; + if (this.state && this.state.startIndices) { + return this.state.startIndices; + } + return null; } - getDuration(startProps, endProps) { - return endProps.transitionDuration; + getBounds() { + var _this$getAttributeMan; + return (_this$getAttributeMan = this.getAttributeManager()) === null || _this$getAttributeMan === void 0 ? void 0 : _this$getAttributeMan.getBounds(["positions", "instancePositions"]); } - _checkRequiredProps(props) { - if (!this._requiredProps) { - return; + getShaders(shaders) { + for (const extension of this.props.extensions) { + shaders = mergeShaders(shaders, extension.getShaders.call(this, extension)); } - this._requiredProps.forEach((propName) => { - const value = props[propName]; - assert10(Number.isFinite(value) || Array.isArray(value), "".concat(propName, " is required for transition")); - }); + return shaders; } - }; - - // node_modules/@deck.gl/core/dist/esm/transitions/linear-interpolator.js - var DEFAULT_PROPS2 = ["longitude", "latitude", "zoom", "bearing", "pitch"]; - var DEFAULT_REQUIRED_PROPS = ["longitude", "latitude", "zoom"]; - var LinearInterpolator = class extends TransitionInterpolator { - constructor(opts = {}) { - const transitionProps = Array.isArray(opts) ? opts : opts.transitionProps; - const normalizedOpts = Array.isArray(opts) ? {} : opts; - normalizedOpts.transitionProps = Array.isArray(transitionProps) ? { - compare: transitionProps, - required: transitionProps - } : transitionProps || { - compare: DEFAULT_PROPS2, - required: DEFAULT_REQUIRED_PROPS - }; - super(normalizedOpts.transitionProps); - _defineProperty(this, "opts", void 0); - this.opts = normalizedOpts; + shouldUpdateState(params) { + return params.changeFlags.propsOrDataChanged; } - initializeProps(startProps, endProps) { - const result = super.initializeProps(startProps, endProps); + updateState(params) { + const attributeManager = this.getAttributeManager(); const { - makeViewport, - around - } = this.opts; - if (makeViewport && around) { - const startViewport = makeViewport(startProps); - const endViewport = makeViewport(endProps); - const aroundPosition = startViewport.unproject(around); - result.start.around = around; - Object.assign(result.end, { - around: endViewport.project(aroundPosition), - aroundPosition, - width: endProps.width, - height: endProps.height - }); + dataChanged + } = params.changeFlags; + if (dataChanged && attributeManager) { + if (Array.isArray(dataChanged)) { + for (const dataRange of dataChanged) { + attributeManager.invalidateAll(dataRange); + } + } else { + attributeManager.invalidateAll(); + } + } + if (attributeManager) { + const { + props + } = params; + const hasPickingBuffer = this.internalState.hasPickingBuffer; + const needsPickingBuffer = Number.isInteger(props.highlightedObjectIndex) || props.pickable || props.extensions.some((extension) => extension.getNeedsPickingBuffer.call(this, extension)); + if (hasPickingBuffer !== needsPickingBuffer) { + this.internalState.hasPickingBuffer = needsPickingBuffer; + const { + pickingColors, + instancePickingColors + } = attributeManager.attributes; + const pickingColorsAttribute = pickingColors || instancePickingColors; + if (pickingColorsAttribute) { + if (needsPickingBuffer && pickingColorsAttribute.constant) { + pickingColorsAttribute.constant = false; + attributeManager.invalidate(pickingColorsAttribute.id); + } + if (!pickingColorsAttribute.value && !needsPickingBuffer) { + pickingColorsAttribute.constant = true; + pickingColorsAttribute.value = [0, 0, 0]; + } + } + } } - return result; } - interpolateProps(startProps, endProps, t2) { - const propsInTransition = {}; - for (const key of this._propsToExtract) { - propsInTransition[key] = lerp(startProps[key] || 0, endProps[key] || 0, t2); + finalizeState(context) { + for (const model of this.getModels()) { + model.delete(); } - if (endProps.aroundPosition && this.opts.makeViewport) { - const viewport = this.opts.makeViewport({ - ...endProps, - ...propsInTransition + const attributeManager = this.getAttributeManager(); + if (attributeManager) { + attributeManager.finalize(); + } + if (this.context) { + this.context.resourceManager.unsubscribe({ + consumerId: this.id }); - Object.assign(propsInTransition, viewport.panByPosition(endProps.aroundPosition, lerp(startProps.around, endProps.around, t2))); } - return propsInTransition; - } - }; - - // node_modules/@deck.gl/core/dist/esm/controllers/controller.js - var NO_TRANSITION_PROPS = { - transitionDuration: 0 - }; - var DEFAULT_INERTIA = 300; - var INERTIA_EASING = (t2) => 1 - (1 - t2) * (1 - t2); - var EVENT_TYPES = { - WHEEL: ["wheel"], - PAN: ["panstart", "panmove", "panend"], - PINCH: ["pinchstart", "pinchmove", "pinchend"], - TRIPLE_PAN: ["tripanstart", "tripanmove", "tripanend"], - DOUBLE_TAP: ["doubletap"], - KEYBOARD: ["keydown"] - }; - var pinchEventWorkaround = {}; - var Controller = class { - constructor(opts) { - _defineProperty(this, "props", void 0); - _defineProperty(this, "state", {}); - _defineProperty(this, "transitionManager", void 0); - _defineProperty(this, "eventManager", void 0); - _defineProperty(this, "onViewStateChange", void 0); - _defineProperty(this, "onStateChange", void 0); - _defineProperty(this, "makeViewport", void 0); - _defineProperty(this, "_controllerState", void 0); - _defineProperty(this, "_events", {}); - _defineProperty(this, "_interactionState", { - isDragging: false - }); - _defineProperty(this, "_customEvents", []); - _defineProperty(this, "_eventStartBlocked", null); - _defineProperty(this, "_panMove", false); - _defineProperty(this, "invertPan", false); - _defineProperty(this, "dragMode", "rotate"); - _defineProperty(this, "inertia", 0); - _defineProperty(this, "scrollZoom", true); - _defineProperty(this, "dragPan", true); - _defineProperty(this, "dragRotate", true); - _defineProperty(this, "doubleClickZoom", true); - _defineProperty(this, "touchZoom", true); - _defineProperty(this, "touchRotate", false); - _defineProperty(this, "keyboard", true); - this.transitionManager = new TransitionManager({ - ...opts, - getControllerState: (props) => new this.ControllerState(props), - onViewStateChange: this._onTransition.bind(this), - onStateChange: this._setInteractionState.bind(this) - }); - this.handleEvent = this.handleEvent.bind(this); - this.eventManager = opts.eventManager; - this.onViewStateChange = opts.onViewStateChange || (() => { - }); - this.onStateChange = opts.onStateChange || (() => { - }); - this.makeViewport = opts.makeViewport; + if (this.internalState) { + this.internalState.uniformTransitions.clear(); + this.internalState.finalize(); + } } - set events(customEvents) { - this.toggleEvents(this._customEvents, false); - this.toggleEvents(customEvents, true); - this._customEvents = customEvents; - if (this.props) { - this.setProps(this.props); + draw(opts) { + for (const model of this.getModels()) { + model.draw(opts); } } - finalize() { - for (const eventName in this._events) { - if (this._events[eventName]) { - var _this$eventManager; - (_this$eventManager = this.eventManager) === null || _this$eventManager === void 0 ? void 0 : _this$eventManager.off(eventName, this.handleEvent); + getPickingInfo({ + info, + mode, + sourceLayer + }) { + const { + index + } = info; + if (index >= 0) { + if (Array.isArray(this.props.data)) { + info.object = this.props.data[index]; } } - this.transitionManager.finalize(); + return info; } - handleEvent(event) { - this._controllerState = void 0; - const eventStartBlocked = this._eventStartBlocked; - switch (event.type) { - case "panstart": - return eventStartBlocked ? false : this._onPanStart(event); - case "panmove": - return this._onPan(event); - case "panend": - return this._onPanEnd(event); - case "pinchstart": - return eventStartBlocked ? false : this._onPinchStart(event); - case "pinchmove": - return this._onPinch(event); - case "pinchend": - return this._onPinchEnd(event); - case "tripanstart": - return eventStartBlocked ? false : this._onTriplePanStart(event); - case "tripanmove": - return this._onTriplePan(event); - case "tripanend": - return this._onTriplePanEnd(event); - case "doubletap": - return this._onDoubleTap(event); - case "wheel": - return this._onWheel(event); - case "keydown": - return this._onKeyDown(event); - default: - return false; + raiseError(error2, message) { + var _this$props$onError, _this$props; + if (message) { + error2 = new Error("".concat(message, ": ").concat(error2.message), { + cause: error2 + }); + } + if (!((_this$props$onError = (_this$props = this.props).onError) !== null && _this$props$onError !== void 0 && _this$props$onError.call(_this$props, error2))) { + var _this$context, _this$context$onError; + (_this$context = this.context) === null || _this$context === void 0 ? void 0 : (_this$context$onError = _this$context.onError) === null || _this$context$onError === void 0 ? void 0 : _this$context$onError.call(_this$context, error2, this); } } - get controllerState() { - this._controllerState = this._controllerState || new this.ControllerState({ - makeViewport: this.makeViewport, - ...this.props, - ...this.state - }); - return this._controllerState; - } - getCenter(event) { - const { - x: x2, - y: y2 - } = this.props; - const { - offsetCenter - } = event; - return [offsetCenter.x - x2, offsetCenter.y - y2]; + getNeedsRedraw(opts = { + clearRedrawFlags: false + }) { + return this._getNeedsRedraw(opts); } - isPointInBounds(pos, event) { - const { - width, - height - } = this.props; - if (event && event.handled) { + needsUpdate() { + if (!this.internalState) { return false; } - const inside = pos[0] >= 0 && pos[0] <= width && pos[1] >= 0 && pos[1] <= height; - if (inside && event) { - event.stopPropagation(); - } - return inside; - } - isFunctionKeyPressed(event) { - const { - srcEvent - } = event; - return Boolean(srcEvent.metaKey || srcEvent.altKey || srcEvent.ctrlKey || srcEvent.shiftKey); + return this.internalState.needsUpdate || this.hasUniformTransition() || this.shouldUpdateState(this._getUpdateParams()); } - isDragging() { - return this._interactionState.isDragging || false; + hasUniformTransition() { + var _this$internalState; + return ((_this$internalState = this.internalState) === null || _this$internalState === void 0 ? void 0 : _this$internalState.uniformTransitions.active) || false; } - blockEvents(timeout) { - const timer = setTimeout(() => { - if (this._eventStartBlocked === timer) { - this._eventStartBlocked = null; + activateViewport(viewport) { + if (!this.internalState) { + return; + } + const oldViewport = this.internalState.viewport; + this.internalState.viewport = viewport; + if (!oldViewport || !areViewportsEqual({ + oldViewport, + viewport + })) { + this.setChangeFlags({ + viewportChanged: true + }); + if (this.isComposite) { + if (this.needsUpdate()) { + this.setNeedsUpdate(); + } + } else { + this._update(); } - }, timeout); - this._eventStartBlocked = timer; + } } - setProps(props) { - if (props.dragMode) { - this.dragMode = props.dragMode; + invalidateAttribute(name = "all") { + const attributeManager = this.getAttributeManager(); + if (!attributeManager) { + return; } - this.props = props; - if (!("transitionInterpolator" in props)) { - props.transitionInterpolator = this._getTransitionProps().transitionInterpolator; + if (name === "all") { + attributeManager.invalidateAll(); + } else { + attributeManager.invalidate(name); } - this.transitionManager.processViewStateChange(props); - const { - inertia - } = props; - this.inertia = Number.isFinite(inertia) ? inertia : inertia === true ? DEFAULT_INERTIA : 0; - const { - scrollZoom = true, - dragPan = true, - dragRotate = true, - doubleClickZoom = true, - touchZoom = true, - touchRotate = false, - keyboard = true - } = props; - const isInteractive = Boolean(this.onViewStateChange); - this.toggleEvents(EVENT_TYPES.WHEEL, isInteractive && scrollZoom); - this.toggleEvents(EVENT_TYPES.PAN, isInteractive); - this.toggleEvents(EVENT_TYPES.PINCH, isInteractive && (touchZoom || touchRotate)); - this.toggleEvents(EVENT_TYPES.TRIPLE_PAN, isInteractive && touchRotate); - this.toggleEvents(EVENT_TYPES.DOUBLE_TAP, isInteractive && doubleClickZoom); - this.toggleEvents(EVENT_TYPES.KEYBOARD, isInteractive && keyboard); - this.scrollZoom = scrollZoom; - this.dragPan = dragPan; - this.dragRotate = dragRotate; - this.doubleClickZoom = doubleClickZoom; - this.touchZoom = touchZoom; - this.touchRotate = touchRotate; - this.keyboard = keyboard; } - updateTransition() { - this.transitionManager.updateTransition(); + updateAttributes(changedAttributes) { + for (const model of this.getModels()) { + this._setModelAttributes(model, changedAttributes); + } } - toggleEvents(eventNames, enabled) { - if (this.eventManager) { - eventNames.forEach((eventName) => { - if (this._events[eventName] !== enabled) { - this._events[eventName] = enabled; - if (enabled) { - this.eventManager.on(eventName, this.handleEvent); - } else { - this.eventManager.off(eventName, this.handleEvent); - } - } - }); + _updateAttributes() { + const attributeManager = this.getAttributeManager(); + if (!attributeManager) { + return; + } + const props = this.props; + const numInstances = this.getNumInstances(); + const startIndices = this.getStartIndices(); + attributeManager.update({ + data: props.data, + numInstances, + startIndices, + props, + transitions: props.transitions, + buffers: props.data.attributes, + context: this + }); + const changedAttributes = attributeManager.getChangedAttributes({ + clearChangedFlags: true + }); + this.updateAttributes(changedAttributes); + } + _updateAttributeTransition() { + const attributeManager = this.getAttributeManager(); + if (attributeManager) { + attributeManager.updateTransition(); } } - updateViewport(newControllerState, extraProps = null, interactionState = {}) { - const viewState = { - ...newControllerState.getViewportProps(), - ...extraProps - }; - const changed = this.controllerState !== newControllerState; - this.state = newControllerState.getState(); - this._setInteractionState(interactionState); - if (changed) { - const oldViewState = this.controllerState && this.controllerState.getViewportProps(); - if (this.onViewStateChange) { - this.onViewStateChange({ - viewState, - interactionState: this._interactionState, - oldViewState + _updateUniformTransition() { + const { + uniformTransitions + } = this.internalState; + if (uniformTransitions.active) { + const propsInTransition = uniformTransitions.update(); + const props = Object.create(this.props); + for (const key in propsInTransition) { + Object.defineProperty(props, key, { + value: propsInTransition[key] }); } + return props; } + return this.props; } - _onTransition(params) { - this.onViewStateChange({ - ...params, - interactionState: this._interactionState - }); + calculateInstancePickingColors(attribute, { + numInstances + }) { + if (attribute.constant) { + return; + } + const cacheSize = Math.floor(pickingColorCache.length / 3); + this.internalState.usesPickingColorCache = true; + if (cacheSize < numInstances) { + if (numInstances > MAX_PICKING_COLOR_CACHE_SIZE) { + log_default.warn("Layer has too many data objects. Picking might not be able to distinguish all objects.")(); + } + pickingColorCache = typed_array_manager_default.allocate(pickingColorCache, numInstances, { + size: 3, + copy: true, + maxCount: Math.max(numInstances, MAX_PICKING_COLOR_CACHE_SIZE) + }); + const newCacheSize = Math.floor(pickingColorCache.length / 3); + const pickingColor = []; + for (let i3 = cacheSize; i3 < newCacheSize; i3++) { + this.encodePickingColor(i3, pickingColor); + pickingColorCache[i3 * 3 + 0] = pickingColor[0]; + pickingColorCache[i3 * 3 + 1] = pickingColor[1]; + pickingColorCache[i3 * 3 + 2] = pickingColor[2]; + } + } + attribute.value = pickingColorCache.subarray(0, numInstances * 3); } - _setInteractionState(newStates) { - Object.assign(this._interactionState, newStates); - this.onStateChange(this._interactionState); + _setModelAttributes(model, changedAttributes) { + const attributeManager = this.getAttributeManager(); + const excludeAttributes = model.userData.excludeAttributes || {}; + const shaderAttributes = attributeManager.getShaderAttributes(changedAttributes, excludeAttributes); + model.setAttributes(shaderAttributes); } - _onPanStart(event) { - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; + disablePickingIndex(objectIndex) { + const data = this.props.data; + if (!("attributes" in data)) { + this._disablePickingIndex(objectIndex); + return; } - let alternateMode = this.isFunctionKeyPressed(event) || event.rightButton || false; - if (this.invertPan || this.dragMode === "pan") { - alternateMode = !alternateMode; + const { + pickingColors, + instancePickingColors + } = this.getAttributeManager().attributes; + const colors = pickingColors || instancePickingColors; + const externalColorAttribute = colors && data.attributes && data.attributes[colors.id]; + if (externalColorAttribute && externalColorAttribute.value) { + const values = externalColorAttribute.value; + const objectColor = this.encodePickingColor(objectIndex); + for (let index = 0; index < data.length; index++) { + const i3 = colors.getVertexOffset(index); + if (values[i3] === objectColor[0] && values[i3 + 1] === objectColor[1] && values[i3 + 2] === objectColor[2]) { + this._disablePickingIndex(index); + } + } + } else { + this._disablePickingIndex(objectIndex); } - const newControllerState = this.controllerState[alternateMode ? "panStart" : "rotateStart"]({ - pos - }); - this._panMove = alternateMode; - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true + } + _disablePickingIndex(objectIndex) { + const { + pickingColors, + instancePickingColors + } = this.getAttributeManager().attributes; + const colors = pickingColors || instancePickingColors; + if (!colors) { + return; + } + const start = colors.getVertexOffset(objectIndex); + const end = colors.getVertexOffset(objectIndex + 1); + colors.buffer.subData({ + data: new Uint8Array(end - start), + offset: start }); - return true; } - _onPan(event) { - if (!this.isDragging()) { - return false; + restorePickingColors() { + const { + pickingColors, + instancePickingColors + } = this.getAttributeManager().attributes; + const colors = pickingColors || instancePickingColors; + if (!colors) { + return; } - return this._panMove ? this._onPanMove(event) : this._onPanRotate(event); - } - _onPanEnd(event) { - if (!this.isDragging()) { - return false; + if (this.internalState.usesPickingColorCache && colors.value.buffer !== pickingColorCache.buffer) { + colors.value = pickingColorCache.subarray(0, colors.value.length); } - return this._panMove ? this._onPanMoveEnd(event) : this._onPanRotateEnd(event); + colors.updateSubBuffer({ + startOffset: 0 + }); } - _onPanMove(event) { - if (!this.dragPan) { - return false; + _initialize() { + assert10(!this.internalState); + assert10(Number.isFinite(this.props.coordinateSystem)); + debug(TRACE_INITIALIZE, this); + const attributeManager = this._getAttributeManager(); + if (attributeManager) { + attributeManager.addInstanced({ + instancePickingColors: { + type: 5121, + size: 3, + noAlloc: true, + update: this.calculateInstancePickingColors + } + }); } - const pos = this.getCenter(event); - const newControllerState = this.controllerState.pan({ - pos + this.internalState = new LayerState({ + attributeManager, + layer: this }); - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true, - isPanning: true + this._clearChangeFlags(); + this.state = {}; + Object.defineProperty(this.state, "attributeManager", { + get: () => { + log_default.deprecated("layer.state.attributeManager", "layer.getAttributeManager()")(); + return attributeManager; + } }); - return true; + this.internalState.uniformTransitions = new UniformTransitionManager(this.context.timeline); + this.internalState.onAsyncPropUpdated = this._onAsyncPropUpdated.bind(this); + this.internalState.setAsyncProps(this.props); + this.initializeState(this.context); + for (const extension of this.props.extensions) { + extension.initializeState.call(this, this.context, extension); + } + this.setChangeFlags({ + dataChanged: "init", + propsChanged: "init", + viewportChanged: true, + extensionsChanged: true + }); + this._update(); } - _onPanMoveEnd(event) { + _transferState(oldLayer) { + debug(TRACE_MATCHED, this, this === oldLayer); const { - inertia - } = this; - if (this.dragPan && inertia && event.velocity) { - const pos = this.getCenter(event); - const endPos = [pos[0] + event.velocityX * inertia / 2, pos[1] + event.velocityY * inertia / 2]; - const newControllerState = this.controllerState.pan({ - pos: endPos - }).panEnd(); - this.updateViewport(newControllerState, { - ...this._getTransitionProps(), - transitionDuration: inertia, - transitionEasing: INERTIA_EASING - }, { - isDragging: false, - isPanning: true - }); - } else { - const newControllerState = this.controllerState.panEnd(); - this.updateViewport(newControllerState, null, { - isDragging: false, - isPanning: false - }); + state, + internalState + } = oldLayer; + if (this === oldLayer) { + return; } - return true; + this.internalState = internalState; + this.state = state; + this.internalState.setAsyncProps(this.props); + this._diffProps(this.props, this.internalState.getOldProps()); } - _onPanRotate(event) { - if (!this.dragRotate) { - return false; + _update() { + const stateNeedsUpdate = this.needsUpdate(); + debug(TRACE_UPDATE, this, stateNeedsUpdate); + if (!stateNeedsUpdate) { + return; + } + const currentProps = this.props; + const context = this.context; + const internalState = this.internalState; + const currentViewport = context.viewport; + const propsInTransition = this._updateUniformTransition(); + internalState.propsInTransition = propsInTransition; + context.viewport = internalState.viewport || currentViewport; + this.props = propsInTransition; + try { + const updateParams = this._getUpdateParams(); + const oldModels = this.getModels(); + if (context.gl) { + this.updateState(updateParams); + } else { + try { + this.updateState(updateParams); + } catch (error2) { + } + } + for (const extension of this.props.extensions) { + extension.updateState.call(this, updateParams, extension); + } + const modelChanged = this.getModels()[0] !== oldModels[0]; + this._postUpdate(updateParams, modelChanged); + } finally { + context.viewport = currentViewport; + this.props = currentProps; + this._clearChangeFlags(); + internalState.needsUpdate = false; + internalState.resetOldProps(); } - const pos = this.getCenter(event); - const newControllerState = this.controllerState.rotate({ - pos - }); - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true, - isRotating: true - }); - return true; } - _onPanRotateEnd(event) { - const { - inertia - } = this; - if (this.dragRotate && inertia && event.velocity) { - const pos = this.getCenter(event); - const endPos = [pos[0] + event.velocityX * inertia / 2, pos[1] + event.velocityY * inertia / 2]; - const newControllerState = this.controllerState.rotate({ - pos: endPos - }).rotateEnd(); - this.updateViewport(newControllerState, { - ...this._getTransitionProps(), - transitionDuration: inertia, - transitionEasing: INERTIA_EASING - }, { - isDragging: false, - isRotating: true + _finalize() { + debug(TRACE_FINALIZE, this); + this.finalizeState(this.context); + for (const extension of this.props.extensions) { + extension.finalizeState.call(this, this.context, extension); + } + } + _drawLayer({ + moduleParameters = null, + uniforms = {}, + parameters = {} + }) { + this._updateAttributeTransition(); + const currentProps = this.props; + const context = this.context; + this.props = this.internalState.propsInTransition || currentProps; + const opacity = this.props.opacity; + uniforms.opacity = Math.pow(opacity, 1 / 2.2); + try { + if (moduleParameters) { + this.setModuleParameters(moduleParameters); + } + const { + getPolygonOffset + } = this.props; + const offsets = getPolygonOffset && getPolygonOffset(uniforms) || [0, 0]; + setParameters(context.gl, { + polygonOffset: offsets }); - } else { - const newControllerState = this.controllerState.rotateEnd(); - this.updateViewport(newControllerState, null, { - isDragging: false, - isRotating: false + withParameters(context.gl, parameters, () => { + const opts = { + moduleParameters, + uniforms, + parameters, + context + }; + for (const extension of this.props.extensions) { + extension.draw.call(this, opts, extension); + } + this.draw(opts); }); + } finally { + this.props = currentProps; } - return true; } - _onWheel(event) { - if (!this.scrollZoom) { - return false; - } - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; + getChangeFlags() { + var _this$internalState2; + return (_this$internalState2 = this.internalState) === null || _this$internalState2 === void 0 ? void 0 : _this$internalState2.changeFlags; + } + setChangeFlags(flags) { + if (!this.internalState) { + return; } - event.srcEvent.preventDefault(); - const { - speed = 0.01, - smooth = false - } = this.scrollZoom === true ? {} : this.scrollZoom; const { - delta - } = event; - let scale3 = 2 / (1 + Math.exp(-Math.abs(delta * speed))); - if (delta < 0 && scale3 !== 0) { - scale3 = 1 / scale3; + changeFlags + } = this.internalState; + for (const key in flags) { + if (flags[key]) { + let flagChanged = false; + switch (key) { + case "dataChanged": + const dataChangedReason = flags[key]; + const prevDataChangedReason = changeFlags[key]; + if (dataChangedReason && Array.isArray(prevDataChangedReason)) { + changeFlags.dataChanged = Array.isArray(dataChangedReason) ? prevDataChangedReason.concat(dataChangedReason) : dataChangedReason; + flagChanged = true; + } + default: + if (!changeFlags[key]) { + changeFlags[key] = flags[key]; + flagChanged = true; + } + } + if (flagChanged) { + debug(TRACE_CHANGE_FLAG, this, key, flags); + } + } } - const newControllerState = this.controllerState.zoom({ - pos, - scale: scale3 - }); - this.updateViewport(newControllerState, { - ...this._getTransitionProps({ - around: pos - }), - transitionDuration: smooth ? 250 : 1 - }, { - isZooming: true, - isPanning: true - }); - return true; + const propsOrDataChanged = Boolean(changeFlags.dataChanged || changeFlags.updateTriggersChanged || changeFlags.propsChanged || changeFlags.extensionsChanged); + changeFlags.propsOrDataChanged = propsOrDataChanged; + changeFlags.somethingChanged = propsOrDataChanged || changeFlags.viewportChanged || changeFlags.stateChanged; } - _onTriplePanStart(event) { - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; - } - const newControllerState = this.controllerState.rotateStart({ - pos - }); - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true - }); - return true; + _clearChangeFlags() { + this.internalState.changeFlags = { + dataChanged: false, + propsChanged: false, + updateTriggersChanged: false, + viewportChanged: false, + stateChanged: false, + extensionsChanged: false, + propsOrDataChanged: false, + somethingChanged: false + }; } - _onTriplePan(event) { - if (!this.touchRotate) { - return false; + _diffProps(newProps, oldProps) { + const changeFlags = diffProps(newProps, oldProps); + if (changeFlags.updateTriggersChanged) { + for (const key in changeFlags.updateTriggersChanged) { + if (changeFlags.updateTriggersChanged[key]) { + this.invalidateAttribute(key); + } + } } - if (!this.isDragging()) { - return false; + if (changeFlags.transitionsChanged) { + for (const key in changeFlags.transitionsChanged) { + var _newProps$transitions; + this.internalState.uniformTransitions.add(key, oldProps[key], newProps[key], (_newProps$transitions = newProps.transitions) === null || _newProps$transitions === void 0 ? void 0 : _newProps$transitions[key]); + } } - const pos = this.getCenter(event); - pos[0] -= event.deltaX; - const newControllerState = this.controllerState.rotate({ - pos - }); - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true, - isRotating: true - }); - return true; + return this.setChangeFlags(changeFlags); } - _onTriplePanEnd(event) { - if (!this.isDragging()) { - return false; + validateProps() { + validateProps(this.props); + } + updateAutoHighlight(info) { + if (this.props.autoHighlight && !Number.isInteger(this.props.highlightedObjectIndex)) { + this._updateAutoHighlight(info); } + } + _updateAutoHighlight(info) { + const pickingModuleParameters = { + pickingSelectedColor: info.picked ? info.color : null + }; const { - inertia - } = this; - if (this.touchRotate && inertia && event.velocityY) { - const pos = this.getCenter(event); - const endPos = [pos[0], pos[1] += event.velocityY * inertia / 2]; - const newControllerState = this.controllerState.rotate({ - pos: endPos - }); - this.updateViewport(newControllerState, { - ...this._getTransitionProps(), - transitionDuration: inertia, - transitionEasing: INERTIA_EASING - }, { - isDragging: false, - isRotating: true - }); - this.blockEvents(inertia); - } else { - const newControllerState = this.controllerState.rotateEnd(); - this.updateViewport(newControllerState, null, { - isDragging: false, - isRotating: false - }); + highlightColor + } = this.props; + if (info.picked && typeof highlightColor === "function") { + pickingModuleParameters.pickingHighlightColor = highlightColor(info); } - return true; + this.setModuleParameters(pickingModuleParameters); + this.setNeedsRedraw(); } - _onPinchStart(event) { - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; - } - const newControllerState = this.controllerState.zoomStart({ - pos - }).rotateStart({ - pos - }); - pinchEventWorkaround._startPinchRotation = event.rotation; - pinchEventWorkaround._lastPinchEvent = event; - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true + _getAttributeManager() { + const context = this.context; + return new AttributeManager(context.gl, { + id: this.props.id, + stats: context.stats, + timeline: context.timeline }); - return true; } - _onPinch(event) { - if (!this.touchZoom && !this.touchRotate) { - return false; - } - if (!this.isDragging()) { - return false; - } - let newControllerState = this.controllerState; - if (this.touchZoom) { - const { - scale: scale3 - } = event; - const pos = this.getCenter(event); - newControllerState = newControllerState.zoom({ - pos, - scale: scale3 - }); - } - if (this.touchRotate) { - const { - rotation - } = event; - newControllerState = newControllerState.rotate({ - deltaAngleX: pinchEventWorkaround._startPinchRotation - rotation - }); + _postUpdate(updateParams, forceUpdate) { + const { + props, + oldProps + } = updateParams; + this.setNeedsRedraw(); + this._updateAttributes(); + const { + model + } = this.state; + model === null || model === void 0 ? void 0 : model.setInstanceCount(this.getNumInstances()); + const { + autoHighlight, + highlightedObjectIndex, + highlightColor + } = props; + if (forceUpdate || oldProps.autoHighlight !== autoHighlight || oldProps.highlightedObjectIndex !== highlightedObjectIndex || oldProps.highlightColor !== highlightColor) { + const parameters = {}; + if (!autoHighlight) { + parameters.pickingSelectedColor = null; + } + if (Array.isArray(highlightColor)) { + parameters.pickingHighlightColor = highlightColor; + } + if (forceUpdate || highlightedObjectIndex !== oldProps.highlightedObjectIndex) { + parameters.pickingSelectedColor = Number.isFinite(highlightedObjectIndex) && highlightedObjectIndex >= 0 ? this.encodePickingColor(highlightedObjectIndex) : null; + } + this.setModuleParameters(parameters); } - this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { - isDragging: true, - isPanning: this.touchZoom, - isZooming: this.touchZoom, - isRotating: this.touchRotate - }); - pinchEventWorkaround._lastPinchEvent = event; - return true; } - _onPinchEnd(event) { - if (!this.isDragging()) { + _getUpdateParams() { + return { + props: this.props, + oldProps: this.internalState.getOldProps(), + context: this.context, + changeFlags: this.internalState.changeFlags + }; + } + _getNeedsRedraw(opts) { + if (!this.internalState) { return false; } - const { - inertia - } = this; - const { - _lastPinchEvent - } = pinchEventWorkaround; - if (this.touchZoom && inertia && _lastPinchEvent && event.scale !== _lastPinchEvent.scale) { - const pos = this.getCenter(event); - let newControllerState = this.controllerState.rotateEnd(); - const z = Math.log2(event.scale); - const velocityZ = (z - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime); - const endScale = Math.pow(2, z + velocityZ * inertia / 2); - newControllerState = newControllerState.zoom({ - pos, - scale: endScale - }).zoomEnd(); - this.updateViewport(newControllerState, { - ...this._getTransitionProps({ - around: pos - }), - transitionDuration: inertia, - transitionEasing: INERTIA_EASING - }, { - isDragging: false, - isPanning: this.touchZoom, - isZooming: this.touchZoom, - isRotating: false - }); - this.blockEvents(inertia); - } else { - const newControllerState = this.controllerState.zoomEnd().rotateEnd(); - this.updateViewport(newControllerState, null, { - isDragging: false, - isPanning: false, - isZooming: false, - isRotating: false - }); + let redraw = false; + redraw = redraw || this.internalState.needsRedraw && this.id; + const attributeManager = this.getAttributeManager(); + const attributeManagerNeedsRedraw = attributeManager ? attributeManager.getNeedsRedraw(opts) : false; + redraw = redraw || attributeManagerNeedsRedraw; + if (redraw) { + for (const extension of this.props.extensions) { + extension.onNeedsRedraw.call(this, extension); + } } - pinchEventWorkaround._startPinchRotation = null; - pinchEventWorkaround._lastPinchEvent = null; + this.internalState.needsRedraw = this.internalState.needsRedraw && !opts.clearRedrawFlags; + return redraw; + } + _onAsyncPropUpdated() { + this._diffProps(this.props, this.internalState.getOldProps()); + this.setNeedsUpdate(); + } + }; + _defineProperty(Layer, "defaultProps", defaultProps2); + _defineProperty(Layer, "layerName", "Layer"); + + // node_modules/@deck.gl/core/dist/esm/lib/composite-layer.js + var TRACE_RENDER_LAYERS2 = "compositeLayer.renderLayers"; + var CompositeLayer = class extends Layer { + get isComposite() { return true; } - _onDoubleTap(event) { - if (!this.doubleClickZoom) { - return false; - } - const pos = this.getCenter(event); - if (!this.isPointInBounds(pos, event)) { - return false; + get isLoaded() { + return super.isLoaded && this.getSubLayers().every((layer) => layer.isLoaded); + } + getSubLayers() { + return this.internalState && this.internalState.subLayers || []; + } + initializeState(context) { + } + setState(updateObject) { + super.setState(updateObject); + this.setNeedsUpdate(); + } + getPickingInfo({ + info + }) { + const { + object + } = info; + const isDataWrapped = object && object.__source && object.__source.parent && object.__source.parent.id === this.id; + if (!isDataWrapped) { + return info; } - const isZoomOut = this.isFunctionKeyPressed(event); - const newControllerState = this.controllerState.zoom({ - pos, - scale: isZoomOut ? 0.5 : 2 - }); - this.updateViewport(newControllerState, this._getTransitionProps({ - around: pos - }), { - isZooming: true, - isPanning: true - }); - this.blockEvents(100); + info.object = object.__source.object; + info.index = object.__source.index; + return info; + } + filterSubLayer(context) { return true; } - _onKeyDown(event) { - if (!this.keyboard) { - return false; - } - const funcKey = this.isFunctionKeyPressed(event); - const { - zoomSpeed, - moveSpeed, - rotateSpeedX, - rotateSpeedY - } = this.keyboard === true ? {} : this.keyboard; + shouldRenderSubLayer(subLayerId, data) { + return data && data.length; + } + getSubLayerClass(subLayerId, DefaultLayerClass) { const { - controllerState - } = this; - let newControllerState; - const interactionState = {}; - switch (event.srcEvent.code) { - case "Minus": - newControllerState = funcKey ? controllerState.zoomOut(zoomSpeed).zoomOut(zoomSpeed) : controllerState.zoomOut(zoomSpeed); - interactionState.isZooming = true; - break; - case "Equal": - newControllerState = funcKey ? controllerState.zoomIn(zoomSpeed).zoomIn(zoomSpeed) : controllerState.zoomIn(zoomSpeed); - interactionState.isZooming = true; - break; - case "ArrowLeft": - if (funcKey) { - newControllerState = controllerState.rotateLeft(rotateSpeedX); - interactionState.isRotating = true; - } else { - newControllerState = controllerState.moveLeft(moveSpeed); - interactionState.isPanning = true; - } - break; - case "ArrowRight": - if (funcKey) { - newControllerState = controllerState.rotateRight(rotateSpeedX); - interactionState.isRotating = true; - } else { - newControllerState = controllerState.moveRight(moveSpeed); - interactionState.isPanning = true; - } - break; - case "ArrowUp": - if (funcKey) { - newControllerState = controllerState.rotateUp(rotateSpeedY); - interactionState.isRotating = true; - } else { - newControllerState = controllerState.moveUp(moveSpeed); - interactionState.isPanning = true; + _subLayerProps: overridingProps + } = this.props; + return overridingProps && overridingProps[subLayerId] && overridingProps[subLayerId].type || DefaultLayerClass; + } + getSubLayerRow(row, sourceObject, sourceObjectIndex) { + row.__source = { + parent: this, + object: sourceObject, + index: sourceObjectIndex + }; + return row; + } + getSubLayerAccessor(accessor) { + if (typeof accessor === "function") { + const objectInfo = { + index: -1, + data: this.props.data, + target: [] + }; + return (x2, i3) => { + if (x2 && x2.__source) { + objectInfo.index = x2.__source.index; + return accessor(x2.__source.object, objectInfo); } - break; - case "ArrowDown": - if (funcKey) { - newControllerState = controllerState.rotateDown(rotateSpeedY); - interactionState.isRotating = true; - } else { - newControllerState = controllerState.moveDown(moveSpeed); - interactionState.isPanning = true; + return accessor(x2, i3); + }; + } + return accessor; + } + getSubLayerProps(sublayerProps = {}) { + var _this$props$updateTri; + const { + opacity, + pickable, + visible, + parameters, + getPolygonOffset, + highlightedObjectIndex, + autoHighlight, + highlightColor, + coordinateSystem, + coordinateOrigin, + wrapLongitude, + positionFormat, + modelMatrix, + extensions, + fetch: fetch2, + operation, + _subLayerProps: overridingProps + } = this.props; + const newProps = { + id: "", + updateTriggers: {}, + opacity, + pickable, + visible, + parameters, + getPolygonOffset, + highlightedObjectIndex, + autoHighlight, + highlightColor, + coordinateSystem, + coordinateOrigin, + wrapLongitude, + positionFormat, + modelMatrix, + extensions, + fetch: fetch2, + operation + }; + const overridingSublayerProps = overridingProps && sublayerProps.id && overridingProps[sublayerProps.id]; + const overridingSublayerTriggers = overridingSublayerProps && overridingSublayerProps.updateTriggers; + const sublayerId = sublayerProps.id || "sublayer"; + if (overridingSublayerProps) { + const propTypes = this.props[PROP_TYPES_SYMBOL]; + const subLayerPropTypes = sublayerProps.type ? sublayerProps.type._propTypes : {}; + for (const key in overridingSublayerProps) { + const propType = subLayerPropTypes[key] || propTypes[key]; + if (propType && propType.type === "accessor") { + overridingSublayerProps[key] = this.getSubLayerAccessor(overridingSublayerProps[key]); } - break; - default: - return false; + } } - this.updateViewport(newControllerState, this._getTransitionProps(), interactionState); - return true; + Object.assign(newProps, sublayerProps, overridingSublayerProps); + newProps.id = "".concat(this.props.id, "-").concat(sublayerId); + newProps.updateTriggers = { + all: (_this$props$updateTri = this.props.updateTriggers) === null || _this$props$updateTri === void 0 ? void 0 : _this$props$updateTri.all, + ...sublayerProps.updateTriggers, + ...overridingSublayerTriggers + }; + for (const extension of extensions) { + const passThroughProps = extension.getSubLayerProps.call(this, extension); + if (passThroughProps) { + Object.assign(newProps, passThroughProps, { + updateTriggers: Object.assign(newProps.updateTriggers, passThroughProps.updateTriggers) + }); + } + } + return newProps; } - _getTransitionProps(opts) { + _updateAutoHighlight(info) { + for (const layer of this.getSubLayers()) { + layer.updateAutoHighlight(info); + } + } + _getAttributeManager() { + return null; + } + _postUpdate(updateParams, forceUpdate) { + let subLayers = this.internalState.subLayers; + const shouldUpdate = !subLayers || this.needsUpdate(); + if (shouldUpdate) { + const subLayersList = this.renderLayers(); + subLayers = flatten(subLayersList, Boolean); + this.internalState.subLayers = subLayers; + } + debug(TRACE_RENDER_LAYERS2, this, shouldUpdate, subLayers); + for (const layer of subLayers) { + layer.parent = this; + } + } + }; + _defineProperty(CompositeLayer, "layerName", "CompositeLayer"); + + // node_modules/@deck.gl/core/dist/esm/viewports/globe-viewport.js + var DEGREES_TO_RADIANS5 = Math.PI / 180; + var RADIANS_TO_DEGREES3 = 180 / Math.PI; + var EARTH_RADIUS = 6370972; + var GLOBE_RADIUS = 256; + function getDistanceScales2() { + const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS; + const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS; + return { + unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2], + unitsPerMeter2: [0, 0, 0], + metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2], + unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2], + unitsPerDegree2: [0, 0, 0], + degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2] + }; + } + var GlobeViewport = class extends Viewport { + constructor(opts = {}) { const { - transition + latitude = 0, + longitude = 0, + zoom = 0, + nearZMultiplier = 0.1, + farZMultiplier = 2, + resolution = 10 + } = opts; + let { + height, + altitude = 1.5 + } = opts; + height = height || 1; + altitude = Math.max(0.75, altitude); + const viewMatrix2 = new Matrix4().lookAt({ + eye: [0, -altitude, 0], + up: [0, 0, 1] + }); + const scale5 = Math.pow(2, zoom); + viewMatrix2.rotateX(latitude * DEGREES_TO_RADIANS5); + viewMatrix2.rotateZ(-longitude * DEGREES_TO_RADIANS5); + viewMatrix2.scale(scale5 / height); + const halfFov = Math.atan(0.5 / altitude); + const relativeScale = GLOBE_RADIUS * 2 * scale5 / height; + super({ + ...opts, + height, + viewMatrix: viewMatrix2, + longitude, + latitude, + zoom, + distanceScales: getDistanceScales2(), + fovyRadians: halfFov * 2, + focalDistance: altitude, + near: nearZMultiplier, + far: Math.min(2, 1 / relativeScale + 1) * altitude * farZMultiplier + }); + _defineProperty(this, "longitude", void 0); + _defineProperty(this, "latitude", void 0); + _defineProperty(this, "resolution", void 0); + this.latitude = latitude; + this.longitude = longitude; + this.resolution = resolution; + } + get projectionMode() { + return PROJECTION_MODE.GLOBE; + } + getDistanceScales() { + return this.distanceScales; + } + getBounds(options = {}) { + const unprojectOption = { + targetZ: options.z || 0 + }; + const left = this.unproject([0, this.height / 2], unprojectOption); + const top = this.unproject([this.width / 2, 0], unprojectOption); + const right = this.unproject([this.width, this.height / 2], unprojectOption); + const bottom = this.unproject([this.width / 2, this.height], unprojectOption); + if (right[0] < this.longitude) + right[0] += 360; + if (left[0] > this.longitude) + left[0] -= 360; + return [Math.min(left[0], right[0], top[0], bottom[0]), Math.min(left[1], right[1], top[1], bottom[1]), Math.max(left[0], right[0], top[0], bottom[0]), Math.max(left[1], right[1], top[1], bottom[1])]; + } + unproject(xyz, { + topLeft = true, + targetZ + } = {}) { + const [x2, y2, z] = xyz; + const y22 = topLeft ? y2 : this.height - y2; + const { + pixelUnprojectionMatrix } = this; - if (!transition || !transition.transitionInterpolator) { - return NO_TRANSITION_PROPS; + let coord; + if (Number.isFinite(z)) { + coord = transformVector2(pixelUnprojectionMatrix, [x2, y22, z, 1]); + } else { + const coord0 = transformVector2(pixelUnprojectionMatrix, [x2, y22, -1, 1]); + const coord1 = transformVector2(pixelUnprojectionMatrix, [x2, y22, 1, 1]); + const lt = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS; + const lSqr = sqrLen(sub([], coord0, coord1)); + const l0Sqr = sqrLen(coord0); + const l1Sqr = sqrLen(coord1); + const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16; + const dSqr = 4 * sSqr / lSqr; + const r0 = Math.sqrt(l0Sqr - dSqr); + const dr = Math.sqrt(Math.max(0, lt * lt - dSqr)); + const t2 = (r0 - dr) / Math.sqrt(lSqr); + coord = lerp3([], coord0, coord1, t2); } - return opts ? { - ...transition, - transitionInterpolator: new LinearInterpolator({ - ...opts, - ...transition.transitionInterpolator.opts, - makeViewport: this.controllerState.makeViewport - }) - } : transition; + const [X, Y, Z] = this.unprojectPosition(coord); + if (Number.isFinite(z)) { + return [X, Y, Z]; + } + return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y]; + } + projectPosition(xyz) { + const [lng, lat, Z = 0] = xyz; + const lambda = lng * DEGREES_TO_RADIANS5; + const phi = lat * DEGREES_TO_RADIANS5; + const cosPhi = Math.cos(phi); + const D2 = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS; + return [Math.sin(lambda) * cosPhi * D2, -Math.cos(lambda) * cosPhi * D2, Math.sin(phi) * D2]; + } + unprojectPosition(xyz) { + const [x2, y2, z] = xyz; + const D2 = len(xyz); + const phi = Math.asin(z / D2); + const lambda = Math.atan2(x2, -y2); + const lng = lambda * RADIANS_TO_DEGREES3; + const lat = phi * RADIANS_TO_DEGREES3; + const Z = (D2 / GLOBE_RADIUS - 1) * EARTH_RADIUS; + return [lng, lat, Z]; + } + projectFlat(xyz) { + return xyz; + } + unprojectFlat(xyz) { + return xyz; + } + panByPosition(coords, pixel) { + const fromPosition = this.unproject(pixel); + return { + longitude: coords[0] - fromPosition[0] + this.longitude, + latitude: coords[1] - fromPosition[1] + this.latitude + }; } }; + function transformVector2(matrix, vector) { + const result = transformMat43([], vector, matrix); + scale3(result, result, 1 / result[3]); + return result; + } - // node_modules/@deck.gl/core/dist/esm/controllers/view-state.js - var ViewState = class { - constructor(props, state) { - _defineProperty(this, "_viewportProps", void 0); - _defineProperty(this, "_state", void 0); - this._viewportProps = this.applyConstraints(props); - this._state = state; + // node_modules/@deck.gl/core/dist/esm/viewports/orbit-viewport.js + var DEGREES_TO_RADIANS6 = Math.PI / 180; + function getViewMatrix2({ + height, + focalDistance, + orbitAxis, + rotationX, + rotationOrbit, + zoom + }) { + const up = orbitAxis === "Z" ? [0, 0, 1] : [0, 1, 0]; + const eye = orbitAxis === "Z" ? [0, -focalDistance, 0] : [0, 0, focalDistance]; + const viewMatrix2 = new Matrix4().lookAt({ + eye, + up + }); + viewMatrix2.rotateX(rotationX * DEGREES_TO_RADIANS6); + if (orbitAxis === "Z") { + viewMatrix2.rotateZ(rotationOrbit * DEGREES_TO_RADIANS6); + } else { + viewMatrix2.rotateY(rotationOrbit * DEGREES_TO_RADIANS6); } - getViewportProps() { - return this._viewportProps; + const projectionScale = Math.pow(2, zoom) / height; + viewMatrix2.scale(projectionScale); + return viewMatrix2; + } + var OrbitViewport = class extends Viewport { + constructor(props) { + const { + height, + projectionMatrix, + fovy = 50, + orbitAxis = "Z", + target = [0, 0, 0], + rotationX = 0, + rotationOrbit = 0, + zoom = 0 + } = props; + const focalDistance = projectionMatrix ? projectionMatrix[5] / 2 : fovyToAltitude(fovy); + super({ + ...props, + longitude: void 0, + viewMatrix: getViewMatrix2({ + height: height || 1, + focalDistance, + orbitAxis, + rotationX, + rotationOrbit, + zoom + }), + fovy, + focalDistance, + position: target, + zoom + }); + _defineProperty(this, "projectedCenter", void 0); + this.projectedCenter = this.project(this.center); } - getState() { - return this._state; + unproject(xyz, { + topLeft = true + } = {}) { + const [x2, y2, z = this.projectedCenter[2]] = xyz; + const y22 = topLeft ? y2 : this.height - y2; + const [X, Y, Z] = pixelsToWorld([x2, y22, z], this.pixelUnprojectionMatrix); + return [X, Y, Z]; + } + panByPosition(coords, pixel) { + const p0 = this.project(coords); + const nextCenter = [this.width / 2 + p0[0] - pixel[0], this.height / 2 + p0[1] - pixel[1], this.projectedCenter[2]]; + return { + target: this.unproject(nextCenter) + }; } }; - // node_modules/@deck.gl/core/dist/esm/controllers/map-controller.js - var PITCH_MOUSE_THRESHOLD = 5; - var PITCH_ACCEL = 1.2; - var MapState = class extends ViewState { + // node_modules/@deck.gl/core/dist/esm/viewports/orthographic-viewport.js + var viewMatrix = new Matrix4().lookAt({ + eye: [0, 0, 1] + }); + function getProjectionMatrix2({ + width, + height, + near, + far, + padding + }) { + let left = -width / 2; + let right = width / 2; + let bottom = -height / 2; + let top = height / 2; + if (padding) { + const { + left: l2 = 0, + right: r2 = 0, + top: t2 = 0, + bottom: b2 = 0 + } = padding; + const offsetX = clamp((l2 + width - r2) / 2, 0, width) - width / 2; + const offsetY = clamp((t2 + height - b2) / 2, 0, height) - height / 2; + left -= offsetX; + right -= offsetX; + bottom += offsetY; + top += offsetY; + } + return new Matrix4().ortho({ + left, + right, + bottom, + top, + near, + far + }); + } + var OrthographicViewport = class extends Viewport { + constructor(props) { + const { + width, + height, + near = 0.1, + far = 1e3, + zoom = 0, + target = [0, 0, 0], + padding = null, + flipY = true + } = props; + const zoomX = Array.isArray(zoom) ? zoom[0] : zoom; + const zoomY = Array.isArray(zoom) ? zoom[1] : zoom; + const zoom_ = Math.min(zoomX, zoomY); + const scale5 = Math.pow(2, zoom_); + let distanceScales; + if (zoomX !== zoomY) { + const scaleX2 = Math.pow(2, zoomX); + const scaleY2 = Math.pow(2, zoomY); + distanceScales = { + unitsPerMeter: [scaleX2 / scale5, scaleY2 / scale5, 1], + metersPerUnit: [scale5 / scaleX2, scale5 / scaleY2, 1] + }; + } + super({ + ...props, + longitude: void 0, + position: target, + viewMatrix: viewMatrix.clone().scale([scale5, scale5 * (flipY ? -1 : 1), scale5]), + projectionMatrix: getProjectionMatrix2({ + width: width || 1, + height: height || 1, + padding, + near, + far + }), + zoom: zoom_, + distanceScales + }); + } + projectFlat([X, Y]) { + const { + unitsPerMeter: unitsPerMeter2 + } = this.distanceScales; + return [X * unitsPerMeter2[0], Y * unitsPerMeter2[1]]; + } + unprojectFlat([x2, y2]) { + const { + metersPerUnit + } = this.distanceScales; + return [x2 * metersPerUnit[0], y2 * metersPerUnit[1]]; + } + panByPosition(coords, pixel) { + const fromLocation = pixelsToWorld(pixel, this.pixelUnprojectionMatrix); + const toLocation = this.projectFlat(coords); + const translate3 = add([], toLocation, negate([], fromLocation)); + const newCenter = add([], this.center, translate3); + return { + target: this.unprojectFlat(newCenter) + }; + } + }; + + // node_modules/@deck.gl/core/dist/esm/controllers/orbit-controller.js + var OrbitState = class extends ViewState { constructor(options) { const { width, height, - latitude, - longitude, - zoom, - bearing = 0, - pitch = 0, - altitude = 1.5, - position = [0, 0, 0], - maxZoom = 20, - minZoom = 0, - maxPitch = 60, - minPitch = 0, - startPanLngLat, - startZoomLngLat, + rotationX = 0, + rotationOrbit = 0, + target = [0, 0, 0], + zoom = 0, + minRotationX = -90, + maxRotationX = 90, + minZoom = -Infinity, + maxZoom = Infinity, + startPanPosition, startRotatePos, - startBearing, - startPitch, - startZoom, - normalize = true + startRotationX, + startRotationOrbit, + startZoomPosition, + startZoom } = options; - assert10(Number.isFinite(longitude)); - assert10(Number.isFinite(latitude)); - assert10(Number.isFinite(zoom)); super({ width, height, - latitude, - longitude, + rotationX, + rotationOrbit, + target, zoom, - bearing, - pitch, - altitude, - maxZoom, + minRotationX, + maxRotationX, minZoom, - maxPitch, - minPitch, - normalize, - position + maxZoom }, { - startPanLngLat, - startZoomLngLat, + startPanPosition, startRotatePos, - startBearing, - startPitch, + startRotationX, + startRotationOrbit, + startZoomPosition, startZoom }); _defineProperty(this, "makeViewport", void 0); @@ -23756,24 +40203,24 @@ pos }) { return this._getUpdatedState({ - startPanLngLat: this._unproject(pos) + startPanPosition: this._unproject(pos) }); } pan({ pos, - startPos + startPosition }) { - const startPanLngLat = this.getState().startPanLngLat || this._unproject(startPos); - if (!startPanLngLat) { + const startPanPosition = this.getState().startPanPosition || startPosition; + if (!startPanPosition) { return this; } const viewport = this.makeViewport(this.getViewportProps()); - const newProps = viewport.panByPosition(startPanLngLat, pos); + const newProps = viewport.panByPosition(startPanPosition, pos); return this._getUpdatedState(newProps); } panEnd() { return this._getUpdatedState({ - startPanLngLat: null + startPanPosition: null }); } rotateStart({ @@ -23781,8 +40228,8 @@ }) { return this._getUpdatedState({ startRotatePos: pos, - startBearing: this.getViewportProps().bearing, - startPitch: this.getViewportProps().pitch + startRotationX: this.getViewportProps().rotationX, + startRotationOrbit: this.getViewportProps().rotationOrbit }); } rotate({ @@ -23792,167 +40239,169 @@ }) { const { startRotatePos, - startBearing, - startPitch + startRotationX, + startRotationOrbit } = this.getState(); - if (!startRotatePos || startBearing === void 0 || startPitch === void 0) { + const { + width, + height + } = this.getViewportProps(); + if (!startRotatePos || startRotationX === void 0 || startRotationOrbit === void 0) { return this; } let newRotation; if (pos) { - newRotation = this._getNewRotation(pos, startRotatePos, startPitch, startBearing); + let deltaScaleX = (pos[0] - startRotatePos[0]) / width; + const deltaScaleY = (pos[1] - startRotatePos[1]) / height; + if (startRotationX < -90 || startRotationX > 90) { + deltaScaleX *= -1; + } + newRotation = { + rotationX: startRotationX + deltaScaleY * 180, + rotationOrbit: startRotationOrbit + deltaScaleX * 180 + }; } else { newRotation = { - bearing: startBearing + deltaAngleX, - pitch: startPitch + deltaAngleY + rotationX: startRotationX + deltaAngleY, + rotationOrbit: startRotationOrbit + deltaAngleX }; } return this._getUpdatedState(newRotation); } rotateEnd() { return this._getUpdatedState({ - startBearing: null, - startPitch: null + startRotationX: null, + startRotationOrbit: null }); } + shortestPathFrom(viewState) { + const fromProps = viewState.getViewportProps(); + const props = { + ...this.getViewportProps() + }; + const { + rotationOrbit + } = props; + if (Math.abs(rotationOrbit - fromProps.rotationOrbit) > 180) { + props.rotationOrbit = rotationOrbit < 0 ? rotationOrbit + 360 : rotationOrbit - 360; + } + return props; + } zoomStart({ pos }) { return this._getUpdatedState({ - startZoomLngLat: this._unproject(pos), + startZoomPosition: this._unproject(pos), startZoom: this.getViewportProps().zoom }); } zoom({ pos, startPos, - scale: scale3 + scale: scale5 }) { let { startZoom, - startZoomLngLat + startZoomPosition } = this.getState(); - if (!startZoomLngLat) { + if (!startZoomPosition) { startZoom = this.getViewportProps().zoom; - startZoomLngLat = this._unproject(startPos) || this._unproject(pos); + startZoomPosition = this._unproject(startPos) || this._unproject(pos); } - if (!startZoomLngLat) { + if (!startZoomPosition) { return this; } - const { - maxZoom, - minZoom - } = this.getViewportProps(); - let zoom = startZoom + Math.log2(scale3); - zoom = clamp(zoom, minZoom, maxZoom); + const newZoom = this._calculateNewZoom({ + scale: scale5, + startZoom + }); const zoomedViewport = this.makeViewport({ ...this.getViewportProps(), - zoom + zoom: newZoom }); return this._getUpdatedState({ - zoom, - ...zoomedViewport.panByPosition(startZoomLngLat, pos) + zoom: newZoom, + ...zoomedViewport.panByPosition(startZoomPosition, pos) }); } zoomEnd() { return this._getUpdatedState({ - startZoomLngLat: null, + startZoomPosition: null, startZoom: null }); } zoomIn(speed = 2) { - return this._zoomFromCenter(speed); + return this._getUpdatedState({ + zoom: this._calculateNewZoom({ + scale: speed + }) + }); } zoomOut(speed = 2) { - return this._zoomFromCenter(1 / speed); - } - moveLeft(speed = 100) { - return this._panFromCenter([speed, 0]); + return this._getUpdatedState({ + zoom: this._calculateNewZoom({ + scale: 1 / speed + }) + }); } - moveRight(speed = 100) { + moveLeft(speed = 50) { return this._panFromCenter([-speed, 0]); } - moveUp(speed = 100) { - return this._panFromCenter([0, speed]); + moveRight(speed = 50) { + return this._panFromCenter([speed, 0]); } - moveDown(speed = 100) { + moveUp(speed = 50) { return this._panFromCenter([0, -speed]); } + moveDown(speed = 50) { + return this._panFromCenter([0, speed]); + } rotateLeft(speed = 15) { return this._getUpdatedState({ - bearing: this.getViewportProps().bearing - speed + rotationOrbit: this.getViewportProps().rotationOrbit - speed }); } rotateRight(speed = 15) { return this._getUpdatedState({ - bearing: this.getViewportProps().bearing + speed + rotationOrbit: this.getViewportProps().rotationOrbit + speed }); } rotateUp(speed = 10) { return this._getUpdatedState({ - pitch: this.getViewportProps().pitch + speed + rotationX: this.getViewportProps().rotationX - speed }); } rotateDown(speed = 10) { return this._getUpdatedState({ - pitch: this.getViewportProps().pitch - speed + rotationX: this.getViewportProps().rotationX + speed }); } - shortestPathFrom(viewState) { - const fromProps = viewState.getViewportProps(); - const props = { - ...this.getViewportProps() - }; - const { - bearing, - longitude - } = props; - if (Math.abs(bearing - fromProps.bearing) > 180) { - props.bearing = bearing < 0 ? bearing + 360 : bearing - 360; - } - if (Math.abs(longitude - fromProps.longitude) > 180) { - props.longitude = longitude < 0 ? longitude + 360 : longitude - 360; - } - return props; + _unproject(pos) { + const viewport = this.makeViewport(this.getViewportProps()); + return pos && viewport.unproject(pos); } - applyConstraints(props) { + _calculateNewZoom({ + scale: scale5, + startZoom + }) { const { maxZoom, - minZoom, - zoom - } = props; - props.zoom = clamp(zoom, minZoom, maxZoom); - const { - maxPitch, - minPitch, - pitch - } = props; - props.pitch = clamp(pitch, minPitch, maxPitch); - const { - normalize = true - } = props; - if (normalize) { - Object.assign(props, normalizeViewportProps(props)); - } - return props; - } - _zoomFromCenter(scale3) { - const { - width, - height + minZoom } = this.getViewportProps(); - return this.zoom({ - pos: [width / 2, height / 2], - scale: scale3 - }); + if (startZoom === void 0) { + startZoom = this.getViewportProps().zoom; + } + const zoom = startZoom + Math.log2(scale5); + return clamp(zoom, minZoom, maxZoom); } _panFromCenter(offset) { const { width, - height + height, + target } = this.getViewportProps(); return this.pan({ - startPos: [width / 2, height / 2], + startPosition: target, pos: [width / 2 + offset[0], height / 2 + offset[1]] }); } @@ -23964,7338 +40413,21538 @@ ...newProps }); } - _unproject(pos) { - const viewport = this.makeViewport(this.getViewportProps()); - return pos && viewport.unproject(pos); - } - _getNewRotation(pos, startPos, startPitch, startBearing) { - const deltaX = pos[0] - startPos[0]; - const deltaY = pos[1] - startPos[1]; - const centerY = pos[1]; - const startY = startPos[1]; - const { - width, - height - } = this.getViewportProps(); - const deltaScaleX = deltaX / width; - let deltaScaleY = 0; - if (deltaY > 0) { - if (Math.abs(height - startY) > PITCH_MOUSE_THRESHOLD) { - deltaScaleY = deltaY / (startY - height) * PITCH_ACCEL; - } - } else if (deltaY < 0) { - if (startY > PITCH_MOUSE_THRESHOLD) { - deltaScaleY = 1 - centerY / startY; - } - } - deltaScaleY = clamp(deltaScaleY, -1, 1); + applyConstraints(props) { const { - minPitch, - maxPitch - } = this.getViewportProps(); - const bearing = startBearing + 180 * deltaScaleX; - let pitch = startPitch; - if (deltaScaleY > 0) { - pitch = startPitch + deltaScaleY * (maxPitch - startPitch); - } else if (deltaScaleY < 0) { - pitch = startPitch - deltaScaleY * (minPitch - startPitch); + maxZoom, + minZoom, + zoom, + maxRotationX, + minRotationX, + rotationOrbit + } = props; + props.zoom = Array.isArray(zoom) ? [clamp(zoom[0], minZoom, maxZoom), clamp(zoom[1], minZoom, maxZoom)] : clamp(zoom, minZoom, maxZoom); + props.rotationX = clamp(props.rotationX, minRotationX, maxRotationX); + if (rotationOrbit < -180 || rotationOrbit > 180) { + props.rotationOrbit = mod2(rotationOrbit + 180, 360) - 180; } - return { - pitch, - bearing - }; + return props; } }; - var MapController = class extends Controller { + var OrbitController = class extends Controller { constructor(...args) { super(...args); - _defineProperty(this, "ControllerState", MapState); + _defineProperty(this, "ControllerState", OrbitState); _defineProperty(this, "transition", { transitionDuration: 300, transitionInterpolator: new LinearInterpolator({ transitionProps: { - compare: ["longitude", "latitude", "zoom", "bearing", "pitch", "position"], - required: ["longitude", "latitude", "zoom"] + compare: ["target", "zoom", "rotationX", "rotationOrbit"], + required: ["target", "zoom"] } }) }); - _defineProperty(this, "dragMode", "pan"); } - setProps(props) { - props.position = props.position || [0, 0, 0]; - const oldProps = this.props; - super.setProps(props); - const dimensionChanged = !oldProps || oldProps.height !== props.height; - if (dimensionChanged) { - this.updateViewport(new this.ControllerState({ - makeViewport: this.makeViewport, - ...props, - ...this.state - })); + }; + + // node_modules/@deck.gl/core/dist/esm/views/orbit-view.js + var OrbitView = class extends View { + constructor(props = {}) { + super(props); + this.props.orbitAxis = props.orbitAxis || "Z"; + } + get ViewportType() { + return OrbitViewport; + } + get ControllerType() { + return OrbitController; + } + }; + _defineProperty(OrbitView, "displayName", "OrbitView"); + + // node_modules/@deck.gl/core/dist/esm/controllers/orthographic-controller.js + var OrthographicState = class extends OrbitState { + constructor(props) { + super(props); + _defineProperty(this, "zoomAxis", void 0); + this.zoomAxis = props.zoomAxis || "all"; + } + _calculateNewZoom({ + scale: scale5, + startZoom + }) { + const { + maxZoom, + minZoom + } = this.getViewportProps(); + if (startZoom === void 0) { + startZoom = this.getViewportProps().zoom; + } + let deltaZoom = Math.log2(scale5); + if (Array.isArray(startZoom)) { + let [newZoomX, newZoomY] = startZoom; + switch (this.zoomAxis) { + case "X": + newZoomX = clamp(newZoomX + deltaZoom, minZoom, maxZoom); + break; + case "Y": + newZoomY = clamp(newZoomY + deltaZoom, minZoom, maxZoom); + break; + default: + let z = Math.min(newZoomX + deltaZoom, newZoomY + deltaZoom); + if (z < minZoom) { + deltaZoom += minZoom - z; + } + z = Math.max(newZoomX + deltaZoom, newZoomY + deltaZoom); + if (z > maxZoom) { + deltaZoom += maxZoom - z; + } + newZoomX += deltaZoom; + newZoomY += deltaZoom; + } + return [newZoomX, newZoomY]; } + return clamp(startZoom + deltaZoom, minZoom, maxZoom); + } + }; + var OrthographicController = class extends Controller { + constructor(...args) { + super(...args); + _defineProperty(this, "ControllerState", OrthographicState); + _defineProperty(this, "transition", { + transitionDuration: 300, + transitionInterpolator: new LinearInterpolator(["target", "zoom"]) + }); + _defineProperty(this, "dragMode", "pan"); + } + _onPanRotate() { + return false; } }; - // node_modules/@deck.gl/core/dist/esm/views/map-view.js - var MapView = class extends View { + // node_modules/@deck.gl/core/dist/esm/views/orthographic-view.js + var OrthographicView = class extends View { get ViewportType() { - return WebMercatorViewport2; + return OrthographicViewport; } get ControllerType() { - return MapController; + return OrthographicController; } }; - _defineProperty(MapView, "displayName", "MapView"); + _defineProperty(OrthographicView, "displayName", "OrthographicView"); - // node_modules/@deck.gl/core/dist/esm/lib/effect-manager.js - var DEFAULT_LIGHTING_EFFECT = new LightingEffect(); - function compareEffects(e1, e2) { - var _e1$order, _e2$order; - const o1 = (_e1$order = e1.order) !== null && _e1$order !== void 0 ? _e1$order : Infinity; - const o2 = (_e2$order = e2.order) !== null && _e2$order !== void 0 ? _e2$order : Infinity; - return o1 - o2; - } - var EffectManager = class { - constructor() { - _defineProperty(this, "effects", void 0); - _defineProperty(this, "_resolvedEffects", []); - _defineProperty(this, "_defaultEffects", []); - _defineProperty(this, "_needsRedraw", void 0); - this.effects = []; - this._needsRedraw = "Initial render"; - this._setEffects([]); + // node_modules/@deck.gl/core/dist/esm/lib/layer-extension.js + var LayerExtension = class { + static get componentName() { + return Object.prototype.hasOwnProperty.call(this, "extensionName") ? this.extensionName : ""; } - addDefaultEffect(effect) { - const defaultEffects = this._defaultEffects; - if (!defaultEffects.find((e2) => e2.id === effect.id)) { - const index = defaultEffects.findIndex((e2) => compareEffects(e2, effect) > 0); - if (index < 0) { - defaultEffects.push(effect); - } else { - defaultEffects.splice(index, 0, effect); - } - this._setEffects(this.effects); + constructor(opts) { + _defineProperty(this, "opts", void 0); + if (opts) { + this.opts = opts; } } - setProps(props) { - if ("effects" in props) { - if (!deepEqual(props.effects, this.effects, 1)) { - this._setEffects(props.effects); + equals(extension) { + if (this === extension) { + return true; + } + return this.constructor === extension.constructor && deepEqual(this.opts, extension.opts, 1); + } + getShaders(extension) { + return null; + } + getSubLayerProps(extension) { + const { + defaultProps: defaultProps18 + } = extension.constructor; + const newProps = { + updateTriggers: {} + }; + for (const key in defaultProps18) { + if (key in this.props) { + const propDef = defaultProps18[key]; + const propValue = this.props[key]; + newProps[key] = propValue; + if (propDef && propDef.type === "accessor") { + newProps.updateTriggers[key] = this.props.updateTriggers[key]; + if (typeof propValue === "function") { + newProps[key] = this.getSubLayerAccessor(propValue); + } + } } } + return newProps; } - needsRedraw(opts = { - clearRedrawFlags: false - }) { - const redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; + initializeState(context, extension) { + } + updateState(params, extension) { + } + onNeedsRedraw(extension) { + } + getNeedsPickingBuffer(extension) { + return false; + } + draw(params, extension) { + } + finalizeState(context, extension) { + } + }; + _defineProperty(LayerExtension, "defaultProps", {}); + _defineProperty(LayerExtension, "extensionName", "LayerExtension"); + + // node_modules/@deck.gl/core/dist/esm/utils/tesselator.js + var Tesselator = class { + constructor(opts) { + _defineProperty(this, "opts", void 0); + _defineProperty(this, "typedArrayManager", void 0); + _defineProperty(this, "indexStarts", [0]); + _defineProperty(this, "vertexStarts", [0]); + _defineProperty(this, "vertexCount", 0); + _defineProperty(this, "instanceCount", 0); + _defineProperty(this, "attributes", void 0); + _defineProperty(this, "_attributeDefs", void 0); + _defineProperty(this, "data", void 0); + _defineProperty(this, "getGeometry", void 0); + _defineProperty(this, "geometryBuffer", void 0); + _defineProperty(this, "buffers", void 0); + _defineProperty(this, "positionSize", void 0); + _defineProperty(this, "normalize", void 0); + const { + attributes = {} + } = opts; + this.typedArrayManager = typed_array_manager_default; + this.attributes = {}; + this._attributeDefs = attributes; + this.opts = opts; + this.updateGeometry(opts); + } + updateGeometry(opts) { + Object.assign(this.opts, opts); + const { + data, + buffers = {}, + getGeometry, + geometryBuffer, + positionFormat, + dataChanged, + normalize: normalize5 = true + } = this.opts; + this.data = data; + this.getGeometry = getGeometry; + this.positionSize = geometryBuffer && geometryBuffer.size || (positionFormat === "XY" ? 2 : 3); + this.buffers = buffers; + this.normalize = normalize5; + if (geometryBuffer) { + assert10(data.startIndices); + this.getGeometry = this.getGeometryFromBuffer(geometryBuffer); + if (!normalize5) { + buffers.positions = geometryBuffer; + } + } + this.geometryBuffer = buffers.positions; + if (Array.isArray(dataChanged)) { + for (const dataRange of dataChanged) { + this._rebuildGeometry(dataRange); + } + } else { + this._rebuildGeometry(); } - return redraw; } - getEffects() { - return this._resolvedEffects; + updatePartialGeometry({ + startRow, + endRow + }) { + this._rebuildGeometry({ + startRow, + endRow + }); } - _setEffects(effects) { - const oldEffectsMap = {}; - for (const effect of this.effects) { - oldEffectsMap[effect.id] = effect; + getGeometryFromBuffer(geometryBuffer) { + const value = geometryBuffer.value || geometryBuffer; + if (!ArrayBuffer.isView(value)) { + return null; } - const nextEffects = []; - for (const effect of effects) { - const oldEffect = oldEffectsMap[effect.id]; - if (oldEffect && oldEffect !== effect) { - if (oldEffect.setProps) { - oldEffect.setProps(effect.props); - nextEffects.push(oldEffect); - } else { - oldEffect.cleanup(); - nextEffects.push(effect); - } + return getAccessorFromBuffer(value, { + size: this.positionSize, + offset: geometryBuffer.offset, + stride: geometryBuffer.stride, + startIndices: this.data.startIndices + }); + } + _allocate(instanceCount, copy3) { + const { + attributes, + buffers, + _attributeDefs, + typedArrayManager + } = this; + for (const name in _attributeDefs) { + if (name in buffers) { + typedArrayManager.release(attributes[name]); + attributes[name] = null; } else { - nextEffects.push(effect); + const def = _attributeDefs[name]; + def.copy = copy3; + attributes[name] = typedArrayManager.allocate(attributes[name], instanceCount, def); } - delete oldEffectsMap[effect.id]; } - for (const removedEffectId in oldEffectsMap) { - oldEffectsMap[removedEffectId].cleanup(); - } - this.effects = nextEffects; - this._resolvedEffects = nextEffects.concat(this._defaultEffects); - if (!effects.some((effect) => effect instanceof LightingEffect)) { - this._resolvedEffects.push(DEFAULT_LIGHTING_EFFECT); + } + _forEachGeometry(visitor, startRow, endRow) { + const { + data, + getGeometry + } = this; + const { + iterable, + objectInfo + } = createIterable(data, startRow, endRow); + for (const object of iterable) { + objectInfo.index++; + const geometry = getGeometry ? getGeometry(object, objectInfo) : null; + visitor(geometry, objectInfo.index); } - this._needsRedraw = "effects changed"; } - finalize() { - for (const effect of this._resolvedEffects) { - effect.cleanup(); + _rebuildGeometry(dataRange) { + if (!this.data) { + return; } - this.effects.length = 0; - this._resolvedEffects.length = 0; - this._defaultEffects.length = 0; + let { + indexStarts, + vertexStarts, + instanceCount + } = this; + const { + data, + geometryBuffer + } = this; + const { + startRow = 0, + endRow = Infinity + } = dataRange || {}; + const normalizedData = {}; + if (!dataRange) { + indexStarts = [0]; + vertexStarts = [0]; + } + if (this.normalize || !geometryBuffer) { + this._forEachGeometry((geometry, dataIndex) => { + const normalizedGeometry = geometry && this.normalizeGeometry(geometry); + normalizedData[dataIndex] = normalizedGeometry; + vertexStarts[dataIndex + 1] = vertexStarts[dataIndex] + (normalizedGeometry ? this.getGeometrySize(normalizedGeometry) : 0); + }, startRow, endRow); + instanceCount = vertexStarts[vertexStarts.length - 1]; + } else { + vertexStarts = data.startIndices; + instanceCount = vertexStarts[data.length] || 0; + if (ArrayBuffer.isView(geometryBuffer)) { + instanceCount = instanceCount || geometryBuffer.length / this.positionSize; + } else if (geometryBuffer instanceof Buffer2) { + const byteStride = geometryBuffer.accessor.stride || this.positionSize * 4; + instanceCount = instanceCount || geometryBuffer.byteLength / byteStride; + } else if (geometryBuffer.buffer) { + const byteStride = geometryBuffer.stride || this.positionSize * 4; + instanceCount = instanceCount || geometryBuffer.buffer.byteLength / byteStride; + } else if (geometryBuffer.value) { + const bufferValue = geometryBuffer.value; + const elementStride = geometryBuffer.stride / bufferValue.BYTES_PER_ELEMENT || this.positionSize; + instanceCount = instanceCount || bufferValue.length / elementStride; + } + } + this._allocate(instanceCount, Boolean(dataRange)); + this.indexStarts = indexStarts; + this.vertexStarts = vertexStarts; + this.instanceCount = instanceCount; + const context = {}; + this._forEachGeometry((geometry, dataIndex) => { + const normalizedGeometry = normalizedData[dataIndex] || geometry; + context.vertexStart = vertexStarts[dataIndex]; + context.indexStart = indexStarts[dataIndex]; + const vertexEnd = dataIndex < vertexStarts.length - 1 ? vertexStarts[dataIndex + 1] : instanceCount; + context.geometrySize = vertexEnd - vertexStarts[dataIndex]; + context.geometryIndex = dataIndex; + this.updateGeometryAttributes(normalizedGeometry, context); + }, startRow, endRow); + this.vertexCount = indexStarts[indexStarts.length - 1]; } }; - // node_modules/@deck.gl/core/dist/esm/passes/draw-layers-pass.js - var DrawLayersPass = class extends LayersPass { - shouldDrawLayer(layer) { - const { - operation - } = layer.props; - return operation.includes("draw") || operation.includes("terrain"); + // node_modules/@deck.gl/layers/dist/esm/bitmap-layer/create-mesh.js + var DEFAULT_INDICES = new Uint16Array([0, 2, 1, 0, 3, 2]); + var DEFAULT_TEX_COORDS = new Float32Array([0, 1, 0, 0, 1, 0, 1, 1]); + function createMesh(bounds, resolution) { + if (!resolution) { + return createQuad(bounds); + } + const maxXSpan = Math.max(Math.abs(bounds[0][0] - bounds[3][0]), Math.abs(bounds[1][0] - bounds[2][0])); + const maxYSpan = Math.max(Math.abs(bounds[1][1] - bounds[0][1]), Math.abs(bounds[2][1] - bounds[3][1])); + const uCount = Math.ceil(maxXSpan / resolution) + 1; + const vCount = Math.ceil(maxYSpan / resolution) + 1; + const vertexCount = (uCount - 1) * (vCount - 1) * 6; + const indices = new Uint32Array(vertexCount); + const texCoords = new Float32Array(uCount * vCount * 2); + const positions = new Float64Array(uCount * vCount * 3); + let vertex = 0; + let index = 0; + for (let u2 = 0; u2 < uCount; u2++) { + const ut = u2 / (uCount - 1); + for (let v2 = 0; v2 < vCount; v2++) { + const vt = v2 / (vCount - 1); + const p2 = interpolateQuad(bounds, ut, vt); + positions[vertex * 3 + 0] = p2[0]; + positions[vertex * 3 + 1] = p2[1]; + positions[vertex * 3 + 2] = p2[2] || 0; + texCoords[vertex * 2 + 0] = ut; + texCoords[vertex * 2 + 1] = 1 - vt; + if (u2 > 0 && v2 > 0) { + indices[index++] = vertex - vCount; + indices[index++] = vertex - vCount - 1; + indices[index++] = vertex - 1; + indices[index++] = vertex - vCount; + indices[index++] = vertex - 1; + indices[index++] = vertex; + } + vertex++; + } } - }; + return { + vertexCount, + positions, + indices, + texCoords + }; + } + function createQuad(bounds) { + const positions = new Float64Array(12); + for (let i3 = 0; i3 < bounds.length; i3++) { + positions[i3 * 3 + 0] = bounds[i3][0]; + positions[i3 * 3 + 1] = bounds[i3][1]; + positions[i3 * 3 + 2] = bounds[i3][2] || 0; + } + return { + vertexCount: 6, + positions, + indices: DEFAULT_INDICES, + texCoords: DEFAULT_TEX_COORDS + }; + } + function interpolateQuad(quad, ut, vt) { + return lerp(lerp(quad[0], quad[1], vt), lerp(quad[3], quad[2], vt), ut); + } - // node_modules/@deck.gl/core/dist/esm/lib/deck-renderer.js - var TRACE_RENDER_LAYERS = "deckRenderer.renderLayers"; - var DeckRenderer = class { - constructor(gl) { - _defineProperty(this, "gl", void 0); - _defineProperty(this, "layerFilter", void 0); - _defineProperty(this, "drawPickingColors", void 0); - _defineProperty(this, "drawLayersPass", void 0); - _defineProperty(this, "pickLayersPass", void 0); - _defineProperty(this, "renderCount", void 0); - _defineProperty(this, "_needsRedraw", void 0); - _defineProperty(this, "renderBuffers", void 0); - _defineProperty(this, "lastPostProcessEffect", void 0); - this.gl = gl; - this.layerFilter = null; - this.drawPickingColors = false; - this.drawLayersPass = new DrawLayersPass(gl); - this.pickLayersPass = new PickLayersPass(gl); - this.renderCount = 0; - this._needsRedraw = "Initial render"; - this.renderBuffers = []; - this.lastPostProcessEffect = null; + // node_modules/@deck.gl/layers/dist/esm/bitmap-layer/bitmap-layer-vertex.js + var bitmap_layer_vertex_default = "\n#define SHADER_NAME bitmap-layer-vertex-shader\n\nattribute vec2 texCoords;\nattribute vec3 positions;\nattribute vec3 positions64Low;\n\nvarying vec2 vTexCoord;\nvarying vec2 vTexPos;\n\nuniform float coordinateConversion;\n\nconst vec3 pickingColor = vec3(1.0, 0.0, 0.0);\n\nvoid main(void) {\n geometry.worldPosition = positions;\n geometry.uv = texCoords;\n geometry.pickingColor = pickingColor;\n\n gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n vTexCoord = texCoords;\n\n if (coordinateConversion < -0.5) {\n vTexPos = geometry.position.xy + project_uCommonOrigin.xy;\n } else if (coordinateConversion > 0.5) {\n vTexPos = geometry.worldPosition.xy;\n }\n\n vec4 color = vec4(0.0);\n DECKGL_FILTER_COLOR(color, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/bitmap-layer/bitmap-layer-fragment.js + var packUVsIntoRGB = "\nvec3 packUVsIntoRGB(vec2 uv) {\n // Extract the top 8 bits. We want values to be truncated down so we can add a fraction\n vec2 uv8bit = floor(uv * 256.);\n\n // Calculate the normalized remainders of u and v parts that do not fit into 8 bits\n // Scale and clamp to 0-1 range\n vec2 uvFraction = fract(uv * 256.);\n vec2 uvFraction4bit = floor(uvFraction * 16.);\n\n // Remainder can be encoded in blue channel, encode as 4 bits for pixel coordinates\n float fractions = uvFraction4bit.x + uvFraction4bit.y * 16.;\n\n return vec3(uv8bit, fractions) / 255.;\n}\n"; + var bitmap_layer_fragment_default = "\n#define SHADER_NAME bitmap-layer-fragment-shader\n\n#ifdef GL_ES\nprecision highp float;\n#endif\n\nuniform sampler2D bitmapTexture;\n\nvarying vec2 vTexCoord;\nvarying vec2 vTexPos;\n\nuniform float desaturate;\nuniform vec4 transparentColor;\nuniform vec3 tintColor;\nuniform float opacity;\n\nuniform float coordinateConversion;\nuniform vec4 bounds;\n\n/* projection utils */\nconst float TILE_SIZE = 512.0;\nconst float PI = 3.1415926536;\nconst float WORLD_SCALE = TILE_SIZE / PI / 2.0;\n\n// from degrees to Web Mercator\nvec2 lnglat_to_mercator(vec2 lnglat) {\n float x = lnglat.x;\n float y = clamp(lnglat.y, -89.9, 89.9);\n return vec2(\n radians(x) + PI,\n PI + log(tan(PI * 0.25 + radians(y) * 0.5))\n ) * WORLD_SCALE;\n}\n\n// from Web Mercator to degrees\nvec2 mercator_to_lnglat(vec2 xy) {\n xy /= WORLD_SCALE;\n return degrees(vec2(\n xy.x - PI,\n atan(exp(xy.y - PI)) * 2.0 - PI * 0.5\n ));\n}\n/* End projection utils */\n\n// apply desaturation\nvec3 color_desaturate(vec3 color) {\n float luminance = (color.r + color.g + color.b) * 0.333333333;\n return mix(color, vec3(luminance), desaturate);\n}\n\n// apply tint\nvec3 color_tint(vec3 color) {\n return color * tintColor;\n}\n\n// blend with background color\nvec4 apply_opacity(vec3 color, float alpha) {\n if (transparentColor.a == 0.0) {\n return vec4(color, alpha);\n }\n float blendedAlpha = alpha + transparentColor.a * (1.0 - alpha);\n float highLightRatio = alpha / blendedAlpha;\n vec3 blendedRGB = mix(transparentColor.rgb, color, highLightRatio);\n return vec4(blendedRGB, blendedAlpha);\n}\n\nvec2 getUV(vec2 pos) {\n return vec2(\n (pos.x - bounds[0]) / (bounds[2] - bounds[0]),\n (pos.y - bounds[3]) / (bounds[1] - bounds[3])\n );\n}\n\n".concat(packUVsIntoRGB, "\n\nvoid main(void) {\n vec2 uv = vTexCoord;\n if (coordinateConversion < -0.5) {\n vec2 lnglat = mercator_to_lnglat(vTexPos);\n uv = getUV(lnglat);\n } else if (coordinateConversion > 0.5) {\n vec2 commonPos = lnglat_to_mercator(vTexPos);\n uv = getUV(commonPos);\n }\n vec4 bitmapColor = texture2D(bitmapTexture, uv);\n\n gl_FragColor = apply_opacity(color_tint(color_desaturate(bitmapColor.rgb)), bitmapColor.a * opacity);\n\n geometry.uv = uv;\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n\n if (picking_uActive && !picking_uAttribute) {\n // Since instance information is not used, we can use picking color for pixel index\n gl_FragColor.rgb = packUVsIntoRGB(uv);\n }\n}\n"); + + // node_modules/@deck.gl/layers/dist/esm/bitmap-layer/bitmap-layer.js + var defaultProps3 = { + image: { + type: "image", + value: null, + async: true + }, + bounds: { + type: "array", + value: [1, 0, 0, 1], + compare: true + }, + _imageCoordinateSystem: COORDINATE_SYSTEM.DEFAULT, + desaturate: { + type: "number", + min: 0, + max: 1, + value: 0 + }, + transparentColor: { + type: "color", + value: [0, 0, 0, 0] + }, + tintColor: { + type: "color", + value: [255, 255, 255] + }, + textureParameters: { + type: "object", + ignore: true } - setProps(props) { - if (this.layerFilter !== props.layerFilter) { - this.layerFilter = props.layerFilter; - this._needsRedraw = "layerFilter changed"; + }; + var BitmapLayer = class extends Layer { + constructor(...args) { + super(...args); + _defineProperty(this, "state", void 0); + } + getShaders() { + return super.getShaders({ + vs: bitmap_layer_vertex_default, + fs: bitmap_layer_fragment_default, + modules: [project32_default, picking_default] + }); + } + initializeState() { + const attributeManager = this.getAttributeManager(); + attributeManager.remove(["instancePickingColors"]); + const noAlloc = true; + attributeManager.add({ + indices: { + size: 1, + isIndexed: true, + update: (attribute) => attribute.value = this.state.mesh.indices, + noAlloc + }, + positions: { + size: 3, + type: 5130, + fp64: this.use64bitPositions(), + update: (attribute) => attribute.value = this.state.mesh.positions, + noAlloc + }, + texCoords: { + size: 2, + update: (attribute) => attribute.value = this.state.mesh.texCoords, + noAlloc + } + }); + } + updateState({ + props, + oldProps, + changeFlags + }) { + const attributeManager = this.getAttributeManager(); + if (changeFlags.extensionsChanged) { + var _this$state$model; + const { + gl + } = this.context; + (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); + this.state.model = this._getModel(gl); + attributeManager.invalidateAll(); } - if (this.drawPickingColors !== props.drawPickingColors) { - this.drawPickingColors = props.drawPickingColors; - this._needsRedraw = "drawPickingColors changed"; + if (props.bounds !== oldProps.bounds) { + const oldMesh = this.state.mesh; + const mesh = this._createMesh(); + this.state.model.setVertexCount(mesh.vertexCount); + for (const key in mesh) { + if (oldMesh && oldMesh[key] !== mesh[key]) { + attributeManager.invalidate(key); + } + } + this.setState({ + mesh, + ...this._getCoordinateUniforms() + }); + } else if (props._imageCoordinateSystem !== oldProps._imageCoordinateSystem) { + this.setState(this._getCoordinateUniforms()); } } - renderLayers(opts) { - if (!opts.viewports.length) { + getPickingInfo(params) { + const { + image + } = this.props; + const info = params.info; + if (!info.color || !image) { + info.bitmap = null; + return info; + } + const { + width, + height + } = image; + info.index = 0; + const uv = unpackUVsFromRGB(info.color); + const pixel = [Math.floor(uv[0] * width), Math.floor(uv[1] * height)]; + info.bitmap = { + size: { + width, + height + }, + uv, + pixel + }; + return info; + } + disablePickingIndex() { + this.setState({ + disablePicking: true + }); + } + restorePickingColors() { + this.setState({ + disablePicking: false + }); + } + _updateAutoHighlight(info) { + super._updateAutoHighlight({ + ...info, + color: this.encodePickingColor(0) + }); + } + _createMesh() { + const { + bounds + } = this.props; + let normalizedBounds = bounds; + if (isRectangularBounds(bounds)) { + normalizedBounds = [[bounds[0], bounds[1]], [bounds[0], bounds[3]], [bounds[2], bounds[3]], [bounds[2], bounds[1]]]; + } + return createMesh(normalizedBounds, this.context.viewport.resolution); + } + _getModel(gl) { + if (!gl) { + return null; + } + return new Model(gl, { + ...this.getShaders(), + id: this.props.id, + geometry: new Geometry({ + drawMode: 4, + vertexCount: 6 + }), + isInstanced: false + }); + } + draw(opts) { + const { + uniforms, + moduleParameters + } = opts; + const { + model, + coordinateConversion, + bounds, + disablePicking + } = this.state; + const { + image, + desaturate, + transparentColor, + tintColor + } = this.props; + if (moduleParameters.pickingActive && disablePicking) { return; } - const layerPass = this.drawPickingColors ? this.pickLayersPass : this.drawLayersPass; - const renderOpts = { - layerFilter: this.layerFilter, - isPicking: this.drawPickingColors, - ...opts, - target: opts.target || Framebuffer.getDefaultFramebuffer(this.gl) + if (image && model) { + model.setUniforms(uniforms).setUniforms({ + bitmapTexture: image, + desaturate, + transparentColor: transparentColor.map((x2) => x2 / 255), + tintColor: tintColor.slice(0, 3).map((x2) => x2 / 255), + coordinateConversion, + bounds + }).draw(); + } + } + _getCoordinateUniforms() { + const { + LNGLAT, + CARTESIAN, + DEFAULT + } = COORDINATE_SYSTEM; + let { + _imageCoordinateSystem: imageCoordinateSystem + } = this.props; + if (imageCoordinateSystem !== DEFAULT) { + const { + bounds + } = this.props; + if (!isRectangularBounds(bounds)) { + throw new Error("_imageCoordinateSystem only supports rectangular bounds"); + } + const defaultImageCoordinateSystem = this.context.viewport.resolution ? LNGLAT : CARTESIAN; + imageCoordinateSystem = imageCoordinateSystem === LNGLAT ? LNGLAT : CARTESIAN; + if (imageCoordinateSystem === LNGLAT && defaultImageCoordinateSystem === CARTESIAN) { + return { + coordinateConversion: -1, + bounds + }; + } + if (imageCoordinateSystem === CARTESIAN && defaultImageCoordinateSystem === LNGLAT) { + const bottomLeft = lngLatToWorld([bounds[0], bounds[1]]); + const topRight = lngLatToWorld([bounds[2], bounds[3]]); + return { + coordinateConversion: 1, + bounds: [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]] + }; + } + } + return { + coordinateConversion: 0, + bounds: [0, 0, 0, 0] + }; + } + }; + _defineProperty(BitmapLayer, "layerName", "BitmapLayer"); + _defineProperty(BitmapLayer, "defaultProps", defaultProps3); + function unpackUVsFromRGB(color) { + const [u2, v2, fracUV] = color; + const vFrac = (fracUV & 240) / 256; + const uFrac = (fracUV & 15) / 16; + return [(u2 + uFrac) / 256, (v2 + vFrac) / 256]; + } + function isRectangularBounds(bounds) { + return Number.isFinite(bounds[0]); + } + + // node_modules/@deck.gl/layers/dist/esm/icon-layer/icon-layer-vertex.glsl.js + var icon_layer_vertex_glsl_default = "#define SHADER_NAME icon-layer-vertex-shader\n\nattribute vec2 positions;\n\nattribute vec3 instancePositions;\nattribute vec3 instancePositions64Low;\nattribute float instanceSizes;\nattribute float instanceAngles;\nattribute vec4 instanceColors;\nattribute vec3 instancePickingColors;\nattribute vec4 instanceIconFrames;\nattribute float instanceColorModes;\nattribute vec2 instanceOffsets;\nattribute vec2 instancePixelOffset;\n\nuniform float sizeScale;\nuniform vec2 iconsTextureDim;\nuniform float sizeMinPixels;\nuniform float sizeMaxPixels;\nuniform bool billboard;\nuniform int sizeUnits;\n\nvarying float vColorMode;\nvarying vec4 vColor;\nvarying vec2 vTextureCoords;\nvarying vec2 uv;\n\nvec2 rotate_by_angle(vec2 vertex, float angle) {\n float angle_radian = angle * PI / 180.0;\n float cos_angle = cos(angle_radian);\n float sin_angle = sin(angle_radian);\n mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle);\n return rotationMatrix * vertex;\n}\n\nvoid main(void) {\n geometry.worldPosition = instancePositions;\n geometry.uv = positions;\n geometry.pickingColor = instancePickingColors;\n uv = positions;\n\n vec2 iconSize = instanceIconFrames.zw;\n float sizePixels = clamp(\n project_size_to_pixel(instanceSizes * sizeScale, sizeUnits), \n sizeMinPixels, sizeMaxPixels\n );\n float instanceScale = iconSize.y == 0.0 ? 0.0 : sizePixels / iconSize.y;\n vec2 pixelOffset = positions / 2.0 * iconSize + instanceOffsets;\n pixelOffset = rotate_by_angle(pixelOffset, instanceAngles) * instanceScale;\n pixelOffset += instancePixelOffset;\n pixelOffset.y *= -1.0;\n\n if (billboard) {\n gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n vec3 offset = vec3(pixelOffset, 0.0);\n DECKGL_FILTER_SIZE(offset, geometry);\n gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);\n\n } else {\n vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0);\n DECKGL_FILTER_SIZE(offset_common, geometry);\n gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position); \n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n }\n\n vTextureCoords = mix(\n instanceIconFrames.xy,\n instanceIconFrames.xy + iconSize,\n (positions.xy + 1.0) / 2.0\n ) / iconsTextureDim;\n\n vColor = instanceColors;\n DECKGL_FILTER_COLOR(vColor, geometry);\n\n vColorMode = instanceColorModes;\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/icon-layer/icon-layer-fragment.glsl.js + var icon_layer_fragment_glsl_default = "#define SHADER_NAME icon-layer-fragment-shader\n\nprecision highp float;\n\nuniform float opacity;\nuniform sampler2D iconsTexture;\nuniform float alphaCutoff;\n\nvarying float vColorMode;\nvarying vec4 vColor;\nvarying vec2 vTextureCoords;\nvarying vec2 uv;\n\nvoid main(void) {\n geometry.uv = uv;\n\n vec4 texColor = texture2D(iconsTexture, vTextureCoords);\n vec3 color = mix(texColor.rgb, vColor.rgb, vColorMode);\n float a = texColor.a * opacity * vColor.a;\n\n if (a < alphaCutoff) {\n discard;\n }\n\n gl_FragColor = vec4(color, a);\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/icon-layer/icon-manager.js + var DEFAULT_CANVAS_WIDTH = 1024; + var DEFAULT_BUFFER = 4; + var noop5 = () => { + }; + var DEFAULT_TEXTURE_PARAMETERS2 = { + [10241]: 9987, + [10240]: 9729, + [10242]: 33071, + [10243]: 33071 + }; + function nextPowOfTwo(number) { + return Math.pow(2, Math.ceil(Math.log2(number))); + } + function resizeImage(ctx, imageData, maxWidth, maxHeight) { + const resizeRatio = Math.min(maxWidth / imageData.width, maxHeight / imageData.height); + const width = Math.floor(imageData.width * resizeRatio); + const height = Math.floor(imageData.height * resizeRatio); + if (resizeRatio === 1) { + return { + data: imageData, + width, + height + }; + } + ctx.canvas.height = height; + ctx.canvas.width = width; + ctx.clearRect(0, 0, width, height); + ctx.drawImage(imageData, 0, 0, imageData.width, imageData.height, 0, 0, width, height); + return { + data: ctx.canvas, + width, + height + }; + } + function getIconId(icon) { + return icon && (icon.id || icon.url); + } + function resizeTexture(texture, width, height, parameters) { + const oldWidth = texture.width; + const oldHeight = texture.height; + const newTexture = new Texture2D(texture.gl, { + width, + height, + parameters + }); + copyToTexture(texture, newTexture, { + targetY: 0, + width: oldWidth, + height: oldHeight + }); + texture.delete(); + return newTexture; + } + function buildRowMapping(mapping, columns, yOffset) { + for (let i3 = 0; i3 < columns.length; i3++) { + const { + icon, + xOffset + } = columns[i3]; + const id = getIconId(icon); + mapping[id] = { + ...icon, + x: xOffset, + y: yOffset }; - if (renderOpts.effects) { - this._preRender(renderOpts.effects, renderOpts); + } + } + function buildMapping({ + icons, + buffer, + mapping = {}, + xOffset = 0, + yOffset = 0, + rowHeight = 0, + canvasWidth + }) { + let columns = []; + for (let i3 = 0; i3 < icons.length; i3++) { + const icon = icons[i3]; + const id = getIconId(icon); + if (!mapping[id]) { + const { + height, + width + } = icon; + if (xOffset + width + buffer > canvasWidth) { + buildRowMapping(mapping, columns, yOffset); + xOffset = 0; + yOffset = rowHeight + yOffset + buffer; + rowHeight = 0; + columns = []; + } + columns.push({ + icon, + xOffset + }); + xOffset = xOffset + width + buffer; + rowHeight = Math.max(rowHeight, height); } - const outputBuffer = this.lastPostProcessEffect ? this.renderBuffers[0] : renderOpts.target; - const renderStats = layerPass.render({ - ...renderOpts, - target: outputBuffer - }); - if (renderOpts.effects) { - this._postRender(renderOpts.effects, renderOpts); + } + if (columns.length > 0) { + buildRowMapping(mapping, columns, yOffset); + } + return { + mapping, + rowHeight, + xOffset, + yOffset, + canvasWidth, + canvasHeight: nextPowOfTwo(rowHeight + yOffset + buffer) + }; + } + function getDiffIcons(data, getIcon, cachedIcons) { + if (!data || !getIcon) { + return null; + } + cachedIcons = cachedIcons || {}; + const icons = {}; + const { + iterable, + objectInfo + } = createIterable(data); + for (const object of iterable) { + objectInfo.index++; + const icon = getIcon(object, objectInfo); + const id = getIconId(icon); + if (!icon) { + throw new Error("Icon is missing."); + } + if (!icon.url) { + throw new Error("Icon url is missing."); + } + if (!icons[id] && (!cachedIcons[id] || icon.url !== cachedIcons[id].url)) { + icons[id] = { + ...icon, + source: object, + sourceIndex: objectInfo.index + }; } - this.renderCount++; - debug(TRACE_RENDER_LAYERS, this, renderStats, opts); } - needsRedraw(opts = { - clearRedrawFlags: false + return icons; + } + var IconManager = class { + constructor(gl, { + onUpdate = noop5, + onError = noop5 }) { - const redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; - } - return redraw; + _defineProperty(this, "gl", void 0); + _defineProperty(this, "onUpdate", void 0); + _defineProperty(this, "onError", void 0); + _defineProperty(this, "_loadOptions", null); + _defineProperty(this, "_texture", null); + _defineProperty(this, "_externalTexture", null); + _defineProperty(this, "_mapping", {}); + _defineProperty(this, "_textureParameters", null); + _defineProperty(this, "_pendingCount", 0); + _defineProperty(this, "_autoPacking", false); + _defineProperty(this, "_xOffset", 0); + _defineProperty(this, "_yOffset", 0); + _defineProperty(this, "_rowHeight", 0); + _defineProperty(this, "_buffer", DEFAULT_BUFFER); + _defineProperty(this, "_canvasWidth", DEFAULT_CANVAS_WIDTH); + _defineProperty(this, "_canvasHeight", 0); + _defineProperty(this, "_canvas", null); + this.gl = gl; + this.onUpdate = onUpdate; + this.onError = onError; } finalize() { - const { - renderBuffers - } = this; - for (const buffer of renderBuffers) { - buffer.delete(); + var _this$_texture; + (_this$_texture = this._texture) === null || _this$_texture === void 0 ? void 0 : _this$_texture.delete(); + } + getTexture() { + return this._texture || this._externalTexture; + } + getIconMapping(icon) { + const id = this._autoPacking ? getIconId(icon) : icon; + return this._mapping[id] || {}; + } + setProps({ + loadOptions, + autoPacking, + iconAtlas, + iconMapping, + textureParameters + }) { + if (loadOptions) { + this._loadOptions = loadOptions; } - renderBuffers.length = 0; - } - _preRender(effects, opts) { - this.lastPostProcessEffect = null; - opts.preRenderStats = opts.preRenderStats || {}; - for (const effect of effects) { - opts.preRenderStats[effect.id] = effect.preRender(this.gl, opts); - if (effect.postRender) { - this.lastPostProcessEffect = effect.id; - } + if (autoPacking !== void 0) { + this._autoPacking = autoPacking; } - if (this.lastPostProcessEffect) { - this._resizeRenderBuffers(); + if (iconMapping) { + this._mapping = iconMapping; } - } - _resizeRenderBuffers() { - const { - renderBuffers - } = this; - if (renderBuffers.length === 0) { - renderBuffers.push(new Framebuffer(this.gl), new Framebuffer(this.gl)); + if (iconAtlas) { + var _this$_texture2; + (_this$_texture2 = this._texture) === null || _this$_texture2 === void 0 ? void 0 : _this$_texture2.delete(); + this._texture = null; + this._externalTexture = iconAtlas; } - for (const buffer of renderBuffers) { - buffer.resize(); + if (textureParameters) { + this._textureParameters = textureParameters; } } - _postRender(effects, opts) { - const { - renderBuffers - } = this; - const params = { - ...opts, - inputBuffer: renderBuffers[0], - swapBuffer: renderBuffers[1], - target: null - }; - for (const effect of effects) { - if (effect.postRender) { - if (effect.id === this.lastPostProcessEffect) { - params.target = opts.target; - effect.postRender(this.gl, params); - break; - } - const buffer = effect.postRender(this.gl, params); - params.inputBuffer = buffer; - params.swapBuffer = buffer === renderBuffers[0] ? renderBuffers[1] : renderBuffers[0]; + get isLoaded() { + return this._pendingCount === 0; + } + packIcons(data, getIcon) { + if (!this._autoPacking || typeof document === "undefined") { + return; + } + const icons = Object.values(getDiffIcons(data, getIcon, this._mapping) || {}); + if (icons.length > 0) { + const { + mapping, + xOffset, + yOffset, + rowHeight, + canvasHeight + } = buildMapping({ + icons, + buffer: this._buffer, + canvasWidth: this._canvasWidth, + mapping: this._mapping, + rowHeight: this._rowHeight, + xOffset: this._xOffset, + yOffset: this._yOffset + }); + this._rowHeight = rowHeight; + this._mapping = mapping; + this._xOffset = xOffset; + this._yOffset = yOffset; + this._canvasHeight = canvasHeight; + if (!this._texture) { + this._texture = new Texture2D(this.gl, { + width: this._canvasWidth, + height: this._canvasHeight, + parameters: this._textureParameters || DEFAULT_TEXTURE_PARAMETERS2 + }); } + if (this._texture.height !== this._canvasHeight) { + this._texture = resizeTexture(this._texture, this._canvasWidth, this._canvasHeight, this._textureParameters || DEFAULT_TEXTURE_PARAMETERS2); + } + this.onUpdate(); + this._canvas = this._canvas || document.createElement("canvas"); + this._loadIcons(icons); + } + } + _loadIcons(icons) { + const ctx = this._canvas.getContext("2d", { + willReadFrequently: true + }); + for (const icon of icons) { + this._pendingCount++; + load(icon.url, this._loadOptions).then((imageData) => { + const id = getIconId(icon); + const iconDef = this._mapping[id]; + const { + x: x2, + y: y2, + width: maxWidth, + height: maxHeight + } = iconDef; + const { + data, + width, + height + } = resizeImage(ctx, imageData, maxWidth, maxHeight); + this._texture.setSubImageData({ + data, + x: x2 + (maxWidth - width) / 2, + y: y2 + (maxHeight - height) / 2, + width, + height + }); + iconDef.width = width; + iconDef.height = height; + this._texture.generateMipmap(); + this.onUpdate(); + }).catch((error2) => { + this.onError({ + url: icon.url, + source: icon.source, + sourceIndex: icon.sourceIndex, + loadOptions: this._loadOptions, + error: error2 + }); + }).finally(() => { + this._pendingCount--; + }); } } }; - // node_modules/@deck.gl/core/dist/esm/lib/picking/query-object.js - var NO_PICKED_OBJECT = { - pickedColor: null, - pickedObjectIndex: -1 + // node_modules/@deck.gl/layers/dist/esm/icon-layer/icon-layer.js + var DEFAULT_COLOR = [0, 0, 0, 255]; + var defaultProps4 = { + iconAtlas: { + type: "image", + value: null, + async: true + }, + iconMapping: { + type: "object", + value: {}, + async: true + }, + sizeScale: { + type: "number", + value: 1, + min: 0 + }, + billboard: true, + sizeUnits: "pixels", + sizeMinPixels: { + type: "number", + min: 0, + value: 0 + }, + sizeMaxPixels: { + type: "number", + min: 0, + value: Number.MAX_SAFE_INTEGER + }, + alphaCutoff: { + type: "number", + value: 0.05, + min: 0, + max: 1 + }, + getPosition: { + type: "accessor", + value: (x2) => x2.position + }, + getIcon: { + type: "accessor", + value: (x2) => x2.icon + }, + getColor: { + type: "accessor", + value: DEFAULT_COLOR + }, + getSize: { + type: "accessor", + value: 1 + }, + getAngle: { + type: "accessor", + value: 0 + }, + getPixelOffset: { + type: "accessor", + value: [0, 0] + }, + onIconError: { + type: "function", + value: null, + optional: true + }, + textureParameters: { + type: "object", + ignore: true + } }; - function getClosestObject({ - pickedColors, - decodePickingColor, - deviceX, - deviceY, - deviceRadius, - deviceRect - }) { - const { - x: x2, - y: y2, - width, - height - } = deviceRect; - let minSquareDistanceToCenter = deviceRadius * deviceRadius; - let closestPixelIndex = -1; - let i2 = 0; - for (let row = 0; row < height; row++) { - const dy = row + y2 - deviceY; - const dy2 = dy * dy; - if (dy2 > minSquareDistanceToCenter) { - i2 += 4 * width; - } else { - for (let col = 0; col < width; col++) { - const pickedLayerIndex = pickedColors[i2 + 3] - 1; - if (pickedLayerIndex >= 0) { - const dx = col + x2 - deviceX; - const d2 = dx * dx + dy2; - if (d2 <= minSquareDistanceToCenter) { - minSquareDistanceToCenter = d2; - closestPixelIndex = i2; - } - } - i2 += 4; + var IconLayer = class extends Layer { + constructor(...args) { + super(...args); + _defineProperty(this, "state", void 0); + } + getShaders() { + return super.getShaders({ + vs: icon_layer_vertex_glsl_default, + fs: icon_layer_fragment_glsl_default, + modules: [project32_default, picking_default] + }); + } + initializeState() { + this.state = { + iconManager: new IconManager(this.context.gl, { + onUpdate: this._onUpdate.bind(this), + onError: this._onError.bind(this) + }) + }; + const attributeManager = this.getAttributeManager(); + attributeManager.addInstanced({ + instancePositions: { + size: 3, + type: 5130, + fp64: this.use64bitPositions(), + transition: true, + accessor: "getPosition" + }, + instanceSizes: { + size: 1, + transition: true, + accessor: "getSize", + defaultValue: 1 + }, + instanceOffsets: { + size: 2, + accessor: "getIcon", + transform: this.getInstanceOffset + }, + instanceIconFrames: { + size: 4, + accessor: "getIcon", + transform: this.getInstanceIconFrame + }, + instanceColorModes: { + size: 1, + type: 5121, + accessor: "getIcon", + transform: this.getInstanceColorMode + }, + instanceColors: { + size: this.props.colorFormat.length, + type: 5121, + normalized: true, + transition: true, + accessor: "getColor", + defaultValue: DEFAULT_COLOR + }, + instanceAngles: { + size: 1, + transition: true, + accessor: "getAngle" + }, + instancePixelOffset: { + size: 2, + transition: true, + accessor: "getPixelOffset" + } + }); + } + updateState(params) { + super.updateState(params); + const { + props, + oldProps, + changeFlags + } = params; + const attributeManager = this.getAttributeManager(); + const { + iconAtlas, + iconMapping, + data, + getIcon, + textureParameters + } = props; + const { + iconManager + } = this.state; + const prePacked = iconAtlas || this.internalState.isAsyncPropLoading("iconAtlas"); + iconManager.setProps({ + loadOptions: props.loadOptions, + autoPacking: !prePacked, + iconAtlas, + iconMapping: prePacked ? iconMapping : null, + textureParameters + }); + if (prePacked) { + if (oldProps.iconMapping !== props.iconMapping) { + attributeManager.invalidate("getIcon"); } + } else if (changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getIcon)) { + iconManager.packIcons(data, getIcon); + } + if (changeFlags.extensionsChanged) { + var _this$state$model; + const { + gl + } = this.context; + (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); + this.state.model = this._getModel(gl); + attributeManager.invalidateAll(); } } - if (closestPixelIndex >= 0) { - const pickedColor = pickedColors.slice(closestPixelIndex, closestPixelIndex + 4); - const pickedObject = decodePickingColor(pickedColor); - if (pickedObject) { - const dy = Math.floor(closestPixelIndex / 4 / width); - const dx = closestPixelIndex / 4 - dy * width; - return { - ...pickedObject, - pickedColor, - pickedX: x2 + dx, - pickedY: y2 + dy - }; + get isLoaded() { + return super.isLoaded && this.state.iconManager.isLoaded; + } + finalizeState(context) { + super.finalizeState(context); + this.state.iconManager.finalize(); + } + draw({ + uniforms + }) { + const { + sizeScale, + sizeMinPixels, + sizeMaxPixels, + sizeUnits, + billboard, + alphaCutoff + } = this.props; + const { + iconManager + } = this.state; + const iconsTexture = iconManager.getTexture(); + if (iconsTexture) { + this.state.model.setUniforms(uniforms).setUniforms({ + iconsTexture, + iconsTextureDim: [iconsTexture.width, iconsTexture.height], + sizeUnits: UNIT[sizeUnits], + sizeScale, + sizeMinPixels, + sizeMaxPixels, + billboard, + alphaCutoff + }).draw(); } - log_default.error("Picked non-existent layer. Is picking buffer corrupt?")(); } - return NO_PICKED_OBJECT; - } - function getUniqueObjects({ - pickedColors, - decodePickingColor - }) { - const uniqueColors = /* @__PURE__ */ new Map(); - if (pickedColors) { - for (let i2 = 0; i2 < pickedColors.length; i2 += 4) { - const pickedLayerIndex = pickedColors[i2 + 3] - 1; - if (pickedLayerIndex >= 0) { - const pickedColor = pickedColors.slice(i2, i2 + 4); - const colorKey = pickedColor.join(","); - if (!uniqueColors.has(colorKey)) { - const pickedObject = decodePickingColor(pickedColor); - if (pickedObject) { - uniqueColors.set(colorKey, { - ...pickedObject, - color: pickedColor - }); - } else { - log_default.error("Picked non-existent layer. Is picking buffer corrupt?")(); + _getModel(gl) { + const positions = [-1, -1, -1, 1, 1, 1, 1, -1]; + return new Model(gl, { + ...this.getShaders(), + id: this.props.id, + geometry: new Geometry({ + drawMode: 6, + attributes: { + positions: { + size: 2, + value: new Float32Array(positions) } } - } + }), + isInstanced: true + }); + } + _onUpdate() { + this.setNeedsRedraw(); + } + _onError(evt) { + var _this$getCurrentLayer; + const onIconError = (_this$getCurrentLayer = this.getCurrentLayer()) === null || _this$getCurrentLayer === void 0 ? void 0 : _this$getCurrentLayer.props.onIconError; + if (onIconError) { + onIconError(evt); + } else { + log_default.error(evt.error.message)(); } } - return Array.from(uniqueColors.values()); - } - - // node_modules/@deck.gl/core/dist/esm/lib/picking/pick-info.js - function getEmptyPickingInfo({ - pickInfo, - viewports, - pixelRatio, - x: x2, - y: y2, - z - }) { - let pickedViewport = viewports[0]; - if (viewports.length > 1) { - pickedViewport = getViewportFromCoordinates((pickInfo === null || pickInfo === void 0 ? void 0 : pickInfo.pickedViewports) || viewports, { + getInstanceOffset(icon) { + const { + width, + height, + anchorX = width / 2, + anchorY = height / 2 + } = this.state.iconManager.getIconMapping(icon); + return [width / 2 - anchorX, height / 2 - anchorY]; + } + getInstanceColorMode(icon) { + const mapping = this.state.iconManager.getIconMapping(icon); + return mapping.mask ? 1 : 0; + } + getInstanceIconFrame(icon) { + const { x: x2, - y: y2 + y: y2, + width, + height + } = this.state.iconManager.getIconMapping(icon); + return [x2, y2, width, height]; + } + }; + _defineProperty(IconLayer, "defaultProps", defaultProps4); + _defineProperty(IconLayer, "layerName", "IconLayer"); + + // node_modules/@deck.gl/layers/dist/esm/line-layer/line-layer-vertex.glsl.js + var line_layer_vertex_glsl_default = "#define SHADER_NAME line-layer-vertex-shader\n\nattribute vec3 positions;\nattribute vec3 instanceSourcePositions;\nattribute vec3 instanceTargetPositions;\nattribute vec3 instanceSourcePositions64Low;\nattribute vec3 instanceTargetPositions64Low;\nattribute vec4 instanceColors;\nattribute vec3 instancePickingColors;\nattribute float instanceWidths;\n\nuniform float opacity;\nuniform float widthScale;\nuniform float widthMinPixels;\nuniform float widthMaxPixels;\nuniform float useShortestPath;\nuniform int widthUnits;\n\nvarying vec4 vColor;\nvarying vec2 uv;\nvec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction, float width) {\n vec2 dir_screenspace = normalize(line_clipspace * project_uViewportSize);\n dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n\n return dir_screenspace * offset_direction * width / 2.0;\n}\n\nvec3 splitLine(vec3 a, vec3 b, float x) {\n float t = (x - a.x) / (b.x - a.x);\n return vec3(x, mix(a.yz, b.yz, t));\n}\n\nvoid main(void) {\n geometry.worldPosition = instanceSourcePositions;\n geometry.worldPositionAlt = instanceTargetPositions;\n\n vec3 source_world = instanceSourcePositions;\n vec3 target_world = instanceTargetPositions;\n vec3 source_world_64low = instanceSourcePositions64Low;\n vec3 target_world_64low = instanceTargetPositions64Low;\n\n if (useShortestPath > 0.5 || useShortestPath < -0.5) {\n source_world.x = mod(source_world.x + 180., 360.0) - 180.;\n target_world.x = mod(target_world.x + 180., 360.0) - 180.;\n float deltaLng = target_world.x - source_world.x;\n\n if (deltaLng * useShortestPath > 180.) {\n source_world.x += 360. * useShortestPath;\n source_world = splitLine(source_world, target_world, 180. * useShortestPath);\n source_world_64low = vec3(0.0);\n } else if (deltaLng * useShortestPath < -180.) {\n target_world.x += 360. * useShortestPath;\n target_world = splitLine(source_world, target_world, 180. * useShortestPath);\n target_world_64low = vec3(0.0);\n } else if (useShortestPath < 0.) {\n gl_Position = vec4(0.);\n return;\n }\n }\n vec4 source_commonspace;\n vec4 target_commonspace;\n vec4 source = project_position_to_clipspace(source_world, source_world_64low, vec3(0.), source_commonspace);\n vec4 target = project_position_to_clipspace(target_world, target_world_64low, vec3(0.), target_commonspace);\n float segmentIndex = positions.x;\n vec4 p = mix(source, target, segmentIndex);\n geometry.position = mix(source_commonspace, target_commonspace, segmentIndex);\n uv = positions.xy;\n geometry.uv = uv;\n geometry.pickingColor = instancePickingColors;\n float widthPixels = clamp(\n project_size_to_pixel(instanceWidths * widthScale, widthUnits),\n widthMinPixels, widthMaxPixels\n );\n vec3 offset = vec3(\n getExtrusionOffset(target.xy - source.xy, positions.y, widthPixels),\n 0.0);\n DECKGL_FILTER_SIZE(offset, geometry);\n DECKGL_FILTER_GL_POSITION(p, geometry);\n gl_Position = p + vec4(project_pixel_size_to_clipspace(offset.xy), 0.0, 0.0);\n vColor = vec4(instanceColors.rgb, instanceColors.a * opacity);\n DECKGL_FILTER_COLOR(vColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/line-layer/line-layer-fragment.glsl.js + var line_layer_fragment_glsl_default = "#define SHADER_NAME line-layer-fragment-shader\n\nprecision highp float;\n\nvarying vec4 vColor;\nvarying vec2 uv;\n\nvoid main(void) {\n geometry.uv = uv;\n\n gl_FragColor = vColor;\n\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/line-layer/line-layer.js + var DEFAULT_COLOR2 = [0, 0, 0, 255]; + var defaultProps5 = { + getSourcePosition: { + type: "accessor", + value: (x2) => x2.sourcePosition + }, + getTargetPosition: { + type: "accessor", + value: (x2) => x2.targetPosition + }, + getColor: { + type: "accessor", + value: DEFAULT_COLOR2 + }, + getWidth: { + type: "accessor", + value: 1 + }, + widthUnits: "pixels", + widthScale: { + type: "number", + value: 1, + min: 0 + }, + widthMinPixels: { + type: "number", + value: 0, + min: 0 + }, + widthMaxPixels: { + type: "number", + value: Number.MAX_SAFE_INTEGER, + min: 0 + } + }; + var LineLayer = class extends Layer { + getBounds() { + var _this$getAttributeMan; + return (_this$getAttributeMan = this.getAttributeManager()) === null || _this$getAttributeMan === void 0 ? void 0 : _this$getAttributeMan.getBounds(["instanceSourcePositions", "instanceTargetPositions"]); + } + getShaders() { + return super.getShaders({ + vs: line_layer_vertex_glsl_default, + fs: line_layer_fragment_glsl_default, + modules: [project32_default, picking_default] }); } - let coordinate; - if (pickedViewport) { - const point = [x2 - pickedViewport.x, y2 - pickedViewport.y]; - if (z !== void 0) { - point[2] = z; - } - coordinate = pickedViewport.unproject(point); + get wrapLongitude() { + return false; } - return { - color: null, - layer: null, - viewport: pickedViewport, - index: -1, - picked: false, - x: x2, - y: y2, - pixel: [x2, y2], - coordinate, - devicePixel: pickInfo && "pickedX" in pickInfo ? [pickInfo.pickedX, pickInfo.pickedY] : void 0, - pixelRatio - }; - } - function processPickInfo(opts) { - const { - pickInfo, - lastPickedInfo, - mode, - layers - } = opts; - const { - pickedColor, - pickedLayer, - pickedObjectIndex - } = pickInfo; - const affectedLayers = pickedLayer ? [pickedLayer] : []; - if (mode === "hover") { - const lastPickedPixelIndex = lastPickedInfo.index; - const lastPickedLayerId = lastPickedInfo.layerId; - const pickedLayerId = pickedLayer ? pickedLayer.props.id : null; - if (pickedLayerId !== lastPickedLayerId || pickedObjectIndex !== lastPickedPixelIndex) { - if (pickedLayerId !== lastPickedLayerId) { - const lastPickedLayer = layers.find((layer) => layer.props.id === lastPickedLayerId); - if (lastPickedLayer) { - affectedLayers.unshift(lastPickedLayer); - } + initializeState() { + const attributeManager = this.getAttributeManager(); + attributeManager.addInstanced({ + instanceSourcePositions: { + size: 3, + type: 5130, + fp64: this.use64bitPositions(), + transition: true, + accessor: "getSourcePosition" + }, + instanceTargetPositions: { + size: 3, + type: 5130, + fp64: this.use64bitPositions(), + transition: true, + accessor: "getTargetPosition" + }, + instanceColors: { + size: this.props.colorFormat.length, + type: 5121, + normalized: true, + transition: true, + accessor: "getColor", + defaultValue: [0, 0, 0, 255] + }, + instanceWidths: { + size: 1, + transition: true, + accessor: "getWidth", + defaultValue: 1 } - lastPickedInfo.layerId = pickedLayerId; - lastPickedInfo.index = pickedObjectIndex; - lastPickedInfo.info = null; - } - } - const baseInfo = getEmptyPickingInfo(opts); - const infos = /* @__PURE__ */ new Map(); - infos.set(null, baseInfo); - affectedLayers.forEach((layer) => { - let info = { - ...baseInfo - }; - if (layer === pickedLayer) { - info.color = pickedColor; - info.index = pickedObjectIndex; - info.picked = true; - } - info = getLayerPickingInfo({ - layer, - info, - mode }); - const rootLayer = info.layer; - if (layer === pickedLayer && mode === "hover") { - lastPickedInfo.info = info; + } + updateState(params) { + super.updateState(params); + if (params.changeFlags.extensionsChanged) { + var _this$state$model; + const { + gl + } = this.context; + (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); + this.state.model = this._getModel(gl); + this.getAttributeManager().invalidateAll(); } - infos.set(rootLayer.id, info); - if (mode === "hover") { - rootLayer.updateAutoHighlight(info); + } + draw({ + uniforms + }) { + const { + widthUnits, + widthScale, + widthMinPixels, + widthMaxPixels, + wrapLongitude + } = this.props; + this.state.model.setUniforms(uniforms).setUniforms({ + widthUnits: UNIT[widthUnits], + widthScale, + widthMinPixels, + widthMaxPixels, + useShortestPath: wrapLongitude ? 1 : 0 + }).draw(); + if (wrapLongitude) { + this.state.model.setUniforms({ + useShortestPath: -1 + }).draw(); } - }); - return infos; - } - function getLayerPickingInfo({ - layer, - info, - mode - }) { - while (layer && info) { - const sourceLayer = info.layer || null; - info.sourceLayer = sourceLayer; - info.layer = layer; - info = layer.getPickingInfo({ - info, - mode, - sourceLayer + } + _getModel(gl) { + const positions = [0, -1, 0, 0, 1, 0, 1, -1, 0, 1, 1, 0]; + return new Model(gl, { + ...this.getShaders(), + id: this.props.id, + geometry: new Geometry({ + drawMode: 5, + attributes: { + positions: new Float32Array(positions) + } + }), + isInstanced: true }); - layer = layer.parent; } - return info; - } - function getViewportFromCoordinates(viewports, pixel) { - for (let i2 = viewports.length - 1; i2 >= 0; i2--) { - const viewport = viewports[i2]; - if (viewport.containsPixel(pixel)) { - return viewport; - } + }; + _defineProperty(LineLayer, "layerName", "LineLayer"); + _defineProperty(LineLayer, "defaultProps", defaultProps5); + + // node_modules/@deck.gl/layers/dist/esm/point-cloud-layer/point-cloud-layer-vertex.glsl.js + var point_cloud_layer_vertex_glsl_default = "#define SHADER_NAME point-cloud-layer-vertex-shader\n\nattribute vec3 positions;\nattribute vec3 instanceNormals;\nattribute vec4 instanceColors;\nattribute vec3 instancePositions;\nattribute vec3 instancePositions64Low;\nattribute vec3 instancePickingColors;\n\nuniform float opacity;\nuniform float radiusPixels;\nuniform int sizeUnits;\n\nvarying vec4 vColor;\nvarying vec2 unitPosition;\n\nvoid main(void) {\n geometry.worldPosition = instancePositions;\n geometry.normal = project_normal(instanceNormals);\n unitPosition = positions.xy;\n geometry.uv = unitPosition;\n geometry.pickingColor = instancePickingColors;\n vec3 offset = vec3(positions.xy * project_size_to_pixel(radiusPixels, sizeUnits), 0.0);\n DECKGL_FILTER_SIZE(offset, geometry);\n\n gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.), geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);\n vec3 lightColor = lighting_getLightColor(instanceColors.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal);\n vColor = vec4(lightColor, instanceColors.a * opacity);\n DECKGL_FILTER_COLOR(vColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/point-cloud-layer/point-cloud-layer-fragment.glsl.js + var point_cloud_layer_fragment_glsl_default = "#define SHADER_NAME point-cloud-layer-fragment-shader\n\nprecision highp float;\n\nvarying vec4 vColor;\nvarying vec2 unitPosition;\n\nvoid main(void) {\n geometry.uv = unitPosition;\n\n float distToCenter = length(unitPosition);\n\n if (distToCenter > 1.0) {\n discard;\n }\n\n gl_FragColor = vColor;\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/point-cloud-layer/point-cloud-layer.js + var DEFAULT_COLOR3 = [0, 0, 0, 255]; + var DEFAULT_NORMAL = [0, 0, 1]; + var defaultProps6 = { + sizeUnits: "pixels", + pointSize: { + type: "number", + min: 0, + value: 10 + }, + getPosition: { + type: "accessor", + value: (x2) => x2.position + }, + getNormal: { + type: "accessor", + value: DEFAULT_NORMAL + }, + getColor: { + type: "accessor", + value: DEFAULT_COLOR3 + }, + material: true, + radiusPixels: { + deprecatedFor: "pointSize" + } + }; + function normalizeData(data) { + const { + header, + attributes + } = data; + if (!header || !attributes) { + return; + } + data.length = header.vertexCount; + if (attributes.POSITION) { + attributes.instancePositions = attributes.POSITION; + } + if (attributes.NORMAL) { + attributes.instanceNormals = attributes.NORMAL; + } + if (attributes.COLOR_0) { + attributes.instanceColors = attributes.COLOR_0; } - return viewports[0]; } - - // node_modules/@deck.gl/core/dist/esm/lib/deck-picker.js - var DeckPicker = class { - constructor(gl) { - _defineProperty(this, "gl", void 0); - _defineProperty(this, "pickingFBO", void 0); - _defineProperty(this, "depthFBO", void 0); - _defineProperty(this, "pickLayersPass", void 0); - _defineProperty(this, "layerFilter", void 0); - _defineProperty(this, "lastPickedInfo", void 0); - _defineProperty(this, "_pickable", true); - this.gl = gl; - this.pickLayersPass = new PickLayersPass(gl); - this.lastPickedInfo = { - index: -1, - layerId: null, - info: null - }; + var PointCloudLayer = class extends Layer { + getShaders() { + return super.getShaders({ + vs: point_cloud_layer_vertex_glsl_default, + fs: point_cloud_layer_fragment_glsl_default, + modules: [project32_default, gouraudLighting, picking_default] + }); } - setProps(props) { - if ("layerFilter" in props) { - this.layerFilter = props.layerFilter; - } - if ("_pickable" in props) { - this._pickable = props._pickable; - } + initializeState() { + this.getAttributeManager().addInstanced({ + instancePositions: { + size: 3, + type: 5130, + fp64: this.use64bitPositions(), + transition: true, + accessor: "getPosition" + }, + instanceNormals: { + size: 3, + transition: true, + accessor: "getNormal", + defaultValue: DEFAULT_NORMAL + }, + instanceColors: { + size: this.props.colorFormat.length, + type: 5121, + normalized: true, + transition: true, + accessor: "getColor", + defaultValue: DEFAULT_COLOR3 + } + }); } - finalize() { - if (this.pickingFBO) { - this.pickingFBO.delete(); + updateState(params) { + const { + changeFlags, + props + } = params; + super.updateState(params); + if (changeFlags.extensionsChanged) { + var _this$state$model; + const { + gl + } = this.context; + (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); + this.state.model = this._getModel(gl); + this.getAttributeManager().invalidateAll(); } - if (this.depthFBO) { - this.depthFBO.color.delete(); - this.depthFBO.delete(); + if (changeFlags.dataChanged) { + normalizeData(props.data); } } - pickObject(opts) { - return this._pickClosestObject(opts); + draw({ + uniforms + }) { + const { + pointSize, + sizeUnits + } = this.props; + this.state.model.setUniforms(uniforms).setUniforms({ + sizeUnits: UNIT[sizeUnits], + radiusPixels: pointSize + }).draw(); } - pickObjects(opts) { - return this._pickVisibleObjects(opts); + _getModel(gl) { + const positions = []; + for (let i3 = 0; i3 < 3; i3++) { + const angle2 = i3 / 3 * Math.PI * 2; + positions.push(Math.cos(angle2) * 2, Math.sin(angle2) * 2, 0); + } + return new Model(gl, { + ...this.getShaders(), + id: this.props.id, + geometry: new Geometry({ + drawMode: 4, + attributes: { + positions: new Float32Array(positions) + } + }), + isInstanced: true + }); } - getLastPickedObject({ - x: x2, - y: y2, - layers, - viewports - }, lastPickedInfo = this.lastPickedInfo.info) { - const lastPickedLayerId = lastPickedInfo && lastPickedInfo.layer && lastPickedInfo.layer.id; - const lastPickedViewportId = lastPickedInfo && lastPickedInfo.viewport && lastPickedInfo.viewport.id; - const layer = lastPickedLayerId ? layers.find((l2) => l2.id === lastPickedLayerId) : null; - const viewport = lastPickedViewportId && viewports.find((v2) => v2.id === lastPickedViewportId) || viewports[0]; - const coordinate = viewport && viewport.unproject([x2 - viewport.x, y2 - viewport.y]); - const info = { - x: x2, - y: y2, - viewport, - coordinate, - layer - }; - return { - ...lastPickedInfo, - ...info - }; + }; + _defineProperty(PointCloudLayer, "layerName", "PointCloudLayer"); + _defineProperty(PointCloudLayer, "defaultProps", defaultProps6); + + // node_modules/@deck.gl/layers/dist/esm/scatterplot-layer/scatterplot-layer-vertex.glsl.js + var scatterplot_layer_vertex_glsl_default = "#define SHADER_NAME scatterplot-layer-vertex-shader\n\nattribute vec3 positions;\n\nattribute vec3 instancePositions;\nattribute vec3 instancePositions64Low;\nattribute float instanceRadius;\nattribute float instanceLineWidths;\nattribute vec4 instanceFillColors;\nattribute vec4 instanceLineColors;\nattribute vec3 instancePickingColors;\n\nuniform float opacity;\nuniform float radiusScale;\nuniform float radiusMinPixels;\nuniform float radiusMaxPixels;\nuniform float lineWidthScale;\nuniform float lineWidthMinPixels;\nuniform float lineWidthMaxPixels;\nuniform float stroked;\nuniform bool filled;\nuniform bool antialiasing;\nuniform bool billboard;\nuniform int radiusUnits;\nuniform int lineWidthUnits;\n\nvarying vec4 vFillColor;\nvarying vec4 vLineColor;\nvarying vec2 unitPosition;\nvarying float innerUnitRadius;\nvarying float outerRadiusPixels;\n\n\nvoid main(void) {\n geometry.worldPosition = instancePositions;\n outerRadiusPixels = clamp(\n project_size_to_pixel(radiusScale * instanceRadius, radiusUnits),\n radiusMinPixels, radiusMaxPixels\n );\n float lineWidthPixels = clamp(\n project_size_to_pixel(lineWidthScale * instanceLineWidths, lineWidthUnits),\n lineWidthMinPixels, lineWidthMaxPixels\n );\n outerRadiusPixels += stroked * lineWidthPixels / 2.0;\n float edgePadding = antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0;\n unitPosition = edgePadding * positions.xy;\n geometry.uv = unitPosition;\n geometry.pickingColor = instancePickingColors;\n\n innerUnitRadius = 1.0 - stroked * lineWidthPixels / outerRadiusPixels;\n \n if (billboard) {\n gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n vec3 offset = edgePadding * positions * outerRadiusPixels;\n DECKGL_FILTER_SIZE(offset, geometry);\n gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);\n } else {\n vec3 offset = edgePadding * positions * project_pixel_size(outerRadiusPixels);\n DECKGL_FILTER_SIZE(offset, geometry);\n gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset, geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n }\n vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity);\n DECKGL_FILTER_COLOR(vFillColor, geometry);\n vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity);\n DECKGL_FILTER_COLOR(vLineColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/scatterplot-layer/scatterplot-layer-fragment.glsl.js + var scatterplot_layer_fragment_glsl_default = "#define SHADER_NAME scatterplot-layer-fragment-shader\n\nprecision highp float;\n\nuniform bool filled;\nuniform float stroked;\nuniform bool antialiasing;\n\nvarying vec4 vFillColor;\nvarying vec4 vLineColor;\nvarying vec2 unitPosition;\nvarying float innerUnitRadius;\nvarying float outerRadiusPixels;\n\nvoid main(void) {\n geometry.uv = unitPosition;\n\n float distToCenter = length(unitPosition) * outerRadiusPixels;\n float inCircle = antialiasing ? \n smoothedge(distToCenter, outerRadiusPixels) : \n step(distToCenter, outerRadiusPixels);\n\n if (inCircle == 0.0) {\n discard;\n }\n\n if (stroked > 0.5) {\n float isLine = antialiasing ? \n smoothedge(innerUnitRadius * outerRadiusPixels, distToCenter) :\n step(innerUnitRadius * outerRadiusPixels, distToCenter);\n\n if (filled) {\n gl_FragColor = mix(vFillColor, vLineColor, isLine);\n } else {\n if (isLine == 0.0) {\n discard;\n }\n gl_FragColor = vec4(vLineColor.rgb, vLineColor.a * isLine);\n }\n } else if (!filled) {\n discard;\n } else {\n gl_FragColor = vFillColor;\n }\n\n gl_FragColor.a *= inCircle;\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/scatterplot-layer/scatterplot-layer.js + var DEFAULT_COLOR4 = [0, 0, 0, 255]; + var defaultProps7 = { + radiusUnits: "meters", + radiusScale: { + type: "number", + min: 0, + value: 1 + }, + radiusMinPixels: { + type: "number", + min: 0, + value: 0 + }, + radiusMaxPixels: { + type: "number", + min: 0, + value: Number.MAX_SAFE_INTEGER + }, + lineWidthUnits: "meters", + lineWidthScale: { + type: "number", + min: 0, + value: 1 + }, + lineWidthMinPixels: { + type: "number", + min: 0, + value: 0 + }, + lineWidthMaxPixels: { + type: "number", + min: 0, + value: Number.MAX_SAFE_INTEGER + }, + stroked: false, + filled: true, + billboard: false, + antialiasing: true, + getPosition: { + type: "accessor", + value: (x2) => x2.position + }, + getRadius: { + type: "accessor", + value: 1 + }, + getFillColor: { + type: "accessor", + value: DEFAULT_COLOR4 + }, + getLineColor: { + type: "accessor", + value: DEFAULT_COLOR4 + }, + getLineWidth: { + type: "accessor", + value: 1 + }, + strokeWidth: { + deprecatedFor: "getLineWidth" + }, + outline: { + deprecatedFor: "stroked" + }, + getColor: { + deprecatedFor: ["getFillColor", "getLineColor"] } - _resizeBuffer() { - var _this$pickingFBO, _this$depthFBO; - const { - gl - } = this; - if (!this.pickingFBO) { - this.pickingFBO = new Framebuffer(gl); - if (Framebuffer.isSupported(gl, { - colorBufferFloat: true - })) { - const depthFBO = new Framebuffer(gl); - depthFBO.attach({ - [36064]: new Texture2D(gl, { - format: isWebGL2(gl) ? 34836 : 6408, - type: 5126 - }) - }); - this.depthFBO = depthFBO; - } - } - (_this$pickingFBO = this.pickingFBO) === null || _this$pickingFBO === void 0 ? void 0 : _this$pickingFBO.resize({ - width: gl.canvas.width, - height: gl.canvas.height + }; + var ScatterplotLayer = class extends Layer { + getShaders() { + return super.getShaders({ + vs: scatterplot_layer_vertex_glsl_default, + fs: scatterplot_layer_fragment_glsl_default, + modules: [project32_default, picking_default] }); - (_this$depthFBO = this.depthFBO) === null || _this$depthFBO === void 0 ? void 0 : _this$depthFBO.resize({ - width: gl.canvas.width, - height: gl.canvas.height + } + initializeState() { + this.getAttributeManager().addInstanced({ + instancePositions: { + size: 3, + type: 5130, + fp64: this.use64bitPositions(), + transition: true, + accessor: "getPosition" + }, + instanceRadius: { + size: 1, + transition: true, + accessor: "getRadius", + defaultValue: 1 + }, + instanceFillColors: { + size: this.props.colorFormat.length, + transition: true, + normalized: true, + type: 5121, + accessor: "getFillColor", + defaultValue: [0, 0, 0, 255] + }, + instanceLineColors: { + size: this.props.colorFormat.length, + transition: true, + normalized: true, + type: 5121, + accessor: "getLineColor", + defaultValue: [0, 0, 0, 255] + }, + instanceLineWidths: { + size: 1, + transition: true, + accessor: "getLineWidth", + defaultValue: 1 + } }); } - _getPickable(layers) { - if (this._pickable === false) { - return null; + updateState(params) { + super.updateState(params); + if (params.changeFlags.extensionsChanged) { + var _this$state$model; + const { + gl + } = this.context; + (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); + this.state.model = this._getModel(gl); + this.getAttributeManager().invalidateAll(); } - const pickableLayers = layers.filter((layer) => this.pickLayersPass.shouldDrawLayer(layer) && !layer.isComposite); - return pickableLayers.length ? pickableLayers : null; } - _pickClosestObject({ - layers, - views, - viewports, - x: x2, - y: y2, - radius = 0, - depth = 1, - mode = "query", - unproject3D, - onViewportActive, - effects + draw({ + uniforms }) { - const pickableLayers = this._getPickable(layers); - const pixelRatio = cssToDeviceRatio(this.gl); - if (!pickableLayers) { - return { - result: [], - emptyInfo: getEmptyPickingInfo({ - viewports, - x: x2, - y: y2, - pixelRatio - }) - }; - } - this._resizeBuffer(); - const devicePixelRange = cssToDevicePixels(this.gl, [x2, y2], true); - const devicePixel = [devicePixelRange.x + Math.floor(devicePixelRange.width / 2), devicePixelRange.y + Math.floor(devicePixelRange.height / 2)]; - const deviceRadius = Math.round(radius * pixelRatio); const { - width, - height - } = this.pickingFBO; - const deviceRect = this._getPickingRect({ - deviceX: devicePixel[0], - deviceY: devicePixel[1], - deviceRadius, - deviceWidth: width, - deviceHeight: height - }); - const cullRect = { - x: x2 - radius, - y: y2 - radius, - width: radius * 2 + 1, - height: radius * 2 + 1 - }; - let infos; - const result = []; - const affectedLayers = /* @__PURE__ */ new Set(); - for (let i2 = 0; i2 < depth; i2++) { - let pickInfo; - if (deviceRect) { - const pickedResult = this._drawAndSample({ - layers: pickableLayers, - views, - viewports, - onViewportActive, - deviceRect, - cullRect, - effects, - pass: "picking:".concat(mode) - }); - pickInfo = getClosestObject({ - ...pickedResult, - deviceX: devicePixel[0], - deviceY: devicePixel[1], - deviceRadius, - deviceRect - }); - } else { - pickInfo = { - pickedColor: null, - pickedObjectIndex: -1 - }; - } - let z; - if (pickInfo.pickedLayer && unproject3D && this.depthFBO) { - const { - pickedColors: pickedColors2 - } = this._drawAndSample({ - layers: [pickInfo.pickedLayer], - views, - viewports, - onViewportActive, - deviceRect: { - x: pickInfo.pickedX, - y: pickInfo.pickedY, - width: 1, - height: 1 - }, - cullRect, - effects, - pass: "picking:".concat(mode, ":z") - }, true); - if (pickedColors2[3]) { - z = pickedColors2[0]; - } - } - if (pickInfo.pickedLayer && i2 + 1 < depth) { - affectedLayers.add(pickInfo.pickedLayer); - pickInfo.pickedLayer.disablePickingIndex(pickInfo.pickedObjectIndex); - } - infos = processPickInfo({ - pickInfo, - lastPickedInfo: this.lastPickedInfo, - mode, - layers: pickableLayers, - viewports, - x: x2, - y: y2, - z, - pixelRatio - }); - for (const info of infos.values()) { - if (info.layer) { - result.push(info); + radiusUnits, + radiusScale, + radiusMinPixels, + radiusMaxPixels, + stroked, + filled, + billboard, + antialiasing, + lineWidthUnits, + lineWidthScale, + lineWidthMinPixels, + lineWidthMaxPixels + } = this.props; + this.state.model.setUniforms(uniforms).setUniforms({ + stroked: stroked ? 1 : 0, + filled, + billboard, + antialiasing, + radiusUnits: UNIT[radiusUnits], + radiusScale, + radiusMinPixels, + radiusMaxPixels, + lineWidthUnits: UNIT[lineWidthUnits], + lineWidthScale, + lineWidthMinPixels, + lineWidthMaxPixels + }).draw(); + } + _getModel(gl) { + const positions = [-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0]; + return new Model(gl, { + ...this.getShaders(), + id: this.props.id, + geometry: new Geometry({ + drawMode: 6, + vertexCount: 4, + attributes: { + positions: { + size: 3, + value: new Float32Array(positions) + } } - } - if (!pickInfo.pickedColor) { + }), + isInstanced: true + }); + } + }; + _defineProperty(ScatterplotLayer, "defaultProps", defaultProps7); + _defineProperty(ScatterplotLayer, "layerName", "ScatterplotLayer"); + + // node_modules/@math.gl/polygon/dist/esm/polygon-utils.js + var WINDING = { + CLOCKWISE: 1, + COUNTER_CLOCKWISE: -1 + }; + function modifyPolygonWindingDirection(points, direction, options = {}) { + const windingDirection = getPolygonWindingDirection(points, options); + if (windingDirection !== direction) { + reversePolygon(points, options); + return true; + } + return false; + } + function getPolygonWindingDirection(points, options = {}) { + return Math.sign(getPolygonSignedArea(points, options)); + } + function getPolygonSignedArea(points, options = {}) { + const { + start = 0, + end = points.length + } = options; + const dim = options.size || 2; + let area = 0; + for (let i3 = start, j = end - dim; i3 < end; i3 += dim) { + area += (points[i3] - points[j]) * (points[i3 + 1] + points[j + 1]); + j = i3; + } + return area / 2; + } + function reversePolygon(points, options) { + const { + start = 0, + end = points.length, + size = 2 + } = options; + const numPoints = (end - start) / size; + const numSwaps = Math.floor(numPoints / 2); + for (let i3 = 0; i3 < numSwaps; ++i3) { + const b1 = start + i3 * size; + const b2 = start + (numPoints - 1 - i3) * size; + for (let j = 0; j < size; ++j) { + const tmp = points[b1 + j]; + points[b1 + j] = points[b2 + j]; + points[b2 + j] = tmp; + } + } + } + + // node_modules/@math.gl/polygon/dist/esm/utils.js + function push(target, source) { + const size = source.length; + const startIndex = target.length; + if (startIndex > 0) { + let isDuplicate = true; + for (let i3 = 0; i3 < size; i3++) { + if (target[startIndex - size + i3] !== source[i3]) { + isDuplicate = false; break; } } - for (const layer of affectedLayers) { - layer.restorePickingColors(); + if (isDuplicate) { + return false; } - return { - result, - emptyInfo: infos.get(null) - }; } - _pickVisibleObjects({ - layers, - views, - viewports, - x: x2, - y: y2, - width = 1, - height = 1, - mode = "query", - maxObjects = null, - onViewportActive, - effects - }) { - const pickableLayers = this._getPickable(layers); - if (!pickableLayers) { - return []; - } - this._resizeBuffer(); - const pixelRatio = cssToDeviceRatio(this.gl); - const leftTop = cssToDevicePixels(this.gl, [x2, y2], true); - const deviceLeft = leftTop.x; - const deviceTop = leftTop.y + leftTop.height; - const rightBottom = cssToDevicePixels(this.gl, [x2 + width, y2 + height], true); - const deviceRight = rightBottom.x + rightBottom.width; - const deviceBottom = rightBottom.y; - const deviceRect = { - x: deviceLeft, - y: deviceBottom, - width: deviceRight - deviceLeft, - height: deviceTop - deviceBottom - }; - const pickedResult = this._drawAndSample({ - layers: pickableLayers, - views, - viewports, - onViewportActive, - deviceRect, - cullRect: { - x: x2, - y: y2, - width, - height - }, - effects, - pass: "picking:".concat(mode) - }); - const pickInfos = getUniqueObjects(pickedResult); - const uniqueInfos = /* @__PURE__ */ new Map(); - const isMaxObjects = Number.isFinite(maxObjects); - for (let i2 = 0; i2 < pickInfos.length; i2++) { - var _info$object; - if (isMaxObjects && maxObjects && uniqueInfos.size >= maxObjects) { - break; + for (let i3 = 0; i3 < size; i3++) { + target[startIndex + i3] = source[i3]; + } + return true; + } + function copy2(target, source) { + const size = source.length; + for (let i3 = 0; i3 < size; i3++) { + target[i3] = source[i3]; + } + } + function getPointAtIndex(positions, index, size, offset, out = []) { + const startI = offset + index * size; + for (let i3 = 0; i3 < size; i3++) { + out[i3] = positions[startI + i3]; + } + return out; + } + + // node_modules/@math.gl/polygon/dist/esm/lineclip.js + function intersect(a2, b2, edge, bbox, out = []) { + let t2; + let snap; + if (edge & 8) { + t2 = (bbox[3] - a2[1]) / (b2[1] - a2[1]); + snap = 3; + } else if (edge & 4) { + t2 = (bbox[1] - a2[1]) / (b2[1] - a2[1]); + snap = 1; + } else if (edge & 2) { + t2 = (bbox[2] - a2[0]) / (b2[0] - a2[0]); + snap = 2; + } else if (edge & 1) { + t2 = (bbox[0] - a2[0]) / (b2[0] - a2[0]); + snap = 0; + } else { + return null; + } + for (let i3 = 0; i3 < a2.length; i3++) { + out[i3] = (snap & 1) === i3 ? bbox[snap] : t2 * (b2[i3] - a2[i3]) + a2[i3]; + } + return out; + } + function bitCode(p2, bbox) { + let code = 0; + if (p2[0] < bbox[0]) + code |= 1; + else if (p2[0] > bbox[2]) + code |= 2; + if (p2[1] < bbox[1]) + code |= 4; + else if (p2[1] > bbox[3]) + code |= 8; + return code; + } + + // node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js + function cutPolylineByGrid(positions, options) { + const { + size = 2, + broken = false, + gridResolution = 10, + gridOffset = [0, 0], + startIndex = 0, + endIndex = positions.length + } = options || {}; + const numPoints = (endIndex - startIndex) / size; + let part = []; + const result = [part]; + const a2 = getPointAtIndex(positions, 0, size, startIndex); + let b2; + let codeB; + const cell = getGridCell(a2, gridResolution, gridOffset, []); + const scratchPoint = []; + push(part, a2); + for (let i3 = 1; i3 < numPoints; i3++) { + b2 = getPointAtIndex(positions, i3, size, startIndex, b2); + codeB = bitCode(b2, cell); + while (codeB) { + intersect(a2, b2, codeB, cell, scratchPoint); + const codeAlt = bitCode(scratchPoint, cell); + if (codeAlt) { + intersect(a2, scratchPoint, codeAlt, cell, scratchPoint); + codeB = codeAlt; + } + push(part, scratchPoint); + copy2(a2, scratchPoint); + moveToNeighborCell(cell, gridResolution, codeB); + if (broken && part.length > size) { + part = []; + result.push(part); + push(part, a2); + } + codeB = bitCode(b2, cell); + } + push(part, b2); + copy2(a2, b2); + } + return broken ? result : result[0]; + } + var TYPE_INSIDE = 0; + var TYPE_BORDER = 1; + function concatInPlace(arr1, arr2) { + for (let i3 = 0; i3 < arr2.length; i3++) { + arr1.push(arr2[i3]); + } + return arr1; + } + function cutPolygonByGrid(positions, holeIndices = null, options) { + if (!positions.length) { + return []; + } + const { + size = 2, + gridResolution = 10, + gridOffset = [0, 0], + edgeTypes = false + } = options || {}; + const result = []; + const queue = [{ + pos: positions, + types: edgeTypes ? new Array(positions.length / size).fill(TYPE_BORDER) : null, + holes: holeIndices || [] + }]; + const bbox = [[], []]; + let cell = []; + while (queue.length) { + const { + pos, + types, + holes + } = queue.shift(); + getBoundingBox(pos, size, holes[0] || pos.length, bbox); + cell = getGridCell(bbox[0], gridResolution, gridOffset, cell); + const code = bitCode(bbox[1], cell); + if (code) { + let parts = bisectPolygon(pos, types, size, 0, holes[0] || pos.length, cell, code); + const polygonLow = { + pos: parts[0].pos, + types: parts[0].types, + holes: [] + }; + const polygonHigh = { + pos: parts[1].pos, + types: parts[1].types, + holes: [] + }; + queue.push(polygonLow, polygonHigh); + for (let i3 = 0; i3 < holes.length; i3++) { + parts = bisectPolygon(pos, types, size, holes[i3], holes[i3 + 1] || pos.length, cell, code); + if (parts[0]) { + polygonLow.holes.push(polygonLow.pos.length); + polygonLow.pos = concatInPlace(polygonLow.pos, parts[0].pos); + if (edgeTypes) { + polygonLow.types = concatInPlace(polygonLow.types, parts[0].types); + } + } + if (parts[1]) { + polygonHigh.holes.push(polygonHigh.pos.length); + polygonHigh.pos = concatInPlace(polygonHigh.pos, parts[1].pos); + if (edgeTypes) { + polygonHigh.types = concatInPlace(polygonHigh.types, parts[1].types); + } + } } - const pickInfo = pickInfos[i2]; - let info = { - color: pickInfo.pickedColor, - layer: null, - index: pickInfo.pickedObjectIndex, - picked: true, - x: x2, - y: y2, - pixelRatio + } else { + const polygon = { + positions: pos }; - info = getLayerPickingInfo({ - layer: pickInfo.pickedLayer, - info, - mode - }); - const pickedObjectKey = (_info$object = info.object) !== null && _info$object !== void 0 ? _info$object : "".concat(info.layer.id, "[").concat(info.index, "]"); - if (!uniqueInfos.has(pickedObjectKey)) { - uniqueInfos.set(pickedObjectKey, info); + if (edgeTypes) { + polygon.edgeTypes = types; } + if (holes.length) { + polygon.holeIndices = holes; + } + result.push(polygon); } - return Array.from(uniqueInfos.values()); } - _drawAndSample({ - layers, - views, - viewports, - onViewportActive, - deviceRect, - cullRect, - effects, - pass - }, pickZ = false) { - const pickingFBO = pickZ ? this.depthFBO : this.pickingFBO; - const opts = { - layers, - layerFilter: this.layerFilter, - views, - viewports, - onViewportActive, - pickingFBO, - deviceRect, - cullRect, - effects, - pass, - pickZ, - preRenderStats: {} - }; - for (const effect of effects) { - if (effect.useInPicking) { - opts.preRenderStats[effect.id] = effect.preRender(this.gl, opts); + return result; + } + function bisectPolygon(positions, edgeTypes, size, startIndex, endIndex, bbox, edge) { + const numPoints = (endIndex - startIndex) / size; + const resultLow = []; + const resultHigh = []; + const typesLow = []; + const typesHigh = []; + const scratchPoint = []; + let p2; + let side; + let type; + const prev = getPointAtIndex(positions, numPoints - 1, size, startIndex); + let prevSide = Math.sign(edge & 8 ? prev[1] - bbox[3] : prev[0] - bbox[2]); + let prevType = edgeTypes && edgeTypes[numPoints - 1]; + let lowPointCount = 0; + let highPointCount = 0; + for (let i3 = 0; i3 < numPoints; i3++) { + p2 = getPointAtIndex(positions, i3, size, startIndex, p2); + side = Math.sign(edge & 8 ? p2[1] - bbox[3] : p2[0] - bbox[2]); + type = edgeTypes && edgeTypes[startIndex / size + i3]; + if (side && prevSide && prevSide !== side) { + intersect(prev, p2, edge, bbox, scratchPoint); + push(resultLow, scratchPoint) && typesLow.push(prevType); + push(resultHigh, scratchPoint) && typesHigh.push(prevType); + } + if (side <= 0) { + push(resultLow, p2) && typesLow.push(type); + lowPointCount -= side; + } else if (typesLow.length) { + typesLow[typesLow.length - 1] = TYPE_INSIDE; + } + if (side >= 0) { + push(resultHigh, p2) && typesHigh.push(type); + highPointCount += side; + } else if (typesHigh.length) { + typesHigh[typesHigh.length - 1] = TYPE_INSIDE; + } + copy2(prev, p2); + prevSide = side; + prevType = type; + } + return [lowPointCount ? { + pos: resultLow, + types: edgeTypes && typesLow + } : null, highPointCount ? { + pos: resultHigh, + types: edgeTypes && typesHigh + } : null]; + } + function getGridCell(p2, gridResolution, gridOffset, out) { + const left = Math.floor((p2[0] - gridOffset[0]) / gridResolution) * gridResolution + gridOffset[0]; + const bottom = Math.floor((p2[1] - gridOffset[1]) / gridResolution) * gridResolution + gridOffset[1]; + out[0] = left; + out[1] = bottom; + out[2] = left + gridResolution; + out[3] = bottom + gridResolution; + return out; + } + function moveToNeighborCell(cell, gridResolution, edge) { + if (edge & 8) { + cell[1] += gridResolution; + cell[3] += gridResolution; + } else if (edge & 4) { + cell[1] -= gridResolution; + cell[3] -= gridResolution; + } else if (edge & 2) { + cell[0] += gridResolution; + cell[2] += gridResolution; + } else if (edge & 1) { + cell[0] -= gridResolution; + cell[2] -= gridResolution; + } + } + function getBoundingBox(positions, size, endIndex, out) { + let minX = Infinity; + let maxX = -Infinity; + let minY = Infinity; + let maxY = -Infinity; + for (let i3 = 0; i3 < endIndex; i3 += size) { + const x2 = positions[i3]; + const y2 = positions[i3 + 1]; + minX = x2 < minX ? x2 : minX; + maxX = x2 > maxX ? x2 : maxX; + minY = y2 < minY ? y2 : minY; + maxY = y2 > maxY ? y2 : maxY; + } + out[0][0] = minX; + out[0][1] = minY; + out[1][0] = maxX; + out[1][1] = maxY; + return out; + } + + // node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js + var DEFAULT_MAX_LATITUDE = 85.051129; + function cutPolylineByMercatorBounds(positions, options) { + const { + size = 2, + startIndex = 0, + endIndex = positions.length, + normalize: normalize5 = true + } = options || {}; + const newPositions = positions.slice(startIndex, endIndex); + wrapLongitudesForShortestPath(newPositions, size, 0, endIndex - startIndex); + const parts = cutPolylineByGrid(newPositions, { + size, + broken: true, + gridResolution: 360, + gridOffset: [-180, -180] + }); + if (normalize5) { + for (const part of parts) { + shiftLongitudesIntoRange(part, size); + } + } + return parts; + } + function cutPolygonByMercatorBounds(positions, holeIndices = null, options) { + const { + size = 2, + normalize: normalize5 = true, + edgeTypes = false + } = options || {}; + holeIndices = holeIndices || []; + const newPositions = []; + const newHoleIndices = []; + let srcStartIndex = 0; + let targetIndex = 0; + for (let ringIndex = 0; ringIndex <= holeIndices.length; ringIndex++) { + const srcEndIndex = holeIndices[ringIndex] || positions.length; + const targetStartIndex = targetIndex; + const splitIndex = findSplitIndex(positions, size, srcStartIndex, srcEndIndex); + for (let i3 = splitIndex; i3 < srcEndIndex; i3++) { + newPositions[targetIndex++] = positions[i3]; + } + for (let i3 = srcStartIndex; i3 < splitIndex; i3++) { + newPositions[targetIndex++] = positions[i3]; + } + wrapLongitudesForShortestPath(newPositions, size, targetStartIndex, targetIndex); + insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options === null || options === void 0 ? void 0 : options.maxLatitude); + srcStartIndex = srcEndIndex; + newHoleIndices[ringIndex] = targetIndex; + } + newHoleIndices.pop(); + const parts = cutPolygonByGrid(newPositions, newHoleIndices, { + size, + gridResolution: 360, + gridOffset: [-180, -180], + edgeTypes + }); + if (normalize5) { + for (const part of parts) { + shiftLongitudesIntoRange(part.positions, size); + } + } + return parts; + } + function findSplitIndex(positions, size, startIndex, endIndex) { + let maxLat = -1; + let pointIndex = -1; + for (let i3 = startIndex + 1; i3 < endIndex; i3 += size) { + const lat = Math.abs(positions[i3]); + if (lat > maxLat) { + maxLat = lat; + pointIndex = i3 - 1; + } + } + return pointIndex; + } + function insertPoleVertices(positions, size, startIndex, endIndex, maxLatitude = DEFAULT_MAX_LATITUDE) { + const firstLng = positions[startIndex]; + const lastLng = positions[endIndex - size]; + if (Math.abs(firstLng - lastLng) > 180) { + const p2 = getPointAtIndex(positions, 0, size, startIndex); + p2[0] += Math.round((lastLng - firstLng) / 360) * 360; + push(positions, p2); + p2[1] = Math.sign(p2[1]) * maxLatitude; + push(positions, p2); + p2[0] = firstLng; + push(positions, p2); + } + } + function wrapLongitudesForShortestPath(positions, size, startIndex, endIndex) { + let prevLng = positions[0]; + let lng; + for (let i3 = startIndex; i3 < endIndex; i3 += size) { + lng = positions[i3]; + const delta = lng - prevLng; + if (delta > 180 || delta < -180) { + lng -= Math.round(delta / 360) * 360; + } + positions[i3] = prevLng = lng; + } + } + function shiftLongitudesIntoRange(positions, size) { + let refLng; + const pointCount = positions.length / size; + for (let i3 = 0; i3 < pointCount; i3++) { + refLng = positions[i3 * size]; + if ((refLng + 180) % 360 !== 0) { + break; + } + } + const delta = -Math.round(refLng / 360) * 360; + if (delta === 0) { + return; + } + for (let i3 = 0; i3 < pointCount; i3++) { + positions[i3 * size] += delta; + } + } + + // node_modules/@deck.gl/layers/dist/esm/path-layer/path.js + function normalizePath(path, size, gridResolution, wrapLongitude) { + let flatPath; + if (Array.isArray(path[0])) { + const length4 = path.length * size; + flatPath = new Array(length4); + for (let i3 = 0; i3 < path.length; i3++) { + for (let j = 0; j < size; j++) { + flatPath[i3 * size + j] = path[i3][j] || 0; } } - const { - decodePickingColor - } = this.pickLayersPass.render(opts); - const { - x: x2, - y: y2, - width, - height - } = deviceRect; - const pickedColors = new (pickZ ? Float32Array : Uint8Array)(width * height * 4); - readPixelsToArray(pickingFBO, { - sourceX: x2, - sourceY: y2, - sourceWidth: width, - sourceHeight: height, - target: pickedColors + } else { + flatPath = path; + } + if (gridResolution) { + return cutPolylineByGrid(flatPath, { + size, + gridResolution }); - return { - pickedColors, - decodePickingColor - }; } - _getPickingRect({ - deviceX, - deviceY, - deviceRadius, - deviceWidth, - deviceHeight - }) { - const x2 = Math.max(0, deviceX - deviceRadius); - const y2 = Math.max(0, deviceY - deviceRadius); - const width = Math.min(deviceWidth, deviceX + deviceRadius + 1) - x2; - const height = Math.min(deviceHeight, deviceY + deviceRadius + 1) - y2; - if (width <= 0 || height <= 0) { - return null; - } - return { - x: x2, - y: y2, - width, - height - }; + if (wrapLongitude) { + return cutPolylineByMercatorBounds(flatPath, { + size + }); } - }; + return flatPath; + } - // node_modules/@deck.gl/core/dist/esm/lib/tooltip.js - var defaultStyle = { - zIndex: "1", - position: "absolute", - pointerEvents: "none", - color: "#a0a7b4", - backgroundColor: "#29323c", - padding: "10px", - top: "0", - left: "0", - display: "none" - }; - var Tooltip = class { - constructor(canvas) { - _defineProperty(this, "el", null); - _defineProperty(this, "isVisible", false); - const canvasParent = canvas.parentElement; - if (canvasParent) { - this.el = document.createElement("div"); - this.el.className = "deck-tooltip"; - Object.assign(this.el.style, defaultStyle); - canvasParent.appendChild(this.el); + // node_modules/@deck.gl/layers/dist/esm/path-layer/path-tesselator.js + var START_CAP = 1; + var END_CAP = 2; + var INVALID = 4; + var PathTesselator = class extends Tesselator { + constructor(opts) { + super({ + ...opts, + attributes: { + positions: { + size: 3, + padding: 18, + initialize: true, + type: opts.fp64 ? Float64Array : Float32Array + }, + segmentTypes: { + size: 1, + type: Uint8ClampedArray + } + } + }); + } + get(attributeName) { + return this.attributes[attributeName]; + } + getGeometryFromBuffer(buffer) { + if (this.normalize) { + return super.getGeometryFromBuffer(buffer); } + return null; } - setTooltip(displayInfo, x2, y2) { - const el = this.el; - if (!el) { - return; + normalizeGeometry(path) { + if (this.normalize) { + return normalizePath(path, this.positionSize, this.opts.resolution, this.opts.wrapLongitude); } - if (typeof displayInfo === "string") { - el.innerText = displayInfo; - } else if (!displayInfo) { - this.isVisible = false; - el.style.display = "none"; - return; - } else { - if (displayInfo.text) { - el.innerText = displayInfo.text; - } - if (displayInfo.html) { - el.innerHTML = displayInfo.html; - } - if (displayInfo.className) { - el.className = displayInfo.className; + return path; + } + getGeometrySize(path) { + if (isCut(path)) { + let size = 0; + for (const subPath of path) { + size += this.getGeometrySize(subPath); } + return size; } - this.isVisible = true; - el.style.display = "block"; - el.style.transform = "translate(".concat(x2, "px, ").concat(y2, "px)"); - if (displayInfo && typeof displayInfo === "object" && "style" in displayInfo) { - Object.assign(el.style, displayInfo.style); + const numPoints = this.getPathLength(path); + if (numPoints < 2) { + return 0; } - } - remove() { - if (this.el) { - this.el.remove(); - this.el = null; + if (this.isClosed(path)) { + return numPoints < 3 ? 0 : numPoints + 2; } + return numPoints; } - }; - - // node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js - var hammerjs = __toESM(require_hammer()); - - // node_modules/mjolnir.js/dist/esm/utils/hammer-overrides.js - var INPUT_START = 1; - var INPUT_MOVE = 2; - var INPUT_END = 4; - var MOUSE_INPUT_MAP = { - mousedown: INPUT_START, - mousemove: INPUT_MOVE, - mouseup: INPUT_END - }; - function some(array, predict) { - for (let i2 = 0; i2 < array.length; i2++) { - if (predict(array[i2])) { - return true; + updateGeometryAttributes(path, context) { + if (context.geometrySize === 0) { + return; } - } - return false; - } - function enhancePointerEventInput(PointerEventInput2) { - const oldHandler = PointerEventInput2.prototype.handler; - PointerEventInput2.prototype.handler = function handler(ev) { - const store = this.store; - if (ev.button > 0 && ev.type === "pointerdown") { - if (!some(store, (e2) => e2.pointerId === ev.pointerId)) { - store.push(ev); + if (path && isCut(path)) { + for (const subPath of path) { + const geometrySize = this.getGeometrySize(subPath); + context.geometrySize = geometrySize; + this.updateGeometryAttributes(subPath, context); + context.vertexStart += geometrySize; } + } else { + this._updateSegmentTypes(path, context); + this._updatePositions(path, context); } - oldHandler.call(this, ev); - }; - } - function enhanceMouseInput(MouseInput2) { - MouseInput2.prototype.handler = function handler(ev) { - let eventType = MOUSE_INPUT_MAP[ev.type]; - if (eventType & INPUT_START && ev.button >= 0) { - this.pressed = true; - } - if (eventType & INPUT_MOVE && ev.which === 0) { - eventType = INPUT_END; + } + _updateSegmentTypes(path, context) { + const segmentTypes = this.attributes.segmentTypes; + const isPathClosed = path ? this.isClosed(path) : false; + const { + vertexStart, + geometrySize + } = context; + segmentTypes.fill(0, vertexStart, vertexStart + geometrySize); + if (isPathClosed) { + segmentTypes[vertexStart] = INVALID; + segmentTypes[vertexStart + geometrySize - 2] = INVALID; + } else { + segmentTypes[vertexStart] += START_CAP; + segmentTypes[vertexStart + geometrySize - 2] += END_CAP; } - if (!this.pressed) { + segmentTypes[vertexStart + geometrySize - 1] = INVALID; + } + _updatePositions(path, context) { + const { + positions + } = this.attributes; + if (!positions || !path) { return; } - if (eventType & INPUT_END) { - this.pressed = false; + const { + vertexStart, + geometrySize + } = context; + const p2 = new Array(3); + for (let i3 = vertexStart, ptIndex = 0; ptIndex < geometrySize; i3++, ptIndex++) { + this.getPointOnPath(path, ptIndex, p2); + positions[i3 * 3] = p2[0]; + positions[i3 * 3 + 1] = p2[1]; + positions[i3 * 3 + 2] = p2[2]; } - this.callback(this.manager, eventType, { - pointers: [ev], - changedPointers: [ev], - pointerType: "mouse", - srcEvent: ev - }); - }; - } - - // node_modules/mjolnir.js/dist/esm/utils/hammer.browser.js - enhancePointerEventInput(hammerjs.PointerEventInput); - enhanceMouseInput(hammerjs.MouseInput); - var Manager2 = hammerjs.Manager; - var hammer_browser_default = hammerjs; - - // node_modules/mjolnir.js/dist/esm/inputs/input.js - var Input = class { - constructor(element, callback, options) { - this.element = element; - this.callback = callback; - this.options = { enable: true, ...options }; + } + getPathLength(path) { + return path.length / this.positionSize; + } + getPointOnPath(path, index, target = []) { + const { + positionSize + } = this; + if (index * positionSize >= path.length) { + index += 1 - path.length / positionSize; + } + const i3 = index * positionSize; + target[0] = path[i3]; + target[1] = path[i3 + 1]; + target[2] = positionSize === 3 && path[i3 + 2] || 0; + return target; + } + isClosed(path) { + if (!this.normalize) { + return Boolean(this.opts.loop); + } + const { + positionSize + } = this; + const lastPointIndex = path.length - positionSize; + return path[0] === path[lastPointIndex] && path[1] === path[lastPointIndex + 1] && (positionSize === 2 || path[2] === path[lastPointIndex + 2]); } }; + function isCut(path) { + return Array.isArray(path[0]); + } - // node_modules/mjolnir.js/dist/esm/constants.js - var RECOGNIZERS = hammer_browser_default ? [ - [hammer_browser_default.Pan, { event: "tripan", pointers: 3, threshold: 0, enable: false }], - [hammer_browser_default.Rotate, { enable: false }], - [hammer_browser_default.Pinch, { enable: false }], - [hammer_browser_default.Swipe, { enable: false }], - [hammer_browser_default.Pan, { threshold: 0, enable: false }], - [hammer_browser_default.Press, { enable: false }], - [hammer_browser_default.Tap, { event: "doubletap", taps: 2, enable: false }], - // TODO - rename to 'tap' and 'singletap' in the next major release - [hammer_browser_default.Tap, { event: "anytap", enable: false }], - [hammer_browser_default.Tap, { enable: false }] - ] : null; - var RECOGNIZER_COMPATIBLE_MAP = { - tripan: ["rotate", "pinch", "pan"], - rotate: ["pinch"], - pinch: ["pan"], - pan: ["press", "doubletap", "anytap", "tap"], - doubletap: ["anytap"], - anytap: ["tap"] - }; - var RECOGNIZER_FALLBACK_MAP = { - doubletap: ["tap"] - }; - var BASIC_EVENT_ALIASES = { - pointerdown: "pointerdown", - pointermove: "pointermove", - pointerup: "pointerup", - touchstart: "pointerdown", - touchmove: "pointermove", - touchend: "pointerup", - mousedown: "pointerdown", - mousemove: "pointermove", - mouseup: "pointerup" - }; - var INPUT_EVENT_TYPES = { - KEY_EVENTS: ["keydown", "keyup"], - MOUSE_EVENTS: ["mousedown", "mousemove", "mouseup", "mouseover", "mouseout", "mouseleave"], - WHEEL_EVENTS: [ - // Chrome, Safari - "wheel", - // IE - "mousewheel" - ] - }; - var EVENT_RECOGNIZER_MAP = { - tap: "tap", - anytap: "anytap", - doubletap: "doubletap", - press: "press", - pinch: "pinch", - pinchin: "pinch", - pinchout: "pinch", - pinchstart: "pinch", - pinchmove: "pinch", - pinchend: "pinch", - pinchcancel: "pinch", - rotate: "rotate", - rotatestart: "rotate", - rotatemove: "rotate", - rotateend: "rotate", - rotatecancel: "rotate", - tripan: "tripan", - tripanstart: "tripan", - tripanmove: "tripan", - tripanup: "tripan", - tripandown: "tripan", - tripanleft: "tripan", - tripanright: "tripan", - tripanend: "tripan", - tripancancel: "tripan", - pan: "pan", - panstart: "pan", - panmove: "pan", - panup: "pan", - pandown: "pan", - panleft: "pan", - panright: "pan", - panend: "pan", - pancancel: "pan", - swipe: "swipe", - swipeleft: "swipe", - swiperight: "swipe", - swipeup: "swipe", - swipedown: "swipe" - }; - var GESTURE_EVENT_ALIASES = { - click: "tap", - anyclick: "anytap", - dblclick: "doubletap", - mousedown: "pointerdown", - mousemove: "pointermove", - mouseup: "pointerup", - mouseover: "pointerover", - mouseout: "pointerout", - mouseleave: "pointerleave" - }; + // node_modules/@deck.gl/layers/dist/esm/path-layer/path-layer-vertex.glsl.js + var path_layer_vertex_glsl_default = "#define SHADER_NAME path-layer-vertex-shader\n\nattribute vec2 positions;\n\nattribute float instanceTypes;\nattribute vec3 instanceStartPositions;\nattribute vec3 instanceEndPositions;\nattribute vec3 instanceLeftPositions;\nattribute vec3 instanceRightPositions;\nattribute vec3 instanceLeftPositions64Low;\nattribute vec3 instanceStartPositions64Low;\nattribute vec3 instanceEndPositions64Low;\nattribute vec3 instanceRightPositions64Low;\nattribute float instanceStrokeWidths;\nattribute vec4 instanceColors;\nattribute vec3 instancePickingColors;\n\nuniform float widthScale;\nuniform float widthMinPixels;\nuniform float widthMaxPixels;\nuniform float jointType;\nuniform float capType;\nuniform float miterLimit;\nuniform bool billboard;\nuniform int widthUnits;\n\nuniform float opacity;\n\nvarying vec4 vColor;\nvarying vec2 vCornerOffset;\nvarying float vMiterLength;\nvarying vec2 vPathPosition;\nvarying float vPathLength;\nvarying float vJointType;\n\nconst float EPSILON = 0.001;\nconst vec3 ZERO_OFFSET = vec3(0.0);\n\nfloat flipIfTrue(bool flag) {\n return -(float(flag) * 2. - 1.);\n}\nvec3 getLineJoinOffset(\n vec3 prevPoint, vec3 currPoint, vec3 nextPoint,\n vec2 width\n) {\n bool isEnd = positions.x > 0.0;\n float sideOfPath = positions.y;\n float isJoint = float(sideOfPath == 0.0);\n\n vec3 deltaA3 = (currPoint - prevPoint);\n vec3 deltaB3 = (nextPoint - currPoint);\n\n mat3 rotationMatrix;\n bool needsRotation = !billboard && project_needs_rotation(currPoint, rotationMatrix);\n if (needsRotation) {\n deltaA3 = deltaA3 * rotationMatrix;\n deltaB3 = deltaB3 * rotationMatrix;\n }\n vec2 deltaA = deltaA3.xy / width;\n vec2 deltaB = deltaB3.xy / width;\n\n float lenA = length(deltaA);\n float lenB = length(deltaB);\n\n vec2 dirA = lenA > 0. ? normalize(deltaA) : vec2(0.0, 0.0);\n vec2 dirB = lenB > 0. ? normalize(deltaB) : vec2(0.0, 0.0);\n\n vec2 perpA = vec2(-dirA.y, dirA.x);\n vec2 perpB = vec2(-dirB.y, dirB.x);\n vec2 tangent = dirA + dirB;\n tangent = length(tangent) > 0. ? normalize(tangent) : perpA;\n vec2 miterVec = vec2(-tangent.y, tangent.x);\n vec2 dir = isEnd ? dirA : dirB;\n vec2 perp = isEnd ? perpA : perpB;\n float L = isEnd ? lenA : lenB;\n float sinHalfA = abs(dot(miterVec, perp));\n float cosHalfA = abs(dot(dirA, miterVec));\n float turnDirection = flipIfTrue(dirA.x * dirB.y >= dirA.y * dirB.x);\n float cornerPosition = sideOfPath * turnDirection;\n\n float miterSize = 1.0 / max(sinHalfA, EPSILON);\n miterSize = mix(\n min(miterSize, max(lenA, lenB) / max(cosHalfA, EPSILON)),\n miterSize,\n step(0.0, cornerPosition)\n );\n\n vec2 offsetVec = mix(miterVec * miterSize, perp, step(0.5, cornerPosition))\n * (sideOfPath + isJoint * turnDirection);\n bool isStartCap = lenA == 0.0 || (!isEnd && (instanceTypes == 1.0 || instanceTypes == 3.0));\n bool isEndCap = lenB == 0.0 || (isEnd && (instanceTypes == 2.0 || instanceTypes == 3.0));\n bool isCap = isStartCap || isEndCap;\n if (isCap) {\n offsetVec = mix(perp * sideOfPath, dir * capType * 4.0 * flipIfTrue(isStartCap), isJoint);\n vJointType = capType;\n } else {\n vJointType = jointType;\n }\n vPathLength = L;\n vCornerOffset = offsetVec;\n vMiterLength = dot(vCornerOffset, miterVec * turnDirection);\n vMiterLength = isCap ? isJoint : vMiterLength;\n\n vec2 offsetFromStartOfPath = vCornerOffset + deltaA * float(isEnd);\n vPathPosition = vec2(\n dot(offsetFromStartOfPath, perp),\n dot(offsetFromStartOfPath, dir)\n );\n geometry.uv = vPathPosition;\n\n float isValid = step(instanceTypes, 3.5);\n vec3 offset = vec3(offsetVec * width * isValid, 0.0);\n\n if (needsRotation) {\n offset = rotationMatrix * offset;\n }\n return offset;\n}\nvoid clipLine(inout vec4 position, vec4 refPosition) {\n if (position.w < EPSILON) {\n float r = (EPSILON - refPosition.w) / (position.w - refPosition.w);\n position = refPosition + (position - refPosition) * r;\n }\n}\n\nvoid main() {\n geometry.pickingColor = instancePickingColors;\n\n vColor = vec4(instanceColors.rgb, instanceColors.a * opacity);\n\n float isEnd = positions.x;\n\n vec3 prevPosition = mix(instanceLeftPositions, instanceStartPositions, isEnd);\n vec3 prevPosition64Low = mix(instanceLeftPositions64Low, instanceStartPositions64Low, isEnd);\n\n vec3 currPosition = mix(instanceStartPositions, instanceEndPositions, isEnd);\n vec3 currPosition64Low = mix(instanceStartPositions64Low, instanceEndPositions64Low, isEnd);\n\n vec3 nextPosition = mix(instanceEndPositions, instanceRightPositions, isEnd);\n vec3 nextPosition64Low = mix(instanceEndPositions64Low, instanceRightPositions64Low, isEnd);\n\n geometry.worldPosition = currPosition;\n vec2 widthPixels = vec2(clamp(\n project_size_to_pixel(instanceStrokeWidths * widthScale, widthUnits),\n widthMinPixels, widthMaxPixels) / 2.0);\n vec3 width;\n\n if (billboard) {\n vec4 prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET);\n vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position);\n vec4 nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET);\n\n clipLine(prevPositionScreen, currPositionScreen);\n clipLine(nextPositionScreen, currPositionScreen);\n clipLine(currPositionScreen, mix(nextPositionScreen, prevPositionScreen, isEnd));\n\n width = vec3(widthPixels, 0.0);\n DECKGL_FILTER_SIZE(width, geometry);\n\n vec3 offset = getLineJoinOffset(\n prevPositionScreen.xyz / prevPositionScreen.w,\n currPositionScreen.xyz / currPositionScreen.w,\n nextPositionScreen.xyz / nextPositionScreen.w,\n project_pixel_size_to_clipspace(width.xy)\n );\n\n DECKGL_FILTER_GL_POSITION(currPositionScreen, geometry);\n gl_Position = vec4(currPositionScreen.xyz + offset * currPositionScreen.w, currPositionScreen.w);\n } else {\n prevPosition = project_position(prevPosition, prevPosition64Low);\n currPosition = project_position(currPosition, currPosition64Low);\n nextPosition = project_position(nextPosition, nextPosition64Low);\n\n width = vec3(project_pixel_size(widthPixels), 0.0);\n DECKGL_FILTER_SIZE(width, geometry);\n\n vec3 offset = getLineJoinOffset(prevPosition, currPosition, nextPosition, width.xy);\n geometry.position = vec4(currPosition + offset, 1.0);\n gl_Position = project_common_position_to_clipspace(geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n }\n DECKGL_FILTER_COLOR(vColor, geometry);\n}\n"; - // node_modules/mjolnir.js/dist/esm/utils/globals.js - var userAgent = typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent.toLowerCase() : ""; - var window_5 = typeof window !== "undefined" ? window : global; - var passiveSupported = false; - try { - const options = { - // This function will be called when the browser - // attempts to access the passive property. - get passive() { - passiveSupported = true; - return true; - } - }; - window_5.addEventListener("test", null, options); - window_5.removeEventListener("test", null); - } catch (err) { - passiveSupported = false; - } + // node_modules/@deck.gl/layers/dist/esm/path-layer/path-layer-fragment.glsl.js + var path_layer_fragment_glsl_default = "#define SHADER_NAME path-layer-fragment-shader\n\nprecision highp float;\n\nuniform float miterLimit;\n\nvarying vec4 vColor;\nvarying vec2 vCornerOffset;\nvarying float vMiterLength;\nvarying vec2 vPathPosition;\nvarying float vPathLength;\nvarying float vJointType;\n\nvoid main(void) {\n geometry.uv = vPathPosition;\n\n if (vPathPosition.y < 0.0 || vPathPosition.y > vPathLength) {\n if (vJointType > 0.5 && length(vCornerOffset) > 1.0) {\n discard;\n }\n if (vJointType < 0.5 && vMiterLength > miterLimit + 1.0) {\n discard;\n }\n }\n gl_FragColor = vColor;\n\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; - // node_modules/mjolnir.js/dist/esm/inputs/wheel-input.js - var firefox = userAgent.indexOf("firefox") !== -1; - var { WHEEL_EVENTS } = INPUT_EVENT_TYPES; - var EVENT_TYPE = "wheel"; - var WHEEL_DELTA_MAGIC_SCALER = 4.000244140625; - var WHEEL_DELTA_PER_LINE = 40; - var SHIFT_MULTIPLIER = 0.25; - var WheelInput = class extends Input { - constructor(element, callback, options) { - super(element, callback, options); - this.handleEvent = (event) => { - if (!this.options.enable) { - return; - } - let value = event.deltaY; - if (window_5.WheelEvent) { - if (firefox && event.deltaMode === window_5.WheelEvent.DOM_DELTA_PIXEL) { - value /= window_5.devicePixelRatio; - } - if (event.deltaMode === window_5.WheelEvent.DOM_DELTA_LINE) { - value *= WHEEL_DELTA_PER_LINE; + // node_modules/@deck.gl/layers/dist/esm/path-layer/path-layer.js + var DEFAULT_COLOR5 = [0, 0, 0, 255]; + var defaultProps8 = { + widthUnits: "meters", + widthScale: { + type: "number", + min: 0, + value: 1 + }, + widthMinPixels: { + type: "number", + min: 0, + value: 0 + }, + widthMaxPixels: { + type: "number", + min: 0, + value: Number.MAX_SAFE_INTEGER + }, + jointRounded: false, + capRounded: false, + miterLimit: { + type: "number", + min: 0, + value: 4 + }, + billboard: false, + _pathType: null, + getPath: { + type: "accessor", + value: (object) => object.path + }, + getColor: { + type: "accessor", + value: DEFAULT_COLOR5 + }, + getWidth: { + type: "accessor", + value: 1 + }, + rounded: { + deprecatedFor: ["jointRounded", "capRounded"] + } + }; + var ATTRIBUTE_TRANSITION = { + enter: (value, chunk) => { + return chunk.length ? chunk.subarray(chunk.length - value.length) : value; + } + }; + var PathLayer = class extends Layer { + constructor(...args) { + super(...args); + _defineProperty(this, "state", void 0); + } + getShaders() { + return super.getShaders({ + vs: path_layer_vertex_glsl_default, + fs: path_layer_fragment_glsl_default, + modules: [project32_default, picking_default] + }); + } + get wrapLongitude() { + return false; + } + initializeState() { + const noAlloc = true; + const attributeManager = this.getAttributeManager(); + attributeManager.addInstanced({ + positions: { + size: 3, + vertexOffset: 1, + type: 5130, + fp64: this.use64bitPositions(), + transition: ATTRIBUTE_TRANSITION, + accessor: "getPath", + update: this.calculatePositions, + noAlloc, + shaderAttributes: { + instanceLeftPositions: { + vertexOffset: 0 + }, + instanceStartPositions: { + vertexOffset: 1 + }, + instanceEndPositions: { + vertexOffset: 2 + }, + instanceRightPositions: { + vertexOffset: 3 + } } + }, + instanceTypes: { + size: 1, + type: 5121, + update: this.calculateSegmentTypes, + noAlloc + }, + instanceStrokeWidths: { + size: 1, + accessor: "getWidth", + transition: ATTRIBUTE_TRANSITION, + defaultValue: 1 + }, + instanceColors: { + size: this.props.colorFormat.length, + type: 5121, + normalized: true, + accessor: "getColor", + transition: ATTRIBUTE_TRANSITION, + defaultValue: DEFAULT_COLOR5 + }, + instancePickingColors: { + size: 3, + type: 5121, + accessor: (object, { + index, + target: value + }) => this.encodePickingColor(object && object.__source ? object.__source.index : index, value) } - if (value !== 0 && value % WHEEL_DELTA_MAGIC_SCALER === 0) { - value = Math.floor(value / WHEEL_DELTA_MAGIC_SCALER); - } - if (event.shiftKey && value) { - value = value * SHIFT_MULTIPLIER; - } - this.callback({ - type: EVENT_TYPE, - center: { - x: event.clientX, - y: event.clientY - }, - delta: -value, - srcEvent: event, - pointerType: "mouse", - target: event.target + }); + this.setState({ + pathTesselator: new PathTesselator({ + fp64: this.use64bitPositions() + }) + }); + } + updateState(params) { + super.updateState(params); + const { + props, + changeFlags + } = params; + const attributeManager = this.getAttributeManager(); + const geometryChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPath); + if (geometryChanged) { + const { + pathTesselator + } = this.state; + const buffers = props.data.attributes || {}; + pathTesselator.updateGeometry({ + data: props.data, + geometryBuffer: buffers.getPath, + buffers, + normalize: !props._pathType, + loop: props._pathType === "loop", + getGeometry: props.getPath, + positionFormat: props.positionFormat, + wrapLongitude: props.wrapLongitude, + resolution: this.context.viewport.resolution, + dataChanged: changeFlags.dataChanged }); - }; - this.events = (this.options.events || []).concat(WHEEL_EVENTS); - this.events.forEach((event) => element.addEventListener(event, this.handleEvent, passiveSupported ? { passive: false } : false)); + this.setState({ + numInstances: pathTesselator.instanceCount, + startIndices: pathTesselator.vertexStarts + }); + if (!changeFlags.dataChanged) { + attributeManager.invalidateAll(); + } + } + if (changeFlags.extensionsChanged) { + var _this$state$model; + const { + gl + } = this.context; + (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); + this.state.model = this._getModel(gl); + attributeManager.invalidateAll(); + } } - destroy() { - this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); + getPickingInfo(params) { + const info = super.getPickingInfo(params); + const { + index + } = info; + const { + data + } = this.props; + if (data[0] && data[0].__source) { + info.object = data.find((d2) => d2.__source.index === index); + } + return info; } - /** - * Enable this input (begin processing events) - * if the specified event type is among those handled by this input. - */ - enableEventType(eventType, enabled) { - if (eventType === EVENT_TYPE) { - this.options.enable = enabled; + disablePickingIndex(objectIndex) { + const { + data + } = this.props; + if (data[0] && data[0].__source) { + for (let i3 = 0; i3 < data.length; i3++) { + if (data[i3].__source.index === objectIndex) { + this._disablePickingIndex(i3); + } + } + } else { + super.disablePickingIndex(objectIndex); } } + draw({ + uniforms + }) { + const { + jointRounded, + capRounded, + billboard, + miterLimit, + widthUnits, + widthScale, + widthMinPixels, + widthMaxPixels + } = this.props; + this.state.model.setUniforms(uniforms).setUniforms({ + jointType: Number(jointRounded), + capType: Number(capRounded), + billboard, + widthUnits: UNIT[widthUnits], + widthScale, + miterLimit, + widthMinPixels, + widthMaxPixels + }).draw(); + } + _getModel(gl) { + const SEGMENT_INDICES = [0, 1, 2, 1, 4, 2, 1, 3, 4, 3, 5, 4]; + const SEGMENT_POSITIONS = [0, 0, 0, -1, 0, 1, 1, -1, 1, 1, 1, 0]; + return new Model(gl, { + ...this.getShaders(), + id: this.props.id, + geometry: new Geometry({ + drawMode: 4, + attributes: { + indices: new Uint16Array(SEGMENT_INDICES), + positions: { + value: new Float32Array(SEGMENT_POSITIONS), + size: 2 + } + } + }), + isInstanced: true + }); + } + calculatePositions(attribute) { + const { + pathTesselator + } = this.state; + attribute.startIndices = pathTesselator.vertexStarts; + attribute.value = pathTesselator.get("positions"); + } + calculateSegmentTypes(attribute) { + const { + pathTesselator + } = this.state; + attribute.startIndices = pathTesselator.vertexStarts; + attribute.value = pathTesselator.get("segmentTypes"); + } }; - - // node_modules/mjolnir.js/dist/esm/inputs/move-input.js - var { MOUSE_EVENTS } = INPUT_EVENT_TYPES; - var MOVE_EVENT_TYPE = "pointermove"; - var OVER_EVENT_TYPE = "pointerover"; - var OUT_EVENT_TYPE = "pointerout"; - var ENTER_EVENT_TYPE = "pointerenter"; - var LEAVE_EVENT_TYPE = "pointerleave"; - var MoveInput = class extends Input { - constructor(element, callback, options) { - super(element, callback, options); - this.handleEvent = (event) => { - this.handleOverEvent(event); - this.handleOutEvent(event); - this.handleEnterEvent(event); - this.handleLeaveEvent(event); - this.handleMoveEvent(event); - }; - this.pressed = false; - const { enable: enable2 } = this.options; - this.enableMoveEvent = enable2; - this.enableLeaveEvent = enable2; - this.enableEnterEvent = enable2; - this.enableOutEvent = enable2; - this.enableOverEvent = enable2; - this.events = (this.options.events || []).concat(MOUSE_EVENTS); - this.events.forEach((event) => element.addEventListener(event, this.handleEvent)); + _defineProperty(PathLayer, "defaultProps", defaultProps8); + _defineProperty(PathLayer, "layerName", "PathLayer"); + + // node_modules/@deck.gl/layers/dist/esm/solid-polygon-layer/polygon.js + var import_earcut2 = __toESM(require_earcut()); + var OUTER_POLYGON_WINDING = WINDING.CLOCKWISE; + var HOLE_POLYGON_WINDING = WINDING.COUNTER_CLOCKWISE; + var windingOptions = { + isClosed: true + }; + function validate(polygon) { + polygon = polygon && polygon.positions || polygon; + if (!Array.isArray(polygon) && !ArrayBuffer.isView(polygon)) { + throw new Error("invalid polygon"); } - destroy() { - this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); + } + function getPositions(polygon) { + return "positions" in polygon ? polygon.positions : polygon; + } + function getHoleIndices(polygon) { + return "holeIndices" in polygon ? polygon.holeIndices : null; + } + function isNested(polygon) { + return Array.isArray(polygon[0]); + } + function isSimple(polygon) { + return polygon.length >= 1 && polygon[0].length >= 2 && Number.isFinite(polygon[0][0]); + } + function isNestedRingClosed(simplePolygon) { + const p0 = simplePolygon[0]; + const p1 = simplePolygon[simplePolygon.length - 1]; + return p0[0] === p1[0] && p0[1] === p1[1] && p0[2] === p1[2]; + } + function isFlatRingClosed(positions, size, startIndex, endIndex) { + for (let i3 = 0; i3 < size; i3++) { + if (positions[startIndex + i3] !== positions[endIndex - size + i3]) { + return false; + } } - /** - * Enable this input (begin processing events) - * if the specified event type is among those handled by this input. - */ - enableEventType(eventType, enabled) { - if (eventType === MOVE_EVENT_TYPE) { - this.enableMoveEvent = enabled; + return true; + } + function copyNestedRing(target, targetStartIndex, simplePolygon, size, windingDirection) { + let targetIndex = targetStartIndex; + const len2 = simplePolygon.length; + for (let i3 = 0; i3 < len2; i3++) { + for (let j = 0; j < size; j++) { + target[targetIndex++] = simplePolygon[i3][j] || 0; } - if (eventType === OVER_EVENT_TYPE) { - this.enableOverEvent = enabled; + } + if (!isNestedRingClosed(simplePolygon)) { + for (let j = 0; j < size; j++) { + target[targetIndex++] = simplePolygon[0][j] || 0; } - if (eventType === OUT_EVENT_TYPE) { - this.enableOutEvent = enabled; + } + windingOptions.start = targetStartIndex; + windingOptions.end = targetIndex; + windingOptions.size = size; + modifyPolygonWindingDirection(target, windingDirection, windingOptions); + return targetIndex; + } + function copyFlatRing(target, targetStartIndex, positions, size, srcStartIndex = 0, srcEndIndex, windingDirection) { + srcEndIndex = srcEndIndex || positions.length; + const srcLength = srcEndIndex - srcStartIndex; + if (srcLength <= 0) { + return targetStartIndex; + } + let targetIndex = targetStartIndex; + for (let i3 = 0; i3 < srcLength; i3++) { + target[targetIndex++] = positions[srcStartIndex + i3]; + } + if (!isFlatRingClosed(positions, size, srcStartIndex, srcEndIndex)) { + for (let i3 = 0; i3 < size; i3++) { + target[targetIndex++] = positions[srcStartIndex + i3]; } - if (eventType === ENTER_EVENT_TYPE) { - this.enableEnterEvent = enabled; + } + windingOptions.start = targetStartIndex; + windingOptions.end = targetIndex; + windingOptions.size = size; + modifyPolygonWindingDirection(target, windingDirection, windingOptions); + return targetIndex; + } + function normalize4(polygon, positionSize) { + validate(polygon); + const positions = []; + const holeIndices = []; + if ("positions" in polygon) { + const { + positions: srcPositions, + holeIndices: srcHoleIndices + } = polygon; + if (srcHoleIndices) { + let targetIndex = 0; + for (let i3 = 0; i3 <= srcHoleIndices.length; i3++) { + targetIndex = copyFlatRing(positions, targetIndex, srcPositions, positionSize, srcHoleIndices[i3 - 1], srcHoleIndices[i3], i3 === 0 ? OUTER_POLYGON_WINDING : HOLE_POLYGON_WINDING); + holeIndices.push(targetIndex); + } + holeIndices.pop(); + return { + positions, + holeIndices + }; } - if (eventType === LEAVE_EVENT_TYPE) { - this.enableLeaveEvent = enabled; + polygon = srcPositions; + } + if (!isNested(polygon)) { + copyFlatRing(positions, 0, polygon, positionSize, 0, positions.length, OUTER_POLYGON_WINDING); + return positions; + } + if (!isSimple(polygon)) { + let targetIndex = 0; + for (const [polygonIndex, simplePolygon] of polygon.entries()) { + targetIndex = copyNestedRing(positions, targetIndex, simplePolygon, positionSize, polygonIndex === 0 ? OUTER_POLYGON_WINDING : HOLE_POLYGON_WINDING); + holeIndices.push(targetIndex); } + holeIndices.pop(); + return { + positions, + holeIndices + }; } - handleOverEvent(event) { - if (this.enableOverEvent) { - if (event.type === "mouseover") { - this._emit(OVER_EVENT_TYPE, event); + copyNestedRing(positions, 0, polygon, positionSize, OUTER_POLYGON_WINDING); + return positions; + } + function getPlaneArea(positions, xIndex, yIndex) { + const numVerts = positions.length / 3; + let area = 0; + for (let i3 = 0; i3 < numVerts; i3++) { + const j = (i3 + 1) % numVerts; + area += positions[i3 * 3 + xIndex] * positions[j * 3 + yIndex]; + area -= positions[j * 3 + xIndex] * positions[i3 * 3 + yIndex]; + } + return Math.abs(area / 2); + } + function permutePositions(positions, xIndex, yIndex, zIndex) { + const numVerts = positions.length / 3; + for (let i3 = 0; i3 < numVerts; i3++) { + const o3 = i3 * 3; + const x2 = positions[o3 + 0]; + const y2 = positions[o3 + 1]; + const z = positions[o3 + 2]; + positions[o3 + xIndex] = x2; + positions[o3 + yIndex] = y2; + positions[o3 + zIndex] = z; + } + } + function getSurfaceIndices(polygon, positionSize, preproject, full3d) { + let holeIndices = getHoleIndices(polygon); + if (holeIndices) { + holeIndices = holeIndices.map((positionIndex) => positionIndex / positionSize); + } + let positions = getPositions(polygon); + const is3d = full3d && positionSize === 3; + if (preproject) { + const n2 = positions.length; + positions = positions.slice(); + const p2 = []; + for (let i3 = 0; i3 < n2; i3 += positionSize) { + p2[0] = positions[i3]; + p2[1] = positions[i3 + 1]; + if (is3d) { + p2[2] = positions[i3 + 2]; + } + const xy = preproject(p2); + positions[i3] = xy[0]; + positions[i3 + 1] = xy[1]; + if (is3d) { + positions[i3 + 2] = xy[2]; + } + } + } + if (is3d) { + const xyArea = getPlaneArea(positions, 0, 1); + const xzArea = getPlaneArea(positions, 0, 2); + const yzArea = getPlaneArea(positions, 1, 2); + if (!xyArea && !xzArea && !yzArea) { + return []; + } + if (xyArea > xzArea && xyArea > yzArea) { + } else if (xzArea > yzArea) { + if (!preproject) { + positions = positions.slice(); } + permutePositions(positions, 0, 2, 1); + } else { + if (!preproject) { + positions = positions.slice(); + } + permutePositions(positions, 2, 0, 1); } } - handleOutEvent(event) { - if (this.enableOutEvent) { - if (event.type === "mouseout") { - this._emit(OUT_EVENT_TYPE, event); + return (0, import_earcut2.default)(positions, holeIndices, positionSize); + } + + // node_modules/@deck.gl/layers/dist/esm/solid-polygon-layer/polygon-tesselator.js + var PolygonTesselator = class extends Tesselator { + constructor(opts) { + const { + fp64: fp642, + IndexType = Uint32Array + } = opts; + super({ + ...opts, + attributes: { + positions: { + size: 3, + type: fp642 ? Float64Array : Float32Array + }, + vertexValid: { + type: Uint8ClampedArray, + size: 1 + }, + indices: { + type: IndexType, + size: 1 + } } - } + }); } - handleEnterEvent(event) { - if (this.enableEnterEvent) { - if (event.type === "mouseenter") { - this._emit(ENTER_EVENT_TYPE, event); + get(attributeName) { + const { + attributes + } = this; + if (attributeName === "indices") { + return attributes.indices && attributes.indices.subarray(0, this.vertexCount); + } + return attributes[attributeName]; + } + updateGeometry(opts) { + super.updateGeometry(opts); + const externalIndices = this.buffers.indices; + if (externalIndices) { + this.vertexCount = (externalIndices.value || externalIndices).length; + } else if (this.data && !this.getGeometry) { + throw new Error("missing indices buffer"); + } + } + normalizeGeometry(polygon) { + if (this.normalize) { + const normalizedPolygon = normalize4(polygon, this.positionSize); + if (this.opts.resolution) { + return cutPolygonByGrid(getPositions(normalizedPolygon), getHoleIndices(normalizedPolygon), { + size: this.positionSize, + gridResolution: this.opts.resolution, + edgeTypes: true + }); } + if (this.opts.wrapLongitude) { + return cutPolygonByMercatorBounds(getPositions(normalizedPolygon), getHoleIndices(normalizedPolygon), { + size: this.positionSize, + maxLatitude: 86, + edgeTypes: true + }); + } + return normalizedPolygon; } + return polygon; } - handleLeaveEvent(event) { - if (this.enableLeaveEvent) { - if (event.type === "mouseleave") { - this._emit(LEAVE_EVENT_TYPE, event); + getGeometrySize(polygon) { + if (isCut2(polygon)) { + let size = 0; + for (const subPolygon of polygon) { + size += this.getGeometrySize(subPolygon); } + return size; } + return getPositions(polygon).length / this.positionSize; } - handleMoveEvent(event) { - if (this.enableMoveEvent) { - switch (event.type) { - case "mousedown": - if (event.button >= 0) { - this.pressed = true; - } - break; - case "mousemove": - if (event.which === 0) { - this.pressed = false; - } - if (!this.pressed) { - this._emit(MOVE_EVENT_TYPE, event); - } - break; - case "mouseup": - this.pressed = false; - break; - default: + getGeometryFromBuffer(buffer) { + if (this.normalize || !this.buffers.indices) { + return super.getGeometryFromBuffer(buffer); + } + return null; + } + updateGeometryAttributes(polygon, context) { + if (polygon && isCut2(polygon)) { + for (const subPolygon of polygon) { + const geometrySize = this.getGeometrySize(subPolygon); + context.geometrySize = geometrySize; + this.updateGeometryAttributes(subPolygon, context); + context.vertexStart += geometrySize; + context.indexStart = this.indexStarts[context.geometryIndex + 1]; } + } else { + this._updateIndices(polygon, context); + this._updatePositions(polygon, context); + this._updateVertexValid(polygon, context); } } - _emit(type, event) { - this.callback({ - type, - center: { - x: event.clientX, - y: event.clientY - }, - srcEvent: event, - pointerType: "mouse", - target: event.target + _updateIndices(polygon, { + geometryIndex, + vertexStart: offset, + indexStart + }) { + const { + attributes, + indexStarts, + typedArrayManager + } = this; + let target = attributes.indices; + if (!target || !polygon) { + return; + } + let i3 = indexStart; + const indices = getSurfaceIndices(polygon, this.positionSize, this.opts.preproject, this.opts.full3d); + target = typedArrayManager.allocate(target, indexStart + indices.length, { + copy: true }); + for (let j = 0; j < indices.length; j++) { + target[i3++] = indices[j] + offset; + } + indexStarts[geometryIndex + 1] = indexStart + indices.length; + attributes.indices = target; + } + _updatePositions(polygon, { + vertexStart, + geometrySize + }) { + const { + attributes: { + positions + }, + positionSize + } = this; + if (!positions || !polygon) { + return; + } + const polygonPositions = getPositions(polygon); + for (let i3 = vertexStart, j = 0; j < geometrySize; i3++, j++) { + const x2 = polygonPositions[j * positionSize]; + const y2 = polygonPositions[j * positionSize + 1]; + const z = positionSize > 2 ? polygonPositions[j * positionSize + 2] : 0; + positions[i3 * 3] = x2; + positions[i3 * 3 + 1] = y2; + positions[i3 * 3 + 2] = z; + } + } + _updateVertexValid(polygon, { + vertexStart, + geometrySize + }) { + const { + positionSize + } = this; + const vertexValid = this.attributes.vertexValid; + const holeIndices = polygon && getHoleIndices(polygon); + if (polygon && polygon.edgeTypes) { + vertexValid.set(polygon.edgeTypes, vertexStart); + } else { + vertexValid.fill(1, vertexStart, vertexStart + geometrySize); + } + if (holeIndices) { + for (let j = 0; j < holeIndices.length; j++) { + vertexValid[vertexStart + holeIndices[j] / positionSize - 1] = 0; + } + } + vertexValid[vertexStart + geometrySize - 1] = 0; } }; + function isCut2(polygon) { + return Array.isArray(polygon) && polygon.length > 0 && !Number.isFinite(polygon[0]); + } - // node_modules/mjolnir.js/dist/esm/inputs/key-input.js - var { KEY_EVENTS } = INPUT_EVENT_TYPES; - var DOWN_EVENT_TYPE = "keydown"; - var UP_EVENT_TYPE = "keyup"; - var KeyInput = class extends Input { - constructor(element, callback, options) { - super(element, callback, options); - this.handleEvent = (event) => { - const targetElement = event.target || event.srcElement; - if (targetElement.tagName === "INPUT" && targetElement.type === "text" || targetElement.tagName === "TEXTAREA") { - return; - } - if (this.enableDownEvent && event.type === "keydown") { - this.callback({ - type: DOWN_EVENT_TYPE, - srcEvent: event, - key: event.key, - target: event.target - }); + // node_modules/@deck.gl/layers/dist/esm/solid-polygon-layer/solid-polygon-layer-vertex-main.glsl.js + var solid_polygon_layer_vertex_main_glsl_default = "\nattribute vec2 vertexPositions;\nattribute float vertexValid;\n\nuniform bool extruded;\nuniform bool isWireframe;\nuniform float elevationScale;\nuniform float opacity;\n\nvarying vec4 vColor;\n\nstruct PolygonProps {\n vec4 fillColors;\n vec4 lineColors;\n vec3 positions;\n vec3 nextPositions;\n vec3 pickingColors;\n vec3 positions64Low;\n vec3 nextPositions64Low;\n float elevations;\n};\n\nvec3 project_offset_normal(vec3 vector) {\n if (project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT ||\n project_uCoordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSETS) {\n return normalize(vector * project_uCommonUnitsPerWorldUnit);\n }\n return project_normal(vector);\n}\n\nvoid calculatePosition(PolygonProps props) {\n#ifdef IS_SIDE_VERTEX\n if(vertexValid < 0.5){\n gl_Position = vec4(0.);\n return;\n }\n#endif\n\n vec3 pos;\n vec3 pos64Low;\n vec3 normal;\n vec4 colors = isWireframe ? props.lineColors : props.fillColors;\n\n geometry.worldPosition = props.positions;\n geometry.worldPositionAlt = props.nextPositions;\n geometry.pickingColor = props.pickingColors;\n\n#ifdef IS_SIDE_VERTEX\n pos = mix(props.positions, props.nextPositions, vertexPositions.x);\n pos64Low = mix(props.positions64Low, props.nextPositions64Low, vertexPositions.x);\n#else\n pos = props.positions;\n pos64Low = props.positions64Low;\n#endif\n\n if (extruded) {\n pos.z += props.elevations * vertexPositions.y * elevationScale;\n }\n gl_Position = project_position_to_clipspace(pos, pos64Low, vec3(0.), geometry.position);\n\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n if (extruded) {\n #ifdef IS_SIDE_VERTEX\n normal = vec3(\n props.positions.y - props.nextPositions.y + (props.positions64Low.y - props.nextPositions64Low.y),\n props.nextPositions.x - props.positions.x + (props.nextPositions64Low.x - props.positions64Low.x),\n 0.0);\n normal = project_offset_normal(normal);\n #else\n normal = project_normal(vec3(0.0, 0.0, 1.0));\n #endif\n geometry.normal = normal;\n vec3 lightColor = lighting_getLightColor(colors.rgb, project_uCameraPosition, geometry.position.xyz, normal);\n vColor = vec4(lightColor, colors.a * opacity);\n } else {\n vColor = vec4(colors.rgb, colors.a * opacity);\n }\n DECKGL_FILTER_COLOR(vColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/solid-polygon-layer/solid-polygon-layer-vertex-top.glsl.js + var solid_polygon_layer_vertex_top_glsl_default = "#define SHADER_NAME solid-polygon-layer-vertex-shader\n\nattribute vec3 positions;\nattribute vec3 positions64Low;\nattribute float elevations;\nattribute vec4 fillColors;\nattribute vec4 lineColors;\nattribute vec3 pickingColors;\n\n".concat(solid_polygon_layer_vertex_main_glsl_default, "\n\nvoid main(void) {\n PolygonProps props;\n\n props.positions = positions;\n props.positions64Low = positions64Low;\n props.elevations = elevations;\n props.fillColors = fillColors;\n props.lineColors = lineColors;\n props.pickingColors = pickingColors;\n\n calculatePosition(props);\n}\n"); + + // node_modules/@deck.gl/layers/dist/esm/solid-polygon-layer/solid-polygon-layer-vertex-side.glsl.js + var solid_polygon_layer_vertex_side_glsl_default = "#define SHADER_NAME solid-polygon-layer-vertex-shader-side\n#define IS_SIDE_VERTEX\n\n\nattribute vec3 instancePositions;\nattribute vec3 nextPositions;\nattribute vec3 instancePositions64Low;\nattribute vec3 nextPositions64Low;\nattribute float instanceElevations;\nattribute vec4 instanceFillColors;\nattribute vec4 instanceLineColors;\nattribute vec3 instancePickingColors;\n\n".concat(solid_polygon_layer_vertex_main_glsl_default, "\n\nvoid main(void) {\n PolygonProps props;\n\n #if RING_WINDING_ORDER_CW == 1\n props.positions = instancePositions;\n props.positions64Low = instancePositions64Low;\n props.nextPositions = nextPositions;\n props.nextPositions64Low = nextPositions64Low;\n #else\n props.positions = nextPositions;\n props.positions64Low = nextPositions64Low;\n props.nextPositions = instancePositions;\n props.nextPositions64Low = instancePositions64Low;\n #endif\n props.elevations = instanceElevations;\n props.fillColors = instanceFillColors;\n props.lineColors = instanceLineColors;\n props.pickingColors = instancePickingColors;\n\n calculatePosition(props);\n}\n"); + + // node_modules/@deck.gl/layers/dist/esm/solid-polygon-layer/solid-polygon-layer-fragment.glsl.js + var solid_polygon_layer_fragment_glsl_default = "#define SHADER_NAME solid-polygon-layer-fragment-shader\n\nprecision highp float;\n\nvarying vec4 vColor;\n\nvoid main(void) {\n gl_FragColor = vColor;\n\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/solid-polygon-layer/solid-polygon-layer.js + var DEFAULT_COLOR6 = [0, 0, 0, 255]; + var defaultProps9 = { + filled: true, + extruded: false, + wireframe: false, + _normalize: true, + _windingOrder: "CW", + _full3d: false, + elevationScale: { + type: "number", + min: 0, + value: 1 + }, + getPolygon: { + type: "accessor", + value: (f2) => f2.polygon + }, + getElevation: { + type: "accessor", + value: 1e3 + }, + getFillColor: { + type: "accessor", + value: DEFAULT_COLOR6 + }, + getLineColor: { + type: "accessor", + value: DEFAULT_COLOR6 + }, + material: true + }; + var ATTRIBUTE_TRANSITION2 = { + enter: (value, chunk) => { + return chunk.length ? chunk.subarray(chunk.length - value.length) : value; + } + }; + var SolidPolygonLayer = class extends Layer { + constructor(...args) { + super(...args); + _defineProperty(this, "state", void 0); + } + getShaders(type) { + return super.getShaders({ + vs: type === "top" ? solid_polygon_layer_vertex_top_glsl_default : solid_polygon_layer_vertex_side_glsl_default, + fs: solid_polygon_layer_fragment_glsl_default, + defines: { + RING_WINDING_ORDER_CW: !this.props._normalize && this.props._windingOrder === "CCW" ? 0 : 1 + }, + modules: [project32_default, gouraudLighting, picking_default] + }); + } + get wrapLongitude() { + return false; + } + initializeState() { + const { + gl, + viewport + } = this.context; + let { + coordinateSystem + } = this.props; + const { + _full3d + } = this.props; + if (viewport.isGeospatial && coordinateSystem === COORDINATE_SYSTEM.DEFAULT) { + coordinateSystem = COORDINATE_SYSTEM.LNGLAT; + } + let preproject; + if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) { + if (_full3d) { + preproject = viewport.projectPosition.bind(viewport); + } else { + preproject = viewport.projectFlat.bind(viewport); } - if (this.enableUpEvent && event.type === "keyup") { - this.callback({ - type: UP_EVENT_TYPE, - srcEvent: event, - key: event.key, - target: event.target - }); + } + this.setState({ + numInstances: 0, + polygonTesselator: new PolygonTesselator({ + preproject, + fp64: this.use64bitPositions(), + IndexType: !gl || hasFeatures(gl, FEATURES.ELEMENT_INDEX_UINT32) ? Uint32Array : Uint16Array + }) + }); + const attributeManager = this.getAttributeManager(); + const noAlloc = true; + attributeManager.remove(["instancePickingColors"]); + attributeManager.add({ + indices: { + size: 1, + isIndexed: true, + update: this.calculateIndices, + noAlloc + }, + positions: { + size: 3, + type: 5130, + fp64: this.use64bitPositions(), + transition: ATTRIBUTE_TRANSITION2, + accessor: "getPolygon", + update: this.calculatePositions, + noAlloc, + shaderAttributes: { + positions: { + vertexOffset: 0, + divisor: 0 + }, + instancePositions: { + vertexOffset: 0, + divisor: 1 + }, + nextPositions: { + vertexOffset: 1, + divisor: 1 + } + } + }, + vertexValid: { + size: 1, + divisor: 1, + type: 5121, + update: this.calculateVertexValid, + noAlloc + }, + elevations: { + size: 1, + transition: ATTRIBUTE_TRANSITION2, + accessor: "getElevation", + shaderAttributes: { + elevations: { + divisor: 0 + }, + instanceElevations: { + divisor: 1 + } + } + }, + fillColors: { + size: this.props.colorFormat.length, + type: 5121, + normalized: true, + transition: ATTRIBUTE_TRANSITION2, + accessor: "getFillColor", + defaultValue: DEFAULT_COLOR6, + shaderAttributes: { + fillColors: { + divisor: 0 + }, + instanceFillColors: { + divisor: 1 + } + } + }, + lineColors: { + size: this.props.colorFormat.length, + type: 5121, + normalized: true, + transition: ATTRIBUTE_TRANSITION2, + accessor: "getLineColor", + defaultValue: DEFAULT_COLOR6, + shaderAttributes: { + lineColors: { + divisor: 0 + }, + instanceLineColors: { + divisor: 1 + } + } + }, + pickingColors: { + size: 3, + type: 5121, + accessor: (object, { + index, + target: value + }) => this.encodePickingColor(object && object.__source ? object.__source.index : index, value), + shaderAttributes: { + pickingColors: { + divisor: 0 + }, + instancePickingColors: { + divisor: 1 + } + } } - }; - this.enableDownEvent = this.options.enable; - this.enableUpEvent = this.options.enable; - this.events = (this.options.events || []).concat(KEY_EVENTS); - element.tabIndex = this.options.tabIndex || 0; - element.style.outline = "none"; - this.events.forEach((event) => element.addEventListener(event, this.handleEvent)); + }); } - destroy() { - this.events.forEach((event) => this.element.removeEventListener(event, this.handleEvent)); + getPickingInfo(params) { + const info = super.getPickingInfo(params); + const { + index + } = info; + const { + data + } = this.props; + if (data[0] && data[0].__source) { + info.object = data.find((d2) => d2.__source.index === index); + } + return info; } - /** - * Enable this input (begin processing events) - * if the specified event type is among those handled by this input. - */ - enableEventType(eventType, enabled) { - if (eventType === DOWN_EVENT_TYPE) { - this.enableDownEvent = enabled; + disablePickingIndex(objectIndex) { + const { + data + } = this.props; + if (data[0] && data[0].__source) { + for (let i3 = 0; i3 < data.length; i3++) { + if (data[i3].__source.index === objectIndex) { + this._disablePickingIndex(i3); + } + } + } else { + super.disablePickingIndex(objectIndex); } - if (eventType === UP_EVENT_TYPE) { - this.enableUpEvent = enabled; + } + draw({ + uniforms + }) { + const { + extruded, + filled, + wireframe, + elevationScale + } = this.props; + const { + topModel, + sideModel, + polygonTesselator + } = this.state; + const renderUniforms = { + ...uniforms, + extruded: Boolean(extruded), + elevationScale + }; + if (sideModel) { + sideModel.setInstanceCount(polygonTesselator.instanceCount - 1); + sideModel.setUniforms(renderUniforms); + if (wireframe) { + sideModel.setDrawMode(3); + sideModel.setUniforms({ + isWireframe: true + }).draw(); + } + if (filled) { + sideModel.setDrawMode(6); + sideModel.setUniforms({ + isWireframe: false + }).draw(); + } + } + if (topModel) { + topModel.setVertexCount(polygonTesselator.vertexCount); + topModel.setUniforms(renderUniforms).draw(); + } + } + updateState(updateParams) { + super.updateState(updateParams); + this.updateGeometry(updateParams); + const { + props, + oldProps, + changeFlags + } = updateParams; + const attributeManager = this.getAttributeManager(); + const regenerateModels = changeFlags.extensionsChanged || props.filled !== oldProps.filled || props.extruded !== oldProps.extruded; + if (regenerateModels) { + var _this$state$models; + (_this$state$models = this.state.models) === null || _this$state$models === void 0 ? void 0 : _this$state$models.forEach((model) => model.delete()); + this.setState(this._getModels(this.context.gl)); + attributeManager.invalidateAll(); } } - }; - - // node_modules/mjolnir.js/dist/esm/inputs/contextmenu-input.js - var EVENT_TYPE2 = "contextmenu"; - var ContextmenuInput = class extends Input { - constructor(element, callback, options) { - super(element, callback, options); - this.handleEvent = (event) => { - if (!this.options.enable) { - return; + updateGeometry({ + props, + oldProps, + changeFlags + }) { + const geometryConfigChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPolygon); + if (geometryConfigChanged) { + const { + polygonTesselator + } = this.state; + const buffers = props.data.attributes || {}; + polygonTesselator.updateGeometry({ + data: props.data, + normalize: props._normalize, + geometryBuffer: buffers.getPolygon, + buffers, + getGeometry: props.getPolygon, + positionFormat: props.positionFormat, + wrapLongitude: props.wrapLongitude, + resolution: this.context.viewport.resolution, + fp64: this.use64bitPositions(), + dataChanged: changeFlags.dataChanged, + full3d: props._full3d + }); + this.setState({ + numInstances: polygonTesselator.instanceCount, + startIndices: polygonTesselator.vertexStarts + }); + if (!changeFlags.dataChanged) { + this.getAttributeManager().invalidateAll(); } - this.callback({ - type: EVENT_TYPE2, - center: { - x: event.clientX, - y: event.clientY + } + } + _getModels(gl) { + const { + id, + filled, + extruded + } = this.props; + let topModel; + let sideModel; + if (filled) { + const shaders = this.getShaders("top"); + shaders.defines.NON_INSTANCED_MODEL = 1; + topModel = new Model(gl, { + ...shaders, + id: "".concat(id, "-top"), + drawMode: 4, + attributes: { + vertexPositions: new Float32Array([0, 1]) }, - srcEvent: event, - pointerType: "mouse", - target: event.target + uniforms: { + isWireframe: false, + isSideVertex: false + }, + vertexCount: 0, + isIndexed: true }); + } + if (extruded) { + sideModel = new Model(gl, { + ...this.getShaders("side"), + id: "".concat(id, "-side"), + geometry: new Geometry({ + drawMode: 1, + vertexCount: 4, + attributes: { + vertexPositions: { + size: 2, + value: new Float32Array([1, 0, 0, 0, 0, 1, 1, 1]) + } + } + }), + instanceCount: 0, + isInstanced: 1 + }); + sideModel.userData.excludeAttributes = { + indices: true + }; + } + return { + models: [sideModel, topModel].filter(Boolean), + topModel, + sideModel }; - element.addEventListener("contextmenu", this.handleEvent); } - destroy() { - this.element.removeEventListener("contextmenu", this.handleEvent); + calculateIndices(attribute) { + const { + polygonTesselator + } = this.state; + attribute.startIndices = polygonTesselator.indexStarts; + attribute.value = polygonTesselator.get("indices"); } - /** - * Enable this input (begin processing events) - * if the specified event type is among those handled by this input. - */ - enableEventType(eventType, enabled) { - if (eventType === EVENT_TYPE2) { - this.options.enable = enabled; - } + calculatePositions(attribute) { + const { + polygonTesselator + } = this.state; + attribute.startIndices = polygonTesselator.vertexStarts; + attribute.value = polygonTesselator.get("positions"); + } + calculateVertexValid(attribute) { + attribute.value = this.state.polygonTesselator.get("vertexValid"); } }; - - // node_modules/mjolnir.js/dist/esm/utils/event-utils.js - var DOWN_EVENT = 1; - var MOVE_EVENT = 2; - var UP_EVENT = 4; - var MOUSE_EVENTS2 = { - pointerdown: DOWN_EVENT, - pointermove: MOVE_EVENT, - pointerup: UP_EVENT, - mousedown: DOWN_EVENT, - mousemove: MOVE_EVENT, - mouseup: UP_EVENT - }; - var MOUSE_EVENT_WHICH_LEFT = 1; - var MOUSE_EVENT_WHICH_MIDDLE = 2; - var MOUSE_EVENT_WHICH_RIGHT = 3; - var MOUSE_EVENT_BUTTON_LEFT = 0; - var MOUSE_EVENT_BUTTON_MIDDLE = 1; - var MOUSE_EVENT_BUTTON_RIGHT = 2; - var MOUSE_EVENT_BUTTONS_LEFT_MASK = 1; - var MOUSE_EVENT_BUTTONS_RIGHT_MASK = 2; - var MOUSE_EVENT_BUTTONS_MIDDLE_MASK = 4; - function whichButtons(event) { - const eventType = MOUSE_EVENTS2[event.srcEvent.type]; - if (!eventType) { - return null; + _defineProperty(SolidPolygonLayer, "defaultProps", defaultProps9); + _defineProperty(SolidPolygonLayer, "layerName", "SolidPolygonLayer"); + + // node_modules/@deck.gl/layers/dist/esm/utils.js + function replaceInRange({ + data, + getIndex, + dataRange, + replace + }) { + const { + startRow = 0, + endRow = Infinity + } = dataRange; + const count2 = data.length; + let replaceStart = count2; + let replaceEnd = count2; + for (let i3 = 0; i3 < count2; i3++) { + const row = getIndex(data[i3]); + if (replaceStart > i3 && row >= startRow) { + replaceStart = i3; + } + if (row >= endRow) { + replaceEnd = i3; + break; + } } - const { buttons, button, which } = event.srcEvent; - let leftButton = false; - let middleButton = false; - let rightButton = false; - if ( - // button is up, need to find out which one was pressed before - eventType === UP_EVENT || // moving but does not support `buttons` API - eventType === MOVE_EVENT && !Number.isFinite(buttons) - ) { - leftButton = which === MOUSE_EVENT_WHICH_LEFT; - middleButton = which === MOUSE_EVENT_WHICH_MIDDLE; - rightButton = which === MOUSE_EVENT_WHICH_RIGHT; - } else if (eventType === MOVE_EVENT) { - leftButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_LEFT_MASK); - middleButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_MIDDLE_MASK); - rightButton = Boolean(buttons & MOUSE_EVENT_BUTTONS_RIGHT_MASK); - } else if (eventType === DOWN_EVENT) { - leftButton = button === MOUSE_EVENT_BUTTON_LEFT; - middleButton = button === MOUSE_EVENT_BUTTON_MIDDLE; - rightButton = button === MOUSE_EVENT_BUTTON_RIGHT; + let index = replaceStart; + const dataLengthChanged = replaceEnd - replaceStart !== replace.length; + const endChunk = dataLengthChanged ? data.slice(replaceEnd) : void 0; + for (let i3 = 0; i3 < replace.length; i3++) { + data[index++] = replace[i3]; } - return { leftButton, middleButton, rightButton }; - } - function getOffsetPosition(event, rootElement) { - const center = event.center; - if (!center) { - return null; + if (endChunk) { + for (let i3 = 0; i3 < endChunk.length; i3++) { + data[index++] = endChunk[i3]; + } + data.length = index; } - const rect = rootElement.getBoundingClientRect(); - const scaleX2 = rect.width / rootElement.offsetWidth || 1; - const scaleY2 = rect.height / rootElement.offsetHeight || 1; - const offsetCenter = { - x: (center.x - rect.left - rootElement.clientLeft) / scaleX2, - y: (center.y - rect.top - rootElement.clientTop) / scaleY2 + return { + startRow: replaceStart, + endRow: replaceStart + replace.length }; - return { center, offsetCenter }; } - // node_modules/mjolnir.js/dist/esm/utils/event-registrar.js - var DEFAULT_OPTIONS = { - srcElement: "root", - priority: 0 + // node_modules/@deck.gl/layers/dist/esm/polygon-layer/polygon-layer.js + var defaultLineColor = [0, 0, 0, 255]; + var defaultFillColor = [0, 0, 0, 255]; + var defaultProps10 = { + stroked: true, + filled: true, + extruded: false, + elevationScale: 1, + wireframe: false, + _normalize: true, + _windingOrder: "CW", + lineWidthUnits: "meters", + lineWidthScale: 1, + lineWidthMinPixels: 0, + lineWidthMaxPixels: Number.MAX_SAFE_INTEGER, + lineJointRounded: false, + lineMiterLimit: 4, + getPolygon: { + type: "accessor", + value: (f2) => f2.polygon + }, + getFillColor: { + type: "accessor", + value: defaultFillColor + }, + getLineColor: { + type: "accessor", + value: defaultLineColor + }, + getLineWidth: { + type: "accessor", + value: 1 + }, + getElevation: { + type: "accessor", + value: 1e3 + }, + material: true }; - var EventRegistrar = class { - constructor(eventManager) { - this.handleEvent = (event) => { - if (this.isEmpty()) { - return; - } - const mjolnirEvent = this._normalizeEvent(event); - let target = event.srcEvent.target; - while (target && target !== mjolnirEvent.rootElement) { - this._emit(mjolnirEvent, target); - if (mjolnirEvent.handled) { - return; - } - target = target.parentNode; - } - this._emit(mjolnirEvent, "root"); - }; - this.eventManager = eventManager; - this.handlers = []; - this.handlersByElement = /* @__PURE__ */ new Map(); - this._active = false; - } - // Returns true if there are no non-passive handlers - isEmpty() { - return !this._active; - } - add(type, handler, options, once = false, passive = false) { - const { handlers, handlersByElement } = this; - let opts = DEFAULT_OPTIONS; - if (typeof options === "string" || options && options.addEventListener) { - opts = { ...DEFAULT_OPTIONS, srcElement: options }; - } else if (options) { - opts = { ...DEFAULT_OPTIONS, ...options }; - } - let entries = handlersByElement.get(opts.srcElement); - if (!entries) { - entries = []; - handlersByElement.set(opts.srcElement, entries); - } - const entry = { - type, - handler, - srcElement: opts.srcElement, - priority: opts.priority + var PolygonLayer = class extends CompositeLayer { + initializeState() { + this.state = { + paths: [] }; - if (once) { - entry.once = true; + if (this.props.getLineDashArray) { + log_default.removed("getLineDashArray", "PathStyleExtension")(); } - if (passive) { - entry.passive = true; - } - handlers.push(entry); - this._active = this._active || !entry.passive; - let insertPosition = entries.length - 1; - while (insertPosition >= 0) { - if (entries[insertPosition].priority >= entry.priority) { - break; - } - insertPosition--; + } + updateState({ + changeFlags + }) { + const geometryChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPolygon); + if (geometryChanged && Array.isArray(changeFlags.dataChanged)) { + const paths = this.state.paths.slice(); + const pathsDiff = changeFlags.dataChanged.map((dataRange) => replaceInRange({ + data: paths, + getIndex: (p2) => p2.__source.index, + dataRange, + replace: this._getPaths(dataRange) + })); + this.setState({ + paths, + pathsDiff + }); + } else if (geometryChanged) { + this.setState({ + paths: this._getPaths(), + pathsDiff: null + }); } - entries.splice(insertPosition + 1, 0, entry); } - remove(type, handler) { - const { handlers, handlersByElement } = this; - for (let i2 = handlers.length - 1; i2 >= 0; i2--) { - const entry = handlers[i2]; - if (entry.type === type && entry.handler === handler) { - handlers.splice(i2, 1); - const entries = handlersByElement.get(entry.srcElement); - entries.splice(entries.indexOf(entry), 1); - if (entries.length === 0) { - handlersByElement.delete(entry.srcElement); + _getPaths(dataRange = {}) { + const { + data, + getPolygon, + positionFormat, + _normalize + } = this.props; + const paths = []; + const positionSize = positionFormat === "XY" ? 2 : 3; + const { + startRow, + endRow + } = dataRange; + const { + iterable, + objectInfo + } = createIterable(data, startRow, endRow); + for (const object of iterable) { + objectInfo.index++; + let polygon = getPolygon(object, objectInfo); + if (_normalize) { + polygon = normalize4(polygon, positionSize); + } + const { + holeIndices + } = polygon; + const positions = polygon.positions || polygon; + if (holeIndices) { + for (let i3 = 0; i3 <= holeIndices.length; i3++) { + const path = positions.slice(holeIndices[i3 - 1] || 0, holeIndices[i3] || positions.length); + paths.push(this.getSubLayerRow({ + path + }, object, objectInfo.index)); } + } else { + paths.push(this.getSubLayerRow({ + path: positions + }, object, objectInfo.index)); } } - this._active = handlers.some((entry) => !entry.passive); + return paths; } - /** - * Invoke handlers on a particular element - */ - _emit(event, srcElement) { - const entries = this.handlersByElement.get(srcElement); - if (entries) { - let immediatePropagationStopped = false; - const stopPropagation = () => { - event.handled = true; - }; - const stopImmediatePropagation = () => { - event.handled = true; - immediatePropagationStopped = true; - }; - const entriesToRemove = []; - for (let i2 = 0; i2 < entries.length; i2++) { - const { type, handler, once } = entries[i2]; - handler({ - ...event, - // @ts-ignore - type, - stopPropagation, - stopImmediatePropagation - }); - if (once) { - entriesToRemove.push(entries[i2]); - } - if (immediatePropagationStopped) { - break; - } + renderLayers() { + const { + data, + _dataDiff, + stroked, + filled, + extruded, + wireframe, + _normalize, + _windingOrder, + elevationScale, + transitions, + positionFormat + } = this.props; + const { + lineWidthUnits, + lineWidthScale, + lineWidthMinPixels, + lineWidthMaxPixels, + lineJointRounded, + lineMiterLimit, + lineDashJustified + } = this.props; + const { + getFillColor, + getLineColor, + getLineWidth, + getLineDashArray, + getElevation, + getPolygon, + updateTriggers, + material + } = this.props; + const { + paths, + pathsDiff + } = this.state; + const FillLayer = this.getSubLayerClass("fill", SolidPolygonLayer); + const StrokeLayer = this.getSubLayerClass("stroke", PathLayer); + const polygonLayer = this.shouldRenderSubLayer("fill", paths) && new FillLayer({ + _dataDiff, + extruded, + elevationScale, + filled, + wireframe, + _normalize, + _windingOrder, + getElevation, + getFillColor, + getLineColor: extruded && wireframe ? getLineColor : defaultLineColor, + material, + transitions + }, this.getSubLayerProps({ + id: "fill", + updateTriggers: updateTriggers && { + getPolygon: updateTriggers.getPolygon, + getElevation: updateTriggers.getElevation, + getFillColor: updateTriggers.getFillColor, + lineColors: extruded && wireframe, + getLineColor: updateTriggers.getLineColor } - for (let i2 = 0; i2 < entriesToRemove.length; i2++) { - const { type, handler } = entriesToRemove[i2]; - this.remove(type, handler); + }), { + data, + positionFormat, + getPolygon + }); + const polygonLineLayer = !extruded && stroked && this.shouldRenderSubLayer("stroke", paths) && new StrokeLayer({ + _dataDiff: pathsDiff && (() => pathsDiff), + widthUnits: lineWidthUnits, + widthScale: lineWidthScale, + widthMinPixels: lineWidthMinPixels, + widthMaxPixels: lineWidthMaxPixels, + jointRounded: lineJointRounded, + miterLimit: lineMiterLimit, + dashJustified: lineDashJustified, + _pathType: "loop", + transitions: transitions && { + getWidth: transitions.getLineWidth, + getColor: transitions.getLineColor, + getPath: transitions.getPolygon + }, + getColor: this.getSubLayerAccessor(getLineColor), + getWidth: this.getSubLayerAccessor(getLineWidth), + getDashArray: this.getSubLayerAccessor(getLineDashArray) + }, this.getSubLayerProps({ + id: "stroke", + updateTriggers: updateTriggers && { + getWidth: updateTriggers.getLineWidth, + getColor: updateTriggers.getLineColor, + getDashArray: updateTriggers.getLineDashArray } + }), { + data: paths, + positionFormat, + getPath: (x2) => x2.path + }); + return [!extruded && polygonLayer, polygonLineLayer, extruded && polygonLayer]; + } + }; + _defineProperty(PolygonLayer, "layerName", "PolygonLayer"); + _defineProperty(PolygonLayer, "defaultProps", defaultProps10); + + // node_modules/@deck.gl/layers/dist/esm/geojson-layer/geojson-binary.js + function binaryToFeatureForAccesor(data, index) { + if (!data) { + return null; + } + const featureIndex = "startIndices" in data ? data.startIndices[index] : index; + const geometryIndex = data.featureIds.value[featureIndex]; + if (featureIndex !== -1) { + return getPropertiesForIndex(data, geometryIndex, featureIndex); + } + return null; + } + function getPropertiesForIndex(data, propertiesIndex, numericPropsIndex) { + const feature = { + properties: { + ...data.properties[propertiesIndex] } + }; + for (const prop in data.numericProps) { + feature.properties[prop] = data.numericProps[prop].value[numericPropsIndex]; } - /** - * Normalizes hammerjs and custom events to have predictable fields. - */ - _normalizeEvent(event) { - const rootElement = this.eventManager.getElement(); - return { - ...event, - ...whichButtons(event), - ...getOffsetPosition(event, rootElement), - preventDefault: () => { - event.srcEvent.preventDefault(); - }, - stopImmediatePropagation: null, - stopPropagation: null, - handled: false, - rootElement - }; + return feature; + } + function calculatePickingColors(geojsonBinary, encodePickingColor) { + const pickingColors = { + points: null, + lines: null, + polygons: null + }; + for (const key in pickingColors) { + const featureIds = geojsonBinary[key].globalFeatureIds.value; + pickingColors[key] = new Uint8ClampedArray(featureIds.length * 3); + const pickingColor = []; + for (let i3 = 0; i3 < featureIds.length; i3++) { + encodePickingColor(featureIds[i3], pickingColor); + pickingColors[key][i3 * 3 + 0] = pickingColor[0]; + pickingColors[key][i3 * 3 + 1] = pickingColor[1]; + pickingColors[key][i3 * 3 + 2] = pickingColor[2]; + } } - }; + return pickingColors; + } - // node_modules/mjolnir.js/dist/esm/event-manager.js - var DEFAULT_OPTIONS2 = { - // event handlers - events: null, - // custom recognizers - recognizers: null, - recognizerOptions: {}, - // Manager class - Manager: Manager2, - // allow browser default touch action - // https://github.com/uber/react-map-gl/issues/506 - touchAction: "none", - tabIndex: 0 + // node_modules/@deck.gl/layers/dist/esm/text-layer/multi-icon-layer/multi-icon-layer-fragment.glsl.js + var multi_icon_layer_fragment_glsl_default = "#define SHADER_NAME multi-icon-layer-fragment-shader\n\nprecision highp float;\n\nuniform float opacity;\nuniform sampler2D iconsTexture;\nuniform float gamma;\nuniform bool sdf;\nuniform float alphaCutoff;\nuniform float sdfBuffer;\nuniform float outlineBuffer;\nuniform vec4 outlineColor;\n\nvarying vec4 vColor;\nvarying vec2 vTextureCoords;\nvarying vec2 uv;\n\nvoid main(void) {\n geometry.uv = uv;\n\n if (!picking_uActive) {\n float alpha = texture2D(iconsTexture, vTextureCoords).a;\n vec4 color = vColor;\n if (sdf) {\n float distance = alpha;\n alpha = smoothstep(sdfBuffer - gamma, sdfBuffer + gamma, distance);\n\n if (outlineBuffer > 0.0) {\n float inFill = alpha;\n float inBorder = smoothstep(outlineBuffer - gamma, outlineBuffer + gamma, distance);\n color = mix(outlineColor, vColor, inFill);\n alpha = inBorder;\n }\n }\n float a = alpha * color.a;\n \n if (a < alphaCutoff) {\n discard;\n }\n\n gl_FragColor = vec4(color.rgb, a * opacity);\n }\n\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/text-layer/multi-icon-layer/multi-icon-layer.js + var DEFAULT_BUFFER2 = 192 / 256; + var EMPTY_ARRAY3 = []; + var defaultProps11 = { + getIconOffsets: { + type: "accessor", + value: (x2) => x2.offsets + }, + alphaCutoff: 1e-3, + smoothing: 0.1, + outlineWidth: 0, + outlineColor: { + type: "color", + value: [0, 0, 0, 255] + } }; - var EventManager = class { - constructor(element = null, options) { - this._onBasicInput = (event) => { - const { srcEvent } = event; - const alias = BASIC_EVENT_ALIASES[srcEvent.type]; - if (alias) { - this.manager.emit(alias, event); - } - }; - this._onOtherEvent = (event) => { - this.manager.emit(event.type, event); + var MultiIconLayer = class extends IconLayer { + constructor(...args) { + super(...args); + _defineProperty(this, "state", void 0); + } + getShaders() { + return { + ...super.getShaders(), + fs: multi_icon_layer_fragment_glsl_default }; - this.options = { ...DEFAULT_OPTIONS2, ...options }; - this.events = /* @__PURE__ */ new Map(); - this.setElement(element); - const { events } = this.options; - if (events) { - this.on(events); - } } - getElement() { - return this.element; + initializeState() { + super.initializeState(); + const attributeManager = this.getAttributeManager(); + attributeManager.addInstanced({ + instanceOffsets: { + size: 2, + accessor: "getIconOffsets" + }, + instancePickingColors: { + type: 5121, + size: 3, + accessor: (object, { + index, + target: value + }) => this.encodePickingColor(index, value) + } + }); } - setElement(element) { - if (this.element) { - this.destroy(); - } - this.element = element; - if (!element) { - return; - } - const { options } = this; - const ManagerClass = options.Manager; - this.manager = new ManagerClass(element, { - touchAction: options.touchAction, - recognizers: options.recognizers || RECOGNIZERS - }).on("hammer.input", this._onBasicInput); - if (!options.recognizers) { - Object.keys(RECOGNIZER_COMPATIBLE_MAP).forEach((name) => { - const recognizer = this.manager.get(name); - if (recognizer) { - RECOGNIZER_COMPATIBLE_MAP[name].forEach((otherName) => { - recognizer.recognizeWith(otherName); - }); - } + updateState(params) { + super.updateState(params); + const { + props, + oldProps + } = params; + let { + outlineColor + } = props; + if (outlineColor !== oldProps.outlineColor) { + outlineColor = outlineColor.map((x2) => x2 / 255); + outlineColor[3] = Number.isFinite(outlineColor[3]) ? outlineColor[3] : 1; + this.setState({ + outlineColor }); } - for (const recognizerName in options.recognizerOptions) { - const recognizer = this.manager.get(recognizerName); - if (recognizer) { - const recognizerOption = options.recognizerOptions[recognizerName]; - delete recognizerOption.enable; - recognizer.set(recognizerOption); - } + if (!props.sdf && props.outlineWidth) { + log_default.warn("".concat(this.id, ": fontSettings.sdf is required to render outline"))(); } - this.wheelInput = new WheelInput(element, this._onOtherEvent, { - enable: false - }); - this.moveInput = new MoveInput(element, this._onOtherEvent, { - enable: false - }); - this.keyInput = new KeyInput(element, this._onOtherEvent, { - enable: false, - tabIndex: options.tabIndex - }); - this.contextmenuInput = new ContextmenuInput(element, this._onOtherEvent, { - enable: false - }); - for (const [eventAlias, eventRegistrar] of this.events) { - if (!eventRegistrar.isEmpty()) { - this._toggleRecognizer(eventRegistrar.recognizerName, true); - this.manager.on(eventAlias, eventRegistrar.handleEvent); + } + draw(params) { + const { + sdf, + smoothing, + outlineWidth + } = this.props; + const { + outlineColor + } = this.state; + const outlineBuffer = outlineWidth ? Math.max(smoothing, DEFAULT_BUFFER2 * (1 - outlineWidth)) : -1; + params.uniforms = { + ...params.uniforms, + sdfBuffer: DEFAULT_BUFFER2, + outlineBuffer, + gamma: smoothing, + sdf: Boolean(sdf), + outlineColor + }; + super.draw(params); + if (sdf && outlineWidth) { + const { + iconManager + } = this.state; + const iconsTexture = iconManager.getTexture(); + if (iconsTexture) { + this.state.model.draw({ + uniforms: { + outlineBuffer: DEFAULT_BUFFER2 + } + }); } } } - // Tear down internal event management implementations. - destroy() { - if (this.element) { - this.wheelInput.destroy(); - this.moveInput.destroy(); - this.keyInput.destroy(); - this.contextmenuInput.destroy(); - this.manager.destroy(); - this.wheelInput = null; - this.moveInput = null; - this.keyInput = null; - this.contextmenuInput = null; - this.manager = null; - this.element = null; - } + getInstanceOffset(icons) { + return icons ? Array.from(icons).flatMap((icon) => super.getInstanceOffset(icon)) : EMPTY_ARRAY3; } - /** Register an event handler function to be called on `event` */ - on(event, handler, opts) { - this._addEventHandler(event, handler, opts, false); + getInstanceColorMode(icons) { + return 1; } - once(event, handler, opts) { - this._addEventHandler(event, handler, opts, true); + getInstanceIconFrame(icons) { + return icons ? Array.from(icons).flatMap((icon) => super.getInstanceIconFrame(icon)) : EMPTY_ARRAY3; } - watch(event, handler, opts) { - this._addEventHandler(event, handler, opts, false, true); + }; + _defineProperty(MultiIconLayer, "defaultProps", defaultProps11); + _defineProperty(MultiIconLayer, "layerName", "MultiIconLayer"); + + // node_modules/@mapbox/tiny-sdf/index.js + var INF = 1e20; + var TinySDF = class { + constructor({ + fontSize = 24, + buffer = 3, + radius = 8, + cutoff = 0.25, + fontFamily = "sans-serif", + fontWeight = "normal", + fontStyle = "normal" + } = {}) { + this.buffer = buffer; + this.cutoff = cutoff; + this.radius = radius; + const size = this.size = fontSize + buffer * 4; + const canvas = this._createCanvas(size); + const ctx = this.ctx = canvas.getContext("2d", { willReadFrequently: true }); + ctx.font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily}`; + ctx.textBaseline = "alphabetic"; + ctx.textAlign = "left"; + ctx.fillStyle = "black"; + this.gridOuter = new Float64Array(size * size); + this.gridInner = new Float64Array(size * size); + this.f = new Float64Array(size); + this.z = new Float64Array(size + 1); + this.v = new Uint16Array(size); + } + _createCanvas(size) { + const canvas = document.createElement("canvas"); + canvas.width = canvas.height = size; + return canvas; } - off(event, handler) { - this._removeEventHandler(event, handler); + draw(char) { + const { + width: glyphAdvance, + actualBoundingBoxAscent, + actualBoundingBoxDescent, + actualBoundingBoxLeft, + actualBoundingBoxRight + } = this.ctx.measureText(char); + const glyphTop = Math.ceil(actualBoundingBoxAscent); + const glyphLeft = 0; + const glyphWidth = Math.max(0, Math.min(this.size - this.buffer, Math.ceil(actualBoundingBoxRight - actualBoundingBoxLeft))); + const glyphHeight = Math.min(this.size - this.buffer, glyphTop + Math.ceil(actualBoundingBoxDescent)); + const width = glyphWidth + 2 * this.buffer; + const height = glyphHeight + 2 * this.buffer; + const len2 = Math.max(width * height, 0); + const data = new Uint8ClampedArray(len2); + const glyph = { data, width, height, glyphWidth, glyphHeight, glyphTop, glyphLeft, glyphAdvance }; + if (glyphWidth === 0 || glyphHeight === 0) + return glyph; + const { ctx, buffer, gridInner, gridOuter } = this; + ctx.clearRect(buffer, buffer, glyphWidth, glyphHeight); + ctx.fillText(char, buffer, buffer + glyphTop); + const imgData = ctx.getImageData(buffer, buffer, glyphWidth, glyphHeight); + gridOuter.fill(INF, 0, len2); + gridInner.fill(0, 0, len2); + for (let y2 = 0; y2 < glyphHeight; y2++) { + for (let x2 = 0; x2 < glyphWidth; x2++) { + const a2 = imgData.data[4 * (y2 * glyphWidth + x2) + 3] / 255; + if (a2 === 0) + continue; + const j = (y2 + buffer) * width + x2 + buffer; + if (a2 === 1) { + gridOuter[j] = 0; + gridInner[j] = INF; + } else { + const d2 = 0.5 - a2; + gridOuter[j] = d2 > 0 ? d2 * d2 : 0; + gridInner[j] = d2 < 0 ? d2 * d2 : 0; + } + } + } + edt(gridOuter, 0, 0, width, height, width, this.f, this.v, this.z); + edt(gridInner, buffer, buffer, glyphWidth, glyphHeight, width, this.f, this.v, this.z); + for (let i3 = 0; i3 < len2; i3++) { + const d2 = Math.sqrt(gridOuter[i3]) - Math.sqrt(gridInner[i3]); + data[i3] = Math.round(255 - 255 * (d2 / this.radius + this.cutoff)); + } + return glyph; } - /* - * Enable/disable recognizer for the given event - */ - _toggleRecognizer(name, enabled) { - const { manager } = this; - if (!manager) { - return; + }; + function edt(data, x0, y0, width, height, gridSize, f2, v2, z) { + for (let x2 = x0; x2 < x0 + width; x2++) + edt1d(data, y0 * gridSize + x2, gridSize, height, f2, v2, z); + for (let y2 = y0; y2 < y0 + height; y2++) + edt1d(data, y2 * gridSize + x0, 1, width, f2, v2, z); + } + function edt1d(grid, offset, stride, length4, f2, v2, z) { + v2[0] = 0; + z[0] = -INF; + z[1] = INF; + f2[0] = grid[offset]; + for (let q = 1, k = 0, s = 0; q < length4; q++) { + f2[q] = grid[offset + q * stride]; + const q2 = q * q; + do { + const r2 = v2[k]; + s = (f2[q] - f2[r2] + q2 - r2 * r2) / (q - r2) / 2; + } while (s <= z[k] && --k > -1); + k++; + v2[k] = q; + z[k] = s; + z[k + 1] = INF; + } + for (let q = 0, k = 0; q < length4; q++) { + while (z[k + 1] < q) + k++; + const r2 = v2[k]; + const qr = q - r2; + grid[offset + q * stride] = f2[r2] + qr * qr; + } + } + + // node_modules/@deck.gl/layers/dist/esm/text-layer/utils.js + var MISSING_CHAR_WIDTH = 32; + var SINGLE_LINE = []; + function nextPowOfTwo2(number) { + return Math.pow(2, Math.ceil(Math.log2(number))); + } + function buildMapping2({ + characterSet, + getFontWidth, + fontHeight, + buffer, + maxCanvasWidth, + mapping = {}, + xOffset = 0, + yOffset = 0 + }) { + let row = 0; + let x2 = xOffset; + const rowHeight = fontHeight + buffer * 2; + for (const char of characterSet) { + if (!mapping[char]) { + const width = getFontWidth(char); + if (x2 + width + buffer * 2 > maxCanvasWidth) { + x2 = 0; + row++; + } + mapping[char] = { + x: x2 + buffer, + y: yOffset + row * rowHeight + buffer, + width, + height: rowHeight, + layoutWidth: width, + layoutHeight: fontHeight + }; + x2 += width + buffer * 2; } - const recognizer = manager.get(name); - if (recognizer && recognizer.options.enable !== enabled) { - recognizer.set({ enable: enabled }); - const fallbackRecognizers = RECOGNIZER_FALLBACK_MAP[name]; - if (fallbackRecognizers && !this.options.recognizers) { - fallbackRecognizers.forEach((otherName) => { - const otherRecognizer = manager.get(otherName); - if (enabled) { - otherRecognizer.requireFailure(name); - recognizer.dropRequireFailure(otherName); - } else { - otherRecognizer.dropRequireFailure(name); - } - }); + } + return { + mapping, + xOffset: x2, + yOffset: yOffset + row * rowHeight, + canvasHeight: nextPowOfTwo2(yOffset + (row + 1) * rowHeight) + }; + } + function getTextWidth(text, startIndex, endIndex, mapping) { + let width = 0; + for (let i3 = startIndex; i3 < endIndex; i3++) { + var _mapping$character; + const character = text[i3]; + width += ((_mapping$character = mapping[character]) === null || _mapping$character === void 0 ? void 0 : _mapping$character.layoutWidth) || 0; + } + return width; + } + function breakAll(text, startIndex, endIndex, maxWidth, iconMapping, target) { + let rowStartCharIndex = startIndex; + let rowOffsetLeft = 0; + for (let i3 = startIndex; i3 < endIndex; i3++) { + const textWidth = getTextWidth(text, i3, i3 + 1, iconMapping); + if (rowOffsetLeft + textWidth > maxWidth) { + if (rowStartCharIndex < i3) { + target.push(i3); + } + rowStartCharIndex = i3; + rowOffsetLeft = 0; + } + rowOffsetLeft += textWidth; + } + return rowOffsetLeft; + } + function breakWord(text, startIndex, endIndex, maxWidth, iconMapping, target) { + let rowStartCharIndex = startIndex; + let groupStartCharIndex = startIndex; + let groupEndCharIndex = startIndex; + let rowOffsetLeft = 0; + for (let i3 = startIndex; i3 < endIndex; i3++) { + if (text[i3] === " ") { + groupEndCharIndex = i3 + 1; + } else if (text[i3 + 1] === " " || i3 + 1 === endIndex) { + groupEndCharIndex = i3 + 1; + } + if (groupEndCharIndex > groupStartCharIndex) { + let groupWidth = getTextWidth(text, groupStartCharIndex, groupEndCharIndex, iconMapping); + if (rowOffsetLeft + groupWidth > maxWidth) { + if (rowStartCharIndex < groupStartCharIndex) { + target.push(groupStartCharIndex); + rowStartCharIndex = groupStartCharIndex; + rowOffsetLeft = 0; + } + if (groupWidth > maxWidth) { + groupWidth = breakAll(text, groupStartCharIndex, groupEndCharIndex, maxWidth, iconMapping, target); + rowStartCharIndex = target[target.length - 1]; + } } + groupStartCharIndex = groupEndCharIndex; + rowOffsetLeft += groupWidth; } - this.wheelInput.enableEventType(name, enabled); - this.moveInput.enableEventType(name, enabled); - this.keyInput.enableEventType(name, enabled); - this.contextmenuInput.enableEventType(name, enabled); } - /** - * Process the event registration for a single event + handler. - */ - _addEventHandler(event, handler, opts, once, passive) { - if (typeof event !== "string") { - opts = handler; - for (const eventName in event) { - this._addEventHandler(eventName, event[eventName], opts, once, passive); + return rowOffsetLeft; + } + function autoWrapping(text, wordBreak, maxWidth, iconMapping, startIndex = 0, endIndex) { + if (endIndex === void 0) { + endIndex = text.length; + } + const result = []; + if (wordBreak === "break-all") { + breakAll(text, startIndex, endIndex, maxWidth, iconMapping, result); + } else { + breakWord(text, startIndex, endIndex, maxWidth, iconMapping, result); + } + return result; + } + function transformRow(line, startIndex, endIndex, iconMapping, leftOffsets, rowSize) { + let x2 = 0; + let rowHeight = 0; + for (let i3 = startIndex; i3 < endIndex; i3++) { + const character = line[i3]; + const frame = iconMapping[character]; + if (frame) { + if (!rowHeight) { + rowHeight = frame.layoutHeight; + } + leftOffsets[i3] = x2 + frame.layoutWidth / 2; + x2 += frame.layoutWidth; + } else { + log_default.warn("Missing character: ".concat(character, " (").concat(character.codePointAt(0), ")"))(); + leftOffsets[i3] = x2; + x2 += MISSING_CHAR_WIDTH; + } + } + rowSize[0] = x2; + rowSize[1] = rowHeight; + } + function transformParagraph(paragraph, lineHeight, wordBreak, maxWidth, iconMapping) { + const characters = Array.from(paragraph); + const numCharacters = characters.length; + const x2 = new Array(numCharacters); + const y2 = new Array(numCharacters); + const rowWidth = new Array(numCharacters); + const autoWrappingEnabled = (wordBreak === "break-word" || wordBreak === "break-all") && isFinite(maxWidth) && maxWidth > 0; + const size = [0, 0]; + const rowSize = [0, 0]; + let rowOffsetTop = 0; + let lineStartIndex = 0; + let lineEndIndex = 0; + for (let i3 = 0; i3 <= numCharacters; i3++) { + const char = characters[i3]; + if (char === "\n" || i3 === numCharacters) { + lineEndIndex = i3; + } + if (lineEndIndex > lineStartIndex) { + const rows = autoWrappingEnabled ? autoWrapping(characters, wordBreak, maxWidth, iconMapping, lineStartIndex, lineEndIndex) : SINGLE_LINE; + for (let rowIndex = 0; rowIndex <= rows.length; rowIndex++) { + const rowStart = rowIndex === 0 ? lineStartIndex : rows[rowIndex - 1]; + const rowEnd = rowIndex < rows.length ? rows[rowIndex] : lineEndIndex; + transformRow(characters, rowStart, rowEnd, iconMapping, x2, rowSize); + for (let j = rowStart; j < rowEnd; j++) { + var _iconMapping$char; + const char2 = characters[j]; + const layoutOffsetY = ((_iconMapping$char = iconMapping[char2]) === null || _iconMapping$char === void 0 ? void 0 : _iconMapping$char.layoutOffsetY) || 0; + y2[j] = rowOffsetTop + rowSize[1] / 2 + layoutOffsetY; + rowWidth[j] = rowSize[0]; + } + rowOffsetTop = rowOffsetTop + rowSize[1] * lineHeight; + size[0] = Math.max(size[0], rowSize[0]); } - return; + lineStartIndex = lineEndIndex; } - const { manager, events } = this; - const eventAlias = GESTURE_EVENT_ALIASES[event] || event; - let eventRegistrar = events.get(eventAlias); - if (!eventRegistrar) { - eventRegistrar = new EventRegistrar(this); - events.set(eventAlias, eventRegistrar); - eventRegistrar.recognizerName = EVENT_RECOGNIZER_MAP[eventAlias] || eventAlias; - if (manager) { - manager.on(eventAlias, eventRegistrar.handleEvent); - } + if (char === "\n") { + x2[lineStartIndex] = 0; + y2[lineStartIndex] = 0; + rowWidth[lineStartIndex] = 0; + lineStartIndex++; } - eventRegistrar.add(event, handler, opts, once, passive); - if (!eventRegistrar.isEmpty()) { - this._toggleRecognizer(eventRegistrar.recognizerName, true); + } + size[1] = rowOffsetTop; + return { + x: x2, + y: y2, + rowWidth, + size + }; + } + function getTextFromBuffer({ + value, + length: length4, + stride, + offset, + startIndices, + characterSet + }) { + const bytesPerElement = value.BYTES_PER_ELEMENT; + const elementStride = stride ? stride / bytesPerElement : 1; + const elementOffset = offset ? offset / bytesPerElement : 0; + const characterCount = startIndices[length4] || Math.ceil((value.length - elementOffset) / elementStride); + const autoCharacterSet = characterSet && /* @__PURE__ */ new Set(); + const texts = new Array(length4); + let codes = value; + if (elementStride > 1 || elementOffset > 0) { + const ArrayType = value.constructor; + codes = new ArrayType(characterCount); + for (let i3 = 0; i3 < characterCount; i3++) { + codes[i3] = value[i3 * elementStride + elementOffset]; + } + } + for (let index = 0; index < length4; index++) { + const startIndex = startIndices[index]; + const endIndex = startIndices[index + 1] || characterCount; + const codesAtIndex = codes.subarray(startIndex, endIndex); + texts[index] = String.fromCodePoint.apply(null, codesAtIndex); + if (autoCharacterSet) { + codesAtIndex.forEach(autoCharacterSet.add, autoCharacterSet); } } - /** - * Process the event deregistration for a single event + handler. - */ - _removeEventHandler(event, handler) { - if (typeof event !== "string") { - for (const eventName in event) { - this._removeEventHandler(eventName, event[eventName]); - } - return; + if (autoCharacterSet) { + for (const charCode of autoCharacterSet) { + characterSet.add(String.fromCodePoint(charCode)); } - const { events } = this; - const eventAlias = GESTURE_EVENT_ALIASES[event] || event; - const eventRegistrar = events.get(eventAlias); - if (!eventRegistrar) { - return; + } + return { + texts, + characterCount + }; + } + + // node_modules/@deck.gl/layers/dist/esm/text-layer/lru-cache.js + var LRUCache = class { + constructor(limit = 5) { + _defineProperty(this, "limit", void 0); + _defineProperty(this, "_cache", {}); + _defineProperty(this, "_order", []); + this.limit = limit; + } + get(key) { + const value = this._cache[key]; + if (value) { + this._deleteOrder(key); + this._appendOrder(key); } - eventRegistrar.remove(event, handler); - if (eventRegistrar.isEmpty()) { - const { recognizerName } = eventRegistrar; - let isRecognizerUsed = false; - for (const eh of events.values()) { - if (eh.recognizerName === recognizerName && !eh.isEmpty()) { - isRecognizerUsed = true; - break; - } - } - if (!isRecognizerUsed) { - this._toggleRecognizer(recognizerName, false); + return value; + } + set(key, value) { + if (!this._cache[key]) { + if (Object.keys(this._cache).length === this.limit) { + this.delete(this._order[0]); } + this._cache[key] = value; + this._appendOrder(key); + } else { + this.delete(key); + this._cache[key] = value; + this._appendOrder(key); + } + } + delete(key) { + const value = this._cache[key]; + if (value) { + delete this._cache[key]; + this._deleteOrder(key); + } + } + _deleteOrder(key) { + const index = this._order.indexOf(key); + if (index >= 0) { + this._order.splice(index, 1); } } + _appendOrder(key) { + this._order.push(key); + } }; - // node_modules/@deck.gl/core/dist/esm/lib/deck.js - function noop4() { - } - var getCursor = ({ - isDragging - }) => isDragging ? "grabbing" : "grab"; - var defaultProps = { - id: "", - width: "100%", - height: "100%", - style: null, - viewState: null, - initialViewState: null, - pickingRadius: 0, - layerFilter: null, - glOptions: {}, - parameters: {}, - parent: null, - gl: null, - canvas: null, - layers: [], - effects: [], - views: null, - controller: null, - useDevicePixels: true, - touchAction: "none", - eventRecognizerOptions: {}, - _framebuffer: null, - _animate: false, - _pickable: true, - _typedArrayManagerProps: {}, - _customRender: null, - onWebGLInitialized: noop4, - onResize: noop4, - onViewStateChange: noop4, - onInteractionStateChange: noop4, - onBeforeRender: noop4, - onAfterRender: noop4, - onLoad: noop4, - onError: (error2) => log_default.error(error2.message, error2.cause)(), - onHover: null, - onClick: null, - onDragStart: null, - onDrag: null, - onDragEnd: null, - _onMetrics: null, - getCursor, - getTooltip: null, - debug: false, - drawPickingColors: false + // node_modules/@deck.gl/layers/dist/esm/text-layer/font-atlas-manager.js + function getDefaultCharacterSet() { + const charSet = []; + for (let i3 = 32; i3 < 128; i3++) { + charSet.push(String.fromCharCode(i3)); + } + return charSet; + } + var DEFAULT_FONT_SETTINGS = { + fontFamily: "Monaco, monospace", + fontWeight: "normal", + characterSet: getDefaultCharacterSet(), + fontSize: 64, + buffer: 4, + sdf: false, + cutoff: 0.25, + radius: 12, + smoothing: 0.1 }; - var Deck = class { - constructor(props) { - _defineProperty(this, "props", void 0); - _defineProperty(this, "width", 0); - _defineProperty(this, "height", 0); - _defineProperty(this, "userData", {}); - _defineProperty(this, "canvas", null); - _defineProperty(this, "viewManager", null); - _defineProperty(this, "layerManager", null); - _defineProperty(this, "effectManager", null); - _defineProperty(this, "deckRenderer", null); - _defineProperty(this, "deckPicker", null); - _defineProperty(this, "eventManager", null); - _defineProperty(this, "tooltip", null); - _defineProperty(this, "metrics", void 0); - _defineProperty(this, "animationLoop", void 0); - _defineProperty(this, "stats", void 0); - _defineProperty(this, "viewState", void 0); - _defineProperty(this, "cursorState", void 0); - _defineProperty(this, "_needsRedraw", void 0); - _defineProperty(this, "_pickRequest", void 0); - _defineProperty(this, "_lastPointerDownInfo", null); - _defineProperty(this, "_metricsCounter", void 0); - _defineProperty(this, "_onPointerMove", (event) => { - const { - _pickRequest - } = this; - if (event.type === "pointerleave") { - _pickRequest.x = -1; - _pickRequest.y = -1; - _pickRequest.radius = 0; - } else if (event.leftButton || event.rightButton) { - return; - } else { - const pos = event.offsetCenter; - if (!pos) { - return; - } - _pickRequest.x = pos.x; - _pickRequest.y = pos.y; - _pickRequest.radius = this.props.pickingRadius; - } - if (this.layerManager) { - this.layerManager.context.mousePosition = { - x: _pickRequest.x, - y: _pickRequest.y - }; - } - _pickRequest.event = event; + var MAX_CANVAS_WIDTH = 1024; + var BASELINE_SCALE = 0.9; + var HEIGHT_SCALE = 1.2; + var CACHE_LIMIT = 3; + var cache3 = new LRUCache(CACHE_LIMIT); + function getNewChars(cacheKey, characterSet) { + let newCharSet; + if (typeof characterSet === "string") { + newCharSet = new Set(Array.from(characterSet)); + } else { + newCharSet = new Set(characterSet); + } + const cachedFontAtlas = cache3.get(cacheKey); + if (!cachedFontAtlas) { + return newCharSet; + } + for (const char in cachedFontAtlas.mapping) { + if (newCharSet.has(char)) { + newCharSet.delete(char); + } + } + return newCharSet; + } + function populateAlphaChannel(alphaChannel, imageData) { + for (let i3 = 0; i3 < alphaChannel.length; i3++) { + imageData.data[4 * i3 + 3] = alphaChannel[i3]; + } + } + function setTextStyle(ctx, fontFamily, fontSize, fontWeight) { + ctx.font = "".concat(fontWeight, " ").concat(fontSize, "px ").concat(fontFamily); + ctx.fillStyle = "#000"; + ctx.textBaseline = "alphabetic"; + ctx.textAlign = "left"; + } + function setFontAtlasCacheLimit(limit) { + log_default.assert(Number.isFinite(limit) && limit >= CACHE_LIMIT, "Invalid cache limit"); + cache3 = new LRUCache(limit); + } + var FontAtlasManager = class { + constructor() { + _defineProperty(this, "props", { + ...DEFAULT_FONT_SETTINGS }); - _defineProperty(this, "_onEvent", (event) => { - const eventOptions = EVENTS[event.type]; - const pos = event.offsetCenter; - if (!eventOptions || !pos || !this.layerManager) { - return; - } - const layers = this.layerManager.getLayers(); - const info = this.deckPicker.getLastPickedObject({ - x: pos.x, - y: pos.y, - layers, - viewports: this.getViewports(pos) - }, this._lastPointerDownInfo); - const { - layer - } = info; - const layerHandler = layer && (layer[eventOptions.handler] || layer.props[eventOptions.handler]); - const rootHandler = this.props[eventOptions.handler]; - let handled = false; - if (layerHandler) { - handled = layerHandler.call(layer, info, event); + _defineProperty(this, "_key", void 0); + _defineProperty(this, "_atlas", void 0); + } + get texture() { + return this._atlas; + } + get mapping() { + return this._atlas && this._atlas.mapping; + } + get scale() { + const { + fontSize, + buffer + } = this.props; + return (fontSize * HEIGHT_SCALE + buffer * 2) / fontSize; + } + setProps(props = {}) { + Object.assign(this.props, props); + this._key = this._getKey(); + const charSet = getNewChars(this._key, this.props.characterSet); + const cachedFontAtlas = cache3.get(this._key); + if (cachedFontAtlas && charSet.size === 0) { + if (this._atlas !== cachedFontAtlas) { + this._atlas = cachedFontAtlas; } - if (!handled && rootHandler) { - rootHandler(info, event); + return; + } + const fontAtlas = this._generateFontAtlas(charSet, cachedFontAtlas); + this._atlas = fontAtlas; + cache3.set(this._key, fontAtlas); + } + _generateFontAtlas(characterSet, cachedFontAtlas) { + const { + fontFamily, + fontWeight, + fontSize, + buffer, + sdf, + radius, + cutoff + } = this.props; + let canvas = cachedFontAtlas && cachedFontAtlas.data; + if (!canvas) { + canvas = document.createElement("canvas"); + canvas.width = MAX_CANVAS_WIDTH; + } + const ctx = canvas.getContext("2d", { + willReadFrequently: true + }); + setTextStyle(ctx, fontFamily, fontSize, fontWeight); + const { + mapping, + canvasHeight, + xOffset, + yOffset + } = buildMapping2({ + getFontWidth: (char) => ctx.measureText(char).width, + fontHeight: fontSize * HEIGHT_SCALE, + buffer, + characterSet, + maxCanvasWidth: MAX_CANVAS_WIDTH, + ...cachedFontAtlas && { + mapping: cachedFontAtlas.mapping, + xOffset: cachedFontAtlas.xOffset, + yOffset: cachedFontAtlas.yOffset } }); - _defineProperty(this, "_onPointerDown", (event) => { - const pos = event.offsetCenter; - const pickedInfo = this._pick("pickObject", "pickObject Time", { - x: pos.x, - y: pos.y, - radius: this.props.pickingRadius + if (canvas.height !== canvasHeight) { + const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height); + canvas.height = canvasHeight; + ctx.putImageData(imageData, 0, 0); + } + setTextStyle(ctx, fontFamily, fontSize, fontWeight); + if (sdf) { + const tinySDF = new TinySDF({ + fontSize, + buffer, + radius, + cutoff, + fontFamily, + fontWeight: "".concat(fontWeight) }); - this._lastPointerDownInfo = pickedInfo.result[0] || pickedInfo.emptyInfo; - }); - this.props = { - ...defaultProps, - ...props - }; - props = this.props; - this._needsRedraw = "Initial render"; - this._pickRequest = { - mode: "hover", - x: -1, - y: -1, - radius: 0, - event: null - }; - this.cursorState = { - isHovering: false, - isDragging: false - }; - if (props.viewState && props.initialViewState) { - log_default.warn("View state tracking is disabled. Use either `initialViewState` for auto update or `viewState` for manual update.")(); - } - if (getBrowser() === "IE") { - log_default.warn("IE 11 is not supported")(); - } - this.viewState = props.initialViewState; - if (!props.gl) { - if (typeof document !== "undefined") { - this.canvas = this._createCanvas(props); + for (const char of characterSet) { + const { + data, + width, + height, + glyphTop + } = tinySDF.draw(char); + mapping[char].width = width; + mapping[char].layoutOffsetY = fontSize * BASELINE_SCALE - glyphTop; + const imageData = ctx.createImageData(width, height); + populateAlphaChannel(data, imageData); + ctx.putImageData(imageData, mapping[char].x, mapping[char].y); + } + } else { + for (const char of characterSet) { + ctx.fillText(char, mapping[char].x, mapping[char].y + buffer + fontSize * BASELINE_SCALE); } } - this.animationLoop = this._createAnimationLoop(props); - this.stats = new Stats({ - id: "deck.gl" - }); - this.metrics = { - fps: 0, - setPropsTime: 0, - updateAttributesTime: 0, - framesRedrawn: 0, - pickTime: 0, - pickCount: 0, - gpuTime: 0, - gpuTimePerFrame: 0, - cpuTime: 0, - cpuTimePerFrame: 0, - bufferMemory: 0, - textureMemory: 0, - renderbufferMemory: 0, - gpuMemory: 0 + return { + xOffset, + yOffset, + mapping, + data: canvas, + width: canvas.width, + height: canvas.height }; - this._metricsCounter = 0; - this.setProps(props); - if (props._typedArrayManagerProps) { - typed_array_manager_default.setOptions(props._typedArrayManagerProps); - } - this.animationLoop.start(); } - finalize() { - var _this$animationLoop, _this$layerManager, _this$viewManager, _this$effectManager, _this$deckRenderer, _this$deckPicker, _this$eventManager, _this$tooltip; - (_this$animationLoop = this.animationLoop) === null || _this$animationLoop === void 0 ? void 0 : _this$animationLoop.stop(); - this.animationLoop = null; - this._lastPointerDownInfo = null; - (_this$layerManager = this.layerManager) === null || _this$layerManager === void 0 ? void 0 : _this$layerManager.finalize(); - this.layerManager = null; - (_this$viewManager = this.viewManager) === null || _this$viewManager === void 0 ? void 0 : _this$viewManager.finalize(); - this.viewManager = null; - (_this$effectManager = this.effectManager) === null || _this$effectManager === void 0 ? void 0 : _this$effectManager.finalize(); - this.effectManager = null; - (_this$deckRenderer = this.deckRenderer) === null || _this$deckRenderer === void 0 ? void 0 : _this$deckRenderer.finalize(); - this.deckRenderer = null; - (_this$deckPicker = this.deckPicker) === null || _this$deckPicker === void 0 ? void 0 : _this$deckPicker.finalize(); - this.deckPicker = null; - (_this$eventManager = this.eventManager) === null || _this$eventManager === void 0 ? void 0 : _this$eventManager.destroy(); - this.eventManager = null; - (_this$tooltip = this.tooltip) === null || _this$tooltip === void 0 ? void 0 : _this$tooltip.remove(); - this.tooltip = null; - if (!this.props.canvas && !this.props.gl && this.canvas) { - var _this$canvas$parentEl; - (_this$canvas$parentEl = this.canvas.parentElement) === null || _this$canvas$parentEl === void 0 ? void 0 : _this$canvas$parentEl.removeChild(this.canvas); - this.canvas = null; + _getKey() { + const { + fontFamily, + fontWeight, + fontSize, + buffer, + sdf, + radius, + cutoff + } = this.props; + if (sdf) { + return "".concat(fontFamily, " ").concat(fontWeight, " ").concat(fontSize, " ").concat(buffer, " ").concat(radius, " ").concat(cutoff); } + return "".concat(fontFamily, " ").concat(fontWeight, " ").concat(fontSize, " ").concat(buffer); } - setProps(props) { - this.stats.get("setProps Time").timeStart(); - if ("onLayerHover" in props) { - log_default.removed("onLayerHover", "onHover")(); - } - if ("onLayerClick" in props) { - log_default.removed("onLayerClick", "onClick")(); - } - if (props.initialViewState && !deepEqual(this.props.initialViewState, props.initialViewState, 3)) { - this.viewState = props.initialViewState; - } - Object.assign(this.props, props); - this._setCanvasSize(this.props); - const resolvedProps = Object.create(this.props); - Object.assign(resolvedProps, { - views: this._getViews(), - width: this.width, - height: this.height, - viewState: this._getViewState() + }; + + // node_modules/@deck.gl/layers/dist/esm/text-layer/text-background-layer/text-background-layer-vertex.glsl.js + var text_background_layer_vertex_glsl_default = "#define SHADER_NAME text-background-layer-vertex-shader\n\nattribute vec2 positions;\n\nattribute vec3 instancePositions;\nattribute vec3 instancePositions64Low;\nattribute vec4 instanceRects;\nattribute float instanceSizes;\nattribute float instanceAngles;\nattribute vec2 instancePixelOffsets;\nattribute float instanceLineWidths;\nattribute vec4 instanceFillColors;\nattribute vec4 instanceLineColors;\nattribute vec3 instancePickingColors;\n\nuniform bool billboard;\nuniform float opacity;\nuniform float sizeScale;\nuniform float sizeMinPixels;\nuniform float sizeMaxPixels;\nuniform vec4 padding;\nuniform int sizeUnits;\n\nvarying vec4 vFillColor;\nvarying vec4 vLineColor;\nvarying float vLineWidth;\nvarying vec2 uv;\nvarying vec2 dimensions;\n\nvec2 rotate_by_angle(vec2 vertex, float angle) {\n float angle_radian = radians(angle);\n float cos_angle = cos(angle_radian);\n float sin_angle = sin(angle_radian);\n mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle);\n return rotationMatrix * vertex;\n}\n\nvoid main(void) {\n geometry.worldPosition = instancePositions;\n geometry.uv = positions;\n geometry.pickingColor = instancePickingColors;\n uv = positions;\n vLineWidth = instanceLineWidths;\n float sizePixels = clamp(\n project_size_to_pixel(instanceSizes * sizeScale, sizeUnits),\n sizeMinPixels, sizeMaxPixels\n );\n\n dimensions = instanceRects.zw * sizePixels + padding.xy + padding.zw;\n\n vec2 pixelOffset = (positions * instanceRects.zw + instanceRects.xy) * sizePixels + mix(-padding.xy, padding.zw, positions);\n pixelOffset = rotate_by_angle(pixelOffset, instanceAngles);\n pixelOffset += instancePixelOffsets;\n pixelOffset.y *= -1.0;\n\n if (billboard) {\n gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n vec3 offset = vec3(pixelOffset, 0.0);\n DECKGL_FILTER_SIZE(offset, geometry);\n gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);\n } else {\n vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0);\n DECKGL_FILTER_SIZE(offset_common, geometry);\n gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n }\n vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * opacity);\n DECKGL_FILTER_COLOR(vFillColor, geometry);\n vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * opacity);\n DECKGL_FILTER_COLOR(vLineColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/text-layer/text-background-layer/text-background-layer-fragment.glsl.js + var text_background_layer_fragment_glsl_default = "#define SHADER_NAME text-background-layer-fragment-shader\n\nprecision highp float;\n\nuniform bool stroked;\n\nvarying vec4 vFillColor;\nvarying vec4 vLineColor;\nvarying float vLineWidth;\nvarying vec2 uv;\nvarying vec2 dimensions;\n\nvoid main(void) {\n geometry.uv = uv;\n\n vec2 pixelPosition = uv * dimensions;\n if (stroked) {\n float distToEdge = min(\n min(pixelPosition.x, dimensions.x - pixelPosition.x),\n min(pixelPosition.y, dimensions.y - pixelPosition.y)\n );\n float isBorder = smoothedge(distToEdge, vLineWidth);\n gl_FragColor = mix(vFillColor, vLineColor, isBorder);\n } else {\n gl_FragColor = vFillColor;\n }\n\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; + + // node_modules/@deck.gl/layers/dist/esm/text-layer/text-background-layer/text-background-layer.js + var defaultProps12 = { + billboard: true, + sizeScale: 1, + sizeUnits: "pixels", + sizeMinPixels: 0, + sizeMaxPixels: Number.MAX_SAFE_INTEGER, + padding: { + type: "array", + value: [0, 0, 0, 0] + }, + getPosition: { + type: "accessor", + value: (x2) => x2.position + }, + getSize: { + type: "accessor", + value: 1 + }, + getAngle: { + type: "accessor", + value: 0 + }, + getPixelOffset: { + type: "accessor", + value: [0, 0] + }, + getBoundingRect: { + type: "accessor", + value: [0, 0, 0, 0] + }, + getFillColor: { + type: "accessor", + value: [0, 0, 0, 255] + }, + getLineColor: { + type: "accessor", + value: [0, 0, 0, 255] + }, + getLineWidth: { + type: "accessor", + value: 1 + } + }; + var TextBackgroundLayer = class extends Layer { + constructor(...args) { + super(...args); + _defineProperty(this, "state", void 0); + } + getShaders() { + return super.getShaders({ + vs: text_background_layer_vertex_glsl_default, + fs: text_background_layer_fragment_glsl_default, + modules: [project32_default, picking_default] }); - this.animationLoop.setProps(resolvedProps); - if (this.layerManager) { - this.viewManager.setProps(resolvedProps); - this.layerManager.activateViewport(this.getViewports()[0]); - this.layerManager.setProps(resolvedProps); - this.effectManager.setProps(resolvedProps); - this.deckRenderer.setProps(resolvedProps); - this.deckPicker.setProps(resolvedProps); + } + initializeState() { + this.getAttributeManager().addInstanced({ + instancePositions: { + size: 3, + type: 5130, + fp64: this.use64bitPositions(), + transition: true, + accessor: "getPosition" + }, + instanceSizes: { + size: 1, + transition: true, + accessor: "getSize", + defaultValue: 1 + }, + instanceAngles: { + size: 1, + transition: true, + accessor: "getAngle" + }, + instanceRects: { + size: 4, + accessor: "getBoundingRect" + }, + instancePixelOffsets: { + size: 2, + transition: true, + accessor: "getPixelOffset" + }, + instanceFillColors: { + size: 4, + transition: true, + normalized: true, + type: 5121, + accessor: "getFillColor", + defaultValue: [0, 0, 0, 255] + }, + instanceLineColors: { + size: 4, + transition: true, + normalized: true, + type: 5121, + accessor: "getLineColor", + defaultValue: [0, 0, 0, 255] + }, + instanceLineWidths: { + size: 1, + transition: true, + accessor: "getLineWidth", + defaultValue: 1 + } + }); + } + updateState(params) { + super.updateState(params); + const { + changeFlags + } = params; + if (changeFlags.extensionsChanged) { + var _this$state$model; + const { + gl + } = this.context; + (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); + this.state.model = this._getModel(gl); + this.getAttributeManager().invalidateAll(); } - this.stats.get("setProps Time").timeEnd(); } - needsRedraw(opts = { - clearRedrawFlags: false + draw({ + uniforms }) { - if (!this.layerManager) { - return false; + const { + billboard, + sizeScale, + sizeUnits, + sizeMinPixels, + sizeMaxPixels, + getLineWidth + } = this.props; + let { + padding + } = this.props; + if (padding.length < 4) { + padding = [padding[0], padding[1], padding[0], padding[1]]; } - if (this.props._animate) { - return "Deck._animate"; + this.state.model.setUniforms(uniforms).setUniforms({ + billboard, + stroked: Boolean(getLineWidth), + padding, + sizeUnits: UNIT[sizeUnits], + sizeScale, + sizeMinPixels, + sizeMaxPixels + }).draw(); + } + _getModel(gl) { + const positions = [0, 0, 1, 0, 1, 1, 0, 1]; + return new Model(gl, { + ...this.getShaders(), + id: this.props.id, + geometry: new Geometry({ + drawMode: 6, + vertexCount: 4, + attributes: { + positions: { + size: 2, + value: new Float32Array(positions) + } + } + }), + isInstanced: true + }); + } + }; + _defineProperty(TextBackgroundLayer, "defaultProps", defaultProps12); + _defineProperty(TextBackgroundLayer, "layerName", "TextBackgroundLayer"); + + // node_modules/@deck.gl/layers/dist/esm/text-layer/text-layer.js + var TEXT_ANCHOR = { + start: 1, + middle: 0, + end: -1 + }; + var ALIGNMENT_BASELINE = { + top: 1, + center: 0, + bottom: -1 + }; + var DEFAULT_COLOR7 = [0, 0, 0, 255]; + var DEFAULT_LINE_HEIGHT = 1; + var defaultProps13 = { + billboard: true, + sizeScale: 1, + sizeUnits: "pixels", + sizeMinPixels: 0, + sizeMaxPixels: Number.MAX_SAFE_INTEGER, + background: false, + getBackgroundColor: { + type: "accessor", + value: [255, 255, 255, 255] + }, + getBorderColor: { + type: "accessor", + value: DEFAULT_COLOR7 + }, + getBorderWidth: { + type: "accessor", + value: 0 + }, + backgroundPadding: { + type: "array", + value: [0, 0, 0, 0] + }, + characterSet: { + type: "object", + value: DEFAULT_FONT_SETTINGS.characterSet + }, + fontFamily: DEFAULT_FONT_SETTINGS.fontFamily, + fontWeight: DEFAULT_FONT_SETTINGS.fontWeight, + lineHeight: DEFAULT_LINE_HEIGHT, + outlineWidth: { + type: "number", + value: 0, + min: 0 + }, + outlineColor: { + type: "color", + value: DEFAULT_COLOR7 + }, + fontSettings: { + type: "object", + value: {}, + compare: 1 + }, + wordBreak: "break-word", + maxWidth: { + type: "number", + value: -1 + }, + getText: { + type: "accessor", + value: (x2) => x2.text + }, + getPosition: { + type: "accessor", + value: (x2) => x2.position + }, + getColor: { + type: "accessor", + value: DEFAULT_COLOR7 + }, + getSize: { + type: "accessor", + value: 32 + }, + getAngle: { + type: "accessor", + value: 0 + }, + getTextAnchor: { + type: "accessor", + value: "middle" + }, + getAlignmentBaseline: { + type: "accessor", + value: "center" + }, + getPixelOffset: { + type: "accessor", + value: [0, 0] + }, + backgroundColor: { + deprecatedFor: ["background", "getBackgroundColor"] + } + }; + var TextLayer = class extends CompositeLayer { + constructor(...args) { + super(...args); + _defineProperty(this, "state", void 0); + _defineProperty(this, "getBoundingRect", (object, objectInfo) => { + let { + size: [width, height] + } = this.transformParagraph(object, objectInfo); + const { + fontSize + } = this.state.fontAtlasManager.props; + width /= fontSize; + height /= fontSize; + const { + getTextAnchor, + getAlignmentBaseline + } = this.props; + const anchorX = TEXT_ANCHOR[typeof getTextAnchor === "function" ? getTextAnchor(object, objectInfo) : getTextAnchor]; + const anchorY = ALIGNMENT_BASELINE[typeof getAlignmentBaseline === "function" ? getAlignmentBaseline(object, objectInfo) : getAlignmentBaseline]; + return [(anchorX - 1) * width / 2, (anchorY - 1) * height / 2, width, height]; + }); + _defineProperty(this, "getIconOffsets", (object, objectInfo) => { + const { + getTextAnchor, + getAlignmentBaseline + } = this.props; + const { + x: x2, + y: y2, + rowWidth, + size: [width, height] + } = this.transformParagraph(object, objectInfo); + const anchorX = TEXT_ANCHOR[typeof getTextAnchor === "function" ? getTextAnchor(object, objectInfo) : getTextAnchor]; + const anchorY = ALIGNMENT_BASELINE[typeof getAlignmentBaseline === "function" ? getAlignmentBaseline(object, objectInfo) : getAlignmentBaseline]; + const numCharacters = x2.length; + const offsets = new Array(numCharacters * 2); + let index = 0; + for (let i3 = 0; i3 < numCharacters; i3++) { + const rowOffset = (1 - anchorX) * (width - rowWidth[i3]) / 2; + offsets[index++] = (anchorX - 1) * width / 2 + rowOffset + x2[i3]; + offsets[index++] = (anchorY - 1) * height / 2 + y2[i3]; + } + return offsets; + }); + } + initializeState() { + this.state = { + styleVersion: 0, + fontAtlasManager: new FontAtlasManager() + }; + if (this.props.maxWidth > 0) { + log_default.warn("v8.9 breaking change: TextLayer maxWidth is now relative to text size")(); } - let redraw = this._needsRedraw; - if (opts.clearRedrawFlags) { - this._needsRedraw = false; + } + updateState(params) { + const { + props, + oldProps, + changeFlags + } = params; + const textChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getText); + if (textChanged) { + this._updateText(); + } + const fontChanged = this._updateFontAtlas(); + const styleChanged = fontChanged || props.lineHeight !== oldProps.lineHeight || props.wordBreak !== oldProps.wordBreak || props.maxWidth !== oldProps.maxWidth; + if (styleChanged) { + this.setState({ + styleVersion: this.state.styleVersion + 1 + }); } - const viewManagerNeedsRedraw = this.viewManager.needsRedraw(opts); - const layerManagerNeedsRedraw = this.layerManager.needsRedraw(opts); - const effectManagerNeedsRedraw = this.effectManager.needsRedraw(opts); - const deckRendererNeedsRedraw = this.deckRenderer.needsRedraw(opts); - redraw = redraw || viewManagerNeedsRedraw || layerManagerNeedsRedraw || effectManagerNeedsRedraw || deckRendererNeedsRedraw; - return redraw; } - redraw(reason) { - if (!this.layerManager) { - return; + getPickingInfo({ + info + }) { + info.object = info.index >= 0 ? this.props.data[info.index] : null; + return info; + } + _updateFontAtlas() { + const { + fontSettings, + fontFamily, + fontWeight + } = this.props; + const { + fontAtlasManager, + characterSet + } = this.state; + const fontProps = { + ...fontSettings, + characterSet, + fontFamily, + fontWeight + }; + if (!fontAtlasManager.mapping) { + fontAtlasManager.setProps(fontProps); + return true; } - let redrawReason = this.needsRedraw({ - clearRedrawFlags: true - }); - redrawReason = reason || redrawReason; - if (!redrawReason) { - return; + for (const key in fontProps) { + if (fontProps[key] !== fontAtlasManager.props[key]) { + fontAtlasManager.setProps(fontProps); + return true; + } } - this.stats.get("Redraw Count").incrementCount(); - if (this.props._customRender) { - this.props._customRender(redrawReason); + return false; + } + _updateText() { + var _attributes; + const { + data, + characterSet + } = this.props; + const textBuffer = (_attributes = data.attributes) === null || _attributes === void 0 ? void 0 : _attributes.getText; + let { + getText + } = this.props; + let startIndices = data.startIndices; + let numInstances; + const autoCharacterSet = characterSet === "auto" && /* @__PURE__ */ new Set(); + if (textBuffer && startIndices) { + const { + texts, + characterCount + } = getTextFromBuffer({ + ...ArrayBuffer.isView(textBuffer) ? { + value: textBuffer + } : textBuffer, + length: data.length, + startIndices, + characterSet: autoCharacterSet + }); + numInstances = characterCount; + getText = (_2, { + index + }) => texts[index]; } else { - this._drawLayers(redrawReason); + const { + iterable, + objectInfo + } = createIterable(data); + startIndices = [0]; + numInstances = 0; + for (const object of iterable) { + objectInfo.index++; + const text = Array.from(getText(object, objectInfo) || ""); + if (autoCharacterSet) { + text.forEach(autoCharacterSet.add, autoCharacterSet); + } + numInstances += text.length; + startIndices.push(numInstances); + } } + this.setState({ + getText, + startIndices, + numInstances, + characterSet: autoCharacterSet || characterSet + }); } - get isInitialized() { - return this.viewManager !== null; + transformParagraph(object, objectInfo) { + const { + fontAtlasManager + } = this.state; + const iconMapping = fontAtlasManager.mapping; + const getText = this.state.getText; + const { + wordBreak, + lineHeight, + maxWidth + } = this.props; + const paragraph = getText(object, objectInfo) || ""; + return transformParagraph(paragraph, lineHeight, wordBreak, maxWidth * fontAtlasManager.props.fontSize, iconMapping); } - getViews() { - assert10(this.viewManager); - return this.viewManager.views; + renderLayers() { + const { + startIndices, + numInstances, + getText, + fontAtlasManager: { + scale: scale5, + texture, + mapping + }, + styleVersion + } = this.state; + const { + data, + _dataDiff, + getPosition: getPosition3, + getColor: getColor3, + getSize, + getAngle, + getPixelOffset, + getBackgroundColor, + getBorderColor, + getBorderWidth, + backgroundPadding, + background, + billboard, + fontSettings, + outlineWidth, + outlineColor, + sizeScale, + sizeUnits, + sizeMinPixels, + sizeMaxPixels, + transitions, + updateTriggers + } = this.props; + const CharactersLayerClass = this.getSubLayerClass("characters", MultiIconLayer); + const BackgroundLayerClass = this.getSubLayerClass("background", TextBackgroundLayer); + return [background && new BackgroundLayerClass({ + getFillColor: getBackgroundColor, + getLineColor: getBorderColor, + getLineWidth: getBorderWidth, + padding: backgroundPadding, + getPosition: getPosition3, + getSize, + getAngle, + getPixelOffset, + billboard, + sizeScale, + sizeUnits, + sizeMinPixels, + sizeMaxPixels, + transitions: transitions && { + getPosition: transitions.getPosition, + getAngle: transitions.getAngle, + getSize: transitions.getSize, + getFillColor: transitions.getBackgroundColor, + getLineColor: transitions.getBorderColor, + getLineWidth: transitions.getBorderWidth, + getPixelOffset: transitions.getPixelOffset + } + }, this.getSubLayerProps({ + id: "background", + updateTriggers: { + getPosition: updateTriggers.getPosition, + getAngle: updateTriggers.getAngle, + getSize: updateTriggers.getSize, + getFillColor: updateTriggers.getBackgroundColor, + getLineColor: updateTriggers.getBorderColor, + getLineWidth: updateTriggers.getBorderWidth, + getPixelOffset: updateTriggers.getPixelOffset, + getBoundingRect: { + getText: updateTriggers.getText, + getTextAnchor: updateTriggers.getTextAnchor, + getAlignmentBaseline: updateTriggers.getAlignmentBaseline, + styleVersion + } + } + }), { + data: data.attributes && data.attributes.background ? { + length: data.length, + attributes: data.attributes.background + } : data, + _dataDiff, + autoHighlight: false, + getBoundingRect: this.getBoundingRect + }), new CharactersLayerClass({ + sdf: fontSettings.sdf, + smoothing: Number.isFinite(fontSettings.smoothing) ? fontSettings.smoothing : DEFAULT_FONT_SETTINGS.smoothing, + outlineWidth: outlineWidth / (fontSettings.radius || DEFAULT_FONT_SETTINGS.radius), + outlineColor, + iconAtlas: texture, + iconMapping: mapping, + getPosition: getPosition3, + getColor: getColor3, + getSize, + getAngle, + getPixelOffset, + billboard, + sizeScale: sizeScale * scale5, + sizeUnits, + sizeMinPixels: sizeMinPixels * scale5, + sizeMaxPixels: sizeMaxPixels * scale5, + transitions: transitions && { + getPosition: transitions.getPosition, + getAngle: transitions.getAngle, + getColor: transitions.getColor, + getSize: transitions.getSize, + getPixelOffset: transitions.getPixelOffset + } + }, this.getSubLayerProps({ + id: "characters", + updateTriggers: { + all: updateTriggers.getText, + getPosition: updateTriggers.getPosition, + getAngle: updateTriggers.getAngle, + getColor: updateTriggers.getColor, + getSize: updateTriggers.getSize, + getPixelOffset: updateTriggers.getPixelOffset, + getIconOffsets: { + getTextAnchor: updateTriggers.getTextAnchor, + getAlignmentBaseline: updateTriggers.getAlignmentBaseline, + styleVersion + } + } + }), { + data, + _dataDiff, + startIndices, + numInstances, + getIconOffsets: this.getIconOffsets, + getIcon: getText + })]; } - getViewports(rect) { - assert10(this.viewManager); - return this.viewManager.getViewports(rect); + static set fontAtlasCacheLimit(limit) { + setFontAtlasCacheLimit(limit); } - getCanvas() { - return this.canvas; + }; + _defineProperty(TextLayer, "defaultProps", defaultProps13); + _defineProperty(TextLayer, "layerName", "TextLayer"); + + // node_modules/@deck.gl/layers/dist/esm/geojson-layer/sub-layer-map.js + var POINT_LAYER = { + circle: { + type: ScatterplotLayer, + props: { + filled: "filled", + stroked: "stroked", + lineWidthMaxPixels: "lineWidthMaxPixels", + lineWidthMinPixels: "lineWidthMinPixels", + lineWidthScale: "lineWidthScale", + lineWidthUnits: "lineWidthUnits", + pointRadiusMaxPixels: "radiusMaxPixels", + pointRadiusMinPixels: "radiusMinPixels", + pointRadiusScale: "radiusScale", + pointRadiusUnits: "radiusUnits", + pointAntialiasing: "antialiasing", + pointBillboard: "billboard", + getFillColor: "getFillColor", + getLineColor: "getLineColor", + getLineWidth: "getLineWidth", + getPointRadius: "getRadius" + } + }, + icon: { + type: IconLayer, + props: { + iconAtlas: "iconAtlas", + iconMapping: "iconMapping", + iconSizeMaxPixels: "sizeMaxPixels", + iconSizeMinPixels: "sizeMinPixels", + iconSizeScale: "sizeScale", + iconSizeUnits: "sizeUnits", + iconAlphaCutoff: "alphaCutoff", + iconBillboard: "billboard", + getIcon: "getIcon", + getIconAngle: "getAngle", + getIconColor: "getColor", + getIconPixelOffset: "getPixelOffset", + getIconSize: "getSize" + } + }, + text: { + type: TextLayer, + props: { + textSizeMaxPixels: "sizeMaxPixels", + textSizeMinPixels: "sizeMinPixels", + textSizeScale: "sizeScale", + textSizeUnits: "sizeUnits", + textBackground: "background", + textBackgroundPadding: "backgroundPadding", + textFontFamily: "fontFamily", + textFontWeight: "fontWeight", + textLineHeight: "lineHeight", + textMaxWidth: "maxWidth", + textOutlineColor: "outlineColor", + textOutlineWidth: "outlineWidth", + textWordBreak: "wordBreak", + textCharacterSet: "characterSet", + textBillboard: "billboard", + textFontSettings: "fontSettings", + getText: "getText", + getTextAngle: "getAngle", + getTextColor: "getColor", + getTextPixelOffset: "getPixelOffset", + getTextSize: "getSize", + getTextAnchor: "getTextAnchor", + getTextAlignmentBaseline: "getAlignmentBaseline", + getTextBackgroundColor: "getBackgroundColor", + getTextBorderColor: "getBorderColor", + getTextBorderWidth: "getBorderWidth" + } } - pickObject(opts) { - const infos = this._pick("pickObject", "pickObject Time", opts).result; - return infos.length ? infos[0] : null; + }; + var LINE_LAYER = { + type: PathLayer, + props: { + lineWidthUnits: "widthUnits", + lineWidthScale: "widthScale", + lineWidthMinPixels: "widthMinPixels", + lineWidthMaxPixels: "widthMaxPixels", + lineJointRounded: "jointRounded", + lineCapRounded: "capRounded", + lineMiterLimit: "miterLimit", + lineBillboard: "billboard", + getLineColor: "getColor", + getLineWidth: "getWidth" } - pickMultipleObjects(opts) { - opts.depth = opts.depth || 10; - return this._pick("pickObject", "pickMultipleObjects Time", opts).result; + }; + var POLYGON_LAYER = { + type: SolidPolygonLayer, + props: { + extruded: "extruded", + filled: "filled", + wireframe: "wireframe", + elevationScale: "elevationScale", + material: "material", + _full3d: "_full3d", + getElevation: "getElevation", + getFillColor: "getFillColor", + getLineColor: "getLineColor" } - pickObjects(opts) { - return this._pick("pickObjects", "pickObjects Time", opts); + }; + function getDefaultProps({ + type, + props + }) { + const result = {}; + for (const key in props) { + result[key] = type.defaultProps[props[key]]; } - _addResources(resources, forceUpdate = false) { - for (const id in resources) { - this.layerManager.resourceManager.add({ - resourceId: id, - data: resources[id], - forceUpdate - }); + return result; + } + function forwardProps(layer, mapping) { + const { + transitions, + updateTriggers + } = layer.props; + const result = { + updateTriggers: {}, + transitions: transitions && { + getPosition: transitions.geometry } - } - _removeResources(resourceIds) { - for (const id of resourceIds) { - this.layerManager.resourceManager.remove(id); + }; + for (const sourceKey in mapping) { + const targetKey = mapping[sourceKey]; + let value = layer.props[sourceKey]; + if (sourceKey.startsWith("get")) { + value = layer.getSubLayerAccessor(value); + result.updateTriggers[targetKey] = updateTriggers[sourceKey]; + if (transitions) { + result.transitions[targetKey] = transitions[sourceKey]; + } } + result[targetKey] = value; } - _addDefaultEffect(effect) { - this.effectManager.addDefaultEffect(effect); + return result; + } + + // node_modules/@deck.gl/layers/dist/esm/geojson-layer/geojson.js + function getGeojsonFeatures(geojson) { + if (Array.isArray(geojson)) { + return geojson; } - _pick(method, statKey, opts) { - assert10(this.deckPicker); - const { - stats - } = this; - stats.get("Pick Count").incrementCount(); - stats.get(statKey).timeStart(); - const infos = this.deckPicker[method]({ - layers: this.layerManager.getLayers(opts), - views: this.viewManager.getViews(), - viewports: this.getViewports(opts), - onViewportActive: this.layerManager.activateViewport, - effects: this.effectManager.getEffects(), - ...opts - }); - stats.get(statKey).timeEnd(); - return infos; + log_default.assert(geojson.type, "GeoJSON does not have type"); + switch (geojson.type) { + case "Feature": + return [geojson]; + case "FeatureCollection": + log_default.assert(Array.isArray(geojson.features), "GeoJSON does not have features array"); + return geojson.features; + default: + return [{ + geometry: geojson + }]; } - _createCanvas(props) { - let canvas = props.canvas; - if (typeof canvas === "string") { - canvas = document.getElementById(canvas); - assert10(canvas); + } + function separateGeojsonFeatures(features, wrapFeature, dataRange = {}) { + const separated = { + pointFeatures: [], + lineFeatures: [], + polygonFeatures: [], + polygonOutlineFeatures: [] + }; + const { + startRow = 0, + endRow = features.length + } = dataRange; + for (let featureIndex = startRow; featureIndex < endRow; featureIndex++) { + const feature = features[featureIndex]; + const { + geometry + } = feature; + if (!geometry) { + continue; } - if (!canvas) { - canvas = document.createElement("canvas"); - canvas.id = props.id || "deckgl-overlay"; - const parent = props.parent || document.body; - parent.appendChild(canvas); + if (geometry.type === "GeometryCollection") { + log_default.assert(Array.isArray(geometry.geometries), "GeoJSON does not have geometries array"); + const { + geometries + } = geometry; + for (let i3 = 0; i3 < geometries.length; i3++) { + const subGeometry = geometries[i3]; + separateGeometry(subGeometry, separated, wrapFeature, feature, featureIndex); + } + } else { + separateGeometry(geometry, separated, wrapFeature, feature, featureIndex); } - Object.assign(canvas.style, props.style); - return canvas; } - _setCanvasSize(props) { - if (!this.canvas) { + return separated; + } + function separateGeometry(geometry, separated, wrapFeature, sourceFeature, sourceFeatureIndex) { + const { + type, + coordinates + } = geometry; + const { + pointFeatures, + lineFeatures, + polygonFeatures, + polygonOutlineFeatures + } = separated; + if (!validateGeometry(type, coordinates)) { + log_default.warn("".concat(type, " coordinates are malformed"))(); + return; + } + switch (type) { + case "Point": + pointFeatures.push(wrapFeature({ + geometry + }, sourceFeature, sourceFeatureIndex)); + break; + case "MultiPoint": + coordinates.forEach((point) => { + pointFeatures.push(wrapFeature({ + geometry: { + type: "Point", + coordinates: point + } + }, sourceFeature, sourceFeatureIndex)); + }); + break; + case "LineString": + lineFeatures.push(wrapFeature({ + geometry + }, sourceFeature, sourceFeatureIndex)); + break; + case "MultiLineString": + coordinates.forEach((path) => { + lineFeatures.push(wrapFeature({ + geometry: { + type: "LineString", + coordinates: path + } + }, sourceFeature, sourceFeatureIndex)); + }); + break; + case "Polygon": + polygonFeatures.push(wrapFeature({ + geometry + }, sourceFeature, sourceFeatureIndex)); + coordinates.forEach((path) => { + polygonOutlineFeatures.push(wrapFeature({ + geometry: { + type: "LineString", + coordinates: path + } + }, sourceFeature, sourceFeatureIndex)); + }); + break; + case "MultiPolygon": + coordinates.forEach((polygon) => { + polygonFeatures.push(wrapFeature({ + geometry: { + type: "Polygon", + coordinates: polygon + } + }, sourceFeature, sourceFeatureIndex)); + polygon.forEach((path) => { + polygonOutlineFeatures.push(wrapFeature({ + geometry: { + type: "LineString", + coordinates: path + } + }, sourceFeature, sourceFeatureIndex)); + }); + }); + break; + default: + } + } + var COORDINATE_NEST_LEVEL = { + Point: 1, + MultiPoint: 2, + LineString: 2, + MultiLineString: 3, + Polygon: 3, + MultiPolygon: 4 + }; + function validateGeometry(type, coordinates) { + let nestLevel = COORDINATE_NEST_LEVEL[type]; + log_default.assert(nestLevel, "Unknown GeoJSON type ".concat(type)); + while (coordinates && --nestLevel > 0) { + coordinates = coordinates[0]; + } + return coordinates && Number.isFinite(coordinates[0]); + } + + // node_modules/@deck.gl/layers/dist/esm/geojson-layer/geojson-layer-props.js + function createEmptyLayerProps() { + return { + points: {}, + lines: {}, + polygons: {}, + polygonsOutline: {} + }; + } + function getCoordinates(f2) { + return f2.geometry.coordinates; + } + function createLayerPropsFromFeatures(features, featuresDiff) { + const layerProps = createEmptyLayerProps(); + const { + pointFeatures, + lineFeatures, + polygonFeatures, + polygonOutlineFeatures + } = features; + layerProps.points.data = pointFeatures; + layerProps.points._dataDiff = featuresDiff.pointFeatures && (() => featuresDiff.pointFeatures); + layerProps.points.getPosition = getCoordinates; + layerProps.lines.data = lineFeatures; + layerProps.lines._dataDiff = featuresDiff.lineFeatures && (() => featuresDiff.lineFeatures); + layerProps.lines.getPath = getCoordinates; + layerProps.polygons.data = polygonFeatures; + layerProps.polygons._dataDiff = featuresDiff.polygonFeatures && (() => featuresDiff.polygonFeatures); + layerProps.polygons.getPolygon = getCoordinates; + layerProps.polygonsOutline.data = polygonOutlineFeatures; + layerProps.polygonsOutline._dataDiff = featuresDiff.polygonOutlineFeatures && (() => featuresDiff.polygonOutlineFeatures); + layerProps.polygonsOutline.getPath = getCoordinates; + return layerProps; + } + function createLayerPropsFromBinary(geojsonBinary, encodePickingColor) { + const layerProps = createEmptyLayerProps(); + const { + points, + lines, + polygons + } = geojsonBinary; + const customPickingColors = calculatePickingColors(geojsonBinary, encodePickingColor); + layerProps.points.data = { + length: points.positions.value.length / points.positions.size, + attributes: { + ...points.attributes, + getPosition: points.positions, + instancePickingColors: { + size: 3, + value: customPickingColors.points + } + }, + properties: points.properties, + numericProps: points.numericProps, + featureIds: points.featureIds + }; + layerProps.lines.data = { + length: lines.pathIndices.value.length - 1, + startIndices: lines.pathIndices.value, + attributes: { + ...lines.attributes, + getPath: lines.positions, + instancePickingColors: { + size: 3, + value: customPickingColors.lines + } + }, + properties: lines.properties, + numericProps: lines.numericProps, + featureIds: lines.featureIds + }; + layerProps.lines._pathType = "open"; + layerProps.polygons.data = { + length: polygons.polygonIndices.value.length - 1, + startIndices: polygons.polygonIndices.value, + attributes: { + ...polygons.attributes, + getPolygon: polygons.positions, + pickingColors: { + size: 3, + value: customPickingColors.polygons + } + }, + properties: polygons.properties, + numericProps: polygons.numericProps, + featureIds: polygons.featureIds + }; + layerProps.polygons._normalize = false; + if (polygons.triangles) { + layerProps.polygons.data.attributes.indices = polygons.triangles.value; + } + layerProps.polygonsOutline.data = { + length: polygons.primitivePolygonIndices.value.length - 1, + startIndices: polygons.primitivePolygonIndices.value, + attributes: { + ...polygons.attributes, + getPath: polygons.positions, + instancePickingColors: { + size: 3, + value: customPickingColors.polygons + } + }, + properties: polygons.properties, + numericProps: polygons.numericProps, + featureIds: polygons.featureIds + }; + layerProps.polygonsOutline._pathType = "open"; + return layerProps; + } + + // node_modules/@deck.gl/layers/dist/esm/geojson-layer/geojson-layer.js + var FEATURE_TYPES = ["points", "linestrings", "polygons"]; + var defaultProps14 = { + ...getDefaultProps(POINT_LAYER.circle), + ...getDefaultProps(POINT_LAYER.icon), + ...getDefaultProps(POINT_LAYER.text), + ...getDefaultProps(LINE_LAYER), + ...getDefaultProps(POLYGON_LAYER), + stroked: true, + filled: true, + extruded: false, + wireframe: false, + _full3d: false, + iconAtlas: { + type: "object", + value: null + }, + iconMapping: { + type: "object", + value: {} + }, + getIcon: { + type: "accessor", + value: (f2) => f2.properties.icon + }, + getText: { + type: "accessor", + value: (f2) => f2.properties.text + }, + pointType: "circle", + getRadius: { + deprecatedFor: "getPointRadius" + } + }; + var GeoJsonLayer = class extends CompositeLayer { + initializeState() { + this.state = { + layerProps: {}, + features: {} + }; + } + updateState({ + props, + changeFlags + }) { + if (!changeFlags.dataChanged) { return; } const { - width, - height - } = props; - if (width || width === 0) { - const cssWidth = Number.isFinite(width) ? "".concat(width, "px") : width; - this.canvas.style.width = cssWidth; + data + } = this.props; + const binary = data && "points" in data && "polygons" in data && "lines" in data; + this.setState({ + binary + }); + if (binary) { + this._updateStateBinary({ + props, + changeFlags + }); + } else { + this._updateStateJSON({ + props, + changeFlags + }); } - if (height || height === 0) { - var _props$style; - const cssHeight = Number.isFinite(height) ? "".concat(height, "px") : height; - this.canvas.style.position = ((_props$style = props.style) === null || _props$style === void 0 ? void 0 : _props$style.position) || "absolute"; - this.canvas.style.height = cssHeight; + } + _updateStateBinary({ + props, + changeFlags + }) { + const layerProps = createLayerPropsFromBinary(props.data, this.encodePickingColor); + this.setState({ + layerProps + }); + } + _updateStateJSON({ + props, + changeFlags + }) { + const features = getGeojsonFeatures(props.data); + const wrapFeature = this.getSubLayerRow.bind(this); + let newFeatures = {}; + const featuresDiff = {}; + if (Array.isArray(changeFlags.dataChanged)) { + const oldFeatures = this.state.features; + for (const key in oldFeatures) { + newFeatures[key] = oldFeatures[key].slice(); + featuresDiff[key] = []; + } + for (const dataRange of changeFlags.dataChanged) { + const partialFeatures = separateGeojsonFeatures(features, wrapFeature, dataRange); + for (const key in oldFeatures) { + featuresDiff[key].push(replaceInRange({ + data: newFeatures[key], + getIndex: (f2) => f2.__source.index, + dataRange, + replace: partialFeatures[key] + })); + } + } + } else { + newFeatures = separateGeojsonFeatures(features, wrapFeature); } + const layerProps = createLayerPropsFromFeatures(newFeatures, featuresDiff); + this.setState({ + features: newFeatures, + featuresDiff, + layerProps + }); } - _updateCanvasSize() { - var _canvas$clientWidth, _canvas$clientHeight; + getPickingInfo(params) { + const info = super.getPickingInfo(params); const { - canvas - } = this; - if (!canvas) { - return; + index, + sourceLayer + } = info; + info.featureType = FEATURE_TYPES.find((ft) => sourceLayer.id.startsWith("".concat(this.id, "-").concat(ft, "-"))); + if (index >= 0 && sourceLayer.id.startsWith("".concat(this.id, "-points-text")) && this.state.binary) { + info.index = this.props.data.points.globalFeatureIds.value[index]; } - const newWidth = (_canvas$clientWidth = canvas.clientWidth) !== null && _canvas$clientWidth !== void 0 ? _canvas$clientWidth : canvas.width; - const newHeight = (_canvas$clientHeight = canvas.clientHeight) !== null && _canvas$clientHeight !== void 0 ? _canvas$clientHeight : canvas.height; - if (newWidth !== this.width || newHeight !== this.height) { - var _this$viewManager2, _this$layerManager2; - this.width = newWidth; - this.height = newHeight; - (_this$viewManager2 = this.viewManager) === null || _this$viewManager2 === void 0 ? void 0 : _this$viewManager2.setProps({ - width: newWidth, - height: newHeight - }); - (_this$layerManager2 = this.layerManager) === null || _this$layerManager2 === void 0 ? void 0 : _this$layerManager2.activateViewport(this.getViewports()[0]); - this.props.onResize({ - width: newWidth, - height: newHeight - }); + return info; + } + _updateAutoHighlight(info) { + const pointLayerIdPrefix = "".concat(this.id, "-points-"); + const sourceIsPoints = info.featureType === "points"; + for (const layer of this.getSubLayers()) { + if (layer.id.startsWith(pointLayerIdPrefix) === sourceIsPoints) { + layer.updateAutoHighlight(info); + } } } - _createAnimationLoop(props) { + _renderPolygonLayer() { const { - width, - height, - gl, - glOptions, - debug: debug2, - onError, - onBeforeRender, - onAfterRender, - useDevicePixels - } = props; - return new AnimationLoop({ - width, - height, - useDevicePixels, - autoResizeDrawingBuffer: !gl, - autoResizeViewport: false, - gl, - onCreateContext: (opts) => createGLContext({ - ...glOptions, - ...opts, - canvas: this.canvas, - debug: debug2, - onContextLost: () => this._onContextLost() - }), - onInitialize: (context) => this._setGLContext(context.gl), - onRender: this._onRenderFrame.bind(this), - onBeforeRender, - onAfterRender, - onError - }); - } - _getViewState() { - return this.props.viewState || this.viewState; - } - _getViews() { - let views = this.props.views || [new MapView({ - id: "default-view" - })]; - views = Array.isArray(views) ? views : [views]; - if (views.length && this.props.controller) { - views[0].props.controller = this.props.controller; + extruded, + wireframe + } = this.props; + const { + layerProps + } = this.state; + const id = "polygons-fill"; + const PolygonFillLayer = this.shouldRenderSubLayer(id, layerProps.polygons.data) && this.getSubLayerClass(id, POLYGON_LAYER.type); + if (PolygonFillLayer) { + const forwardedProps = forwardProps(this, POLYGON_LAYER.props); + const useLineColor = extruded && wireframe; + if (!useLineColor) { + delete forwardedProps.getLineColor; + } + forwardedProps.updateTriggers.lineColors = useLineColor; + return new PolygonFillLayer(forwardedProps, this.getSubLayerProps({ + id, + updateTriggers: forwardedProps.updateTriggers + }), layerProps.polygons); } - return views; + return null; } - _onContextLost() { + _renderLineLayers() { const { - onError + extruded, + stroked } = this.props; - if (this.animationLoop && onError) { - onError(new Error("WebGL context is lost")); + const { + layerProps + } = this.state; + const polygonStrokeLayerId = "polygons-stroke"; + const lineStringsLayerId = "linestrings"; + const PolygonStrokeLayer = !extruded && stroked && this.shouldRenderSubLayer(polygonStrokeLayerId, layerProps.polygonsOutline.data) && this.getSubLayerClass(polygonStrokeLayerId, LINE_LAYER.type); + const LineStringsLayer = this.shouldRenderSubLayer(lineStringsLayerId, layerProps.lines.data) && this.getSubLayerClass(lineStringsLayerId, LINE_LAYER.type); + if (PolygonStrokeLayer || LineStringsLayer) { + const forwardedProps = forwardProps(this, LINE_LAYER.props); + return [PolygonStrokeLayer && new PolygonStrokeLayer(forwardedProps, this.getSubLayerProps({ + id: polygonStrokeLayerId, + updateTriggers: forwardedProps.updateTriggers + }), layerProps.polygonsOutline), LineStringsLayer && new LineStringsLayer(forwardedProps, this.getSubLayerProps({ + id: lineStringsLayerId, + updateTriggers: forwardedProps.updateTriggers + }), layerProps.lines)]; } + return null; } - _pickAndCallback() { + _renderPointLayers() { const { - _pickRequest - } = this; - if (_pickRequest.event) { - const { - result, - emptyInfo - } = this._pick("pickObject", "pickObject Time", _pickRequest); - this.cursorState.isHovering = result.length > 0; - let pickedInfo = emptyInfo; - let handled = false; - for (const info of result) { - var _info$layer; - pickedInfo = info; - handled = ((_info$layer = info.layer) === null || _info$layer === void 0 ? void 0 : _info$layer.onHover(info, _pickRequest.event)) || handled; - } - if (!handled && this.props.onHover) { - this.props.onHover(pickedInfo, _pickRequest.event); - } - if (this.props.getTooltip && this.tooltip) { - const displayInfo = this.props.getTooltip(pickedInfo); - this.tooltip.setTooltip(displayInfo, pickedInfo.x, pickedInfo.y); + pointType + } = this.props; + const { + layerProps, + binary + } = this.state; + let { + highlightedObjectIndex + } = this.props; + if (!binary && Number.isFinite(highlightedObjectIndex)) { + highlightedObjectIndex = layerProps.points.data.findIndex((d2) => d2.__source.index === highlightedObjectIndex); + } + const types = new Set(pointType.split("+")); + const pointLayers = []; + for (const type of types) { + const id = "points-".concat(type); + const PointLayerMapping = POINT_LAYER[type]; + const PointsLayer = PointLayerMapping && this.shouldRenderSubLayer(id, layerProps.points.data) && this.getSubLayerClass(id, PointLayerMapping.type); + if (PointsLayer) { + const forwardedProps = forwardProps(this, PointLayerMapping.props); + let pointsLayerProps = layerProps.points; + if (type === "text" && binary) { + const { + instancePickingColors, + ...rest + } = pointsLayerProps.data.attributes; + pointsLayerProps = { + ...pointsLayerProps, + data: { + ...pointsLayerProps.data, + attributes: rest + } + }; + } + pointLayers.push(new PointsLayer(forwardedProps, this.getSubLayerProps({ + id, + updateTriggers: forwardedProps.updateTriggers, + highlightedObjectIndex + }), pointsLayerProps)); } - _pickRequest.event = null; } + return pointLayers; } - _updateCursor() { - const container = this.props.parent || this.canvas; - if (container) { - container.style.cursor = this.props.getCursor(this.cursorState); + renderLayers() { + const { + extruded + } = this.props; + const polygonFillLayer = this._renderPolygonLayer(); + const lineLayers = this._renderLineLayers(); + const pointLayers = this._renderPointLayers(); + return [!extruded && polygonFillLayer, lineLayers, pointLayers, extruded && polygonFillLayer]; + } + getSubLayerAccessor(accessor) { + const { + binary + } = this.state; + if (!binary || typeof accessor !== "function") { + return super.getSubLayerAccessor(accessor); } + return (object, info) => { + const { + data, + index + } = info; + const feature = binaryToFeatureForAccesor(data, index); + return accessor(feature, info); + }; } - _setGLContext(gl) { - if (this.layerManager) { + }; + _defineProperty(GeoJsonLayer, "layerName", "GeoJsonLayer"); + _defineProperty(GeoJsonLayer, "defaultProps", defaultProps14); + + // node_modules/@deck.gl/geo-layers/dist/esm/tile-layer/tile-2d-header.js + var Tile2DHeader = class { + constructor(index) { + _defineProperty(this, "index", void 0); + _defineProperty(this, "isVisible", void 0); + _defineProperty(this, "isSelected", void 0); + _defineProperty(this, "parent", void 0); + _defineProperty(this, "children", void 0); + _defineProperty(this, "content", void 0); + _defineProperty(this, "state", void 0); + _defineProperty(this, "layers", void 0); + _defineProperty(this, "id", void 0); + _defineProperty(this, "bbox", void 0); + _defineProperty(this, "zoom", void 0); + _defineProperty(this, "userData", void 0); + _defineProperty(this, "_abortController", void 0); + _defineProperty(this, "_loader", void 0); + _defineProperty(this, "_loaderId", void 0); + _defineProperty(this, "_isLoaded", void 0); + _defineProperty(this, "_isCancelled", void 0); + _defineProperty(this, "_needsReload", void 0); + this.index = index; + this.isVisible = false; + this.isSelected = false; + this.parent = null; + this.children = []; + this.content = null; + this._loader = void 0; + this._abortController = null; + this._loaderId = 0; + this._isLoaded = false; + this._isCancelled = false; + this._needsReload = false; + } + get data() { + return this.isLoading && this._loader ? this._loader.then(() => this.data) : this.content; + } + get isLoaded() { + return this._isLoaded && !this._needsReload; + } + get isLoading() { + return Boolean(this._loader) && !this._isCancelled; + } + get needsReload() { + return this._needsReload || this._isCancelled; + } + get byteLength() { + const result = this.content ? this.content.byteLength : 0; + if (!Number.isFinite(result)) { + log_default.error("byteLength not defined in tile data")(); + } + return result; + } + async _loadData({ + getData, + requestScheduler, + onLoad, + onError + }) { + const { + index, + id, + bbox, + userData, + zoom + } = this; + const loaderId = this._loaderId; + this._abortController = new AbortController(); + const { + signal + } = this._abortController; + const requestToken = await requestScheduler.scheduleRequest(this, (tile) => { + return tile.isSelected ? 1 : -1; + }); + if (!requestToken) { + this._isCancelled = true; return; } - if (!this.canvas) { - this.canvas = gl.canvas; - instrumentGLContext(gl, { - enable: true, - copyState: true + if (this._isCancelled) { + requestToken.done(); + return; + } + let tileData = null; + let error2; + try { + tileData = await getData({ + index, + id, + bbox, + userData, + zoom, + signal }); + } catch (err3) { + error2 = err3 || true; + } finally { + requestToken.done(); } - this.tooltip = new Tooltip(this.canvas); - setParameters(gl, { - blend: true, - blendFunc: [770, 771, 1, 771], - polygonOffsetFill: true, - depthTest: true, - depthFunc: 515 - }); - this.props.onWebGLInitialized(gl); - const timeline = new Timeline(); - timeline.play(); - this.animationLoop.attachTimeline(timeline); - this.eventManager = new EventManager(this.props.parent || gl.canvas, { - touchAction: this.props.touchAction, - recognizerOptions: this.props.eventRecognizerOptions, - events: { - pointerdown: this._onPointerDown, - pointermove: this._onPointerMove, - pointerleave: this._onPointerMove - } - }); - for (const eventType in EVENTS) { - this.eventManager.on(eventType, this._onEvent); + if (loaderId !== this._loaderId) { + return; } - this.viewManager = new ViewManager({ - timeline, - eventManager: this.eventManager, - onViewStateChange: this._onViewStateChange.bind(this), - onInteractionStateChange: this._onInteractionStateChange.bind(this), - views: this._getViews(), - viewState: this._getViewState(), - width: this.width, - height: this.height - }); - const viewport = this.viewManager.getViewports()[0]; - this.layerManager = new LayerManager(gl, { - deck: this, - stats: this.stats, - viewport, - timeline - }); - this.effectManager = new EffectManager(); - this.deckRenderer = new DeckRenderer(gl); - this.deckPicker = new DeckPicker(gl); - this.setProps(this.props); - this._updateCanvasSize(); - this.props.onLoad(); - } - _drawLayers(redrawReason, renderOptions) { - const { - gl - } = this.layerManager.context; - setParameters(gl, this.props.parameters); - this.props.onBeforeRender({ - gl - }); - this.deckRenderer.renderLayers({ - target: this.props._framebuffer, - layers: this.layerManager.getLayers(), - viewports: this.viewManager.getViewports(), - onViewportActive: this.layerManager.activateViewport, - views: this.viewManager.getViews(), - pass: "screen", - effects: this.effectManager.getEffects(), - ...renderOptions - }); - this.props.onAfterRender({ - gl - }); - } - _onRenderFrame(animationProps) { - this._getFrameStats(); - if (this._metricsCounter++ % 60 === 0) { - this._getMetrics(); - this.stats.reset(); - log_default.table(4, this.metrics)(); - if (this.props._onMetrics) { - this.props._onMetrics(this.metrics); - } + this._loader = void 0; + this.content = tileData; + if (this._isCancelled && !tileData) { + this._isLoaded = false; + return; } - this._updateCanvasSize(); - this._updateCursor(); - if (this.tooltip.isVisible && this.viewManager.needsRedraw()) { - this.tooltip.setTooltip(null); + this._isLoaded = true; + this._isCancelled = false; + if (error2) { + onError(error2, this); + } else { + onLoad(this); } - this.layerManager.updateLayers(); - this._pickAndCallback(); - this.redraw(); - if (this.viewManager) { - this.viewManager.updateViewStates(); + } + loadData(opts) { + this._isLoaded = false; + this._isCancelled = false; + this._needsReload = false; + this._loaderId++; + this._loader = this._loadData(opts); + return this._loader; + } + setNeedsReload() { + if (this.isLoading) { + this.abort(); + this._loader = void 0; } + this._needsReload = true; } - _onViewStateChange(params) { - const viewState = this.props.onViewStateChange(params) || params.viewState; - if (this.viewState) { - this.viewState = { - ...this.viewState, - [params.viewId]: viewState - }; - if (!this.props.viewState) { - if (this.viewManager) { - this.viewManager.setProps({ - viewState: this.viewState - }); - } - } + abort() { + var _this$_abortControlle; + if (this.isLoaded) { + return; } + this._isCancelled = true; + (_this$_abortControlle = this._abortController) === null || _this$_abortControlle === void 0 ? void 0 : _this$_abortControlle.abort(); } - _onInteractionStateChange(interactionState) { - this.cursorState.isDragging = interactionState.isDragging || false; - this.props.onInteractionStateChange(interactionState); + }; + + // node_modules/@math.gl/culling/dist/esm/constants.js + var INTERSECTION = { + OUTSIDE: -1, + INTERSECTING: 0, + INSIDE: 1 + }; + + // node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/axis-aligned-bounding-box.js + var scratchVector2 = new Vector3(); + var scratchNormal = new Vector3(); + var AxisAlignedBoundingBox = class _AxisAlignedBoundingBox { + constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center) { + _defineProperty(this, "center", void 0); + _defineProperty(this, "halfDiagonal", void 0); + _defineProperty(this, "minimum", void 0); + _defineProperty(this, "maximum", void 0); + center = center || scratchVector2.copy(minimum).add(maximum).scale(0.5); + this.center = new Vector3(center); + this.halfDiagonal = new Vector3(maximum).subtract(this.center); + this.minimum = new Vector3(minimum); + this.maximum = new Vector3(maximum); + } + clone() { + return new _AxisAlignedBoundingBox(this.minimum, this.maximum, this.center); + } + equals(right) { + return this === right || Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum); + } + transform(transform2) { + this.center.transformAsPoint(transform2); + this.halfDiagonal.transform(transform2); + this.minimum.transform(transform2); + this.maximum.transform(transform2); + return this; } - _getFrameStats() { + intersectPlane(plane) { const { - stats + halfDiagonal } = this; - stats.get("frameRate").timeEnd(); - stats.get("frameRate").timeStart(); - const animationLoopStats = this.animationLoop.stats; - stats.get("GPU Time").addTime(animationLoopStats.get("GPU Time").lastTiming); - stats.get("CPU Time").addTime(animationLoopStats.get("CPU Time").lastTiming); + const normal = scratchNormal.from(plane.normal); + const e2 = halfDiagonal.x * Math.abs(normal.x) + halfDiagonal.y * Math.abs(normal.y) + halfDiagonal.z * Math.abs(normal.z); + const s = this.center.dot(normal) + plane.distance; + if (s - e2 > 0) { + return INTERSECTION.INSIDE; + } + if (s + e2 < 0) { + return INTERSECTION.OUTSIDE; + } + return INTERSECTION.INTERSECTING; } - _getMetrics() { + distanceTo(point) { + return Math.sqrt(this.distanceSquaredTo(point)); + } + distanceSquaredTo(point) { + const offset = scratchVector2.from(point).subtract(this.center); const { - metrics, - stats + halfDiagonal } = this; - metrics.fps = stats.get("frameRate").getHz(); - metrics.setPropsTime = stats.get("setProps Time").time; - metrics.updateAttributesTime = stats.get("Update Attributes").time; - metrics.framesRedrawn = stats.get("Redraw Count").count; - metrics.pickTime = stats.get("pickObject Time").time + stats.get("pickMultipleObjects Time").time + stats.get("pickObjects Time").time; - metrics.pickCount = stats.get("Pick Count").count; - metrics.gpuTime = stats.get("GPU Time").time; - metrics.cpuTime = stats.get("CPU Time").time; - metrics.gpuTimePerFrame = stats.get("GPU Time").getAverageTime(); - metrics.cpuTimePerFrame = stats.get("CPU Time").getAverageTime(); - const memoryStats = lumaStats.get("Memory Usage"); - metrics.bufferMemory = memoryStats.get("Buffer Memory").count; - metrics.textureMemory = memoryStats.get("Texture Memory").count; - metrics.renderbufferMemory = memoryStats.get("Renderbuffer Memory").count; - metrics.gpuMemory = memoryStats.get("GPU Memory").count; + let distanceSquared = 0; + let d2; + d2 = Math.abs(offset.x) - halfDiagonal.x; + if (d2 > 0) { + distanceSquared += d2 * d2; + } + d2 = Math.abs(offset.y) - halfDiagonal.y; + if (d2 > 0) { + distanceSquared += d2 * d2; + } + d2 = Math.abs(offset.z) - halfDiagonal.z; + if (d2 > 0) { + distanceSquared += d2 * d2; + } + return distanceSquared; } }; - _defineProperty(Deck, "defaultProps", defaultProps); - _defineProperty(Deck, "VERSION", VERSION5); - // node_modules/@deck.gl/core/dist/esm/lib/attribute/shader-attribute.js - var ShaderAttribute = class { - constructor(dataColumn, opts) { - _defineProperty(this, "opts", void 0); - _defineProperty(this, "source", void 0); - this.opts = opts; - this.source = dataColumn; + // node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/bounding-sphere.js + var scratchVector3 = new Vector3(); + var scratchVector22 = new Vector3(); + var BoundingSphere = class _BoundingSphere { + constructor(center = [0, 0, 0], radius = 0) { + _defineProperty(this, "center", void 0); + _defineProperty(this, "radius", void 0); + this.radius = -0; + this.center = new Vector3(); + this.fromCenterRadius(center, radius); + } + fromCenterRadius(center, radius) { + this.center.from(center); + this.radius = radius; + return this; } - get value() { - return this.source.value; + fromCornerPoints(corner, oppositeCorner) { + oppositeCorner = scratchVector3.from(oppositeCorner); + this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5); + this.radius = this.center.distance(oppositeCorner); + return this; } - getValue() { - const buffer = this.source.getBuffer(); - const accessor = this.getAccessor(); - if (buffer) { - return [buffer, accessor]; + equals(right) { + return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius; + } + clone() { + return new _BoundingSphere(this.center, this.radius); + } + union(boundingSphere) { + const leftCenter = this.center; + const leftRadius = this.radius; + const rightCenter = boundingSphere.center; + const rightRadius = boundingSphere.radius; + const toRightCenter = scratchVector3.copy(rightCenter).subtract(leftCenter); + const centerSeparation = toRightCenter.magnitude(); + if (leftRadius >= centerSeparation + rightRadius) { + return this.clone(); + } + if (rightRadius >= centerSeparation + leftRadius) { + return boundingSphere.clone(); + } + const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5; + scratchVector22.copy(toRightCenter).scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation).add(leftCenter); + this.center.copy(scratchVector22); + this.radius = halfDistanceBetweenTangentPoints; + return this; + } + expand(point) { + const scratchPoint = scratchVector3.from(point); + const radius = scratchPoint.subtract(this.center).magnitude(); + if (radius > this.radius) { + this.radius = radius; } - const { - value - } = this.source; - const { - size - } = accessor; - let constantValue = value; - if (value && value.length !== size) { - constantValue = new Float32Array(size); - const index = accessor.elementOffset || 0; - for (let i2 = 0; i2 < size; ++i2) { - constantValue[i2] = value[index + i2]; - } + return this; + } + transform(transform2) { + this.center.transform(transform2); + const scale5 = getScaling(scratchVector3, transform2); + this.radius = Math.max(scale5[0], Math.max(scale5[1], scale5[2])) * this.radius; + return this; + } + distanceSquaredTo(point) { + const d2 = this.distanceTo(point); + return d2 * d2; + } + distanceTo(point) { + const scratchPoint = scratchVector3.from(point); + const delta = scratchPoint.subtract(this.center); + return Math.max(0, delta.len() - this.radius); + } + intersectPlane(plane) { + const center = this.center; + const radius = this.radius; + const normal = plane.normal; + const distanceToPlane = normal.dot(center) + plane.distance; + if (distanceToPlane < -radius) { + return INTERSECTION.OUTSIDE; } - return constantValue; + if (distanceToPlane < radius) { + return INTERSECTION.INTERSECTING; + } + return INTERSECTION.INSIDE; } - getAccessor() { - return { - ...this.source.getAccessor(), - ...this.opts - }; + }; + + // node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/oriented-bounding-box.js + var scratchVector32 = new Vector3(); + var scratchOffset = new Vector3(); + var scratchVectorU = new Vector3(); + var scratchVectorV = new Vector3(); + var scratchVectorW = new Vector3(); + var scratchCorner = new Vector3(); + var scratchToCenter = new Vector3(); + var MATRIX3 = { + COLUMN0ROW0: 0, + COLUMN0ROW1: 1, + COLUMN0ROW2: 2, + COLUMN1ROW0: 3, + COLUMN1ROW1: 4, + COLUMN1ROW2: 5, + COLUMN2ROW0: 6, + COLUMN2ROW1: 7, + COLUMN2ROW2: 8 + }; + var OrientedBoundingBox = class _OrientedBoundingBox { + constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) { + _defineProperty(this, "center", void 0); + _defineProperty(this, "halfAxes", void 0); + this.center = new Vector3().from(center); + this.halfAxes = new Matrix3(halfAxes); + } + get halfSize() { + const xAxis = this.halfAxes.getColumn(0); + const yAxis = this.halfAxes.getColumn(1); + const zAxis = this.halfAxes.getColumn(2); + return [new Vector3(xAxis).len(), new Vector3(yAxis).len(), new Vector3(zAxis).len()]; + } + get quaternion() { + const xAxis = this.halfAxes.getColumn(0); + const yAxis = this.halfAxes.getColumn(1); + const zAxis = this.halfAxes.getColumn(2); + const normXAxis = new Vector3(xAxis).normalize(); + const normYAxis = new Vector3(yAxis).normalize(); + const normZAxis = new Vector3(zAxis).normalize(); + return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis])); + } + fromCenterHalfSizeQuaternion(center, halfSize, quaternion) { + const quaternionObject = new Quaternion(quaternion); + const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject); + directionsMatrix[0] = directionsMatrix[0] * halfSize[0]; + directionsMatrix[1] = directionsMatrix[1] * halfSize[0]; + directionsMatrix[2] = directionsMatrix[2] * halfSize[0]; + directionsMatrix[3] = directionsMatrix[3] * halfSize[1]; + directionsMatrix[4] = directionsMatrix[4] * halfSize[1]; + directionsMatrix[5] = directionsMatrix[5] * halfSize[1]; + directionsMatrix[6] = directionsMatrix[6] * halfSize[2]; + directionsMatrix[7] = directionsMatrix[7] * halfSize[2]; + directionsMatrix[8] = directionsMatrix[8] * halfSize[2]; + this.center = new Vector3().from(center); + this.halfAxes = directionsMatrix; + return this; + } + clone() { + return new _OrientedBoundingBox(this.center, this.halfAxes); + } + equals(right) { + return this === right || Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes); + } + getBoundingSphere(result = new BoundingSphere()) { + const halfAxes = this.halfAxes; + const u2 = halfAxes.getColumn(0, scratchVectorU); + const v2 = halfAxes.getColumn(1, scratchVectorV); + const w3 = halfAxes.getColumn(2, scratchVectorW); + const cornerVector = scratchVector32.copy(u2).add(v2).add(w3); + result.center.copy(this.center); + result.radius = cornerVector.magnitude(); + return result; + } + intersectPlane(plane) { + const center = this.center; + const normal = plane.normal; + const halfAxes = this.halfAxes; + const normalX = normal.x; + const normalY = normal.y; + const normalZ = normal.z; + const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] + normalY * halfAxes[MATRIX3.COLUMN0ROW1] + normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] + normalY * halfAxes[MATRIX3.COLUMN1ROW1] + normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] + normalY * halfAxes[MATRIX3.COLUMN2ROW1] + normalZ * halfAxes[MATRIX3.COLUMN2ROW2]); + const distanceToPlane = normal.dot(center) + plane.distance; + if (distanceToPlane <= -radEffective) { + return INTERSECTION.OUTSIDE; + } else if (distanceToPlane >= radEffective) { + return INTERSECTION.INSIDE; + } + return INTERSECTION.INTERSECTING; + } + distanceTo(point) { + return Math.sqrt(this.distanceSquaredTo(point)); + } + distanceSquaredTo(point) { + const offset = scratchOffset.from(point).subtract(this.center); + const halfAxes = this.halfAxes; + const u2 = halfAxes.getColumn(0, scratchVectorU); + const v2 = halfAxes.getColumn(1, scratchVectorV); + const w3 = halfAxes.getColumn(2, scratchVectorW); + const uHalf = u2.magnitude(); + const vHalf = v2.magnitude(); + const wHalf = w3.magnitude(); + u2.normalize(); + v2.normalize(); + w3.normalize(); + let distanceSquared = 0; + let d2; + d2 = Math.abs(offset.dot(u2)) - uHalf; + if (d2 > 0) { + distanceSquared += d2 * d2; + } + d2 = Math.abs(offset.dot(v2)) - vHalf; + if (d2 > 0) { + distanceSquared += d2 * d2; + } + d2 = Math.abs(offset.dot(w3)) - wHalf; + if (d2 > 0) { + distanceSquared += d2 * d2; + } + return distanceSquared; + } + computePlaneDistances(position, direction, result = [-0, -0]) { + let minDist = Number.POSITIVE_INFINITY; + let maxDist = Number.NEGATIVE_INFINITY; + const center = this.center; + const halfAxes = this.halfAxes; + const u2 = halfAxes.getColumn(0, scratchVectorU); + const v2 = halfAxes.getColumn(1, scratchVectorV); + const w3 = halfAxes.getColumn(2, scratchVectorW); + const corner = scratchCorner.copy(u2).add(v2).add(w3).add(center); + const toCenter = scratchToCenter.copy(corner).subtract(position); + let mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + corner.copy(center).add(u2).add(v2).subtract(w3); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + corner.copy(center).add(u2).subtract(v2).add(w3); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + corner.copy(center).add(u2).subtract(v2).subtract(w3); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + center.copy(corner).subtract(u2).add(v2).add(w3); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + center.copy(corner).subtract(u2).add(v2).subtract(w3); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + center.copy(corner).subtract(u2).subtract(v2).add(w3); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + center.copy(corner).subtract(u2).subtract(v2).subtract(w3); + toCenter.copy(corner).subtract(position); + mag = direction.dot(toCenter); + minDist = Math.min(mag, minDist); + maxDist = Math.max(mag, maxDist); + result[0] = minDist; + result[1] = maxDist; + return result; + } + transform(transformation) { + this.center.transformAsPoint(transformation); + const xAxis = this.halfAxes.getColumn(0, scratchVectorU); + xAxis.transformAsPoint(transformation); + const yAxis = this.halfAxes.getColumn(1, scratchVectorV); + yAxis.transformAsPoint(transformation); + const zAxis = this.halfAxes.getColumn(2, scratchVectorW); + zAxis.transformAsPoint(transformation); + this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]); + return this; + } + getTransform() { + throw new Error("not implemented"); } }; - // node_modules/@deck.gl/core/dist/esm/lib/attribute/gl-utils.js - function glArrayFromType(glType) { - switch (glType) { - case 5126: - return Float32Array; - case 5130: - return Float64Array; - case 5123: - case 33635: - case 32819: - case 32820: - return Uint16Array; - case 5125: - return Uint32Array; - case 5121: - return Uint8ClampedArray; - case 5120: - return Int8Array; - case 5122: - return Int16Array; - case 5124: - return Int32Array; - default: - throw new Error("Unknown GL type"); + // node_modules/@math.gl/culling/dist/esm/lib/plane.js + var scratchPosition = new Vector3(); + var scratchNormal2 = new Vector3(); + var Plane = class _Plane { + constructor(normal = [0, 0, 1], distance2 = 0) { + _defineProperty(this, "normal", void 0); + _defineProperty(this, "distance", void 0); + this.normal = new Vector3(); + this.distance = -0; + this.fromNormalDistance(normal, distance2); + } + fromNormalDistance(normal, distance2) { + assert8(Number.isFinite(distance2)); + this.normal.from(normal).normalize(); + this.distance = distance2; + return this; } - } + fromPointNormal(point, normal) { + point = scratchPosition.from(point); + this.normal.from(normal).normalize(); + const distance2 = -this.normal.dot(point); + this.distance = distance2; + return this; + } + fromCoefficients(a2, b2, c2, d2) { + this.normal.set(a2, b2, c2); + assert8(equals(this.normal.len(), 1)); + this.distance = d2; + return this; + } + clone() { + return new _Plane(this.normal, this.distance); + } + equals(right) { + return equals(this.distance, right.distance) && equals(this.normal, right.normal); + } + getPointDistance(point) { + return this.normal.dot(point) + this.distance; + } + transform(matrix4) { + const normal = scratchNormal2.copy(this.normal).transformAsVector(matrix4).normalize(); + const point = this.normal.scale(-this.distance).transform(matrix4); + return this.fromPointNormal(point, normal); + } + projectPointOntoPlane(point, result = [0, 0, 0]) { + point = scratchPosition.from(point); + const pointDistance = this.getPointDistance(point); + const scaledNormal = scratchNormal2.copy(this.normal).scale(pointDistance); + return point.subtract(scaledNormal).to(result); + } + }; - // node_modules/@deck.gl/core/dist/esm/lib/attribute/data-column.js - function getStride(accessor) { - return accessor.stride || accessor.size * accessor.bytesPerElement; - } - function resolveShaderAttribute(baseAccessor, shaderAttributeOptions) { - if (shaderAttributeOptions.offset) { - log_default.removed("shaderAttribute.offset", "vertexOffset, elementOffset")(); + // node_modules/@math.gl/culling/dist/esm/lib/culling-volume.js + var faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])]; + var scratchPlaneCenter = new Vector3(); + var scratchPlaneNormal = new Vector3(); + var scratchPlane = new Plane(new Vector3(1, 0, 0), 0); + var CullingVolume = class _CullingVolume { + constructor(planes = []) { + _defineProperty(this, "planes", void 0); + this.planes = planes; + } + fromBoundingSphere(boundingSphere) { + this.planes.length = 2 * faces.length; + const center = boundingSphere.center; + const radius = boundingSphere.radius; + let planeIndex = 0; + for (const faceNormal of faces) { + let plane0 = this.planes[planeIndex]; + let plane1 = this.planes[planeIndex + 1]; + if (!plane0) { + plane0 = this.planes[planeIndex] = new Plane(); + } + if (!plane1) { + plane1 = this.planes[planeIndex + 1] = new Plane(); + } + const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center); + const plane0Distance = -faceNormal.dot(plane0Center); + plane0.fromPointNormal(plane0Center, faceNormal); + const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center); + const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate(); + const plane1Distance = -negatedFaceNormal.dot(plane1Center); + plane1.fromPointNormal(plane1Center, negatedFaceNormal); + planeIndex += 2; + } + return this; } - const stride = getStride(baseAccessor); - const vertexOffset = shaderAttributeOptions.vertexOffset !== void 0 ? shaderAttributeOptions.vertexOffset : baseAccessor.vertexOffset || 0; - const elementOffset = shaderAttributeOptions.elementOffset || 0; - const offset = vertexOffset * stride + elementOffset * baseAccessor.bytesPerElement + (baseAccessor.offset || 0); - return { - ...shaderAttributeOptions, - offset, - stride - }; - } - function resolveDoublePrecisionShaderAttributes(baseAccessor, shaderAttributeOptions) { - const resolvedOptions = resolveShaderAttribute(baseAccessor, shaderAttributeOptions); - return { - high: resolvedOptions, - low: { - ...resolvedOptions, - offset: resolvedOptions.offset + baseAccessor.size * 4 + computeVisibility(boundingVolume) { + let intersect2 = INTERSECTION.INSIDE; + for (const plane of this.planes) { + const result = boundingVolume.intersectPlane(plane); + switch (result) { + case INTERSECTION.OUTSIDE: + return INTERSECTION.OUTSIDE; + case INTERSECTION.INTERSECTING: + intersect2 = INTERSECTION.INTERSECTING; + break; + default: + } } - }; + return intersect2; + } + computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) { + assert8(Number.isFinite(parentPlaneMask), "parentPlaneMask is required."); + if (parentPlaneMask === _CullingVolume.MASK_OUTSIDE || parentPlaneMask === _CullingVolume.MASK_INSIDE) { + return parentPlaneMask; + } + let mask = _CullingVolume.MASK_INSIDE; + const planes = this.planes; + for (let k = 0; k < this.planes.length; ++k) { + const flag = k < 31 ? 1 << k : 0; + if (k < 31 && (parentPlaneMask & flag) === 0) { + continue; + } + const plane = planes[k]; + const result = boundingVolume.intersectPlane(plane); + if (result === INTERSECTION.OUTSIDE) { + return _CullingVolume.MASK_OUTSIDE; + } else if (result === INTERSECTION.INTERSECTING) { + mask |= flag; + } + } + return mask; + } + }; + _defineProperty(CullingVolume, "MASK_OUTSIDE", 4294967295); + _defineProperty(CullingVolume, "MASK_INSIDE", 0); + _defineProperty(CullingVolume, "MASK_INDETERMINATE", 2147483647); + + // node_modules/@math.gl/culling/dist/esm/lib/perspective-off-center-frustum.js + var scratchPlaneUpVector = new Vector3(); + var scratchPlaneRightVector = new Vector3(); + var scratchPlaneNearCenter = new Vector3(); + var scratchPlaneFarCenter = new Vector3(); + var scratchPlaneNormal2 = new Vector3(); + + // node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-sphere-from-points.js + var fromPointsXMin = new Vector3(); + var fromPointsYMin = new Vector3(); + var fromPointsZMin = new Vector3(); + var fromPointsXMax = new Vector3(); + var fromPointsYMax = new Vector3(); + var fromPointsZMax = new Vector3(); + var fromPointsCurrentPos = new Vector3(); + var fromPointsScratch = new Vector3(); + var fromPointsRitterCenter = new Vector3(); + var fromPointsMinBoxPt = new Vector3(); + var fromPointsMaxBoxPt = new Vector3(); + var fromPointsNaiveCenterScratch = new Vector3(); + var volumeConstant = 4 / 3 * Math.PI; + + // node_modules/@math.gl/culling/dist/esm/lib/algorithms/compute-eigen-decomposition.js + var scratchMatrix = new Matrix3(); + var scratchUnitary = new Matrix3(); + var scratchDiagonal = new Matrix3(); + var jMatrix = new Matrix3(); + var jMatrixTranspose = new Matrix3(); + function computeEigenDecomposition(matrix, result = {}) { + const EIGEN_TOLERANCE = math_utils_default.EPSILON20; + const EIGEN_MAX_SWEEPS = 10; + let count2 = 0; + let sweep = 0; + const unitaryMatrix = scratchUnitary; + const diagonalMatrix = scratchDiagonal; + unitaryMatrix.identity(); + diagonalMatrix.copy(matrix); + const epsilon = EIGEN_TOLERANCE * computeFrobeniusNorm(diagonalMatrix); + while (sweep < EIGEN_MAX_SWEEPS && offDiagonalFrobeniusNorm(diagonalMatrix) > epsilon) { + shurDecomposition(diagonalMatrix, jMatrix); + jMatrixTranspose.copy(jMatrix).transpose(); + diagonalMatrix.multiplyRight(jMatrix); + diagonalMatrix.multiplyLeft(jMatrixTranspose); + unitaryMatrix.multiplyRight(jMatrix); + if (++count2 > 2) { + ++sweep; + count2 = 0; + } + } + result.unitary = unitaryMatrix.toTarget(result.unitary); + result.diagonal = diagonalMatrix.toTarget(result.diagonal); + return result; } - var DataColumn = class { - constructor(gl, opts, state) { - _defineProperty(this, "gl", void 0); - _defineProperty(this, "id", void 0); - _defineProperty(this, "size", void 0); - _defineProperty(this, "settings", void 0); - _defineProperty(this, "value", void 0); - _defineProperty(this, "doublePrecision", void 0); - _defineProperty(this, "_buffer", void 0); - _defineProperty(this, "state", void 0); - this.gl = gl; - this.id = opts.id || ""; - this.size = opts.size || 1; - const logicalType = opts.logicalType || opts.type; - const doublePrecision = logicalType === 5130; - let { - defaultValue - } = opts; - defaultValue = Number.isFinite(defaultValue) ? [defaultValue] : defaultValue || new Array(this.size).fill(0); - let bufferType; - if (doublePrecision) { - bufferType = 5126; - } else if (!logicalType && opts.isIndexed) { - bufferType = gl && hasFeature(gl, FEATURES.ELEMENT_INDEX_UINT32) ? 5125 : 5123; + function computeFrobeniusNorm(matrix) { + let norm = 0; + for (let i3 = 0; i3 < 9; ++i3) { + const temp = matrix[i3]; + norm += temp * temp; + } + return Math.sqrt(norm); + } + var rowVal = [1, 0, 0]; + var colVal = [2, 2, 1]; + function offDiagonalFrobeniusNorm(matrix) { + let norm = 0; + for (let i3 = 0; i3 < 3; ++i3) { + const temp = matrix[scratchMatrix.getElementIndex(colVal[i3], rowVal[i3])]; + norm += 2 * temp * temp; + } + return Math.sqrt(norm); + } + function shurDecomposition(matrix, result) { + const tolerance = math_utils_default.EPSILON15; + let maxDiagonal = 0; + let rotAxis = 1; + for (let i3 = 0; i3 < 3; ++i3) { + const temp = Math.abs(matrix[scratchMatrix.getElementIndex(colVal[i3], rowVal[i3])]); + if (temp > maxDiagonal) { + rotAxis = i3; + maxDiagonal = temp; + } + } + const p2 = rowVal[rotAxis]; + const q = colVal[rotAxis]; + let c2 = 1; + let s = 0; + if (Math.abs(matrix[scratchMatrix.getElementIndex(q, p2)]) > tolerance) { + const qq = matrix[scratchMatrix.getElementIndex(q, q)]; + const pp = matrix[scratchMatrix.getElementIndex(p2, p2)]; + const qp = matrix[scratchMatrix.getElementIndex(q, p2)]; + const tau = (qq - pp) / 2 / qp; + let t2; + if (tau < 0) { + t2 = -1 / (-tau + Math.sqrt(1 + tau * tau)); } else { - bufferType = logicalType || 5126; - } - let defaultType = glArrayFromType(logicalType || bufferType || 5126); - this.doublePrecision = doublePrecision; - if (doublePrecision && opts.fp64 === false) { - defaultType = Float32Array; + t2 = 1 / (tau + Math.sqrt(1 + tau * tau)); } - this.value = null; - this.settings = { - ...opts, - defaultType, - defaultValue, - logicalType, - type: bufferType, - size: this.size, - bytesPerElement: defaultType.BYTES_PER_ELEMENT - }; - this.state = { - ...state, - externalBuffer: null, - bufferAccessor: this.settings, - allocatedValue: null, - numInstances: 0, - bounds: null, - constant: false - }; - this._buffer = null; + c2 = 1 / Math.sqrt(1 + t2 * t2); + s = t2 * c2; } - get isConstant() { - return this.state.constant; + Matrix3.IDENTITY.to(result); + result[scratchMatrix.getElementIndex(p2, p2)] = result[scratchMatrix.getElementIndex(q, q)] = c2; + result[scratchMatrix.getElementIndex(q, p2)] = s; + result[scratchMatrix.getElementIndex(p2, q)] = -s; + return result; + } + + // node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-box-from-points.js + var scratchVector23 = new Vector3(); + var scratchVector33 = new Vector3(); + var scratchVector4 = new Vector3(); + var scratchVector5 = new Vector3(); + var scratchVector6 = new Vector3(); + var scratchCovarianceResult = new Matrix3(); + var scratchEigenResult = { + diagonal: new Matrix3(), + unitary: new Matrix3() + }; + function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) { + if (!positions || positions.length === 0) { + result.halfAxes = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]); + result.center = new Vector3(); + return result; } - get buffer() { - if (!this._buffer) { - const { - isIndexed, - type - } = this.settings; - this._buffer = new Buffer2(this.gl, { - id: this.id, - target: isIndexed ? 34963 : 34962, - accessor: { - type - } - }); + const length4 = positions.length; + const meanPoint = new Vector3(0, 0, 0); + for (const position of positions) { + meanPoint.add(position); + } + const invLength = 1 / length4; + meanPoint.multiplyByScalar(invLength); + let exx = 0; + let exy = 0; + let exz = 0; + let eyy = 0; + let eyz = 0; + let ezz = 0; + for (const position of positions) { + const p2 = scratchVector23.copy(position).subtract(meanPoint); + exx += p2.x * p2.x; + exy += p2.x * p2.y; + exz += p2.x * p2.z; + eyy += p2.y * p2.y; + eyz += p2.y * p2.z; + ezz += p2.z * p2.z; + } + exx *= invLength; + exy *= invLength; + exz *= invLength; + eyy *= invLength; + eyz *= invLength; + ezz *= invLength; + const covarianceMatrix = scratchCovarianceResult; + covarianceMatrix[0] = exx; + covarianceMatrix[1] = exy; + covarianceMatrix[2] = exz; + covarianceMatrix[3] = exy; + covarianceMatrix[4] = eyy; + covarianceMatrix[5] = eyz; + covarianceMatrix[6] = exz; + covarianceMatrix[7] = eyz; + covarianceMatrix[8] = ezz; + const { + unitary + } = computeEigenDecomposition(covarianceMatrix, scratchEigenResult); + const rotation = result.halfAxes.copy(unitary); + let v1 = rotation.getColumn(0, scratchVector4); + let v2 = rotation.getColumn(1, scratchVector5); + let v3 = rotation.getColumn(2, scratchVector6); + let u1 = -Number.MAX_VALUE; + let u2 = -Number.MAX_VALUE; + let u3 = -Number.MAX_VALUE; + let l1 = Number.MAX_VALUE; + let l2 = Number.MAX_VALUE; + let l3 = Number.MAX_VALUE; + for (const position of positions) { + scratchVector23.copy(position); + u1 = Math.max(scratchVector23.dot(v1), u1); + u2 = Math.max(scratchVector23.dot(v2), u2); + u3 = Math.max(scratchVector23.dot(v3), u3); + l1 = Math.min(scratchVector23.dot(v1), l1); + l2 = Math.min(scratchVector23.dot(v2), l2); + l3 = Math.min(scratchVector23.dot(v3), l3); + } + v1 = v1.multiplyByScalar(0.5 * (l1 + u1)); + v2 = v2.multiplyByScalar(0.5 * (l2 + u2)); + v3 = v3.multiplyByScalar(0.5 * (l3 + u3)); + result.center.copy(v1).add(v2).add(v3); + const scale5 = scratchVector33.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5); + const scaleMatrix = new Matrix3([scale5[0], 0, 0, 0, scale5[1], 0, 0, 0, scale5[2]]); + result.halfAxes.multiplyRight(scaleMatrix); + return result; + } + + // node_modules/@deck.gl/geo-layers/dist/esm/tile-layer/tile-2d-traversal.js + var TILE_SIZE3 = 512; + var MAX_MAPS = 3; + var REF_POINTS_5 = [[0.5, 0.5], [0, 0], [0, 1], [1, 0], [1, 1]]; + var REF_POINTS_9 = REF_POINTS_5.concat([[0, 0.5], [0.5, 0], [1, 0.5], [0.5, 1]]); + var REF_POINTS_11 = REF_POINTS_9.concat([[0.25, 0.5], [0.75, 0.5]]); + var OSMNode = class _OSMNode { + constructor(x2, y2, z) { + _defineProperty(this, "x", void 0); + _defineProperty(this, "y", void 0); + _defineProperty(this, "z", void 0); + _defineProperty(this, "childVisible", void 0); + _defineProperty(this, "selected", void 0); + _defineProperty(this, "_children", void 0); + this.x = x2; + this.y = y2; + this.z = z; + } + get children() { + if (!this._children) { + const x2 = this.x * 2; + const y2 = this.y * 2; + const z = this.z + 1; + this._children = [new _OSMNode(x2, y2, z), new _OSMNode(x2, y2 + 1, z), new _OSMNode(x2 + 1, y2, z), new _OSMNode(x2 + 1, y2 + 1, z)]; + } + return this._children; + } + update(params) { + const { + viewport, + cullingVolume, + elevationBounds, + minZ, + maxZ, + bounds, + offset, + project: project2 + } = params; + const boundingVolume = this.getBoundingVolume(elevationBounds, offset, project2); + if (bounds && !this.insideBounds(bounds)) { + return false; } - return this._buffer; - } - get byteOffset() { - const accessor = this.getAccessor(); - if (accessor.vertexOffset) { - return accessor.vertexOffset * getStride(accessor); + const isInside = cullingVolume.computeVisibility(boundingVolume); + if (isInside < 0) { + return false; } - return 0; + if (!this.childVisible) { + let { + z + } = this; + if (z < maxZ && z >= minZ) { + const distance2 = boundingVolume.distanceTo(viewport.cameraPosition) * viewport.scale / viewport.height; + z += Math.floor(Math.log2(distance2)); + } + if (z >= maxZ) { + this.selected = true; + return true; + } + } + this.selected = false; + this.childVisible = true; + for (const child of this.children) { + child.update(params); + } + return true; } - get numInstances() { - return this.state.numInstances; + getSelected(result = []) { + if (this.selected) { + result.push(this); + } + if (this._children) { + for (const node of this._children) { + node.getSelected(result); + } + } + return result; } - set numInstances(n2) { - this.state.numInstances = n2; + insideBounds([minX, minY, maxX, maxY]) { + const scale5 = Math.pow(2, this.z); + const extent = TILE_SIZE3 / scale5; + return this.x * extent < maxX && this.y * extent < maxY && (this.x + 1) * extent > minX && (this.y + 1) * extent > minY; + } + getBoundingVolume(zRange, worldOffset, project2) { + if (project2) { + const refPoints = this.z < 1 ? REF_POINTS_11 : this.z < 2 ? REF_POINTS_9 : REF_POINTS_5; + const refPointPositions = []; + for (const p2 of refPoints) { + const lngLat = osmTile2lngLat(this.x + p2[0], this.y + p2[1], this.z); + lngLat[2] = zRange[0]; + refPointPositions.push(project2(lngLat)); + if (zRange[0] !== zRange[1]) { + lngLat[2] = zRange[1]; + refPointPositions.push(project2(lngLat)); + } + } + return makeOrientedBoundingBoxFromPoints(refPointPositions); + } + const scale5 = Math.pow(2, this.z); + const extent = TILE_SIZE3 / scale5; + const originX = this.x * extent + worldOffset * TILE_SIZE3; + const originY = TILE_SIZE3 - (this.y + 1) * extent; + return new AxisAlignedBoundingBox([originX, originY, zRange[0]], [originX + extent, originY + extent, zRange[1]]); } - delete() { - if (this._buffer) { - this._buffer.delete(); - this._buffer = null; + }; + function getOSMTileIndices(viewport, maxZ, zRange, bounds) { + const project2 = viewport instanceof GlobeViewport && viewport.resolution ? viewport.projectPosition : null; + const planes = Object.values(viewport.getFrustumPlanes()).map(({ + normal, + distance: distance2 + }) => new Plane(normal.clone().negate(), distance2)); + const cullingVolume = new CullingVolume(planes); + const unitsPerMeter2 = viewport.distanceScales.unitsPerMeter[2]; + const elevationMin = zRange && zRange[0] * unitsPerMeter2 || 0; + const elevationMax = zRange && zRange[1] * unitsPerMeter2 || 0; + const minZ = viewport instanceof WebMercatorViewport2 && viewport.pitch <= 60 ? maxZ : 0; + if (bounds) { + const [minLng, minLat, maxLng, maxLat] = bounds; + const topLeft = lngLatToWorld([minLng, maxLat]); + const bottomRight = lngLatToWorld([maxLng, minLat]); + bounds = [topLeft[0], TILE_SIZE3 - topLeft[1], bottomRight[0], TILE_SIZE3 - bottomRight[1]]; + } + const root = new OSMNode(0, 0, 0); + const traversalParams = { + viewport, + project: project2, + cullingVolume, + elevationBounds: [elevationMin, elevationMax], + minZ, + maxZ, + bounds, + offset: 0 + }; + root.update(traversalParams); + if (viewport instanceof WebMercatorViewport2 && viewport.subViewports && viewport.subViewports.length > 1) { + traversalParams.offset = -1; + while (root.update(traversalParams)) { + if (--traversalParams.offset < -MAX_MAPS) { + break; + } + } + traversalParams.offset = 1; + while (root.update(traversalParams)) { + if (++traversalParams.offset > MAX_MAPS) { + break; + } } - typed_array_manager_default.release(this.state.allocatedValue); } - getShaderAttributes(id, options) { - if (this.doublePrecision) { - const shaderAttributes = {}; - const isBuffer64Bit = this.value instanceof Float64Array; - const doubleShaderAttributeDefs = resolveDoublePrecisionShaderAttributes(this.getAccessor(), options || {}); - shaderAttributes[id] = new ShaderAttribute(this, doubleShaderAttributeDefs.high); - shaderAttributes["".concat(id, "64Low")] = isBuffer64Bit ? new ShaderAttribute(this, doubleShaderAttributeDefs.low) : new Float32Array(this.size); - return shaderAttributes; + return root.getSelected(); + } + + // node_modules/@deck.gl/geo-layers/dist/esm/tile-layer/utils.js + var TILE_SIZE4 = 512; + var DEFAULT_EXTENT = [-Infinity, -Infinity, Infinity, Infinity]; + var urlType = { + type: "url", + value: null, + validate: (value, propType) => propType.optional && value === null || typeof value === "string" || Array.isArray(value) && value.every((url) => typeof url === "string"), + equals: (value1, value2) => { + if (value1 === value2) { + return true; } - if (options) { - const shaderAttributeDef = resolveShaderAttribute(this.getAccessor(), options); - return { - [id]: new ShaderAttribute(this, shaderAttributeDef) - }; + if (!Array.isArray(value1) || !Array.isArray(value2)) { + return false; + } + const len2 = value1.length; + if (len2 !== value2.length) { + return false; + } + for (let i3 = 0; i3 < len2; i3++) { + if (value1[i3] !== value2[i3]) { + return false; + } } + return true; + } + }; + function transformBox(bbox, modelMatrix) { + const transformedCoords = [modelMatrix.transformAsPoint([bbox[0], bbox[1]]), modelMatrix.transformAsPoint([bbox[2], bbox[1]]), modelMatrix.transformAsPoint([bbox[0], bbox[3]]), modelMatrix.transformAsPoint([bbox[2], bbox[3]])]; + const transformedBox = [Math.min(...transformedCoords.map((i3) => i3[0])), Math.min(...transformedCoords.map((i3) => i3[1])), Math.max(...transformedCoords.map((i3) => i3[0])), Math.max(...transformedCoords.map((i3) => i3[1]))]; + return transformedBox; + } + function stringHash(s) { + return Math.abs(s.split("").reduce((a2, b2) => (a2 << 5) - a2 + b2.charCodeAt(0) | 0, 0)); + } + function getURLFromTemplate(template2, tile) { + if (!template2 || !template2.length) { + return null; + } + const { + index, + id + } = tile; + if (Array.isArray(template2)) { + const i3 = stringHash(id) % template2.length; + template2 = template2[i3]; + } + let url = template2; + for (const key of Object.keys(index)) { + const regex = new RegExp("{".concat(key, "}"), "g"); + url = url.replace(regex, String(index[key])); + } + if (Number.isInteger(index.y) && Number.isInteger(index.z)) { + url = url.replace(/\{-y\}/g, String(Math.pow(2, index.z) - index.y - 1)); + } + return url; + } + function getBoundingBox2(viewport, zRange, extent) { + let bounds; + if (zRange && zRange.length === 2) { + const [minZ, maxZ] = zRange; + const bounds0 = viewport.getBounds({ + z: minZ + }); + const bounds1 = viewport.getBounds({ + z: maxZ + }); + bounds = [Math.min(bounds0[0], bounds1[0]), Math.min(bounds0[1], bounds1[1]), Math.max(bounds0[2], bounds1[2]), Math.max(bounds0[3], bounds1[3])]; + } else { + bounds = viewport.getBounds(); + } + if (!viewport.isGeospatial) { + return [Math.max(Math.min(bounds[0], extent[2]), extent[0]), Math.max(Math.min(bounds[1], extent[3]), extent[1]), Math.min(Math.max(bounds[2], extent[0]), extent[2]), Math.min(Math.max(bounds[3], extent[1]), extent[3])]; + } + return [Math.max(bounds[0], extent[0]), Math.max(bounds[1], extent[1]), Math.min(bounds[2], extent[2]), Math.min(bounds[3], extent[3])]; + } + function getCullBounds({ + viewport, + z = 0, + cullRect + }) { + const subViewports = viewport.subViewports || [viewport]; + return subViewports.map((v2) => getCullBoundsInViewport(v2, z, cullRect)); + } + function getCullBoundsInViewport(viewport, z, cullRect) { + if (!Array.isArray(z)) { + const x2 = cullRect.x - viewport.x; + const y2 = cullRect.y - viewport.y; + const { + width, + height + } = cullRect; + const unprojectOption = { + targetZ: z + }; + const topLeft = viewport.unproject([x2, y2], unprojectOption); + const topRight = viewport.unproject([x2 + width, y2], unprojectOption); + const bottomLeft = viewport.unproject([x2, y2 + height], unprojectOption); + const bottomRight = viewport.unproject([x2 + width, y2 + height], unprojectOption); + return [Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]), Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]), Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1])]; + } + const bounds0 = getCullBoundsInViewport(viewport, z[0], cullRect); + const bounds1 = getCullBoundsInViewport(viewport, z[1], cullRect); + return [Math.min(bounds0[0], bounds1[0]), Math.min(bounds0[1], bounds1[1]), Math.max(bounds0[2], bounds1[2]), Math.max(bounds0[3], bounds1[3])]; + } + function getIndexingCoords(bbox, scale5, modelMatrixInverse) { + if (modelMatrixInverse) { + const transformedTileIndex = transformBox(bbox, modelMatrixInverse).map((i3) => i3 * scale5 / TILE_SIZE4); + return transformedTileIndex; + } + return bbox.map((i3) => i3 * scale5 / TILE_SIZE4); + } + function getScale(z, tileSize) { + return Math.pow(2, z) * TILE_SIZE4 / tileSize; + } + function osmTile2lngLat(x2, y2, z) { + const scale5 = getScale(z, TILE_SIZE4); + const lng = x2 / scale5 * 360 - 180; + const n2 = Math.PI - 2 * Math.PI * y2 / scale5; + const lat = 180 / Math.PI * Math.atan(0.5 * (Math.exp(n2) - Math.exp(-n2))); + return [lng, lat]; + } + function tile2XY(x2, y2, z, tileSize) { + const scale5 = getScale(z, tileSize); + return [x2 / scale5 * TILE_SIZE4, y2 / scale5 * TILE_SIZE4]; + } + function tileToBoundingBox(viewport, x2, y2, z, tileSize = TILE_SIZE4) { + if (viewport.isGeospatial) { + const [west, north] = osmTile2lngLat(x2, y2, z); + const [east, south] = osmTile2lngLat(x2 + 1, y2 + 1, z); return { - [id]: this + west, + north, + east, + south }; } - getBuffer() { - if (this.state.constant) { - return null; + const [left, top] = tile2XY(x2, y2, z, tileSize); + const [right, bottom] = tile2XY(x2 + 1, y2 + 1, z, tileSize); + return { + left, + top, + right, + bottom + }; + } + function getIdentityTileIndices(viewport, z, tileSize, extent, modelMatrixInverse) { + const bbox = getBoundingBox2(viewport, null, extent); + const scale5 = getScale(z, tileSize); + const [minX, minY, maxX, maxY] = getIndexingCoords(bbox, scale5, modelMatrixInverse); + const indices = []; + for (let x2 = Math.floor(minX); x2 < maxX; x2++) { + for (let y2 = Math.floor(minY); y2 < maxY; y2++) { + indices.push({ + x: x2, + y: y2, + z + }); } - return this.state.externalBuffer || this._buffer; } - getValue() { - if (this.state.constant) { - return this.value; + return indices; + } + function getTileIndices({ + viewport, + maxZoom, + minZoom, + zRange, + extent, + tileSize = TILE_SIZE4, + modelMatrix, + modelMatrixInverse, + zoomOffset = 0 + }) { + let z = viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE4 / tileSize)) + zoomOffset : Math.ceil(viewport.zoom) + zoomOffset; + if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) { + if (!extent) { + return []; } - return [this.getBuffer(), this.getAccessor()]; + z = minZoom; } - getAccessor() { - return this.state.bufferAccessor; + if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) { + z = maxZoom; } - getBounds() { - if (this.state.bounds) { - return this.state.bounds; - } - let result = null; - if (this.state.constant && this.value) { - const min = Array.from(this.value); - result = [min, min]; - } else { - const { - value, - numInstances, - size - } = this; - const len = numInstances * size; - if (value && len && value.length >= len) { - const min = new Array(size).fill(Infinity); - const max = new Array(size).fill(-Infinity); - for (let i2 = 0; i2 < len; ) { - for (let j = 0; j < size; j++) { - const v2 = value[i2++]; - if (v2 < min[j]) - min[j] = v2; - if (v2 > max[j]) - max[j] = v2; - } - } - result = [min, max]; + let transformedExtent = extent; + if (modelMatrix && modelMatrixInverse && extent && !viewport.isGeospatial) { + transformedExtent = transformBox(extent, modelMatrix); + } + return viewport.isGeospatial ? getOSMTileIndices(viewport, z, zRange, extent) : getIdentityTileIndices(viewport, z, tileSize, transformedExtent || DEFAULT_EXTENT, modelMatrixInverse); + } + + // node_modules/@deck.gl/geo-layers/dist/esm/tile-layer/tileset-2d.js + var TILE_STATE_VISITED = 1; + var TILE_STATE_VISIBLE = 2; + var STRATEGY_NEVER = "never"; + var STRATEGY_REPLACE = "no-overlap"; + var STRATEGY_DEFAULT = "best-available"; + var DEFAULT_CACHE_SCALE = 5; + var STRATEGIES = { + [STRATEGY_DEFAULT]: updateTileStateDefault, + [STRATEGY_REPLACE]: updateTileStateReplace, + [STRATEGY_NEVER]: () => { + } + }; + var Tileset2D = class { + constructor(opts) { + _defineProperty(this, "opts", void 0); + _defineProperty(this, "_requestScheduler", void 0); + _defineProperty(this, "_cache", void 0); + _defineProperty(this, "_dirty", void 0); + _defineProperty(this, "_tiles", void 0); + _defineProperty(this, "_cacheByteSize", void 0); + _defineProperty(this, "_viewport", void 0); + _defineProperty(this, "_zRange", void 0); + _defineProperty(this, "_selectedTiles", void 0); + _defineProperty(this, "_frameNumber", void 0); + _defineProperty(this, "_modelMatrix", void 0); + _defineProperty(this, "_modelMatrixInverse", void 0); + _defineProperty(this, "_maxZoom", void 0); + _defineProperty(this, "_minZoom", void 0); + _defineProperty(this, "onTileLoad", void 0); + _defineProperty(this, "_getCullBounds", memoize(getCullBounds)); + this.opts = opts; + this.onTileLoad = (tile) => { + this.opts.onTileLoad(tile); + if (this.opts.maxCacheByteSize) { + this._cacheByteSize += tile.byteLength; + this._resizeCache(); } - } - this.state.bounds = result; - return result; + }; + this._requestScheduler = new RequestScheduler({ + maxRequests: opts.maxRequests, + throttleRequests: opts.maxRequests > 0 + }); + this._cache = /* @__PURE__ */ new Map(); + this._tiles = []; + this._dirty = false; + this._cacheByteSize = 0; + this._viewport = null; + this._selectedTiles = null; + this._frameNumber = 0; + this._modelMatrix = new Matrix4(); + this._modelMatrixInverse = new Matrix4(); + this.setOptions(opts); + } + get tiles() { + return this._tiles; + } + get selectedTiles() { + return this._selectedTiles; } - setData(data) { - const { - state - } = this; - let opts; - if (ArrayBuffer.isView(data)) { - opts = { - value: data - }; - } else if (data instanceof Buffer2) { - opts = { - buffer: data - }; - } else { - opts = data; + get isLoaded() { + return this._selectedTiles !== null && this._selectedTiles.every((tile) => tile.isLoaded); + } + get needsReload() { + return this._selectedTiles !== null && this._selectedTiles.some((tile) => tile.needsReload); + } + setOptions(opts) { + Object.assign(this.opts, opts); + if (Number.isFinite(opts.maxZoom)) { + this._maxZoom = Math.floor(opts.maxZoom); } - const accessor = { - ...this.settings, - ...opts - }; - state.bufferAccessor = accessor; - state.bounds = null; - if (opts.constant) { - let value = opts.value; - value = this._normalizeValue(value, [], 0); - if (this.settings.normalized) { - value = this.normalizeConstant(value); - } - const hasChanged = !state.constant || !this._areValuesEqual(value, this.value); - if (!hasChanged) { - return false; - } - state.externalBuffer = null; - state.constant = true; - this.value = value; - } else if (opts.buffer) { - const buffer = opts.buffer; - state.externalBuffer = buffer; - state.constant = false; - this.value = opts.value || null; - const isBuffer64Bit = opts.value instanceof Float64Array; - accessor.type = opts.type || buffer.accessor.type; - accessor.bytesPerElement = buffer.accessor.BYTES_PER_ELEMENT * (isBuffer64Bit ? 2 : 1); - accessor.stride = getStride(accessor); - } else if (opts.value) { - this._checkExternalBuffer(opts); - let value = opts.value; - state.externalBuffer = null; - state.constant = false; - this.value = value; - accessor.bytesPerElement = value.BYTES_PER_ELEMENT; - accessor.stride = getStride(accessor); - const { - buffer, - byteOffset - } = this; - if (this.doublePrecision && value instanceof Float64Array) { - value = toDoublePrecisionArray(value, accessor); + if (Number.isFinite(opts.minZoom)) { + this._minZoom = Math.ceil(opts.minZoom); + } + } + finalize() { + for (const tile of this._cache.values()) { + if (tile.isLoading) { + tile.abort(); } - const requiredBufferSize = value.byteLength + byteOffset + accessor.stride * 2; - if (buffer.byteLength < requiredBufferSize) { - buffer.reallocate(requiredBufferSize); + } + this._cache.clear(); + this._tiles = []; + this._selectedTiles = null; + } + reloadAll() { + for (const id of this._cache.keys()) { + const tile = this._cache.get(id); + if (!this._selectedTiles || !this._selectedTiles.includes(tile)) { + this._cache.delete(id); + } else { + tile.setNeedsReload(); } - buffer.setAccessor(null); - buffer.subData({ - data: value, - offset: byteOffset + } + } + update(viewport, { + zRange, + modelMatrix + } = {}) { + const modelMatrixAsMatrix4 = new Matrix4(modelMatrix); + const isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix); + if (!this._viewport || !viewport.equals(this._viewport) || !equals(this._zRange, zRange) || isModelMatrixNew) { + if (isModelMatrixNew) { + this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert(); + this._modelMatrix = modelMatrixAsMatrix4; + } + this._viewport = viewport; + this._zRange = zRange; + const tileIndices = this.getTileIndices({ + viewport, + maxZoom: this._maxZoom, + minZoom: this._minZoom, + zRange, + modelMatrix: this._modelMatrix, + modelMatrixInverse: this._modelMatrixInverse }); - accessor.type = opts.type || buffer.accessor.type; + this._selectedTiles = tileIndices.map((index) => this._getTile(index, true)); + if (this._dirty) { + this._rebuildTree(); + } + } else if (this.needsReload) { + this._selectedTiles = this._selectedTiles.map((tile) => this._getTile(tile.index, true)); } - return true; + const changed = this.updateTileStates(); + this._pruneRequests(); + if (this._dirty) { + this._resizeCache(); + } + if (changed) { + this._frameNumber++; + } + return this._frameNumber; } - updateSubBuffer(opts = {}) { - this.state.bounds = null; - const value = this.value; - const { - startOffset = 0, - endOffset - } = opts; - this.buffer.subData({ - data: this.doublePrecision && value instanceof Float64Array ? toDoublePrecisionArray(value, { - size: this.size, - startIndex: startOffset, - endIndex: endOffset - }) : value.subarray(startOffset, endOffset), - offset: startOffset * value.BYTES_PER_ELEMENT + this.byteOffset - }); + isTileVisible(tile, cullRect) { + if (!tile.isVisible) { + return false; + } + if (cullRect && this._viewport) { + const boundsArr = this._getCullBounds({ + viewport: this._viewport, + z: this._zRange, + cullRect + }); + const { + bbox + } = tile; + for (const [minX, minY, maxX, maxY] of boundsArr) { + let overlaps; + if ("west" in bbox) { + overlaps = bbox.west < maxX && bbox.east > minX && bbox.south < maxY && bbox.north > minY; + } else { + const y0 = Math.min(bbox.top, bbox.bottom); + const y1 = Math.max(bbox.top, bbox.bottom); + overlaps = bbox.left < maxX && bbox.right > minX && y0 < maxY && y1 > minY; + } + if (overlaps) { + return true; + } + } + return false; + } + return true; } - allocate(numInstances, copy = false) { + getTileIndices({ + viewport, + maxZoom, + minZoom, + zRange, + modelMatrix, + modelMatrixInverse + }) { const { - state - } = this; - const oldValue = state.allocatedValue; - const value = typed_array_manager_default.allocate(oldValue, numInstances + 1, { - size: this.size, - type: this.settings.defaultType, - copy + tileSize, + extent, + zoomOffset + } = this.opts; + return getTileIndices({ + viewport, + maxZoom, + minZoom, + zRange, + tileSize, + extent, + modelMatrix, + modelMatrixInverse, + zoomOffset }); - this.value = value; + } + getTileId(index) { + return "".concat(index.x, "-").concat(index.y, "-").concat(index.z); + } + getTileZoom(index) { + return index.z; + } + getTileMetadata(index) { const { - buffer, - byteOffset - } = this; - if (buffer.byteLength < value.byteLength + byteOffset) { - buffer.reallocate(value.byteLength + byteOffset); - if (copy && oldValue) { - buffer.subData({ - data: oldValue instanceof Float64Array ? toDoublePrecisionArray(oldValue, this) : oldValue, - offset: byteOffset - }); + tileSize + } = this.opts; + return { + bbox: tileToBoundingBox(this._viewport, index.x, index.y, index.z, tileSize) + }; + } + getParentIndex(index) { + const x2 = Math.floor(index.x / 2); + const y2 = Math.floor(index.y / 2); + const z = index.z - 1; + return { + x: x2, + y: y2, + z + }; + } + updateTileStates() { + const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT; + const visibilities = new Array(this._cache.size); + let i3 = 0; + for (const tile of this._cache.values()) { + visibilities[i3++] = tile.isVisible; + tile.isSelected = false; + tile.isVisible = false; + } + for (const tile of this._selectedTiles) { + tile.isSelected = true; + tile.isVisible = true; + } + (typeof refinementStrategy === "function" ? refinementStrategy : STRATEGIES[refinementStrategy])(Array.from(this._cache.values())); + i3 = 0; + for (const tile of this._cache.values()) { + if (visibilities[i3++] !== tile.isVisible) { + return true; } } - state.allocatedValue = value; - state.constant = false; - state.externalBuffer = null; - state.bufferAccessor = this.settings; - return true; + return false; } - _checkExternalBuffer(opts) { + _pruneRequests() { const { - value - } = opts; - if (!ArrayBuffer.isView(value)) { - throw new Error("Attribute ".concat(this.id, " value is not TypedArray")); - } - const ArrayType = this.settings.defaultType; - let illegalArrayType = false; - if (this.doublePrecision) { - illegalArrayType = value.BYTES_PER_ELEMENT < 4; - } - if (illegalArrayType) { - throw new Error("Attribute ".concat(this.id, " does not support ").concat(value.constructor.name)); - } - if (!(value instanceof ArrayType) && this.settings.normalized && !("normalized" in opts)) { - log_default.warn("Attribute ".concat(this.id, " is normalized"))(); + maxRequests + } = this.opts; + const abortCandidates = []; + let ongoingRequestCount = 0; + for (const tile of this._cache.values()) { + if (tile.isLoading) { + ongoingRequestCount++; + if (!tile.isSelected && !tile.isVisible) { + abortCandidates.push(tile); + } + } } - } - normalizeConstant(value) { - switch (this.settings.type) { - case 5120: - return new Float32Array(value).map((x2) => (x2 + 128) / 255 * 2 - 1); - case 5122: - return new Float32Array(value).map((x2) => (x2 + 32768) / 65535 * 2 - 1); - case 5121: - return new Float32Array(value).map((x2) => x2 / 255); - case 5123: - return new Float32Array(value).map((x2) => x2 / 65535); - default: - return value; + while (maxRequests > 0 && ongoingRequestCount > maxRequests && abortCandidates.length > 0) { + const tile = abortCandidates.shift(); + tile.abort(); + ongoingRequestCount--; } } - _normalizeValue(value, out, start) { + _rebuildTree() { const { - defaultValue, - size - } = this.settings; - if (Number.isFinite(value)) { - out[start] = value; - return out; + _cache + } = this; + for (const tile of _cache.values()) { + tile.parent = null; + if (tile.children) { + tile.children.length = 0; + } } - if (!value) { - let i2 = size; - while (--i2 >= 0) { - out[start + i2] = defaultValue[i2]; + for (const tile of _cache.values()) { + const parent = this._getNearestAncestor(tile); + tile.parent = parent; + if (parent !== null && parent !== void 0 && parent.children) { + parent.children.push(tile); } - return out; } - switch (size) { - case 4: - out[start + 3] = Number.isFinite(value[3]) ? value[3] : defaultValue[3]; - case 3: - out[start + 2] = Number.isFinite(value[2]) ? value[2] : defaultValue[2]; - case 2: - out[start + 1] = Number.isFinite(value[1]) ? value[1] : defaultValue[1]; - case 1: - out[start + 0] = Number.isFinite(value[0]) ? value[0] : defaultValue[0]; - break; - default: - let i2 = size; - while (--i2 >= 0) { - out[start + i2] = Number.isFinite(value[i2]) ? value[i2] : defaultValue[i2]; + } + _resizeCache() { + const { + _cache, + opts + } = this; + const maxCacheSize = opts.maxCacheSize || (opts.maxCacheByteSize ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length); + const maxCacheByteSize = opts.maxCacheByteSize || Infinity; + const overflown = _cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize; + if (overflown) { + for (const [id, tile] of _cache) { + if (!tile.isVisible && !tile.isSelected) { + this._cacheByteSize -= opts.maxCacheByteSize ? tile.byteLength : 0; + _cache.delete(id); + this.opts.onTileUnload(tile); + } + if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) { + break; } + } + this._rebuildTree(); + this._dirty = true; + } + if (this._dirty) { + this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.zoom - t2.zoom); + this._dirty = false; } - return out; } - _areValuesEqual(value1, value2) { - if (!value1 || !value2) { - return false; + _getTile(index, create6) { + const id = this.getTileId(index); + let tile = this._cache.get(id); + let needsReload = false; + if (!tile && create6) { + tile = new Tile2DHeader(index); + Object.assign(tile, this.getTileMetadata(tile.index)); + Object.assign(tile, { + id, + zoom: this.getTileZoom(tile.index) + }); + needsReload = true; + this._cache.set(id, tile); + this._dirty = true; + } else if (tile && tile.needsReload) { + needsReload = true; + } + if (tile && needsReload) { + tile.loadData({ + getData: this.opts.getTileData, + requestScheduler: this._requestScheduler, + onLoad: this.onTileLoad, + onError: this.opts.onTileError + }); } + return tile; + } + _getNearestAncestor(tile) { const { - size + _minZoom = 0 } = this; - for (let i2 = 0; i2 < size; i2++) { - if (value1[i2] !== value2[i2]) { - return false; + let index = tile.index; + while (this.getTileZoom(index) > _minZoom) { + index = this.getParentIndex(index); + const parent = this._getTile(index); + if (parent) { + return parent; } } - return true; + return null; } }; - - // node_modules/@deck.gl/core/dist/esm/utils/iterable-utils.js - var EMPTY_ARRAY = []; - var placeholderArray = []; - function createIterable(data, startRow = 0, endRow = Infinity) { - let iterable = EMPTY_ARRAY; - const objectInfo = { - index: -1, - data, - target: [] - }; - if (!data) { - iterable = EMPTY_ARRAY; - } else if (typeof data[Symbol.iterator] === "function") { - iterable = data; - } else if (data.length > 0) { - placeholderArray.length = data.length; - iterable = placeholderArray; + function updateTileStateDefault(allTiles) { + for (const tile of allTiles) { + tile.state = 0; } - if (startRow > 0 || Number.isFinite(endRow)) { - iterable = (Array.isArray(iterable) ? iterable : Array.from(iterable)).slice(startRow, endRow); - objectInfo.index = startRow - 1; + for (const tile of allTiles) { + if (tile.isSelected && !getPlaceholderInAncestors(tile)) { + getPlaceholderInChildren(tile); + } + } + for (const tile of allTiles) { + tile.isVisible = Boolean(tile.state & TILE_STATE_VISIBLE); } - return { - iterable, - objectInfo - }; - } - function isAsyncIterable2(data) { - return data && data[Symbol.asyncIterator]; } - function getAccessorFromBuffer(typedArray, options) { - const { - size, - stride, - offset, - startIndices, - nested - } = options; - const bytesPerElement = typedArray.BYTES_PER_ELEMENT; - const elementStride = stride ? stride / bytesPerElement : size; - const elementOffset = offset ? offset / bytesPerElement : 0; - const vertexCount = Math.floor((typedArray.length - elementOffset) / elementStride); - return (_2, { - index, - target - }) => { - if (!startIndices) { - const sourceIndex = index * elementStride + elementOffset; - for (let j = 0; j < size; j++) { - target[j] = typedArray[sourceIndex + j]; - } - return target; + function updateTileStateReplace(allTiles) { + for (const tile of allTiles) { + tile.state = 0; + } + for (const tile of allTiles) { + if (tile.isSelected) { + getPlaceholderInAncestors(tile); } - const startIndex = startIndices[index]; - const endIndex = startIndices[index + 1] || vertexCount; - let result; - if (nested) { - result = new Array(endIndex - startIndex); - for (let i2 = startIndex; i2 < endIndex; i2++) { - const sourceIndex = i2 * elementStride + elementOffset; - target = new Array(size); - for (let j = 0; j < size; j++) { - target[j] = typedArray[sourceIndex + j]; - } - result[i2 - startIndex] = target; - } - } else if (elementStride === size) { - result = typedArray.subarray(startIndex * size + elementOffset, endIndex * size + elementOffset); - } else { - result = new typedArray.constructor((endIndex - startIndex) * size); - let targetIndex = 0; - for (let i2 = startIndex; i2 < endIndex; i2++) { - const sourceIndex = i2 * elementStride + elementOffset; - for (let j = 0; j < size; j++) { - result[targetIndex++] = typedArray[sourceIndex + j]; - } + } + const sortedTiles = Array.from(allTiles).sort((t1, t2) => t1.zoom - t2.zoom); + for (const tile of sortedTiles) { + tile.isVisible = Boolean(tile.state & TILE_STATE_VISIBLE); + if (tile.children && (tile.isVisible || tile.state & TILE_STATE_VISITED)) { + for (const child of tile.children) { + child.state = TILE_STATE_VISITED; } + } else if (tile.isSelected) { + getPlaceholderInChildren(tile); } - return result; - }; - } - - // node_modules/@deck.gl/core/dist/esm/utils/range.js - var EMPTY = []; - var FULL = [[0, Infinity]]; - function add2(rangeList, range) { - if (rangeList === FULL) { - return rangeList; - } - if (range[0] < 0) { - range[0] = 0; } - if (range[0] >= range[1]) { - return rangeList; + } + function getPlaceholderInAncestors(startTile) { + let tile = startTile; + while (tile) { + if (tile.isLoaded || tile.content) { + tile.state |= TILE_STATE_VISIBLE; + return true; + } + tile = tile.parent; } - const newRangeList = []; - const len = rangeList.length; - let insertPosition = 0; - for (let i2 = 0; i2 < len; i2++) { - const range0 = rangeList[i2]; - if (range0[1] < range[0]) { - newRangeList.push(range0); - insertPosition = i2 + 1; - } else if (range0[0] > range[1]) { - newRangeList.push(range0); + return false; + } + function getPlaceholderInChildren(tile) { + for (const child of tile.children) { + if (child.isLoaded || child.content) { + child.state |= TILE_STATE_VISIBLE; } else { - range = [Math.min(range0[0], range[0]), Math.max(range0[1], range[1])]; + getPlaceholderInChildren(child); } } - newRangeList.splice(insertPosition, 0, range); - return newRangeList; } - // node_modules/@deck.gl/core/dist/esm/utils/array-utils.js - function padArrayChunk(options) { - const { - source, - target, - start = 0, - size, - getData - } = options; - const end = options.end || target.length; - const sourceLength = source.length; - const targetLength = end - start; - if (sourceLength > targetLength) { - target.set(source.subarray(0, targetLength), start); - return; + // node_modules/@deck.gl/geo-layers/dist/esm/tile-layer/tile-layer.js + var defaultProps15 = { + TilesetClass: Tileset2D, + data: { + type: "data", + value: [] + }, + dataComparator: urlType.equals, + renderSubLayers: { + type: "function", + value: (props) => new GeoJsonLayer(props), + compare: false + }, + getTileData: { + type: "function", + optional: true, + value: null, + compare: false + }, + onViewportLoad: { + type: "function", + optional: true, + value: null, + compare: false + }, + onTileLoad: { + type: "function", + value: (tile) => { + }, + compare: false + }, + onTileUnload: { + type: "function", + value: (tile) => { + }, + compare: false + }, + onTileError: { + type: "function", + value: (err3) => console.error(err3), + compare: false + }, + extent: { + type: "array", + optional: true, + value: null, + compare: true + }, + tileSize: 512, + maxZoom: null, + minZoom: 0, + maxCacheSize: null, + maxCacheByteSize: null, + refinementStrategy: STRATEGY_DEFAULT, + zRange: null, + maxRequests: 6, + zoomOffset: 0 + }; + var TileLayer = class extends CompositeLayer { + initializeState() { + this.state = { + tileset: null, + isLoaded: false + }; } - target.set(source, start); - if (!getData) { - return; + finalizeState() { + var _this$state, _this$state$tileset; + (_this$state = this.state) === null || _this$state === void 0 ? void 0 : (_this$state$tileset = _this$state.tileset) === null || _this$state$tileset === void 0 ? void 0 : _this$state$tileset.finalize(); } - let i2 = sourceLength; - while (i2 < targetLength) { - const datum = getData(i2, source); - for (let j = 0; j < size; j++) { - target[start + i2] = datum[j] || 0; - i2++; + get isLoaded() { + var _this$state2, _this$state2$tileset; + return (_this$state2 = this.state) === null || _this$state2 === void 0 ? void 0 : (_this$state2$tileset = _this$state2.tileset) === null || _this$state2$tileset === void 0 ? void 0 : _this$state2$tileset.selectedTiles.every((tile) => tile.isLoaded && tile.layers && tile.layers.every((layer) => layer.isLoaded)); + } + shouldUpdateState({ + changeFlags + }) { + return changeFlags.somethingChanged; + } + updateState({ + changeFlags + }) { + let { + tileset + } = this.state; + const propsChanged = changeFlags.propsOrDataChanged || changeFlags.updateTriggersChanged; + const dataChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getTileData); + if (!tileset) { + tileset = new this.props.TilesetClass(this._getTilesetOptions()); + this.setState({ + tileset + }); + } else if (propsChanged) { + tileset.setOptions(this._getTilesetOptions()); + if (dataChanged) { + tileset.reloadAll(); + } else { + this.state.tileset.tiles.forEach((tile) => { + tile.layers = null; + }); + } } + this._updateTileset(); } - } - function padArray({ - source, - target, - size, - getData, - sourceStartIndices, - targetStartIndices - }) { - if (!Array.isArray(targetStartIndices)) { - padArrayChunk({ - source, - target, - size, - getData - }); - return target; + _getTilesetOptions() { + const { + tileSize, + maxCacheSize, + maxCacheByteSize, + refinementStrategy, + extent, + maxZoom, + minZoom, + maxRequests, + zoomOffset + } = this.props; + return { + maxCacheSize, + maxCacheByteSize, + maxZoom, + minZoom, + tileSize, + refinementStrategy, + extent, + maxRequests, + zoomOffset, + getTileData: this.getTileData.bind(this), + onTileLoad: this._onTileLoad.bind(this), + onTileError: this._onTileError.bind(this), + onTileUnload: this._onTileUnload.bind(this) + }; } - let sourceIndex = 0; - let targetIndex = 0; - const getChunkData = getData && ((i2, chunk) => getData(i2 + targetIndex, chunk)); - const n2 = Math.min(sourceStartIndices.length, targetStartIndices.length); - for (let i2 = 1; i2 < n2; i2++) { - const nextSourceIndex = sourceStartIndices[i2] * size; - const nextTargetIndex = targetStartIndices[i2] * size; - padArrayChunk({ - source: source.subarray(sourceIndex, nextSourceIndex), - target, - start: targetIndex, - end: nextTargetIndex, - size, - getData: getChunkData + _updateTileset() { + const { + tileset + } = this.state; + const { + zRange, + modelMatrix + } = this.props; + const frameNumber = tileset.update(this.context.viewport, { + zRange, + modelMatrix }); - sourceIndex = nextSourceIndex; - targetIndex = nextTargetIndex; + const { + isLoaded + } = tileset; + const loadingStateChanged = this.state.isLoaded !== isLoaded; + const tilesetChanged = this.state.frameNumber !== frameNumber; + if (isLoaded && (loadingStateChanged || tilesetChanged)) { + this._onViewportLoad(); + } + if (tilesetChanged) { + this.setState({ + frameNumber + }); + } + this.state.isLoaded = isLoaded; } - if (targetIndex < target.length) { - padArrayChunk({ - source: [], - target, - start: targetIndex, - size, - getData: getChunkData - }); + _onViewportLoad() { + const { + tileset + } = this.state; + const { + onViewportLoad + } = this.props; + if (onViewportLoad) { + onViewportLoad(tileset.selectedTiles); + } } - return target; - } - - // node_modules/@deck.gl/core/dist/esm/lib/attribute/attribute-transition-utils.js - var DEFAULT_TRANSITION_SETTINGS = { - interpolation: { - duration: 0, - easing: (t2) => t2 - }, - spring: { - stiffness: 0.05, - damping: 0.5 + _onTileLoad(tile) { + this.props.onTileLoad(tile); + tile.layers = null; + this.setNeedsUpdate(); } - }; - function normalizeTransitionSettings(userSettings, layerSettings) { - if (!userSettings) { + _onTileError(error2, tile) { + this.props.onTileError(error2); + tile.layers = null; + this.setNeedsUpdate(); + } + _onTileUnload(tile) { + this.props.onTileUnload(tile); + } + getTileData(tile) { + const { + data, + getTileData, + fetch: fetch2 + } = this.props; + const { + signal + } = tile; + tile.url = typeof data === "string" || Array.isArray(data) ? getURLFromTemplate(data, tile) : null; + if (getTileData) { + return getTileData(tile); + } + if (fetch2 && tile.url) { + return fetch2(tile.url, { + propName: "data", + layer: this, + signal + }); + } return null; } - if (Number.isFinite(userSettings)) { - userSettings = { - type: "interpolation", - duration: userSettings - }; + renderSubLayers(props) { + return this.props.renderSubLayers(props); } - const type = userSettings.type || "interpolation"; - return { - ...DEFAULT_TRANSITION_SETTINGS[type], - ...layerSettings, - ...userSettings, - type - }; - } - function getSourceBufferAttribute(gl, attribute) { - const buffer = attribute.getBuffer(); - if (buffer) { - return [buffer, { - divisor: 0, - size: attribute.size, - normalized: attribute.settings.normalized - }]; + getSubLayerPropsByTile(tile) { + return null; } - return attribute.value; - } - function getAttributeTypeFromSize(size) { - switch (size) { - case 1: - return "float"; - case 2: - return "vec2"; - case 3: - return "vec3"; - case 4: - return "vec4"; - default: - throw new Error('No defined attribute type for size "'.concat(size, '"')); + getPickingInfo({ + info, + sourceLayer + }) { + const sourceTile = sourceLayer.props.tile; + if (info.picked) { + info.tile = sourceTile; + } + info.sourceTile = sourceTile; + return info; } - } - function cycleBuffers(buffers) { - buffers.push(buffers.shift()); - } - function getAttributeBufferLength(attribute, numInstances) { - const { - doublePrecision, - settings, - value, - size - } = attribute; - const multiplier = doublePrecision && value instanceof Float64Array ? 2 : 1; - return (settings.noAlloc ? value.length : numInstances * size) * multiplier; - } - function padBuffer({ - buffer, - numInstances, - attribute, - fromLength, - fromStartIndices, - getData = (x2) => x2 - }) { - const precisionMultiplier = attribute.doublePrecision && attribute.value instanceof Float64Array ? 2 : 1; - const size = attribute.size * precisionMultiplier; - const byteOffset = attribute.byteOffset; - const toStartIndices = attribute.startIndices; - const hasStartIndices = fromStartIndices && toStartIndices; - const toLength = getAttributeBufferLength(attribute, numInstances); - const isConstant = attribute.isConstant; - if (!hasStartIndices && fromLength >= toLength) { - return; + _updateAutoHighlight(info) { + const sourceTile = info.sourceTile; + if (sourceTile && sourceTile.layers) { + for (const layer of sourceTile.layers) { + layer.updateAutoHighlight(info); + } + } + } + renderLayers() { + return this.state.tileset.tiles.map((tile) => { + const subLayerProps = this.getSubLayerPropsByTile(tile); + if (!tile.isLoaded && !tile.content) { + } else if (!tile.layers) { + const layers = this.renderSubLayers({ + ...this.props, + id: "".concat(this.id, "-").concat(tile.id), + data: tile.content, + _offset: 0, + tile + }); + tile.layers = flatten(layers, Boolean).map((layer) => layer.clone({ + tile, + ...subLayerProps + })); + } else if (subLayerProps && tile.layers[0] && Object.keys(subLayerProps).some((propName) => tile.layers[0].props[propName] !== subLayerProps[propName])) { + tile.layers = tile.layers.map((layer) => layer.clone(subLayerProps)); + } + return tile.layers; + }); } - const toData = isConstant ? attribute.value : attribute.getBuffer().getData({ - srcByteOffset: byteOffset - }); - if (attribute.settings.normalized && !isConstant) { - const getter = getData; - getData = (value, chunk) => attribute.normalizeConstant(getter(value, chunk)); + filterSubLayer({ + layer, + cullRect + }) { + const { + tile + } = layer.props; + return this.state.tileset.isTileVisible(tile, cullRect); } - const getMissingData = isConstant ? (i2, chunk) => getData(toData, chunk) : (i2, chunk) => getData(toData.subarray(i2, i2 + size), chunk); - const source = buffer.getData({ - length: fromLength - }); - const data = new Float32Array(toLength); - padArray({ - source, - target: data, - sourceStartIndices: fromStartIndices, - targetStartIndices: toStartIndices, - size, - getData: getMissingData - }); - if (buffer.byteLength < data.byteLength + byteOffset) { - buffer.reallocate(data.byteLength + byteOffset); + }; + _defineProperty(TileLayer, "defaultProps", defaultProps15); + _defineProperty(TileLayer, "layerName", "TileLayer"); + + // node_modules/@deck.gl/carto/dist/esm/style/palette.js + var cartoColors = __toESM(require_cartocolor2()); + + // node_modules/@deck.gl/carto/dist/esm/style/utils.js + var ALLOWED_ATTR_TYPES = Object.freeze(["function", "string"]); + function getAttrValue(attr, d2) { + var _properties; + assert11(typeof d2 === "object", 'Expected "data" to be an object'); + assert11(ALLOWED_ATTR_TYPES.includes(typeof attr), 'Expected "attr" to be a function or string'); + if (typeof attr === "function") { + return attr(d2); } - buffer.subData({ - data, - offset: byteOffset - }); + return d2 === null || d2 === void 0 ? void 0 : (_properties = d2.properties) === null || _properties === void 0 ? void 0 : _properties[attr]; } - - // node_modules/@deck.gl/core/dist/esm/lib/attribute/attribute.js - var Attribute = class extends DataColumn { - constructor(gl, opts) { - super(gl, opts, { - startIndices: null, - lastExternalBuffer: null, - binaryValue: null, - binaryAccessor: null, - needsUpdate: true, - needsRedraw: false, - updateRanges: FULL - }); - _defineProperty(this, "constant", false); - this.settings.update = opts.update || (opts.accessor ? this._autoUpdater : void 0); - Object.seal(this.settings); - Object.seal(this.state); - this._validateAttributeUpdaters(); + function assert11(condition, message = "") { + if (!condition) { + throw new Error("CARTO style error: ".concat(message)); } - get startIndices() { - return this.state.startIndices; + } + + // node_modules/@deck.gl/carto/dist/esm/style/palette.js + var DEFAULT_PALETTE = "PurpOr"; + var NULL_COLOR = [204, 204, 204]; + var OTHERS_COLOR = [119, 119, 119]; + function getPalette(name, numCategories) { + const palette = cartoColors[name]; + let paletteIndex = numCategories; + assert11(palette, 'Palette "'.concat(name, '" not found. Expected a CARTOColors string')); + const palettesColorVariants = Object.keys(palette).filter((p2) => p2 !== "tags").map(Number); + const longestPaletteIndex = Math.max(...palettesColorVariants); + const smallestPaletteIndex = Math.min(...palettesColorVariants); + if (!Number.isInteger(numCategories) || numCategories > longestPaletteIndex) { + paletteIndex = longestPaletteIndex; + } else if (numCategories < smallestPaletteIndex) { + paletteIndex = smallestPaletteIndex; } - set startIndices(layout) { - this.state.startIndices = layout; + let colors = palette[paletteIndex]; + if (palette.tags && palette.tags.includes("qualitative")) { + colors = colors.slice(0, -1); } - needsUpdate() { - return this.state.needsUpdate; + return colors.map((c2) => hexToRgb(c2)); + } + function hexToRgb(hex) { + let result = /^#?([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})$/i.exec(hex); + if (result) { + return [parseInt(result[1] + result[1], 16), parseInt(result[2] + result[2], 16), parseInt(result[3] + result[3], 16), 255]; } - needsRedraw({ - clearChangedFlags = false - } = {}) { - const needsRedraw = this.state.needsRedraw; - this.state.needsRedraw = needsRedraw && !clearChangedFlags; - return needsRedraw; + result = /^#?([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})$/i.exec(hex); + if (result) { + return [parseInt(result[1] + result[1], 16), parseInt(result[2] + result[2], 16), parseInt(result[3] + result[3], 16), parseInt(result[4] + result[4], 16)]; } - getUpdateTriggers() { - const { - accessor - } = this.settings; - return [this.id].concat(typeof accessor !== "function" && accessor || []); + result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex); + if (result) { + return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16), 255]; } - supportsTransition() { - return Boolean(this.settings.transition); + result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex); + assert11(result, 'Hexadecimal color "'.concat(hex, '" was not parsed correctly')); + return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16), parseInt(result[4], 16)]; + } + + // node_modules/@deck.gl/carto/dist/esm/style/color-categories-style.js + function colorCategories({ + attr, + domain, + colors = DEFAULT_PALETTE, + nullColor = NULL_COLOR, + othersColor = OTHERS_COLOR + }) { + assert11(Array.isArray(domain), 'Expected "domain" to be an array of numbers or strings'); + const colorsByCategory = {}; + const palette = typeof colors === "string" ? getPalette(colors, domain.length) : colors; + for (const [i3, c2] of domain.entries()) { + colorsByCategory[c2] = palette[i3]; } - getTransitionSetting(opts) { - if (!opts || !this.supportsTransition()) { - return null; + return (d2) => { + const value = getAttrValue(attr, d2); + return typeof value === "number" && Number.isFinite(value) || typeof value === "string" ? colorsByCategory[value] || othersColor : nullColor; + }; + } + + // node_modules/@preact/signals-core/dist/signals-core.module.js + function i() { + throw new Error("Cycle detected"); + } + var t = Symbol.for("preact-signals"); + function r() { + if (!(v > 1)) { + var i3, t2 = false; + while (void 0 !== f) { + var r2 = f; + f = void 0; + e++; + while (void 0 !== r2) { + var n2 = r2.o; + r2.o = void 0; + r2.f &= -3; + if (!(8 & r2.f) && l(r2)) + try { + r2.c(); + } catch (r3) { + if (!t2) { + i3 = r3; + t2 = true; + } + } + r2 = n2; + } } - const { - accessor - } = this.settings; - const layerSettings = this.settings.transition; - const userSettings = Array.isArray(accessor) ? opts[accessor.find((a2) => opts[a2])] : opts[accessor]; - return normalizeTransitionSettings(userSettings, layerSettings); + e = 0; + v--; + if (t2) + throw i3; + } else + v--; + } + function n(i3) { + if (v > 0) + return i3(); + v++; + try { + return i3(); + } finally { + r(); } - setNeedsUpdate(reason = this.id, dataRange) { - this.state.needsUpdate = this.state.needsUpdate || reason; - this.setNeedsRedraw(reason); - if (dataRange) { - const { - startRow = 0, - endRow = Infinity - } = dataRange; - this.state.updateRanges = add2(this.state.updateRanges, [startRow, endRow]); - } else { - this.state.updateRanges = FULL; + } + var o = void 0; + var f = void 0; + var v = 0; + var e = 0; + var u = 0; + function c(i3) { + if (void 0 !== o) { + var t2 = i3.n; + if (void 0 === t2 || t2.t !== o) { + t2 = { i: 0, S: i3, p: o.s, n: void 0, t: o, e: void 0, x: void 0, r: t2 }; + if (void 0 !== o.s) + o.s.n = t2; + o.s = t2; + i3.n = t2; + if (32 & o.f) + i3.S(t2); + return t2; + } else if (-1 === t2.i) { + t2.i = 0; + if (void 0 !== t2.n) { + t2.n.p = t2.p; + if (void 0 !== t2.p) + t2.p.n = t2.n; + t2.p = o.s; + t2.n = void 0; + o.s.n = t2; + o.s = t2; + } + return t2; } } - clearNeedsUpdate() { - this.state.needsUpdate = false; - this.state.updateRanges = EMPTY; - } - setNeedsRedraw(reason = this.id) { - this.state.needsRedraw = this.state.needsRedraw || reason; + } + function d(i3) { + this.v = i3; + this.i = 0; + this.n = void 0; + this.t = void 0; + } + d.prototype.brand = t; + d.prototype.h = function() { + return true; + }; + d.prototype.S = function(i3) { + if (this.t !== i3 && void 0 === i3.e) { + i3.x = this.t; + if (void 0 !== this.t) + this.t.e = i3; + this.t = i3; } - allocate(numInstances) { - const { - state, - settings - } = this; - if (settings.noAlloc) { - return false; + }; + d.prototype.U = function(i3) { + if (void 0 !== this.t) { + var t2 = i3.e, r2 = i3.x; + if (void 0 !== t2) { + t2.x = r2; + i3.e = void 0; } - if (settings.update) { - super.allocate(numInstances, state.updateRanges !== FULL); - return true; + if (void 0 !== r2) { + r2.e = t2; + i3.x = void 0; } - return false; + if (i3 === this.t) + this.t = r2; } - updateBuffer({ - numInstances, - data, - props, - context - }) { - if (!this.needsUpdate()) { - return false; + }; + d.prototype.subscribe = function(i3) { + var t2 = this; + return O(function() { + var r2 = t2.value, n2 = 32 & this.f; + this.f &= -33; + try { + i3(r2); + } finally { + this.f |= n2; } - const { - state: { - updateRanges - }, - settings: { - update, - noAlloc - } - } = this; - let updated = true; - if (update) { - for (const [startRow, endRow] of updateRanges) { - update.call(context, this, { - data, - startRow, - endRow, - props, - numInstances - }); - } - if (!this.value) { - } else if (this.constant || this.buffer.byteLength < this.value.byteLength + this.byteOffset) { - this.setData({ - value: this.value, - constant: this.constant - }); - this.constant = false; - } else { - for (const [startRow, endRow] of updateRanges) { - const startOffset = Number.isFinite(startRow) ? this.getVertexOffset(startRow) : 0; - const endOffset = Number.isFinite(endRow) ? this.getVertexOffset(endRow) : noAlloc || !Number.isFinite(numInstances) ? this.value.length : numInstances * this.size; - super.updateSubBuffer({ - startOffset, - endOffset - }); - } - } - this._checkAttributeArray(); - } else { - updated = false; + }); + }; + d.prototype.valueOf = function() { + return this.value; + }; + d.prototype.toString = function() { + return this.value + ""; + }; + d.prototype.toJSON = function() { + return this.value; + }; + d.prototype.peek = function() { + return this.v; + }; + Object.defineProperty(d.prototype, "value", { get: function() { + var i3 = c(this); + if (void 0 !== i3) + i3.i = this.i; + return this.v; + }, set: function(t2) { + if (o instanceof _) + !function() { + throw new Error("Computed cannot have side-effects"); + }(); + if (t2 !== this.v) { + if (e > 100) + i(); + this.v = t2; + this.i++; + u++; + v++; + try { + for (var n2 = this.t; void 0 !== n2; n2 = n2.x) + n2.t.N(); + } finally { + r(); } - this.clearNeedsUpdate(); - this.setNeedsRedraw(); - return updated; } - setConstantValue(value) { - if (value === void 0 || typeof value === "function") { - return false; - } - const hasChanged = this.setData({ - constant: true, - value - }); - if (hasChanged) { - this.setNeedsRedraw(); + } }); + function a(i3) { + return new d(i3); + } + function l(i3) { + for (var t2 = i3.s; void 0 !== t2; t2 = t2.n) + if (t2.S.i !== t2.i || !t2.S.h() || t2.S.i !== t2.i) + return true; + return false; + } + function y(i3) { + for (var t2 = i3.s; void 0 !== t2; t2 = t2.n) { + var r2 = t2.S.n; + if (void 0 !== r2) + t2.r = r2; + t2.S.n = t2; + t2.i = -1; + if (void 0 === t2.n) { + i3.s = t2; + break; } - this.clearNeedsUpdate(); + } + } + function w(i3) { + var t2 = i3.s, r2 = void 0; + while (void 0 !== t2) { + var n2 = t2.p; + if (-1 === t2.i) { + t2.S.U(t2); + if (void 0 !== n2) + n2.n = t2.n; + if (void 0 !== t2.n) + t2.n.p = n2; + } else + r2 = t2; + t2.S.n = t2.r; + if (void 0 !== t2.r) + t2.r = void 0; + t2 = n2; + } + i3.s = r2; + } + function _(i3) { + d.call(this, void 0); + this.x = i3; + this.s = void 0; + this.g = u - 1; + this.f = 4; + } + (_.prototype = new d()).h = function() { + this.f &= -3; + if (1 & this.f) + return false; + if (32 == (36 & this.f)) + return true; + this.f &= -5; + if (this.g === u) + return true; + this.g = u; + this.f |= 1; + if (this.i > 0 && !l(this)) { + this.f &= -2; return true; } - setExternalBuffer(buffer) { - const { - state - } = this; - if (!buffer) { - state.lastExternalBuffer = null; - return false; + var i3 = o; + try { + y(this); + o = this; + var t2 = this.x(); + if (16 & this.f || this.v !== t2 || 0 === this.i) { + this.v = t2; + this.f &= -17; + this.i++; } - this.clearNeedsUpdate(); - if (state.lastExternalBuffer === buffer) { - return true; + } catch (i4) { + this.v = i4; + this.f |= 16; + this.i++; + } + o = i3; + w(this); + this.f &= -2; + return true; + }; + _.prototype.S = function(i3) { + if (void 0 === this.t) { + this.f |= 36; + for (var t2 = this.s; void 0 !== t2; t2 = t2.n) + t2.S.S(t2); + } + d.prototype.S.call(this, i3); + }; + _.prototype.U = function(i3) { + if (void 0 !== this.t) { + d.prototype.U.call(this, i3); + if (void 0 === this.t) { + this.f &= -33; + for (var t2 = this.s; void 0 !== t2; t2 = t2.n) + t2.S.U(t2); } - state.lastExternalBuffer = buffer; - this.setNeedsRedraw(); - this.setData(buffer); - return true; } - setBinaryValue(buffer, startIndices = null) { - const { - state, - settings - } = this; - if (!buffer) { - state.binaryValue = null; - state.binaryAccessor = null; - return false; + }; + _.prototype.N = function() { + if (!(2 & this.f)) { + this.f |= 6; + for (var i3 = this.t; void 0 !== i3; i3 = i3.x) + i3.t.N(); + } + }; + _.prototype.peek = function() { + if (!this.h()) + i(); + if (16 & this.f) + throw this.v; + return this.v; + }; + Object.defineProperty(_.prototype, "value", { get: function() { + if (1 & this.f) + i(); + var t2 = c(this); + this.h(); + if (void 0 !== t2) + t2.i = this.i; + if (16 & this.f) + throw this.v; + return this.v; + } }); + function p(i3) { + return new _(i3); + } + function g(i3) { + var t2 = i3.u; + i3.u = void 0; + if ("function" == typeof t2) { + v++; + var n2 = o; + o = void 0; + try { + t2(); + } catch (t3) { + i3.f &= -2; + i3.f |= 8; + b(i3); + throw t3; + } finally { + o = n2; + r(); } - if (settings.noAlloc) { - return false; + } + } + function b(i3) { + for (var t2 = i3.s; void 0 !== t2; t2 = t2.n) + t2.S.U(t2); + i3.x = void 0; + i3.s = void 0; + g(i3); + } + function x(i3) { + if (o !== this) + throw new Error("Out-of-order effect"); + w(this); + o = i3; + this.f &= -2; + if (8 & this.f) + b(this); + r(); + } + function E(i3) { + this.x = i3; + this.u = void 0; + this.s = void 0; + this.o = void 0; + this.f = 32; + } + E.prototype.c = function() { + var i3 = this.S(); + try { + if (8 & this.f) + return; + if (void 0 === this.x) + return; + var t2 = this.x(); + if ("function" == typeof t2) + this.u = t2; + } finally { + i3(); + } + }; + E.prototype.S = function() { + if (1 & this.f) + i(); + this.f |= 1; + this.f &= -9; + g(this); + y(this); + v++; + var t2 = o; + o = this; + return x.bind(this, t2); + }; + E.prototype.N = function() { + if (!(2 & this.f)) { + this.f |= 2; + this.o = f; + f = this; + } + }; + E.prototype.d = function() { + this.f |= 8; + if (!(1 & this.f)) + b(this); + }; + function O(i3) { + var t2 = new E(i3); + try { + t2.c(); + } catch (i4) { + t2.d(); + throw i4; + } + return t2.d.bind(t2); + } + + // node_modules/@luma.gl/constants/dist/esm/index.js + var esm_default2 = { + DEPTH_BUFFER_BIT: 256, + STENCIL_BUFFER_BIT: 1024, + COLOR_BUFFER_BIT: 16384, + POINTS: 0, + LINES: 1, + LINE_LOOP: 2, + LINE_STRIP: 3, + TRIANGLES: 4, + TRIANGLE_STRIP: 5, + TRIANGLE_FAN: 6, + ZERO: 0, + ONE: 1, + SRC_COLOR: 768, + ONE_MINUS_SRC_COLOR: 769, + SRC_ALPHA: 770, + ONE_MINUS_SRC_ALPHA: 771, + DST_ALPHA: 772, + ONE_MINUS_DST_ALPHA: 773, + DST_COLOR: 774, + ONE_MINUS_DST_COLOR: 775, + SRC_ALPHA_SATURATE: 776, + CONSTANT_COLOR: 32769, + ONE_MINUS_CONSTANT_COLOR: 32770, + CONSTANT_ALPHA: 32771, + ONE_MINUS_CONSTANT_ALPHA: 32772, + FUNC_ADD: 32774, + FUNC_SUBTRACT: 32778, + FUNC_REVERSE_SUBTRACT: 32779, + BLEND_EQUATION: 32777, + BLEND_EQUATION_RGB: 32777, + BLEND_EQUATION_ALPHA: 34877, + BLEND_DST_RGB: 32968, + BLEND_SRC_RGB: 32969, + BLEND_DST_ALPHA: 32970, + BLEND_SRC_ALPHA: 32971, + BLEND_COLOR: 32773, + ARRAY_BUFFER_BINDING: 34964, + ELEMENT_ARRAY_BUFFER_BINDING: 34965, + LINE_WIDTH: 2849, + ALIASED_POINT_SIZE_RANGE: 33901, + ALIASED_LINE_WIDTH_RANGE: 33902, + CULL_FACE_MODE: 2885, + FRONT_FACE: 2886, + DEPTH_RANGE: 2928, + DEPTH_WRITEMASK: 2930, + DEPTH_CLEAR_VALUE: 2931, + DEPTH_FUNC: 2932, + STENCIL_CLEAR_VALUE: 2961, + STENCIL_FUNC: 2962, + STENCIL_FAIL: 2964, + STENCIL_PASS_DEPTH_FAIL: 2965, + STENCIL_PASS_DEPTH_PASS: 2966, + STENCIL_REF: 2967, + STENCIL_VALUE_MASK: 2963, + STENCIL_WRITEMASK: 2968, + STENCIL_BACK_FUNC: 34816, + STENCIL_BACK_FAIL: 34817, + STENCIL_BACK_PASS_DEPTH_FAIL: 34818, + STENCIL_BACK_PASS_DEPTH_PASS: 34819, + STENCIL_BACK_REF: 36003, + STENCIL_BACK_VALUE_MASK: 36004, + STENCIL_BACK_WRITEMASK: 36005, + VIEWPORT: 2978, + SCISSOR_BOX: 3088, + COLOR_CLEAR_VALUE: 3106, + COLOR_WRITEMASK: 3107, + UNPACK_ALIGNMENT: 3317, + PACK_ALIGNMENT: 3333, + MAX_TEXTURE_SIZE: 3379, + MAX_VIEWPORT_DIMS: 3386, + SUBPIXEL_BITS: 3408, + RED_BITS: 3410, + GREEN_BITS: 3411, + BLUE_BITS: 3412, + ALPHA_BITS: 3413, + DEPTH_BITS: 3414, + STENCIL_BITS: 3415, + POLYGON_OFFSET_UNITS: 10752, + POLYGON_OFFSET_FACTOR: 32824, + TEXTURE_BINDING_2D: 32873, + SAMPLE_BUFFERS: 32936, + SAMPLES: 32937, + SAMPLE_COVERAGE_VALUE: 32938, + SAMPLE_COVERAGE_INVERT: 32939, + COMPRESSED_TEXTURE_FORMATS: 34467, + VENDOR: 7936, + RENDERER: 7937, + VERSION: 7938, + IMPLEMENTATION_COLOR_READ_TYPE: 35738, + IMPLEMENTATION_COLOR_READ_FORMAT: 35739, + BROWSER_DEFAULT_WEBGL: 37444, + STATIC_DRAW: 35044, + STREAM_DRAW: 35040, + DYNAMIC_DRAW: 35048, + ARRAY_BUFFER: 34962, + ELEMENT_ARRAY_BUFFER: 34963, + BUFFER_SIZE: 34660, + BUFFER_USAGE: 34661, + CURRENT_VERTEX_ATTRIB: 34342, + VERTEX_ATTRIB_ARRAY_ENABLED: 34338, + VERTEX_ATTRIB_ARRAY_SIZE: 34339, + VERTEX_ATTRIB_ARRAY_STRIDE: 34340, + VERTEX_ATTRIB_ARRAY_TYPE: 34341, + VERTEX_ATTRIB_ARRAY_NORMALIZED: 34922, + VERTEX_ATTRIB_ARRAY_POINTER: 34373, + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 34975, + CULL_FACE: 2884, + FRONT: 1028, + BACK: 1029, + FRONT_AND_BACK: 1032, + BLEND: 3042, + DEPTH_TEST: 2929, + DITHER: 3024, + POLYGON_OFFSET_FILL: 32823, + SAMPLE_ALPHA_TO_COVERAGE: 32926, + SAMPLE_COVERAGE: 32928, + SCISSOR_TEST: 3089, + STENCIL_TEST: 2960, + NO_ERROR: 0, + INVALID_ENUM: 1280, + INVALID_VALUE: 1281, + INVALID_OPERATION: 1282, + OUT_OF_MEMORY: 1285, + CONTEXT_LOST_WEBGL: 37442, + CW: 2304, + CCW: 2305, + DONT_CARE: 4352, + FASTEST: 4353, + NICEST: 4354, + GENERATE_MIPMAP_HINT: 33170, + BYTE: 5120, + UNSIGNED_BYTE: 5121, + SHORT: 5122, + UNSIGNED_SHORT: 5123, + INT: 5124, + UNSIGNED_INT: 5125, + FLOAT: 5126, + DOUBLE: 5130, + DEPTH_COMPONENT: 6402, + ALPHA: 6406, + RGB: 6407, + RGBA: 6408, + LUMINANCE: 6409, + LUMINANCE_ALPHA: 6410, + UNSIGNED_SHORT_4_4_4_4: 32819, + UNSIGNED_SHORT_5_5_5_1: 32820, + UNSIGNED_SHORT_5_6_5: 33635, + FRAGMENT_SHADER: 35632, + VERTEX_SHADER: 35633, + COMPILE_STATUS: 35713, + DELETE_STATUS: 35712, + LINK_STATUS: 35714, + VALIDATE_STATUS: 35715, + ATTACHED_SHADERS: 35717, + ACTIVE_ATTRIBUTES: 35721, + ACTIVE_UNIFORMS: 35718, + MAX_VERTEX_ATTRIBS: 34921, + MAX_VERTEX_UNIFORM_VECTORS: 36347, + MAX_VARYING_VECTORS: 36348, + MAX_COMBINED_TEXTURE_IMAGE_UNITS: 35661, + MAX_VERTEX_TEXTURE_IMAGE_UNITS: 35660, + MAX_TEXTURE_IMAGE_UNITS: 34930, + MAX_FRAGMENT_UNIFORM_VECTORS: 36349, + SHADER_TYPE: 35663, + SHADING_LANGUAGE_VERSION: 35724, + CURRENT_PROGRAM: 35725, + NEVER: 512, + ALWAYS: 519, + LESS: 513, + EQUAL: 514, + LEQUAL: 515, + GREATER: 516, + GEQUAL: 518, + NOTEQUAL: 517, + KEEP: 7680, + REPLACE: 7681, + INCR: 7682, + DECR: 7683, + INVERT: 5386, + INCR_WRAP: 34055, + DECR_WRAP: 34056, + NEAREST: 9728, + LINEAR: 9729, + NEAREST_MIPMAP_NEAREST: 9984, + LINEAR_MIPMAP_NEAREST: 9985, + NEAREST_MIPMAP_LINEAR: 9986, + LINEAR_MIPMAP_LINEAR: 9987, + TEXTURE_MAG_FILTER: 10240, + TEXTURE_MIN_FILTER: 10241, + TEXTURE_WRAP_S: 10242, + TEXTURE_WRAP_T: 10243, + TEXTURE_2D: 3553, + TEXTURE: 5890, + TEXTURE_CUBE_MAP: 34067, + TEXTURE_BINDING_CUBE_MAP: 34068, + TEXTURE_CUBE_MAP_POSITIVE_X: 34069, + TEXTURE_CUBE_MAP_NEGATIVE_X: 34070, + TEXTURE_CUBE_MAP_POSITIVE_Y: 34071, + TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072, + TEXTURE_CUBE_MAP_POSITIVE_Z: 34073, + TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074, + MAX_CUBE_MAP_TEXTURE_SIZE: 34076, + TEXTURE0: 33984, + ACTIVE_TEXTURE: 34016, + REPEAT: 10497, + CLAMP_TO_EDGE: 33071, + MIRRORED_REPEAT: 33648, + TEXTURE_WIDTH: 4096, + TEXTURE_HEIGHT: 4097, + FLOAT_VEC2: 35664, + FLOAT_VEC3: 35665, + FLOAT_VEC4: 35666, + INT_VEC2: 35667, + INT_VEC3: 35668, + INT_VEC4: 35669, + BOOL: 35670, + BOOL_VEC2: 35671, + BOOL_VEC3: 35672, + BOOL_VEC4: 35673, + FLOAT_MAT2: 35674, + FLOAT_MAT3: 35675, + FLOAT_MAT4: 35676, + SAMPLER_2D: 35678, + SAMPLER_CUBE: 35680, + LOW_FLOAT: 36336, + MEDIUM_FLOAT: 36337, + HIGH_FLOAT: 36338, + LOW_INT: 36339, + MEDIUM_INT: 36340, + HIGH_INT: 36341, + FRAMEBUFFER: 36160, + RENDERBUFFER: 36161, + RGBA4: 32854, + RGB5_A1: 32855, + RGB565: 36194, + DEPTH_COMPONENT16: 33189, + STENCIL_INDEX: 6401, + STENCIL_INDEX8: 36168, + DEPTH_STENCIL: 34041, + RENDERBUFFER_WIDTH: 36162, + RENDERBUFFER_HEIGHT: 36163, + RENDERBUFFER_INTERNAL_FORMAT: 36164, + RENDERBUFFER_RED_SIZE: 36176, + RENDERBUFFER_GREEN_SIZE: 36177, + RENDERBUFFER_BLUE_SIZE: 36178, + RENDERBUFFER_ALPHA_SIZE: 36179, + RENDERBUFFER_DEPTH_SIZE: 36180, + RENDERBUFFER_STENCIL_SIZE: 36181, + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 36048, + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 36049, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 36050, + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 36051, + COLOR_ATTACHMENT0: 36064, + DEPTH_ATTACHMENT: 36096, + STENCIL_ATTACHMENT: 36128, + DEPTH_STENCIL_ATTACHMENT: 33306, + NONE: 0, + FRAMEBUFFER_COMPLETE: 36053, + FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 36054, + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 36055, + FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 36057, + FRAMEBUFFER_UNSUPPORTED: 36061, + FRAMEBUFFER_BINDING: 36006, + RENDERBUFFER_BINDING: 36007, + READ_FRAMEBUFFER: 36008, + DRAW_FRAMEBUFFER: 36009, + MAX_RENDERBUFFER_SIZE: 34024, + INVALID_FRAMEBUFFER_OPERATION: 1286, + UNPACK_FLIP_Y_WEBGL: 37440, + UNPACK_PREMULTIPLY_ALPHA_WEBGL: 37441, + UNPACK_COLORSPACE_CONVERSION_WEBGL: 37443, + READ_BUFFER: 3074, + UNPACK_ROW_LENGTH: 3314, + UNPACK_SKIP_ROWS: 3315, + UNPACK_SKIP_PIXELS: 3316, + PACK_ROW_LENGTH: 3330, + PACK_SKIP_ROWS: 3331, + PACK_SKIP_PIXELS: 3332, + TEXTURE_BINDING_3D: 32874, + UNPACK_SKIP_IMAGES: 32877, + UNPACK_IMAGE_HEIGHT: 32878, + MAX_3D_TEXTURE_SIZE: 32883, + MAX_ELEMENTS_VERTICES: 33e3, + MAX_ELEMENTS_INDICES: 33001, + MAX_TEXTURE_LOD_BIAS: 34045, + MAX_FRAGMENT_UNIFORM_COMPONENTS: 35657, + MAX_VERTEX_UNIFORM_COMPONENTS: 35658, + MAX_ARRAY_TEXTURE_LAYERS: 35071, + MIN_PROGRAM_TEXEL_OFFSET: 35076, + MAX_PROGRAM_TEXEL_OFFSET: 35077, + MAX_VARYING_COMPONENTS: 35659, + FRAGMENT_SHADER_DERIVATIVE_HINT: 35723, + RASTERIZER_DISCARD: 35977, + VERTEX_ARRAY_BINDING: 34229, + MAX_VERTEX_OUTPUT_COMPONENTS: 37154, + MAX_FRAGMENT_INPUT_COMPONENTS: 37157, + MAX_SERVER_WAIT_TIMEOUT: 37137, + MAX_ELEMENT_INDEX: 36203, + RED: 6403, + RGB8: 32849, + RGBA8: 32856, + RGB10_A2: 32857, + TEXTURE_3D: 32879, + TEXTURE_WRAP_R: 32882, + TEXTURE_MIN_LOD: 33082, + TEXTURE_MAX_LOD: 33083, + TEXTURE_BASE_LEVEL: 33084, + TEXTURE_MAX_LEVEL: 33085, + TEXTURE_COMPARE_MODE: 34892, + TEXTURE_COMPARE_FUNC: 34893, + SRGB: 35904, + SRGB8: 35905, + SRGB8_ALPHA8: 35907, + COMPARE_REF_TO_TEXTURE: 34894, + RGBA32F: 34836, + RGB32F: 34837, + RGBA16F: 34842, + RGB16F: 34843, + TEXTURE_2D_ARRAY: 35866, + TEXTURE_BINDING_2D_ARRAY: 35869, + R11F_G11F_B10F: 35898, + RGB9_E5: 35901, + RGBA32UI: 36208, + RGB32UI: 36209, + RGBA16UI: 36214, + RGB16UI: 36215, + RGBA8UI: 36220, + RGB8UI: 36221, + RGBA32I: 36226, + RGB32I: 36227, + RGBA16I: 36232, + RGB16I: 36233, + RGBA8I: 36238, + RGB8I: 36239, + RED_INTEGER: 36244, + RGB_INTEGER: 36248, + RGBA_INTEGER: 36249, + R8: 33321, + RG8: 33323, + R16F: 33325, + R32F: 33326, + RG16F: 33327, + RG32F: 33328, + R8I: 33329, + R8UI: 33330, + R16I: 33331, + R16UI: 33332, + R32I: 33333, + R32UI: 33334, + RG8I: 33335, + RG8UI: 33336, + RG16I: 33337, + RG16UI: 33338, + RG32I: 33339, + RG32UI: 33340, + R8_SNORM: 36756, + RG8_SNORM: 36757, + RGB8_SNORM: 36758, + RGBA8_SNORM: 36759, + RGB10_A2UI: 36975, + TEXTURE_IMMUTABLE_FORMAT: 37167, + TEXTURE_IMMUTABLE_LEVELS: 33503, + UNSIGNED_INT_2_10_10_10_REV: 33640, + UNSIGNED_INT_10F_11F_11F_REV: 35899, + UNSIGNED_INT_5_9_9_9_REV: 35902, + FLOAT_32_UNSIGNED_INT_24_8_REV: 36269, + UNSIGNED_INT_24_8: 34042, + HALF_FLOAT: 5131, + RG: 33319, + RG_INTEGER: 33320, + INT_2_10_10_10_REV: 36255, + CURRENT_QUERY: 34917, + QUERY_RESULT: 34918, + QUERY_RESULT_AVAILABLE: 34919, + ANY_SAMPLES_PASSED: 35887, + ANY_SAMPLES_PASSED_CONSERVATIVE: 36202, + MAX_DRAW_BUFFERS: 34852, + DRAW_BUFFER0: 34853, + DRAW_BUFFER1: 34854, + DRAW_BUFFER2: 34855, + DRAW_BUFFER3: 34856, + DRAW_BUFFER4: 34857, + DRAW_BUFFER5: 34858, + DRAW_BUFFER6: 34859, + DRAW_BUFFER7: 34860, + DRAW_BUFFER8: 34861, + DRAW_BUFFER9: 34862, + DRAW_BUFFER10: 34863, + DRAW_BUFFER11: 34864, + DRAW_BUFFER12: 34865, + DRAW_BUFFER13: 34866, + DRAW_BUFFER14: 34867, + DRAW_BUFFER15: 34868, + MAX_COLOR_ATTACHMENTS: 36063, + COLOR_ATTACHMENT1: 36065, + COLOR_ATTACHMENT2: 36066, + COLOR_ATTACHMENT3: 36067, + COLOR_ATTACHMENT4: 36068, + COLOR_ATTACHMENT5: 36069, + COLOR_ATTACHMENT6: 36070, + COLOR_ATTACHMENT7: 36071, + COLOR_ATTACHMENT8: 36072, + COLOR_ATTACHMENT9: 36073, + COLOR_ATTACHMENT10: 36074, + COLOR_ATTACHMENT11: 36075, + COLOR_ATTACHMENT12: 36076, + COLOR_ATTACHMENT13: 36077, + COLOR_ATTACHMENT14: 36078, + COLOR_ATTACHMENT15: 36079, + SAMPLER_3D: 35679, + SAMPLER_2D_SHADOW: 35682, + SAMPLER_2D_ARRAY: 36289, + SAMPLER_2D_ARRAY_SHADOW: 36292, + SAMPLER_CUBE_SHADOW: 36293, + INT_SAMPLER_2D: 36298, + INT_SAMPLER_3D: 36299, + INT_SAMPLER_CUBE: 36300, + INT_SAMPLER_2D_ARRAY: 36303, + UNSIGNED_INT_SAMPLER_2D: 36306, + UNSIGNED_INT_SAMPLER_3D: 36307, + UNSIGNED_INT_SAMPLER_CUBE: 36308, + UNSIGNED_INT_SAMPLER_2D_ARRAY: 36311, + MAX_SAMPLES: 36183, + SAMPLER_BINDING: 35097, + PIXEL_PACK_BUFFER: 35051, + PIXEL_UNPACK_BUFFER: 35052, + PIXEL_PACK_BUFFER_BINDING: 35053, + PIXEL_UNPACK_BUFFER_BINDING: 35055, + COPY_READ_BUFFER: 36662, + COPY_WRITE_BUFFER: 36663, + COPY_READ_BUFFER_BINDING: 36662, + COPY_WRITE_BUFFER_BINDING: 36663, + FLOAT_MAT2x3: 35685, + FLOAT_MAT2x4: 35686, + FLOAT_MAT3x2: 35687, + FLOAT_MAT3x4: 35688, + FLOAT_MAT4x2: 35689, + FLOAT_MAT4x3: 35690, + UNSIGNED_INT_VEC2: 36294, + UNSIGNED_INT_VEC3: 36295, + UNSIGNED_INT_VEC4: 36296, + UNSIGNED_NORMALIZED: 35863, + SIGNED_NORMALIZED: 36764, + VERTEX_ATTRIB_ARRAY_INTEGER: 35069, + VERTEX_ATTRIB_ARRAY_DIVISOR: 35070, + TRANSFORM_FEEDBACK_BUFFER_MODE: 35967, + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 35968, + TRANSFORM_FEEDBACK_VARYINGS: 35971, + TRANSFORM_FEEDBACK_BUFFER_START: 35972, + TRANSFORM_FEEDBACK_BUFFER_SIZE: 35973, + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 35976, + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 35978, + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 35979, + INTERLEAVED_ATTRIBS: 35980, + SEPARATE_ATTRIBS: 35981, + TRANSFORM_FEEDBACK_BUFFER: 35982, + TRANSFORM_FEEDBACK_BUFFER_BINDING: 35983, + TRANSFORM_FEEDBACK: 36386, + TRANSFORM_FEEDBACK_PAUSED: 36387, + TRANSFORM_FEEDBACK_ACTIVE: 36388, + TRANSFORM_FEEDBACK_BINDING: 36389, + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 33296, + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 33297, + FRAMEBUFFER_ATTACHMENT_RED_SIZE: 33298, + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 33299, + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 33300, + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 33301, + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 33302, + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 33303, + FRAMEBUFFER_DEFAULT: 33304, + DEPTH24_STENCIL8: 35056, + DRAW_FRAMEBUFFER_BINDING: 36006, + READ_FRAMEBUFFER_BINDING: 36010, + RENDERBUFFER_SAMPLES: 36011, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 36052, + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 36182, + UNIFORM_BUFFER: 35345, + UNIFORM_BUFFER_BINDING: 35368, + UNIFORM_BUFFER_START: 35369, + UNIFORM_BUFFER_SIZE: 35370, + MAX_VERTEX_UNIFORM_BLOCKS: 35371, + MAX_FRAGMENT_UNIFORM_BLOCKS: 35373, + MAX_COMBINED_UNIFORM_BLOCKS: 35374, + MAX_UNIFORM_BUFFER_BINDINGS: 35375, + MAX_UNIFORM_BLOCK_SIZE: 35376, + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 35377, + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 35379, + UNIFORM_BUFFER_OFFSET_ALIGNMENT: 35380, + ACTIVE_UNIFORM_BLOCKS: 35382, + UNIFORM_TYPE: 35383, + UNIFORM_SIZE: 35384, + UNIFORM_BLOCK_INDEX: 35386, + UNIFORM_OFFSET: 35387, + UNIFORM_ARRAY_STRIDE: 35388, + UNIFORM_MATRIX_STRIDE: 35389, + UNIFORM_IS_ROW_MAJOR: 35390, + UNIFORM_BLOCK_BINDING: 35391, + UNIFORM_BLOCK_DATA_SIZE: 35392, + UNIFORM_BLOCK_ACTIVE_UNIFORMS: 35394, + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 35395, + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 35396, + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 35398, + OBJECT_TYPE: 37138, + SYNC_CONDITION: 37139, + SYNC_STATUS: 37140, + SYNC_FLAGS: 37141, + SYNC_FENCE: 37142, + SYNC_GPU_COMMANDS_COMPLETE: 37143, + UNSIGNALED: 37144, + SIGNALED: 37145, + ALREADY_SIGNALED: 37146, + TIMEOUT_EXPIRED: 37147, + CONDITION_SATISFIED: 37148, + WAIT_FAILED: 37149, + SYNC_FLUSH_COMMANDS_BIT: 1, + COLOR: 6144, + DEPTH: 6145, + STENCIL: 6146, + MIN: 32775, + MAX: 32776, + DEPTH_COMPONENT24: 33190, + STREAM_READ: 35041, + STREAM_COPY: 35042, + STATIC_READ: 35045, + STATIC_COPY: 35046, + DYNAMIC_READ: 35049, + DYNAMIC_COPY: 35050, + DEPTH_COMPONENT32F: 36012, + DEPTH32F_STENCIL8: 36013, + INVALID_INDEX: 4294967295, + TIMEOUT_IGNORED: -1, + MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 37447, + VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 35070, + UNMASKED_VENDOR_WEBGL: 37445, + UNMASKED_RENDERER_WEBGL: 37446, + MAX_TEXTURE_MAX_ANISOTROPY_EXT: 34047, + TEXTURE_MAX_ANISOTROPY_EXT: 34046, + COMPRESSED_RGB_S3TC_DXT1_EXT: 33776, + COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777, + COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778, + COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779, + COMPRESSED_R11_EAC: 37488, + COMPRESSED_SIGNED_R11_EAC: 37489, + COMPRESSED_RG11_EAC: 37490, + COMPRESSED_SIGNED_RG11_EAC: 37491, + COMPRESSED_RGB8_ETC2: 37492, + COMPRESSED_RGBA8_ETC2_EAC: 37493, + COMPRESSED_SRGB8_ETC2: 37494, + COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495, + COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496, + COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497, + COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840, + COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842, + COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841, + COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843, + COMPRESSED_RGB_ETC1_WEBGL: 36196, + COMPRESSED_RGB_ATC_WEBGL: 35986, + COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35986, + COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798, + UNSIGNED_INT_24_8_WEBGL: 34042, + HALF_FLOAT_OES: 36193, + RGBA32F_EXT: 34836, + RGB32F_EXT: 34837, + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: 33297, + UNSIGNED_NORMALIZED_EXT: 35863, + MIN_EXT: 32775, + MAX_EXT: 32776, + SRGB_EXT: 35904, + SRGB_ALPHA_EXT: 35906, + SRGB8_ALPHA8_EXT: 35907, + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: 33296, + FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 35723, + COLOR_ATTACHMENT0_WEBGL: 36064, + COLOR_ATTACHMENT1_WEBGL: 36065, + COLOR_ATTACHMENT2_WEBGL: 36066, + COLOR_ATTACHMENT3_WEBGL: 36067, + COLOR_ATTACHMENT4_WEBGL: 36068, + COLOR_ATTACHMENT5_WEBGL: 36069, + COLOR_ATTACHMENT6_WEBGL: 36070, + COLOR_ATTACHMENT7_WEBGL: 36071, + COLOR_ATTACHMENT8_WEBGL: 36072, + COLOR_ATTACHMENT9_WEBGL: 36073, + COLOR_ATTACHMENT10_WEBGL: 36074, + COLOR_ATTACHMENT11_WEBGL: 36075, + COLOR_ATTACHMENT12_WEBGL: 36076, + COLOR_ATTACHMENT13_WEBGL: 36077, + COLOR_ATTACHMENT14_WEBGL: 36078, + COLOR_ATTACHMENT15_WEBGL: 36079, + DRAW_BUFFER0_WEBGL: 34853, + DRAW_BUFFER1_WEBGL: 34854, + DRAW_BUFFER2_WEBGL: 34855, + DRAW_BUFFER3_WEBGL: 34856, + DRAW_BUFFER4_WEBGL: 34857, + DRAW_BUFFER5_WEBGL: 34858, + DRAW_BUFFER6_WEBGL: 34859, + DRAW_BUFFER7_WEBGL: 34860, + DRAW_BUFFER8_WEBGL: 34861, + DRAW_BUFFER9_WEBGL: 34862, + DRAW_BUFFER10_WEBGL: 34863, + DRAW_BUFFER11_WEBGL: 34864, + DRAW_BUFFER12_WEBGL: 34865, + DRAW_BUFFER13_WEBGL: 34866, + DRAW_BUFFER14_WEBGL: 34867, + DRAW_BUFFER15_WEBGL: 34868, + MAX_COLOR_ATTACHMENTS_WEBGL: 36063, + MAX_DRAW_BUFFERS_WEBGL: 34852, + VERTEX_ARRAY_BINDING_OES: 34229, + QUERY_COUNTER_BITS_EXT: 34916, + CURRENT_QUERY_EXT: 34917, + QUERY_RESULT_EXT: 34918, + QUERY_RESULT_AVAILABLE_EXT: 34919, + TIME_ELAPSED_EXT: 35007, + TIMESTAMP_EXT: 36392, + GPU_DISJOINT_EXT: 36795 + }; + + // node_modules/geotiff/dist-module/compression/index.js + var registry = /* @__PURE__ */ new Map(); + function addDecoder(cases, importFn) { + if (!Array.isArray(cases)) { + cases = [cases]; + } + cases.forEach((c2) => registry.set(c2, importFn)); + } + addDecoder([void 0, 1], () => Promise.resolve().then(() => (init_raw(), raw_exports)).then((m) => m.default)); + addDecoder(5, () => Promise.resolve().then(() => (init_lzw(), lzw_exports)).then((m) => m.default)); + addDecoder(6, () => { + throw new Error("old style JPEG compression is not supported."); + }); + addDecoder(7, () => Promise.resolve().then(() => (init_jpeg(), jpeg_exports)).then((m) => m.default)); + addDecoder([8, 32946], () => Promise.resolve().then(() => (init_deflate(), deflate_exports)).then((m) => m.default)); + addDecoder(32773, () => Promise.resolve().then(() => (init_packbits(), packbits_exports)).then((m) => m.default)); + addDecoder( + 34887, + () => Promise.resolve().then(() => (init_lerc(), lerc_exports)).then(async (m) => { + await m.zstd.init(); + return m; + }).then((m) => m.default) + ); + addDecoder(50001, () => Promise.resolve().then(() => (init_webimage(), webimage_exports)).then((m) => m.default)); + + // node_modules/geotiff/dist-module/geotiff.js + init_basedecoder(); + + // node_modules/lzw-tiff-decoder/index.mjs + var A; + var I = null; + function g2() { + return null !== I && I.buffer === A.memory.buffer || (I = new Uint8Array(A.memory.buffer)), I; + } + var B = 0; + var Q = null; + function C() { + return null !== Q && Q.buffer === A.memory.buffer || (Q = new Int32Array(A.memory.buffer)), Q; + } + async function E2(I2) { + void 0 === I2 && (I2 = "".replace(/\.js$/, "_bg.wasm")); + ("string" == typeof I2 || "function" == typeof Request && I2 instanceof Request || "function" == typeof URL && I2 instanceof URL) && (I2 = fetch(I2)); + const { instance: g3, module: B2 } = await async function(A2, I3) { + if ("function" == typeof Response && A2 instanceof Response) { + if ("function" == typeof WebAssembly.instantiateStreaming) + try { + return await WebAssembly.instantiateStreaming(A2, I3); + } catch (I4) { + if ("application/wasm" == A2.headers.get("Content-Type")) + throw I4; + console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", I4); + } + const g4 = await A2.arrayBuffer(); + return await WebAssembly.instantiate(g4, I3); } - if (state.binaryValue === buffer) { - this.clearNeedsUpdate(); - return true; + { + const g4 = await WebAssembly.instantiate(A2, I3); + return g4 instanceof WebAssembly.Instance ? { instance: g4, module: A2 } : g4; } - state.binaryValue = buffer; - this.setNeedsRedraw(); - const needsUpdate = settings.transform || startIndices !== this.startIndices; - if (needsUpdate) { - if (ArrayBuffer.isView(buffer)) { - buffer = { - value: buffer - }; - } - const binaryValue = buffer; - assert10(ArrayBuffer.isView(binaryValue.value), "invalid ".concat(settings.accessor)); - const needsNormalize = Boolean(binaryValue.size) && binaryValue.size !== this.size; - state.binaryAccessor = getAccessorFromBuffer(binaryValue.value, { - size: binaryValue.size || this.size, - stride: binaryValue.stride, - offset: binaryValue.offset, - startIndices, - nested: needsNormalize - }); - return false; + }(await I2, {}); + return A = g3.exports, E2.__wbindgen_wasm_module = B2, A; + } + var D = Object.freeze({ __proto__: null, decompress: function(I2, Q2) { + try { + const F = A.__wbindgen_add_to_stack_pointer(-16); + var E3 = function(A2, I3) { + const Q3 = I3(1 * A2.length); + return g2().set(A2, Q3 / 1), B = A2.length, Q3; + }(I2, A.__wbindgen_malloc), D2 = B; + A.decompress(F, E3, D2, Q2); + var i3 = C()[F / 4 + 0], w3 = C()[F / 4 + 1], G2 = (o3 = i3, N2 = w3, g2().subarray(o3 / 1, o3 / 1 + N2)).slice(); + return A.__wbindgen_free(i3, 1 * w3), G2; + } finally { + A.__wbindgen_add_to_stack_pointer(16); + } + var o3, N2; + }, default: E2 }); + var i2 = [62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51]; + function w2(A2) { + return i2[A2 - 43]; + } + var G = function(A2) { + let I2, g3 = A2.endsWith("==") ? 2 : A2.endsWith("=") ? 1 : 0, B2 = A2.length, Q2 = new Uint8Array(B2 / 4 * 3); + for (let g4 = 0, C2 = 0; g4 < B2; g4 += 4, C2 += 3) + I2 = w2(A2.charCodeAt(g4)) << 18 | w2(A2.charCodeAt(g4 + 1)) << 12 | w2(A2.charCodeAt(g4 + 2)) << 6 | w2(A2.charCodeAt(g4 + 3)), Q2[C2] = I2 >> 16, Q2[C2 + 1] = I2 >> 8 & 255, Q2[C2 + 2] = 255 & I2; + return Q2.subarray(0, Q2.length - g3); + }("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"); + var o2; + async function N(A2, I2) { + o2 || (o2 = await (async () => (await E2(G), D))()); + const g3 = o2.decompress(A2, I2); + if (0 === g3.length) + throw Error("Failed to decode with LZW decoder."); + return g3; + } + + // node_modules/zod/lib/index.mjs + var util; + (function(util2) { + util2.assertEqual = (val) => val; + function assertIs(_arg) { + } + util2.assertIs = assertIs; + function assertNever(_x) { + throw new Error(); + } + util2.assertNever = assertNever; + util2.arrayToEnum = (items) => { + const obj = {}; + for (const item of items) { + obj[item] = item; + } + return obj; + }; + util2.getValidEnumValues = (obj) => { + const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number"); + const filtered = {}; + for (const k of validKeys) { + filtered[k] = obj[k]; } - this.clearNeedsUpdate(); - this.setData(buffer); - return true; + return util2.objectValues(filtered); + }; + util2.objectValues = (obj) => { + return util2.objectKeys(obj).map(function(e2) { + return obj[e2]; + }); + }; + util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => { + const keys = []; + for (const key in object) { + if (Object.prototype.hasOwnProperty.call(object, key)) { + keys.push(key); + } + } + return keys; + }; + util2.find = (arr, checker) => { + for (const item of arr) { + if (checker(item)) + return item; + } + return void 0; + }; + util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val; + function joinValues(array, separator = " | ") { + return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator); } - getVertexOffset(row) { - const { - startIndices - } = this; - const vertexIndex = startIndices ? row < startIndices.length ? startIndices[row] : this.numInstances : row; - return vertexIndex * this.size; + util2.joinValues = joinValues; + util2.jsonStringifyReplacer = (_2, value) => { + if (typeof value === "bigint") { + return value.toString(); + } + return value; + }; + })(util || (util = {})); + var objectUtil; + (function(objectUtil2) { + objectUtil2.mergeShapes = (first, second) => { + return { + ...first, + ...second + // second overwrites first + }; + }; + })(objectUtil || (objectUtil = {})); + var ZodParsedType = util.arrayToEnum([ + "string", + "nan", + "number", + "integer", + "float", + "boolean", + "date", + "bigint", + "symbol", + "function", + "undefined", + "null", + "array", + "object", + "unknown", + "promise", + "void", + "never", + "map", + "set" + ]); + var getParsedType = (data) => { + const t2 = typeof data; + switch (t2) { + case "undefined": + return ZodParsedType.undefined; + case "string": + return ZodParsedType.string; + case "number": + return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number; + case "boolean": + return ZodParsedType.boolean; + case "function": + return ZodParsedType.function; + case "bigint": + return ZodParsedType.bigint; + case "symbol": + return ZodParsedType.symbol; + case "object": + if (Array.isArray(data)) { + return ZodParsedType.array; + } + if (data === null) { + return ZodParsedType.null; + } + if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { + return ZodParsedType.promise; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return ZodParsedType.map; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return ZodParsedType.set; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return ZodParsedType.date; + } + return ZodParsedType.object; + default: + return ZodParsedType.unknown; } - getShaderAttributes() { - const shaderAttributeDefs = this.settings.shaderAttributes || { - [this.id]: null + }; + var ZodIssueCode = util.arrayToEnum([ + "invalid_type", + "invalid_literal", + "custom", + "invalid_union", + "invalid_union_discriminator", + "invalid_enum_value", + "unrecognized_keys", + "invalid_arguments", + "invalid_return_type", + "invalid_date", + "invalid_string", + "too_small", + "too_big", + "invalid_intersection_types", + "not_multiple_of", + "not_finite" + ]); + var ZodError = class extends Error { + constructor(issues) { + super(); + this.issues = []; + this.addIssue = (sub2) => { + this.issues = [...this.issues, sub2]; }; - const shaderAttributes = {}; - for (const shaderAttributeName in shaderAttributeDefs) { - Object.assign(shaderAttributes, super.getShaderAttributes(shaderAttributeName, shaderAttributeDefs[shaderAttributeName])); + this.addIssues = (subs = []) => { + this.issues = [...this.issues, ...subs]; + }; + const actualProto = new.target.prototype; + if (Object.setPrototypeOf) { + Object.setPrototypeOf(this, actualProto); + } else { + this.__proto__ = actualProto; } - return shaderAttributes; + this.name = "ZodError"; + this.issues = issues; } - _autoUpdater(attribute, { - data, - startRow, - endRow, - props, - numInstances - }) { - if (attribute.constant) { - return; - } - const { - settings, - state, - value, - size, - startIndices - } = attribute; - const { - accessor, - transform: transform2 - } = settings; - const accessorFunc = state.binaryAccessor || (typeof accessor === "function" ? accessor : props[accessor]); - assert10(typeof accessorFunc === "function", 'accessor "'.concat(accessor, '" is not a function')); - let i2 = attribute.getVertexOffset(startRow); - const { - iterable, - objectInfo - } = createIterable(data, startRow, endRow); - for (const object of iterable) { - objectInfo.index++; - let objectValue = accessorFunc(object, objectInfo); - if (transform2) { - objectValue = transform2.call(this, objectValue); - } - if (startIndices) { - const numVertices = (objectInfo.index < startIndices.length - 1 ? startIndices[objectInfo.index + 1] : numInstances) - startIndices[objectInfo.index]; - if (objectValue && Array.isArray(objectValue[0])) { - let startIndex = i2; - for (const item of objectValue) { - attribute._normalizeValue(item, value, startIndex); - startIndex += size; - } - } else if (objectValue && objectValue.length > size) { - value.set(objectValue, i2); + get errors() { + return this.issues; + } + format(_mapper) { + const mapper = _mapper || function(issue) { + return issue.message; + }; + const fieldErrors = { _errors: [] }; + const processError = (error2) => { + for (const issue of error2.issues) { + if (issue.code === "invalid_union") { + issue.unionErrors.map(processError); + } else if (issue.code === "invalid_return_type") { + processError(issue.returnTypeError); + } else if (issue.code === "invalid_arguments") { + processError(issue.argumentsError); + } else if (issue.path.length === 0) { + fieldErrors._errors.push(mapper(issue)); } else { - attribute._normalizeValue(objectValue, objectInfo.target, 0); - fillArray2({ - target: value, - source: objectInfo.target, - start: i2, - count: numVertices - }); + let curr = fieldErrors; + let i3 = 0; + while (i3 < issue.path.length) { + const el = issue.path[i3]; + const terminal = i3 === issue.path.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + } else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue)); + } + curr = curr[el]; + i3++; + } } - i2 += numVertices * size; + } + }; + processError(this); + return fieldErrors; + } + toString() { + return this.message; + } + get message() { + return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2); + } + get isEmpty() { + return this.issues.length === 0; + } + flatten(mapper = (issue) => issue.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub2 of this.issues) { + if (sub2.path.length > 0) { + fieldErrors[sub2.path[0]] = fieldErrors[sub2.path[0]] || []; + fieldErrors[sub2.path[0]].push(mapper(sub2)); } else { - attribute._normalizeValue(objectValue, value, i2); - i2 += size; + formErrors.push(mapper(sub2)); } } + return { formErrors, fieldErrors }; } - _validateAttributeUpdaters() { - const { - settings - } = this; - const hasUpdater = settings.noAlloc || typeof settings.update === "function"; - if (!hasUpdater) { - throw new Error("Attribute ".concat(this.id, " missing update or accessor")); - } + get formErrors() { + return this.flatten(); } - _checkAttributeArray() { - const { - value - } = this; - const limit = Math.min(4, this.size); - if (value && value.length >= limit) { - let valid = true; - switch (limit) { - case 4: - valid = valid && Number.isFinite(value[3]); - case 3: - valid = valid && Number.isFinite(value[2]); - case 2: - valid = valid && Number.isFinite(value[1]); - case 1: - valid = valid && Number.isFinite(value[0]); - break; - default: - valid = false; + }; + ZodError.create = (issues) => { + const error2 = new ZodError(issues); + return error2; + }; + var errorMap = (issue, _ctx) => { + let message; + switch (issue.code) { + case ZodIssueCode.invalid_type: + if (issue.received === ZodParsedType.undefined) { + message = "Required"; + } else { + message = `Expected ${issue.expected}, received ${issue.received}`; } - if (!valid) { - throw new Error("Illegal attribute generated for ".concat(this.id)); + break; + case ZodIssueCode.invalid_literal: + message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`; + break; + case ZodIssueCode.unrecognized_keys: + message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`; + break; + case ZodIssueCode.invalid_union: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_union_discriminator: + message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`; + break; + case ZodIssueCode.invalid_enum_value: + message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`; + break; + case ZodIssueCode.invalid_arguments: + message = `Invalid function arguments`; + break; + case ZodIssueCode.invalid_return_type: + message = `Invalid function return type`; + break; + case ZodIssueCode.invalid_date: + message = `Invalid date`; + break; + case ZodIssueCode.invalid_string: + if (typeof issue.validation === "object") { + if ("includes" in issue.validation) { + message = `Invalid input: must include "${issue.validation.includes}"`; + if (typeof issue.validation.position === "number") { + message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`; + } + } else if ("startsWith" in issue.validation) { + message = `Invalid input: must start with "${issue.validation.startsWith}"`; + } else if ("endsWith" in issue.validation) { + message = `Invalid input: must end with "${issue.validation.endsWith}"`; + } else { + util.assertNever(issue.validation); + } + } else if (issue.validation !== "regex") { + message = `Invalid ${issue.validation}`; + } else { + message = "Invalid"; } - } + break; + case ZodIssueCode.too_small: + if (issue.type === "array") + message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`; + else if (issue.type === "string") + message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`; + else if (issue.type === "number") + message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`; + else if (issue.type === "date") + message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.too_big: + if (issue.type === "array") + message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`; + else if (issue.type === "string") + message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`; + else if (issue.type === "number") + message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`; + else if (issue.type === "bigint") + message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`; + else if (issue.type === "date") + message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.custom: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_intersection_types: + message = `Intersection results could not be merged`; + break; + case ZodIssueCode.not_multiple_of: + message = `Number must be a multiple of ${issue.multipleOf}`; + break; + case ZodIssueCode.not_finite: + message = "Number must be finite"; + break; + default: + message = _ctx.defaultError; + util.assertNever(issue); } + return { message }; }; - - // node_modules/@deck.gl/core/dist/esm/transitions/gpu-interpolation-transition.js - var GPUInterpolationTransition = class { - constructor({ - gl, - attribute, - timeline - }) { - _defineProperty(this, "gl", void 0); - _defineProperty(this, "type", "interpolation"); - _defineProperty(this, "attributeInTransition", void 0); - _defineProperty(this, "settings", void 0); - _defineProperty(this, "attribute", void 0); - _defineProperty(this, "transition", void 0); - _defineProperty(this, "currentStartIndices", void 0); - _defineProperty(this, "currentLength", void 0); - _defineProperty(this, "transform", void 0); - _defineProperty(this, "buffers", void 0); - this.gl = gl; - this.transition = new Transition(timeline); - this.attribute = attribute; - this.attributeInTransition = new Attribute(gl, attribute.settings); - this.currentStartIndices = attribute.startIndices; - this.currentLength = 0; - this.transform = getTransform(gl, attribute); - const bufferOpts = { - byteLength: 0, - usage: 35050 - }; - this.buffers = [new Buffer2(gl, bufferOpts), new Buffer2(gl, bufferOpts)]; - } - get inProgress() { - return this.transition.inProgress; + var overrideErrorMap = errorMap; + function getErrorMap() { + return overrideErrorMap; + } + var makeIssue = (params) => { + const { data, path, errorMaps, issueData } = params; + const fullPath = [...path, ...issueData.path || []]; + const fullIssue = { + ...issueData, + path: fullPath + }; + let errorMessage = ""; + const maps = errorMaps.filter((m) => !!m).slice().reverse(); + for (const map2 of maps) { + errorMessage = map2(fullIssue, { data, defaultError: errorMessage }).message; } - start(transitionSettings, numInstances) { - if (transitionSettings.duration <= 0) { - this.transition.cancel(); - return; - } - this.settings = transitionSettings; - const { - gl, - buffers, - attribute - } = this; - cycleBuffers(buffers); - const padBufferOpts = { - numInstances, - attribute, - fromLength: this.currentLength, - fromStartIndices: this.currentStartIndices, - getData: transitionSettings.enter - }; - for (const buffer of buffers) { - padBuffer({ - buffer, - ...padBufferOpts + return { + ...issueData, + path: fullPath, + message: issueData.message || errorMessage + }; + }; + function addIssueToContext(ctx, issueData) { + const issue = makeIssue({ + issueData, + data: ctx.data, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + ctx.schemaErrorMap, + getErrorMap(), + errorMap + // then global default map + ].filter((x2) => !!x2) + }); + ctx.common.issues.push(issue); + } + var ParseStatus = class _ParseStatus { + constructor() { + this.value = "valid"; + } + dirty() { + if (this.value === "valid") + this.value = "dirty"; + } + abort() { + if (this.value !== "aborted") + this.value = "aborted"; + } + static mergeArray(status, results) { + const arrayValue = []; + for (const s of results) { + if (s.status === "aborted") + return INVALID2; + if (s.status === "dirty") + status.dirty(); + arrayValue.push(s.value); + } + return { status: status.value, value: arrayValue }; + } + static async mergeObjectAsync(status, pairs) { + const syncPairs = []; + for (const pair of pairs) { + syncPairs.push({ + key: await pair.key, + value: await pair.value }); } - this.currentStartIndices = attribute.startIndices; - this.currentLength = getAttributeBufferLength(attribute, numInstances); - this.attributeInTransition.setData({ - buffer: buffers[1], - value: attribute.value - }); - this.transition.start(transitionSettings); - this.transform.update({ - elementCount: Math.floor(this.currentLength / attribute.size), - sourceBuffers: { - aFrom: buffers[0], - aTo: getSourceBufferAttribute(gl, attribute) - }, - feedbackBuffers: { - vCurrent: buffers[1] + return _ParseStatus.mergeObjectSync(status, syncPairs); + } + static mergeObjectSync(status, pairs) { + const finalObject = {}; + for (const pair of pairs) { + const { key, value } = pair; + if (key.status === "aborted") + return INVALID2; + if (value.status === "aborted") + return INVALID2; + if (key.status === "dirty") + status.dirty(); + if (value.status === "dirty") + status.dirty(); + if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) { + finalObject[key.value] = value.value; } - }); + } + return { status: status.value, value: finalObject }; } - update() { - const updated = this.transition.update(); - if (updated) { - const { - duration, - easing - } = this.settings; - const { - time - } = this.transition; - let t2 = time / duration; - if (easing) { - t2 = easing(t2); + }; + var INVALID2 = Object.freeze({ + status: "aborted" + }); + var DIRTY = (value) => ({ status: "dirty", value }); + var OK = (value) => ({ status: "valid", value }); + var isAborted = (x2) => x2.status === "aborted"; + var isDirty = (x2) => x2.status === "dirty"; + var isValid = (x2) => x2.status === "valid"; + var isAsync = (x2) => typeof Promise !== "undefined" && x2 instanceof Promise; + var errorUtil; + (function(errorUtil2) { + errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {}; + errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message; + })(errorUtil || (errorUtil = {})); + var ParseInputLazyPath = class { + constructor(parent, value, path, key) { + this._cachedPath = []; + this.parent = parent; + this.data = value; + this._path = path; + this._key = key; + } + get path() { + if (!this._cachedPath.length) { + if (this._key instanceof Array) { + this._cachedPath.push(...this._path, ...this._key); + } else { + this._cachedPath.push(...this._path, this._key); } - this.transform.run({ - uniforms: { - time: t2 - } - }); } - return updated; + return this._cachedPath; } - cancel() { - this.transition.cancel(); - this.transform.delete(); - for (const buffer of this.buffers) { - buffer.delete(); + }; + var handleResult = (ctx, result) => { + if (isValid(result)) { + return { success: true, data: result.value }; + } else { + if (!ctx.common.issues.length) { + throw new Error("Validation failed but no issues detected."); } - this.buffers.length = 0; + return { + success: false, + get error() { + if (this._error) + return this._error; + const error2 = new ZodError(ctx.common.issues); + this._error = error2; + return this._error; + } + }; } }; - var vs6 = "\n#define SHADER_NAME interpolation-transition-vertex-shader\n\nuniform float time;\nattribute ATTRIBUTE_TYPE aFrom;\nattribute ATTRIBUTE_TYPE aTo;\nvarying ATTRIBUTE_TYPE vCurrent;\n\nvoid main(void) {\n vCurrent = mix(aFrom, aTo, time);\n gl_Position = vec4(0.0);\n}\n"; - function getTransform(gl, attribute) { - const attributeType = getAttributeTypeFromSize(attribute.size); - return new Transform(gl, { - vs: vs6, - defines: { - ATTRIBUTE_TYPE: attributeType - }, - varyings: ["vCurrent"] - }); - } - - // node_modules/@deck.gl/core/dist/esm/transitions/gpu-spring-transition.js - var GPUSpringTransition = class { - constructor({ - gl, - attribute, - timeline - }) { - _defineProperty(this, "gl", void 0); - _defineProperty(this, "type", "spring"); - _defineProperty(this, "attributeInTransition", void 0); - _defineProperty(this, "settings", void 0); - _defineProperty(this, "attribute", void 0); - _defineProperty(this, "transition", void 0); - _defineProperty(this, "currentStartIndices", void 0); - _defineProperty(this, "currentLength", void 0); - _defineProperty(this, "texture", void 0); - _defineProperty(this, "framebuffer", void 0); - _defineProperty(this, "transform", void 0); - _defineProperty(this, "buffers", void 0); - this.gl = gl; - this.type = "spring"; - this.transition = new Transition(timeline); - this.attribute = attribute; - this.attributeInTransition = new Attribute(gl, { - ...attribute.settings, - normalized: false - }); - this.currentStartIndices = attribute.startIndices; - this.currentLength = 0; - this.texture = getTexture(gl); - this.framebuffer = getFramebuffer2(gl, this.texture); - this.transform = getTransform2(gl, attribute, this.framebuffer); - const bufferOpts = { - byteLength: 0, - usage: 35050 + function processCreateParams(params) { + if (!params) + return {}; + const { errorMap: errorMap2, invalid_type_error, required_error, description } = params; + if (errorMap2 && (invalid_type_error || required_error)) { + throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`); + } + if (errorMap2) + return { errorMap: errorMap2, description }; + const customMap = (iss, ctx) => { + if (iss.code !== "invalid_type") + return { message: ctx.defaultError }; + if (typeof ctx.data === "undefined") { + return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError }; + } + return { message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError }; + }; + return { errorMap: customMap, description }; + } + var ZodType = class { + constructor(def) { + this.spa = this.safeParseAsync; + this._def = def; + this.parse = this.parse.bind(this); + this.safeParse = this.safeParse.bind(this); + this.parseAsync = this.parseAsync.bind(this); + this.safeParseAsync = this.safeParseAsync.bind(this); + this.spa = this.spa.bind(this); + this.refine = this.refine.bind(this); + this.refinement = this.refinement.bind(this); + this.superRefine = this.superRefine.bind(this); + this.optional = this.optional.bind(this); + this.nullable = this.nullable.bind(this); + this.nullish = this.nullish.bind(this); + this.array = this.array.bind(this); + this.promise = this.promise.bind(this); + this.or = this.or.bind(this); + this.and = this.and.bind(this); + this.transform = this.transform.bind(this); + this.brand = this.brand.bind(this); + this.default = this.default.bind(this); + this.catch = this.catch.bind(this); + this.describe = this.describe.bind(this); + this.pipe = this.pipe.bind(this); + this.readonly = this.readonly.bind(this); + this.isNullable = this.isNullable.bind(this); + this.isOptional = this.isOptional.bind(this); + } + get description() { + return this._def.description; + } + _getType(input) { + return getParsedType(input.data); + } + _getOrReturnCtx(input, ctx) { + return ctx || { + common: input.parent.common, + data: input.data, + parsedType: getParsedType(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent }; - this.buffers = [new Buffer2(gl, bufferOpts), new Buffer2(gl, bufferOpts), new Buffer2(gl, bufferOpts)]; } - get inProgress() { - return this.transition.inProgress; + _processInputParams(input) { + return { + status: new ParseStatus(), + ctx: { + common: input.parent.common, + data: input.data, + parsedType: getParsedType(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent + } + }; } - start(transitionSettings, numInstances) { - const { - gl, - buffers, - attribute - } = this; - const padBufferOpts = { - numInstances, - attribute, - fromLength: this.currentLength, - fromStartIndices: this.currentStartIndices, - getData: transitionSettings.enter + _parseSync(input) { + const result = this._parse(input); + if (isAsync(result)) { + throw new Error("Synchronous parse encountered promise."); + } + return result; + } + _parseAsync(input) { + const result = this._parse(input); + return Promise.resolve(result); + } + parse(data, params) { + const result = this.safeParse(data, params); + if (result.success) + return result.data; + throw result.error; + } + safeParse(data, params) { + var _a2; + const ctx = { + common: { + issues: [], + async: (_a2 = params === null || params === void 0 ? void 0 : params.async) !== null && _a2 !== void 0 ? _a2 : false, + contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap + }, + path: (params === null || params === void 0 ? void 0 : params.path) || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) }; - for (const buffer of buffers) { - padBuffer({ - buffer, - ...padBufferOpts + const result = this._parseSync({ data, path: ctx.path, parent: ctx }); + return handleResult(ctx, result); + } + async parseAsync(data, params) { + const result = await this.safeParseAsync(data, params); + if (result.success) + return result.data; + throw result.error; + } + async safeParseAsync(data, params) { + const ctx = { + common: { + issues: [], + contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap, + async: true + }, + path: (params === null || params === void 0 ? void 0 : params.path) || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) + }; + const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx }); + const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult)); + return handleResult(ctx, result); + } + refine(check, message) { + const getIssueProperties = (val) => { + if (typeof message === "string" || typeof message === "undefined") { + return { message }; + } else if (typeof message === "function") { + return message(val); + } else { + return message; + } + }; + return this._refinement((val, ctx) => { + const result = check(val); + const setError = () => ctx.addIssue({ + code: ZodIssueCode.custom, + ...getIssueProperties(val) }); - } - this.settings = transitionSettings; - this.currentStartIndices = attribute.startIndices; - this.currentLength = getAttributeBufferLength(attribute, numInstances); - this.attributeInTransition.setData({ - buffer: buffers[1], - value: attribute.value - }); - this.transition.start({ - ...transitionSettings, - duration: Infinity - }); - this.transform.update({ - elementCount: Math.floor(this.currentLength / attribute.size), - sourceBuffers: { - aTo: getSourceBufferAttribute(gl, attribute) + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then((data) => { + if (!data) { + setError(); + return false; + } else { + return true; + } + }); + } + if (!result) { + setError(); + return false; + } else { + return true; } }); } - update() { - const { - buffers, - transform: transform2, - framebuffer, - transition - } = this; - const updated = transition.update(); - if (!updated) { - return false; - } - const settings = this.settings; - transform2.update({ - sourceBuffers: { - aPrev: buffers[0], - aCur: buffers[1] - }, - feedbackBuffers: { - vNext: buffers[2] + refinement(check, refinementData) { + return this._refinement((val, ctx) => { + if (!check(val)) { + ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData); + return false; + } else { + return true; } }); - transform2.run({ - framebuffer, - discard: false, - clearRenderTarget: true, - uniforms: { - stiffness: settings.stiffness, - damping: settings.damping - }, - parameters: { - depthTest: false, - blend: true, - viewport: [0, 0, 1, 1], - blendFunc: [1, 1], - blendEquation: [32776, 32776] - } + } + _refinement(refinement) { + return new ZodEffects({ + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "refinement", refinement } }); - cycleBuffers(buffers); - this.attributeInTransition.setData({ - buffer: buffers[1], - value: this.attribute.value + } + superRefine(refinement) { + return this._refinement(refinement); + } + optional() { + return ZodOptional.create(this, this._def); + } + nullable() { + return ZodNullable.create(this, this._def); + } + nullish() { + return this.nullable().optional(); + } + array() { + return ZodArray.create(this, this._def); + } + promise() { + return ZodPromise.create(this, this._def); + } + or(option) { + return ZodUnion.create([this, option], this._def); + } + and(incoming) { + return ZodIntersection.create(this, incoming, this._def); + } + transform(transform2) { + return new ZodEffects({ + ...processCreateParams(this._def), + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "transform", transform: transform2 } }); - const isTransitioning = readPixelsToArray(framebuffer)[0] > 0; - if (!isTransitioning) { - transition.end(); - } - return true; } - cancel() { - this.transition.cancel(); - this.transform.delete(); - for (const buffer of this.buffers) { - buffer.delete(); - } - this.buffers.length = 0; - this.texture.delete(); - this.framebuffer.delete(); + default(def) { + const defaultValueFunc = typeof def === "function" ? def : () => def; + return new ZodDefault({ + ...processCreateParams(this._def), + innerType: this, + defaultValue: defaultValueFunc, + typeName: ZodFirstPartyTypeKind.ZodDefault + }); } - }; - function getTransform2(gl, attribute, framebuffer) { - const attributeType = getAttributeTypeFromSize(attribute.size); - return new Transform(gl, { - framebuffer, - vs: "\n#define SHADER_NAME spring-transition-vertex-shader\n\n#define EPSILON 0.00001\n\nuniform float stiffness;\nuniform float damping;\nattribute ATTRIBUTE_TYPE aPrev;\nattribute ATTRIBUTE_TYPE aCur;\nattribute ATTRIBUTE_TYPE aTo;\nvarying ATTRIBUTE_TYPE vNext;\nvarying float vIsTransitioningFlag;\n\nATTRIBUTE_TYPE getNextValue(ATTRIBUTE_TYPE cur, ATTRIBUTE_TYPE prev, ATTRIBUTE_TYPE dest) {\n ATTRIBUTE_TYPE velocity = cur - prev;\n ATTRIBUTE_TYPE delta = dest - cur;\n ATTRIBUTE_TYPE spring = delta * stiffness;\n ATTRIBUTE_TYPE damper = velocity * -1.0 * damping;\n return spring + damper + velocity + cur;\n}\n\nvoid main(void) {\n bool isTransitioning = length(aCur - aPrev) > EPSILON || length(aTo - aCur) > EPSILON;\n vIsTransitioningFlag = isTransitioning ? 1.0 : 0.0;\n\n vNext = getNextValue(aCur, aPrev, aTo);\n gl_Position = vec4(0, 0, 0, 1);\n gl_PointSize = 100.0;\n}\n", - fs: "\n#define SHADER_NAME spring-transition-is-transitioning-fragment-shader\n\nvarying float vIsTransitioningFlag;\n\nvoid main(void) {\n if (vIsTransitioningFlag == 0.0) {\n discard;\n }\n gl_FragColor = vec4(1.0);\n}", - defines: { - ATTRIBUTE_TYPE: attributeType - }, - varyings: ["vNext"] - }); - } - function getTexture(gl) { - return new Texture2D(gl, { - data: new Uint8Array(4), - format: 6408, - type: 5121, - border: 0, - mipmaps: false, - dataFormat: 6408, - width: 1, - height: 1 - }); - } - function getFramebuffer2(gl, texture) { - return new Framebuffer(gl, { - id: "spring-transition-is-transitioning-framebuffer", - width: 1, - height: 1, - attachments: { - [36064]: texture - } - }); - } - - // node_modules/@deck.gl/core/dist/esm/lib/attribute/attribute-transition-manager.js - var TRANSITION_TYPES = { - interpolation: GPUInterpolationTransition, - spring: GPUSpringTransition - }; - var AttributeTransitionManager = class { - constructor(gl, { - id, - timeline - }) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "isSupported", void 0); - _defineProperty(this, "gl", void 0); - _defineProperty(this, "timeline", void 0); - _defineProperty(this, "transitions", void 0); - _defineProperty(this, "needsRedraw", void 0); - _defineProperty(this, "numInstances", void 0); - this.id = id; - this.gl = gl; - this.timeline = timeline; - this.transitions = {}; - this.needsRedraw = false; - this.numInstances = 1; - this.isSupported = Transform.isSupported(gl); + brand() { + return new ZodBranded({ + typeName: ZodFirstPartyTypeKind.ZodBranded, + type: this, + ...processCreateParams(this._def) + }); + } + catch(def) { + const catchValueFunc = typeof def === "function" ? def : () => def; + return new ZodCatch({ + ...processCreateParams(this._def), + innerType: this, + catchValue: catchValueFunc, + typeName: ZodFirstPartyTypeKind.ZodCatch + }); + } + describe(description) { + const This = this.constructor; + return new This({ + ...this._def, + description + }); } - finalize() { - for (const attributeName in this.transitions) { - this._removeTransition(attributeName); - } + pipe(target) { + return ZodPipeline.create(this, target); } - update({ - attributes, - transitions, - numInstances - }) { - this.numInstances = numInstances || 1; - for (const attributeName in attributes) { - const attribute = attributes[attributeName]; - const settings = attribute.getTransitionSetting(transitions); - if (!settings) - continue; - this._updateAttribute(attributeName, attribute, settings); - } - for (const attributeName in this.transitions) { - const attribute = attributes[attributeName]; - if (!attribute || !attribute.getTransitionSetting(transitions)) { - this._removeTransition(attributeName); - } - } + readonly() { + return ZodReadonly.create(this); } - hasAttribute(attributeName) { - const transition = this.transitions[attributeName]; - return transition && transition.inProgress; + isOptional() { + return this.safeParse(void 0).success; } - getAttributes() { - const animatedAttributes = {}; - for (const attributeName in this.transitions) { - const transition = this.transitions[attributeName]; - if (transition.inProgress) { - animatedAttributes[attributeName] = transition.attributeInTransition; - } - } - return animatedAttributes; + isNullable() { + return this.safeParse(null).success; } - run() { - if (!this.isSupported || this.numInstances === 0) { - return false; + }; + var cuidRegex = /^c[^\s-]{8,}$/i; + var cuid2Regex = /^[a-z][a-z0-9]*$/; + var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/; + var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i; + var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_+-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i; + var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; + var emojiRegex; + var ipv4Regex = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/; + var ipv6Regex = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/; + var datetimeRegex = (args) => { + if (args.precision) { + if (args.offset) { + return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}(:?\\d{2})?)|Z)$`); + } else { + return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}Z$`); } - for (const attributeName in this.transitions) { - const updated = this.transitions[attributeName].update(); - if (updated) { - this.needsRedraw = true; - } + } else if (args.precision === 0) { + if (args.offset) { + return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}(:?\\d{2})?)|Z)$`); + } else { + return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$`); + } + } else { + if (args.offset) { + return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}(:?\\d{2})?)|Z)$`); + } else { + return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`); } - const needsRedraw = this.needsRedraw; - this.needsRedraw = false; - return needsRedraw; } - _removeTransition(attributeName) { - this.transitions[attributeName].cancel(); - delete this.transitions[attributeName]; + }; + function isValidIP(ip, version) { + if ((version === "v4" || !version) && ipv4Regex.test(ip)) { + return true; } - _updateAttribute(attributeName, attribute, settings) { - const transition = this.transitions[attributeName]; - let isNew = !transition || transition.type !== settings.type; - if (isNew) { - if (!this.isSupported) { - log_default.warn("WebGL2 not supported by this browser. Transition for ".concat(attributeName, " is disabled."))(); - return; - } - if (transition) { - this._removeTransition(attributeName); - } - const TransitionType = TRANSITION_TYPES[settings.type]; - if (TransitionType) { - this.transitions[attributeName] = new TransitionType({ - attribute, - timeline: this.timeline, - gl: this.gl - }); + if ((version === "v6" || !version) && ipv6Regex.test(ip)) { + return true; + } + return false; + } + var ZodString = class _ZodString extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = String(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.string) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext( + ctx2, + { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.string, + received: ctx2.parsedType + } + // + ); + return INVALID2; + } + const status = new ParseStatus(); + let ctx = void 0; + for (const check of this._def.checks) { + if (check.kind === "min") { + if (input.data.length < check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "string", + inclusive: true, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + if (input.data.length > check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "string", + inclusive: true, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "length") { + const tooBig = input.data.length > check.value; + const tooSmall = input.data.length < check.value; + if (tooBig || tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + if (tooBig) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "string", + inclusive: true, + exact: true, + message: check.message + }); + } else if (tooSmall) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "string", + inclusive: true, + exact: true, + message: check.message + }); + } + status.dirty(); + } + } else if (check.kind === "email") { + if (!emailRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "email", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "emoji") { + if (!emojiRegex) { + emojiRegex = new RegExp(_emojiRegex, "u"); + } + if (!emojiRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "emoji", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "uuid") { + if (!uuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "uuid", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "cuid") { + if (!cuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "cuid2") { + if (!cuid2Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid2", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "ulid") { + if (!ulidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ulid", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "url") { + try { + new URL(input.data); + } catch (_a2) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "url", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "regex") { + check.regex.lastIndex = 0; + const testResult = check.regex.test(input.data); + if (!testResult) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "regex", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "trim") { + input.data = input.data.trim(); + } else if (check.kind === "includes") { + if (!input.data.includes(check.value, check.position)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { includes: check.value, position: check.position }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "toLowerCase") { + input.data = input.data.toLowerCase(); + } else if (check.kind === "toUpperCase") { + input.data = input.data.toUpperCase(); + } else if (check.kind === "startsWith") { + if (!input.data.startsWith(check.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { startsWith: check.value }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "endsWith") { + if (!input.data.endsWith(check.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { endsWith: check.value }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "datetime") { + const regex = datetimeRegex(check); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "datetime", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "ip") { + if (!isValidIP(input.data, check.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ip", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } } else { - log_default.error("unsupported transition type '".concat(settings.type, "'"))(); - isNew = false; + util.assertNever(check); } } - if (isNew || attribute.needsRedraw()) { - this.needsRedraw = true; - this.transitions[attributeName].start(settings, this.numInstances); - } + return { status: status.value, value: input.data }; } - }; - - // node_modules/@deck.gl/core/dist/esm/lib/attribute/attribute-manager.js - var TRACE_INVALIDATE = "attributeManager.invalidate"; - var TRACE_UPDATE_START = "attributeManager.updateStart"; - var TRACE_UPDATE_END = "attributeManager.updateEnd"; - var TRACE_ATTRIBUTE_UPDATE_START = "attribute.updateStart"; - var TRACE_ATTRIBUTE_ALLOCATE = "attribute.allocate"; - var TRACE_ATTRIBUTE_UPDATE_END = "attribute.updateEnd"; - var AttributeManager = class { - constructor(gl, { - id = "attribute-manager", - stats, - timeline - } = {}) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "gl", void 0); - _defineProperty(this, "attributes", void 0); - _defineProperty(this, "updateTriggers", void 0); - _defineProperty(this, "needsRedraw", void 0); - _defineProperty(this, "userData", void 0); - _defineProperty(this, "stats", void 0); - _defineProperty(this, "attributeTransitionManager", void 0); - _defineProperty(this, "mergeBoundsMemoized", memoize(mergeBounds)); - this.id = id; - this.gl = gl; - this.attributes = {}; - this.updateTriggers = {}; - this.needsRedraw = true; - this.userData = {}; - this.stats = stats; - this.attributeTransitionManager = new AttributeTransitionManager(gl, { - id: "".concat(id, "-transitions"), - timeline + _regex(regex, validation, message) { + return this.refinement((data) => regex.test(data), { + validation, + code: ZodIssueCode.invalid_string, + ...errorUtil.errToObj(message) }); - Object.seal(this); } - finalize() { - for (const attributeName in this.attributes) { - this.attributes[attributeName].delete(); - } - this.attributeTransitionManager.finalize(); + _addCheck(check) { + return new _ZodString({ + ...this._def, + checks: [...this._def.checks, check] + }); } - getNeedsRedraw(opts = { - clearRedrawFlags: false - }) { - const redraw = this.needsRedraw; - this.needsRedraw = this.needsRedraw && !opts.clearRedrawFlags; - return redraw && this.id; + email(message) { + return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) }); } - setNeedsRedraw() { - this.needsRedraw = true; + url(message) { + return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) }); } - add(attributes) { - this._add(attributes); + emoji(message) { + return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) }); } - addInstanced(attributes) { - this._add(attributes, { - instanced: 1 - }); + uuid(message) { + return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) }); } - remove(attributeNameArray) { - for (const name of attributeNameArray) { - if (this.attributes[name] !== void 0) { - this.attributes[name].delete(); - delete this.attributes[name]; - } - } + cuid(message) { + return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) }); } - invalidate(triggerName, dataRange) { - const invalidatedAttributes = this._invalidateTrigger(triggerName, dataRange); - debug(TRACE_INVALIDATE, this, triggerName, invalidatedAttributes); + cuid2(message) { + return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) }); } - invalidateAll(dataRange) { - for (const attributeName in this.attributes) { - this.attributes[attributeName].setNeedsUpdate(attributeName, dataRange); - } - debug(TRACE_INVALIDATE, this, "all"); + ulid(message) { + return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) }); } - update({ - data, - numInstances, - startIndices = null, - transitions, - props = {}, - buffers = {}, - context = {} - }) { - let updated = false; - debug(TRACE_UPDATE_START, this); - if (this.stats) { - this.stats.get("Update Attributes").timeStart(); - } - for (const attributeName in this.attributes) { - const attribute = this.attributes[attributeName]; - const accessorName = attribute.settings.accessor; - attribute.startIndices = startIndices; - attribute.numInstances = numInstances; - if (props[attributeName]) { - log_default.removed("props.".concat(attributeName), "data.attributes.".concat(attributeName))(); - } - if (attribute.setExternalBuffer(buffers[attributeName])) { - } else if (attribute.setBinaryValue(typeof accessorName === "string" ? buffers[accessorName] : void 0, data.startIndices)) { - } else if (typeof accessorName === "string" && !buffers[accessorName] && attribute.setConstantValue(props[accessorName])) { - } else if (attribute.needsUpdate()) { - updated = true; - this._updateAttribute({ - attribute, - numInstances, - data, - props, - context - }); - } - this.needsRedraw = this.needsRedraw || attribute.needsRedraw(); - } - if (updated) { - debug(TRACE_UPDATE_END, this, numInstances); - } - if (this.stats) { - this.stats.get("Update Attributes").timeEnd(); + ip(options) { + return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) }); + } + datetime(options) { + var _a2; + if (typeof options === "string") { + return this._addCheck({ + kind: "datetime", + precision: null, + offset: false, + message: options + }); } - this.attributeTransitionManager.update({ - attributes: this.attributes, - numInstances, - transitions + return this._addCheck({ + kind: "datetime", + precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision, + offset: (_a2 = options === null || options === void 0 ? void 0 : options.offset) !== null && _a2 !== void 0 ? _a2 : false, + ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message) }); } - updateTransition() { - const { - attributeTransitionManager - } = this; - const transitionUpdated = attributeTransitionManager.run(); - this.needsRedraw = this.needsRedraw || transitionUpdated; - return transitionUpdated; + regex(regex, message) { + return this._addCheck({ + kind: "regex", + regex, + ...errorUtil.errToObj(message) + }); } - getAttributes() { - return this.attributes; + includes(value, options) { + return this._addCheck({ + kind: "includes", + value, + position: options === null || options === void 0 ? void 0 : options.position, + ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message) + }); } - getBounds(attributeNames) { - const bounds = attributeNames.map((attributeName) => { - var _this$attributes$attr; - return (_this$attributes$attr = this.attributes[attributeName]) === null || _this$attributes$attr === void 0 ? void 0 : _this$attributes$attr.getBounds(); + startsWith(value, message) { + return this._addCheck({ + kind: "startsWith", + value, + ...errorUtil.errToObj(message) }); - return this.mergeBoundsMemoized(bounds); } - getChangedAttributes(opts = { - clearChangedFlags: false - }) { - const { - attributes, - attributeTransitionManager - } = this; - const changedAttributes = { - ...attributeTransitionManager.getAttributes() - }; - for (const attributeName in attributes) { - const attribute = attributes[attributeName]; - if (attribute.needsRedraw(opts) && !attributeTransitionManager.hasAttribute(attributeName)) { - changedAttributes[attributeName] = attribute; + endsWith(value, message) { + return this._addCheck({ + kind: "endsWith", + value, + ...errorUtil.errToObj(message) + }); + } + min(minLength, message) { + return this._addCheck({ + kind: "min", + value: minLength, + ...errorUtil.errToObj(message) + }); + } + max(maxLength, message) { + return this._addCheck({ + kind: "max", + value: maxLength, + ...errorUtil.errToObj(message) + }); + } + length(len2, message) { + return this._addCheck({ + kind: "length", + value: len2, + ...errorUtil.errToObj(message) + }); + } + /** + * @deprecated Use z.string().min(1) instead. + * @see {@link ZodString.min} + */ + nonempty(message) { + return this.min(1, errorUtil.errToObj(message)); + } + trim() { + return new _ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "trim" }] + }); + } + toLowerCase() { + return new _ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "toLowerCase" }] + }); + } + toUpperCase() { + return new _ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "toUpperCase" }] + }); + } + get isDatetime() { + return !!this._def.checks.find((ch) => ch.kind === "datetime"); + } + get isEmail() { + return !!this._def.checks.find((ch) => ch.kind === "email"); + } + get isURL() { + return !!this._def.checks.find((ch) => ch.kind === "url"); + } + get isEmoji() { + return !!this._def.checks.find((ch) => ch.kind === "emoji"); + } + get isUUID() { + return !!this._def.checks.find((ch) => ch.kind === "uuid"); + } + get isCUID() { + return !!this._def.checks.find((ch) => ch.kind === "cuid"); + } + get isCUID2() { + return !!this._def.checks.find((ch) => ch.kind === "cuid2"); + } + get isULID() { + return !!this._def.checks.find((ch) => ch.kind === "ulid"); + } + get isIP() { + return !!this._def.checks.find((ch) => ch.kind === "ip"); + } + get minLength() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; } } - return changedAttributes; + return min; } - getShaderAttributes(attributes, excludeAttributes = {}) { - if (!attributes) { - attributes = this.getAttributes(); - } - const shaderAttributes = {}; - for (const attributeName in attributes) { - if (!excludeAttributes[attributeName]) { - Object.assign(shaderAttributes, attributes[attributeName].getShaderAttributes()); + get maxLength() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; } } - return shaderAttributes; + return max; } - _add(attributes, extraProps = {}) { - for (const attributeName in attributes) { - const attribute = attributes[attributeName]; - this.attributes[attributeName] = this._createAttribute(attributeName, attribute, extraProps); + }; + ZodString.create = (params) => { + var _a2; + return new ZodString({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodString, + coerce: (_a2 = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a2 !== void 0 ? _a2 : false, + ...processCreateParams(params) + }); + }; + function floatSafeRemainder(val, step) { + const valDecCount = (val.toString().split(".")[1] || "").length; + const stepDecCount = (step.toString().split(".")[1] || "").length; + const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount; + const valInt = parseInt(val.toFixed(decCount).replace(".", "")); + const stepInt = parseInt(step.toFixed(decCount).replace(".", "")); + return valInt % stepInt / Math.pow(10, decCount); + } + var ZodNumber = class _ZodNumber extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + this.step = this.multipleOf; + } + _parse(input) { + if (this._def.coerce) { + input.data = Number(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.number) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.number, + received: ctx2.parsedType + }); + return INVALID2; + } + let ctx = void 0; + const status = new ParseStatus(); + for (const check of this._def.checks) { + if (check.kind === "int") { + if (!util.isInteger(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: "integer", + received: "float", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "min") { + const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "number", + inclusive: check.inclusive, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "number", + inclusive: check.inclusive, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "multipleOf") { + if (floatSafeRemainder(input.data, check.value) !== 0) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check.value, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "finite") { + if (!Number.isFinite(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_finite, + message: check.message + }); + status.dirty(); + } + } else { + util.assertNever(check); + } } - this._mapUpdateTriggersToAttributes(); + return { status: status.value, value: input.data }; } - _createAttribute(name, attribute, extraProps) { - const props = { - ...attribute, - id: name, - size: attribute.isIndexed && 1 || attribute.size || 1, - divisor: extraProps.instanced ? 1 : attribute.divisor || 0 - }; - return new Attribute(this.gl, props); + gte(value, message) { + return this.setLimit("min", value, true, errorUtil.toString(message)); } - _mapUpdateTriggersToAttributes() { - const triggers = {}; - for (const attributeName in this.attributes) { - const attribute = this.attributes[attributeName]; - attribute.getUpdateTriggers().forEach((triggerName) => { - if (!triggers[triggerName]) { - triggers[triggerName] = []; - } - triggers[triggerName].push(attributeName); - }); - } - this.updateTriggers = triggers; + gt(value, message) { + return this.setLimit("min", value, false, errorUtil.toString(message)); } - _invalidateTrigger(triggerName, dataRange) { - const { - attributes, - updateTriggers - } = this; - const invalidatedAttributes = updateTriggers[triggerName]; - if (invalidatedAttributes) { - invalidatedAttributes.forEach((name) => { - const attribute = attributes[name]; - if (attribute) { - attribute.setNeedsUpdate(attribute.id, dataRange); + lte(value, message) { + return this.setLimit("max", value, true, errorUtil.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new _ZodNumber({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil.toString(message) } - }); - } - return invalidatedAttributes; + ] + }); } - _updateAttribute(opts) { - const { - attribute, - numInstances - } = opts; - debug(TRACE_ATTRIBUTE_UPDATE_START, attribute); - if (attribute.constant) { - attribute.setConstantValue(attribute.value); - return; - } - if (attribute.allocate(numInstances)) { - debug(TRACE_ATTRIBUTE_ALLOCATE, attribute, numInstances); - } - const updated = attribute.updateBuffer(opts); - if (updated) { - this.needsRedraw = true; - debug(TRACE_ATTRIBUTE_UPDATE_END, attribute, numInstances); - } + _addCheck(check) { + return new _ZodNumber({ + ...this._def, + checks: [...this._def.checks, check] + }); } - }; - - // node_modules/@deck.gl/core/dist/esm/transitions/cpu-interpolation-transition.js - var CPUInterpolationTransition = class extends Transition { - get value() { - return this._value; + int(message) { + return this._addCheck({ + kind: "int", + message: errorUtil.toString(message) + }); } - _onUpdate() { - const { - time, - settings: { - fromValue, - toValue, - duration, - easing - } - } = this; - const t2 = easing(time / duration); - this._value = lerp(fromValue, toValue, t2); + positive(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: false, + message: errorUtil.toString(message) + }); } - }; - - // node_modules/@deck.gl/core/dist/esm/transitions/cpu-spring-transition.js - var EPSILON2 = 1e-5; - function updateSpringElement(prev, cur, dest, damping, stiffness) { - const velocity = cur - prev; - const delta = dest - cur; - const spring = delta * stiffness; - const damper = -velocity * damping; - return spring + damper + velocity + cur; - } - function updateSpring(prev, cur, dest, damping, stiffness) { - if (Array.isArray(dest)) { - const next = []; - for (let i2 = 0; i2 < dest.length; i2++) { - next[i2] = updateSpringElement(prev[i2], cur[i2], dest[i2], damping, stiffness); + negative(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: false, + message: errorUtil.toString(message) + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: true, + message: errorUtil.toString(message) + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: true, + message: errorUtil.toString(message) + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil.toString(message) + }); + } + finite(message) { + return this._addCheck({ + kind: "finite", + message: errorUtil.toString(message) + }); + } + safe(message) { + return this._addCheck({ + kind: "min", + inclusive: true, + value: Number.MIN_SAFE_INTEGER, + message: errorUtil.toString(message) + })._addCheck({ + kind: "max", + inclusive: true, + value: Number.MAX_SAFE_INTEGER, + message: errorUtil.toString(message) + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } } - return next; + return min; } - return updateSpringElement(prev, cur, dest, damping, stiffness); - } - function distance(value1, value2) { - if (Array.isArray(value1)) { - let distanceSquare = 0; - for (let i2 = 0; i2 < value1.length; i2++) { - const d2 = value1[i2] - value2[i2]; - distanceSquare += d2 * d2; + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } } - return Math.sqrt(distanceSquare); + return max; } - return Math.abs(value1 - value2); - } - var CPUSpringTransition = class extends Transition { - get value() { - return this._currValue; + get isInt() { + return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value)); } - _onUpdate() { - const { - fromValue, - toValue, - damping, - stiffness - } = this.settings; - const { - _prevValue = fromValue, - _currValue = fromValue - } = this; - let nextValue = updateSpring(_prevValue, _currValue, toValue, damping, stiffness); - const delta = distance(nextValue, toValue); - const velocity = distance(nextValue, _currValue); - if (delta < EPSILON2 && velocity < EPSILON2) { - nextValue = toValue; - this.end(); + get isFinite() { + let max = null, min = null; + for (const ch of this._def.checks) { + if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") { + return true; + } else if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } else if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } } - this._prevValue = _currValue; - this._currValue = nextValue; + return Number.isFinite(min) && Number.isFinite(max); } }; - - // node_modules/@deck.gl/core/dist/esm/lib/uniform-transition-manager.js - var TRANSITION_TYPES2 = { - interpolation: CPUInterpolationTransition, - spring: CPUSpringTransition + ZodNumber.create = (params) => { + return new ZodNumber({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodNumber, + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + ...processCreateParams(params) + }); }; - var UniformTransitionManager = class { - constructor(timeline) { - this.transitions = /* @__PURE__ */ new Map(); - this.timeline = timeline; - } - get active() { - return this.transitions.size > 0; - } - add(key, fromValue, toValue, settings) { - const { - transitions - } = this; - if (transitions.has(key)) { - const transition2 = transitions.get(key); - const { - value = transition2.settings.fromValue - } = transition2; - fromValue = value; - this.remove(key); - } - settings = normalizeTransitionSettings(settings); - if (!settings) { - return; - } - const TransitionType = TRANSITION_TYPES2[settings.type]; - if (!TransitionType) { - log_default.error("unsupported transition type '".concat(settings.type, "'"))(); - return; + var ZodBigInt = class _ZodBigInt extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + } + _parse(input) { + if (this._def.coerce) { + input.data = BigInt(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.bigint) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.bigint, + received: ctx2.parsedType + }); + return INVALID2; + } + let ctx = void 0; + const status = new ParseStatus(); + for (const check of this._def.checks) { + if (check.kind === "min") { + const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + type: "bigint", + minimum: check.value, + inclusive: check.inclusive, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + type: "bigint", + maximum: check.value, + inclusive: check.inclusive, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "multipleOf") { + if (input.data % check.value !== BigInt(0)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check.value, + message: check.message + }); + status.dirty(); + } + } else { + util.assertNever(check); + } } - const transition = new TransitionType(this.timeline); - transition.start({ - ...settings, - fromValue, - toValue + return { status: status.value, value: input.data }; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new _ZodBigInt({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil.toString(message) + } + ] }); - transitions.set(key, transition); } - remove(key) { - const { - transitions - } = this; - if (transitions.has(key)) { - transitions.get(key).cancel(); - transitions.delete(key); - } + _addCheck(check) { + return new _ZodBigInt({ + ...this._def, + checks: [...this._def.checks, check] + }); } - update() { - const propsInTransition = {}; - for (const [key, transition] of this.transitions) { - transition.update(); - propsInTransition[key] = transition.value; - if (!transition.inProgress) { - this.remove(key); + positive(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: false, + message: errorUtil.toString(message) + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: false, + message: errorUtil.toString(message) + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: true, + message: errorUtil.toString(message) + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: true, + message: errorUtil.toString(message) + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil.toString(message) + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; } } - return propsInTransition; + return min; } - clear() { - for (const key of this.transitions.keys()) { - this.remove(key); + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } } + return max; } }; - - // node_modules/@deck.gl/core/dist/esm/lifecycle/props.js - function validateProps(props) { - const propTypes = props[PROP_TYPES_SYMBOL]; - for (const propName in propTypes) { - const propType = propTypes[propName]; - const { - validate - } = propType; - if (validate && !validate(props[propName], propType)) { - throw new Error("Invalid prop ".concat(propName, ": ").concat(props[propName])); + ZodBigInt.create = (params) => { + var _a2; + return new ZodBigInt({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodBigInt, + coerce: (_a2 = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a2 !== void 0 ? _a2 : false, + ...processCreateParams(params) + }); + }; + var ZodBoolean = class extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = Boolean(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.boolean) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.boolean, + received: ctx.parsedType + }); + return INVALID2; } + return OK(input.data); } - } - function diffProps(props, oldProps) { - const propsChangedReason = compareProps({ - newProps: props, - oldProps, - propTypes: props[PROP_TYPES_SYMBOL], - ignoreProps: { - data: null, - updateTriggers: null, - extensions: null, - transitions: null - } + }; + ZodBoolean.create = (params) => { + return new ZodBoolean({ + typeName: ZodFirstPartyTypeKind.ZodBoolean, + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + ...processCreateParams(params) }); - const dataChangedReason = diffDataProps(props, oldProps); - let updateTriggersChangedReason = false; - if (!dataChangedReason) { - updateTriggersChangedReason = diffUpdateTriggers(props, oldProps); - } - return { - dataChanged: dataChangedReason, - propsChanged: propsChangedReason, - updateTriggersChanged: updateTriggersChangedReason, - extensionsChanged: diffExtensions(props, oldProps), - transitionsChanged: diffTransitions(props, oldProps) - }; - } - function diffTransitions(props, oldProps) { - if (!props.transitions) { - return false; - } - const result = {}; - const propTypes = props[PROP_TYPES_SYMBOL]; - let changed = false; - for (const key in props.transitions) { - const propType = propTypes[key]; - const type = propType && propType.type; - const isTransitionable = type === "number" || type === "color" || type === "array"; - if (isTransitionable && comparePropValues(props[key], oldProps[key], propType)) { - result[key] = true; - changed = true; + }; + var ZodDate = class _ZodDate extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = new Date(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.date) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.date, + received: ctx2.parsedType + }); + return INVALID2; + } + if (isNaN(input.data.getTime())) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_date + }); + return INVALID2; + } + const status = new ParseStatus(); + let ctx = void 0; + for (const check of this._def.checks) { + if (check.kind === "min") { + if (input.data.getTime() < check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + message: check.message, + inclusive: true, + exact: false, + minimum: check.value, + type: "date" + }); + status.dirty(); + } + } else if (check.kind === "max") { + if (input.data.getTime() > check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + message: check.message, + inclusive: true, + exact: false, + maximum: check.value, + type: "date" + }); + status.dirty(); + } + } else { + util.assertNever(check); + } } + return { + status: status.value, + value: new Date(input.data.getTime()) + }; } - return changed ? result : false; - } - function compareProps({ - newProps, - oldProps, - ignoreProps = {}, - propTypes = {}, - triggerName = "props" - }) { - if (oldProps === newProps) { - return false; + _addCheck(check) { + return new _ZodDate({ + ...this._def, + checks: [...this._def.checks, check] + }); } - if (typeof newProps !== "object" || newProps === null) { - return "".concat(triggerName, " changed shallowly"); + min(minDate, message) { + return this._addCheck({ + kind: "min", + value: minDate.getTime(), + message: errorUtil.toString(message) + }); } - if (typeof oldProps !== "object" || oldProps === null) { - return "".concat(triggerName, " changed shallowly"); + max(maxDate, message) { + return this._addCheck({ + kind: "max", + value: maxDate.getTime(), + message: errorUtil.toString(message) + }); } - for (const key of Object.keys(newProps)) { - if (!(key in ignoreProps)) { - if (!(key in oldProps)) { - return "".concat(triggerName, ".").concat(key, " added"); - } - const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]); - if (changed) { - return "".concat(triggerName, ".").concat(key, " ").concat(changed); + get minDate() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; } } + return min != null ? new Date(min) : null; } - for (const key of Object.keys(oldProps)) { - if (!(key in ignoreProps)) { - if (!(key in newProps)) { - return "".concat(triggerName, ".").concat(key, " dropped"); - } - if (!Object.hasOwnProperty.call(newProps, key)) { - const changed = comparePropValues(newProps[key], oldProps[key], propTypes[key]); - if (changed) { - return "".concat(triggerName, ".").concat(key, " ").concat(changed); - } + get maxDate() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; } } + return max != null ? new Date(max) : null; } - return false; - } - function comparePropValues(newProp, oldProp, propType) { - let equal = propType && propType.equal; - if (equal && !equal(newProp, oldProp, propType)) { - return "changed deeply"; + }; + ZodDate.create = (params) => { + return new ZodDate({ + checks: [], + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + typeName: ZodFirstPartyTypeKind.ZodDate, + ...processCreateParams(params) + }); + }; + var ZodSymbol = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.symbol) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.symbol, + received: ctx.parsedType + }); + return INVALID2; + } + return OK(input.data); } - if (!equal) { - equal = newProp && oldProp && newProp.equals; - if (equal && !equal.call(newProp, oldProp)) { - return "changed deeply"; + }; + ZodSymbol.create = (params) => { + return new ZodSymbol({ + typeName: ZodFirstPartyTypeKind.ZodSymbol, + ...processCreateParams(params) + }); + }; + var ZodUndefined = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.undefined, + received: ctx.parsedType + }); + return INVALID2; } + return OK(input.data); } - if (!equal && oldProp !== newProp) { - return "changed shallowly"; + }; + ZodUndefined.create = (params) => { + return new ZodUndefined({ + typeName: ZodFirstPartyTypeKind.ZodUndefined, + ...processCreateParams(params) + }); + }; + var ZodNull = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.null) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.null, + received: ctx.parsedType + }); + return INVALID2; + } + return OK(input.data); } - return null; - } - function diffDataProps(props, oldProps) { - if (oldProps === null) { - return "oldProps is null, initial diff"; + }; + ZodNull.create = (params) => { + return new ZodNull({ + typeName: ZodFirstPartyTypeKind.ZodNull, + ...processCreateParams(params) + }); + }; + var ZodAny = class extends ZodType { + constructor() { + super(...arguments); + this._any = true; } - let dataChanged = false; - const { - dataComparator, - _dataDiff - } = props; - if (dataComparator) { - if (!dataComparator(props.data, oldProps.data)) { - dataChanged = "Data comparator detected a change"; - } - } else if (props.data !== oldProps.data) { - dataChanged = "A new data container was supplied"; + _parse(input) { + return OK(input.data); } - if (dataChanged && _dataDiff) { - dataChanged = _dataDiff(props.data, oldProps.data) || dataChanged; + }; + ZodAny.create = (params) => { + return new ZodAny({ + typeName: ZodFirstPartyTypeKind.ZodAny, + ...processCreateParams(params) + }); + }; + var ZodUnknown = class extends ZodType { + constructor() { + super(...arguments); + this._unknown = true; } - return dataChanged; - } - function diffUpdateTriggers(props, oldProps) { - if (oldProps === null) { - return { - all: true - }; + _parse(input) { + return OK(input.data); } - if ("all" in props.updateTriggers) { - const diffReason = diffUpdateTrigger(props, oldProps, "all"); - if (diffReason) { - return { - all: true - }; + }; + ZodUnknown.create = (params) => { + return new ZodUnknown({ + typeName: ZodFirstPartyTypeKind.ZodUnknown, + ...processCreateParams(params) + }); + }; + var ZodNever = class extends ZodType { + _parse(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.never, + received: ctx.parsedType + }); + return INVALID2; + } + }; + ZodNever.create = (params) => { + return new ZodNever({ + typeName: ZodFirstPartyTypeKind.ZodNever, + ...processCreateParams(params) + }); + }; + var ZodVoid = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.void, + received: ctx.parsedType + }); + return INVALID2; } + return OK(input.data); } - const reason = {}; - let changed = false; - for (const triggerName in props.updateTriggers) { - if (triggerName !== "all") { - const diffReason = diffUpdateTrigger(props, oldProps, triggerName); - if (diffReason) { - reason[triggerName] = true; - changed = true; + }; + ZodVoid.create = (params) => { + return new ZodVoid({ + typeName: ZodFirstPartyTypeKind.ZodVoid, + ...processCreateParams(params) + }); + }; + var ZodArray = class _ZodArray extends ZodType { + _parse(input) { + const { ctx, status } = this._processInputParams(input); + const def = this._def; + if (ctx.parsedType !== ZodParsedType.array) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.array, + received: ctx.parsedType + }); + return INVALID2; + } + if (def.exactLength !== null) { + const tooBig = ctx.data.length > def.exactLength.value; + const tooSmall = ctx.data.length < def.exactLength.value; + if (tooBig || tooSmall) { + addIssueToContext(ctx, { + code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small, + minimum: tooSmall ? def.exactLength.value : void 0, + maximum: tooBig ? def.exactLength.value : void 0, + type: "array", + inclusive: true, + exact: true, + message: def.exactLength.message + }); + status.dirty(); + } + } + if (def.minLength !== null) { + if (ctx.data.length < def.minLength.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: def.minLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.minLength.message + }); + status.dirty(); + } + } + if (def.maxLength !== null) { + if (ctx.data.length > def.maxLength.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: def.maxLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.maxLength.message + }); + status.dirty(); } } + if (ctx.common.async) { + return Promise.all([...ctx.data].map((item, i3) => { + return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i3)); + })).then((result2) => { + return ParseStatus.mergeArray(status, result2); + }); + } + const result = [...ctx.data].map((item, i3) => { + return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i3)); + }); + return ParseStatus.mergeArray(status, result); } - return changed ? reason : false; - } - function diffExtensions(props, oldProps) { - if (oldProps === null) { - return true; + get element() { + return this._def.type; } - const oldExtensions = oldProps.extensions; - const { - extensions - } = props; - if (extensions === oldExtensions) { - return false; + min(minLength, message) { + return new _ZodArray({ + ...this._def, + minLength: { value: minLength, message: errorUtil.toString(message) } + }); } - if (!oldExtensions || !extensions) { - return true; + max(maxLength, message) { + return new _ZodArray({ + ...this._def, + maxLength: { value: maxLength, message: errorUtil.toString(message) } + }); } - if (extensions.length !== oldExtensions.length) { - return true; + length(len2, message) { + return new _ZodArray({ + ...this._def, + exactLength: { value: len2, message: errorUtil.toString(message) } + }); } - for (let i2 = 0; i2 < extensions.length; i2++) { - if (!extensions[i2].equals(oldExtensions[i2])) { - return true; - } + nonempty(message) { + return this.min(1, message); } - return false; - } - function diffUpdateTrigger(props, oldProps, triggerName) { - let newTriggers = props.updateTriggers[triggerName]; - newTriggers = newTriggers === void 0 || newTriggers === null ? {} : newTriggers; - let oldTriggers = oldProps.updateTriggers[triggerName]; - oldTriggers = oldTriggers === void 0 || oldTriggers === null ? {} : oldTriggers; - const diffReason = compareProps({ - oldProps: oldTriggers, - newProps: newTriggers, - triggerName + }; + ZodArray.create = (schema, params) => { + return new ZodArray({ + type: schema, + minLength: null, + maxLength: null, + exactLength: null, + typeName: ZodFirstPartyTypeKind.ZodArray, + ...processCreateParams(params) }); - return diffReason; + }; + function deepPartialify(schema) { + if (schema instanceof ZodObject) { + const newShape = {}; + for (const key in schema.shape) { + const fieldSchema = schema.shape[key]; + newShape[key] = ZodOptional.create(deepPartialify(fieldSchema)); + } + return new ZodObject({ + ...schema._def, + shape: () => newShape + }); + } else if (schema instanceof ZodArray) { + return new ZodArray({ + ...schema._def, + type: deepPartialify(schema.element) + }); + } else if (schema instanceof ZodOptional) { + return ZodOptional.create(deepPartialify(schema.unwrap())); + } else if (schema instanceof ZodNullable) { + return ZodNullable.create(deepPartialify(schema.unwrap())); + } else if (schema instanceof ZodTuple) { + return ZodTuple.create(schema.items.map((item) => deepPartialify(item))); + } else { + return schema; + } } - - // node_modules/@deck.gl/core/dist/esm/utils/count.js - var ERR_NOT_OBJECT = "count(): argument not an object"; - var ERR_NOT_CONTAINER = "count(): argument not a container"; - function count(container) { - if (!isObject2(container)) { - throw new Error(ERR_NOT_OBJECT); + var ZodObject = class _ZodObject extends ZodType { + constructor() { + super(...arguments); + this._cached = null; + this.nonstrict = this.passthrough; + this.augment = this.extend; + } + _getCached() { + if (this._cached !== null) + return this._cached; + const shape = this._def.shape(); + const keys = util.objectKeys(shape); + return this._cached = { shape, keys }; + } + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.object) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx2.parsedType + }); + return INVALID2; + } + const { status, ctx } = this._processInputParams(input); + const { shape, keys: shapeKeys } = this._getCached(); + const extraKeys = []; + if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) { + for (const key in ctx.data) { + if (!shapeKeys.includes(key)) { + extraKeys.push(key); + } + } + } + const pairs = []; + for (const key of shapeKeys) { + const keyValidator = shape[key]; + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)), + alwaysSet: key in ctx.data + }); + } + if (this._def.catchall instanceof ZodNever) { + const unknownKeys = this._def.unknownKeys; + if (unknownKeys === "passthrough") { + for (const key of extraKeys) { + pairs.push({ + key: { status: "valid", value: key }, + value: { status: "valid", value: ctx.data[key] } + }); + } + } else if (unknownKeys === "strict") { + if (extraKeys.length > 0) { + addIssueToContext(ctx, { + code: ZodIssueCode.unrecognized_keys, + keys: extraKeys + }); + status.dirty(); + } + } else if (unknownKeys === "strip") + ; + else { + throw new Error(`Internal ZodObject error: invalid unknownKeys value.`); + } + } else { + const catchall = this._def.catchall; + for (const key of extraKeys) { + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: catchall._parse( + new ParseInputLazyPath(ctx, value, ctx.path, key) + //, ctx.child(key), value, getParsedType(value) + ), + alwaysSet: key in ctx.data + }); + } + } + if (ctx.common.async) { + return Promise.resolve().then(async () => { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + syncPairs.push({ + key, + value: await pair.value, + alwaysSet: pair.alwaysSet + }); + } + return syncPairs; + }).then((syncPairs) => { + return ParseStatus.mergeObjectSync(status, syncPairs); + }); + } else { + return ParseStatus.mergeObjectSync(status, pairs); + } + } + get shape() { + return this._def.shape(); + } + strict(message) { + errorUtil.errToObj; + return new _ZodObject({ + ...this._def, + unknownKeys: "strict", + ...message !== void 0 ? { + errorMap: (issue, ctx) => { + var _a2, _b, _c, _d; + const defaultError = (_c = (_b = (_a2 = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a2, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError; + if (issue.code === "unrecognized_keys") + return { + message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError + }; + return { + message: defaultError + }; + } + } : {} + }); } - if (typeof container.count === "function") { - return container.count(); + strip() { + return new _ZodObject({ + ...this._def, + unknownKeys: "strip" + }); } - if (Number.isFinite(container.size)) { - return container.size; + passthrough() { + return new _ZodObject({ + ...this._def, + unknownKeys: "passthrough" + }); } - if (Number.isFinite(container.length)) { - return container.length; + // const AugmentFactory = + // (def: Def) => + // ( + // augmentation: Augmentation + // ): ZodObject< + // extendShape, Augmentation>, + // Def["unknownKeys"], + // Def["catchall"] + // > => { + // return new ZodObject({ + // ...def, + // shape: () => ({ + // ...def.shape(), + // ...augmentation, + // }), + // }) as any; + // }; + extend(augmentation) { + return new _ZodObject({ + ...this._def, + shape: () => ({ + ...this._def.shape(), + ...augmentation + }) + }); } - if (isPlainObject(container)) { - return Object.keys(container).length; + /** + * Prior to zod@1.0.12 there was a bug in the + * inferred type of merged objects. Please + * upgrade if you are experiencing issues. + */ + merge(merging) { + const merged = new _ZodObject({ + unknownKeys: merging._def.unknownKeys, + catchall: merging._def.catchall, + shape: () => ({ + ...this._def.shape(), + ...merging._def.shape() + }), + typeName: ZodFirstPartyTypeKind.ZodObject + }); + return merged; + } + // merge< + // Incoming extends AnyZodObject, + // Augmentation extends Incoming["shape"], + // NewOutput extends { + // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation + // ? Augmentation[k]["_output"] + // : k extends keyof Output + // ? Output[k] + // : never; + // }, + // NewInput extends { + // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation + // ? Augmentation[k]["_input"] + // : k extends keyof Input + // ? Input[k] + // : never; + // } + // >( + // merging: Incoming + // ): ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"], + // NewOutput, + // NewInput + // > { + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + setKey(key, schema) { + return this.augment({ [key]: schema }); + } + // merge( + // merging: Incoming + // ): //ZodObject = (merging) => { + // ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"] + // > { + // // const mergedShape = objectUtil.mergeShapes( + // // this._def.shape(), + // // merging._def.shape() + // // ); + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + catchall(index) { + return new _ZodObject({ + ...this._def, + catchall: index + }); } - throw new Error(ERR_NOT_CONTAINER); - } - function isPlainObject(value) { - return value !== null && typeof value === "object" && value.constructor === Object; - } - function isObject2(value) { - return value !== null && typeof value === "object"; - } - - // node_modules/@deck.gl/core/dist/esm/utils/shader.js - function mergeShaders(target, source) { - if (!source) { - return target; + pick(mask) { + const shape = {}; + util.objectKeys(mask).forEach((key) => { + if (mask[key] && this.shape[key]) { + shape[key] = this.shape[key]; + } + }); + return new _ZodObject({ + ...this._def, + shape: () => shape + }); } - const result = { - ...target, - ...source - }; - if ("defines" in source) { - result.defines = { - ...target.defines, - ...source.defines - }; + omit(mask) { + const shape = {}; + util.objectKeys(this.shape).forEach((key) => { + if (!mask[key]) { + shape[key] = this.shape[key]; + } + }); + return new _ZodObject({ + ...this._def, + shape: () => shape + }); } - if ("modules" in source) { - result.modules = (target.modules || []).concat(source.modules); - if (source.modules.some((module) => module.name === "project64")) { - const index = result.modules.findIndex((module) => module.name === "project32"); - if (index >= 0) { - result.modules.splice(index, 1); + /** + * @deprecated + */ + deepPartial() { + return deepPartialify(this); + } + partial(mask) { + const newShape = {}; + util.objectKeys(this.shape).forEach((key) => { + const fieldSchema = this.shape[key]; + if (mask && !mask[key]) { + newShape[key] = fieldSchema; + } else { + newShape[key] = fieldSchema.optional(); } - } + }); + return new _ZodObject({ + ...this._def, + shape: () => newShape + }); } - if ("inject" in source) { - if (!target.inject) { - result.inject = source.inject; + required(mask) { + const newShape = {}; + util.objectKeys(this.shape).forEach((key) => { + if (mask && !mask[key]) { + newShape[key] = this.shape[key]; + } else { + const fieldSchema = this.shape[key]; + let newField = fieldSchema; + while (newField instanceof ZodOptional) { + newField = newField._def.innerType; + } + newShape[key] = newField; + } + }); + return new _ZodObject({ + ...this._def, + shape: () => newShape + }); + } + keyof() { + return createZodEnum(util.objectKeys(this.shape)); + } + }; + ZodObject.create = (shape, params) => { + return new ZodObject({ + shape: () => shape, + unknownKeys: "strip", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); + }; + ZodObject.strictCreate = (shape, params) => { + return new ZodObject({ + shape: () => shape, + unknownKeys: "strict", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); + }; + ZodObject.lazycreate = (shape, params) => { + return new ZodObject({ + shape, + unknownKeys: "strip", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); + }; + var ZodUnion = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const options = this._def.options; + function handleResults(results) { + for (const result of results) { + if (result.result.status === "valid") { + return result.result; + } + } + for (const result of results) { + if (result.result.status === "dirty") { + ctx.common.issues.push(...result.ctx.common.issues); + return result.result; + } + } + const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues)); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union, + unionErrors + }); + return INVALID2; + } + if (ctx.common.async) { + return Promise.all(options.map(async (option) => { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + }, + parent: null + }; + return { + result: await option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: childCtx + }), + ctx: childCtx + }; + })).then(handleResults); } else { - const mergedInjection = { - ...target.inject - }; - for (const key in source.inject) { - mergedInjection[key] = (mergedInjection[key] || "") + source.inject[key]; + let dirty = void 0; + const issues = []; + for (const option of options) { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + }, + parent: null + }; + const result = option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: childCtx + }); + if (result.status === "valid") { + return result; + } else if (result.status === "dirty" && !dirty) { + dirty = { result, ctx: childCtx }; + } + if (childCtx.common.issues.length) { + issues.push(childCtx.common.issues); + } } - result.inject = mergedInjection; + if (dirty) { + ctx.common.issues.push(...dirty.ctx.common.issues); + return dirty.result; + } + const unionErrors = issues.map((issues2) => new ZodError(issues2)); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union, + unionErrors + }); + return INVALID2; } } - return result; - } - - // node_modules/@deck.gl/core/dist/esm/utils/texture.js - var DEFAULT_TEXTURE_PARAMETERS = { - [10241]: 9987, - [10240]: 9729, - [10242]: 33071, - [10243]: 33071 + get options() { + return this._def.options; + } }; - var internalTextures = {}; - function createTexture(owner, gl, image, parameters) { - if (image instanceof Texture2D) { - return image; - } else if (image.constructor && image.constructor.name !== "Object") { - image = { - data: image - }; + ZodUnion.create = (types, params) => { + return new ZodUnion({ + options: types, + typeName: ZodFirstPartyTypeKind.ZodUnion, + ...processCreateParams(params) + }); + }; + var getDiscriminator = (type) => { + if (type instanceof ZodLazy) { + return getDiscriminator(type.schema); + } else if (type instanceof ZodEffects) { + return getDiscriminator(type.innerType()); + } else if (type instanceof ZodLiteral) { + return [type.value]; + } else if (type instanceof ZodEnum) { + return type.options; + } else if (type instanceof ZodNativeEnum) { + return Object.keys(type.enum); + } else if (type instanceof ZodDefault) { + return getDiscriminator(type._def.innerType); + } else if (type instanceof ZodUndefined) { + return [void 0]; + } else if (type instanceof ZodNull) { + return [null]; + } else { + return null; } - let specialTextureParameters = null; - if (image.compressed) { - specialTextureParameters = { - [10241]: image.data.length > 1 ? 9985 : 9729 - }; + }; + var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.object) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType + }); + return INVALID2; + } + const discriminator = this.discriminator; + const discriminatorValue = ctx.data[discriminator]; + const option = this.optionsMap.get(discriminatorValue); + if (!option) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union_discriminator, + options: Array.from(this.optionsMap.keys()), + path: [discriminator] + }); + return INVALID2; + } + if (ctx.common.async) { + return option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + } else { + return option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + } } - const texture = new Texture2D(gl, { - ...image, - parameters: { - ...DEFAULT_TEXTURE_PARAMETERS, - ...specialTextureParameters, - ...parameters + get discriminator() { + return this._def.discriminator; + } + get options() { + return this._def.options; + } + get optionsMap() { + return this._def.optionsMap; + } + /** + * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor. + * However, it only allows a union of objects, all of which need to share a discriminator property. This property must + * have a different value for each object in the union. + * @param discriminator the name of the discriminator property + * @param types an array of object schemas + * @param params + */ + static create(discriminator, options, params) { + const optionsMap = /* @__PURE__ */ new Map(); + for (const type of options) { + const discriminatorValues = getDiscriminator(type.shape[discriminator]); + if (!discriminatorValues) { + throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`); + } + for (const value of discriminatorValues) { + if (optionsMap.has(value)) { + throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`); + } + optionsMap.set(value, type); + } } - }); - internalTextures[texture.id] = owner; - return texture; - } - function destroyTexture(owner, texture) { - if (!texture || !(texture instanceof Texture2D)) { - return; + return new _ZodDiscriminatedUnion({ + typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion, + discriminator, + options, + optionsMap, + ...processCreateParams(params) + }); } - if (internalTextures[texture.id] === owner) { - texture.delete(); - delete internalTextures[texture.id]; + }; + function mergeValues(a2, b2) { + const aType = getParsedType(a2); + const bType = getParsedType(b2); + if (a2 === b2) { + return { valid: true, data: a2 }; + } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) { + const bKeys = util.objectKeys(b2); + const sharedKeys = util.objectKeys(a2).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a2, ...b2 }; + for (const key of sharedKeys) { + const sharedValue = mergeValues(a2[key], b2[key]); + if (!sharedValue.valid) { + return { valid: false }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) { + if (a2.length !== b2.length) { + return { valid: false }; + } + const newArray = []; + for (let index = 0; index < a2.length; index++) { + const itemA = a2[index]; + const itemB = b2[index]; + const sharedValue = mergeValues(itemA, itemB); + if (!sharedValue.valid) { + return { valid: false }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a2 === +b2) { + return { valid: true, data: a2 }; + } else { + return { valid: false }; } } - - // node_modules/@deck.gl/core/dist/esm/lifecycle/prop-types.js - var TYPE_DEFINITIONS2 = { - boolean: { - validate(value, propType) { - return true; - }, - equal(value1, value2, propType) { - return Boolean(value1) === Boolean(value2); - } - }, - number: { - validate(value, propType) { - return Number.isFinite(value) && (!("max" in propType) || value <= propType.max) && (!("min" in propType) || value >= propType.min); - } - }, - color: { - validate(value, propType) { - return propType.optional && !value || isArray3(value) && (value.length === 3 || value.length === 4); - }, - equal(value1, value2, propType) { - return deepEqual(value1, value2, 1); - } - }, - accessor: { - validate(value, propType) { - const valueType = getTypeOf2(value); - return valueType === "function" || valueType === getTypeOf2(propType.value); - }, - equal(value1, value2, propType) { - if (typeof value2 === "function") { - return true; + var ZodIntersection = class extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const handleParsed = (parsedLeft, parsedRight) => { + if (isAborted(parsedLeft) || isAborted(parsedRight)) { + return INVALID2; } - return deepEqual(value1, value2, 1); + const merged = mergeValues(parsedLeft.value, parsedRight.value); + if (!merged.valid) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_intersection_types + }); + return INVALID2; + } + if (isDirty(parsedLeft) || isDirty(parsedRight)) { + status.dirty(); + } + return { status: status.value, value: merged.data }; + }; + if (ctx.common.async) { + return Promise.all([ + this._def.left._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }), + this._def.right._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }) + ]).then(([left, right]) => handleParsed(left, right)); + } else { + return handleParsed(this._def.left._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }), this._def.right._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + })); + } + } + }; + ZodIntersection.create = (left, right, params) => { + return new ZodIntersection({ + left, + right, + typeName: ZodFirstPartyTypeKind.ZodIntersection, + ...processCreateParams(params) + }); + }; + var ZodTuple = class _ZodTuple extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.array) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.array, + received: ctx.parsedType + }); + return INVALID2; + } + if (ctx.data.length < this._def.items.length) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: this._def.items.length, + inclusive: true, + exact: false, + type: "array" + }); + return INVALID2; + } + const rest = this._def.rest; + if (!rest && ctx.data.length > this._def.items.length) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: this._def.items.length, + inclusive: true, + exact: false, + type: "array" + }); + status.dirty(); } - }, - array: { - validate(value, propType) { - return propType.optional && !value || isArray3(value); - }, - equal(value1, value2, propType) { - const { - compare - } = propType; - const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0; - return compare ? deepEqual(value1, value2, depth) : value1 === value2; + const items = [...ctx.data].map((item, itemIndex) => { + const schema = this._def.items[itemIndex] || this._def.rest; + if (!schema) + return null; + return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex)); + }).filter((x2) => !!x2); + if (ctx.common.async) { + return Promise.all(items).then((results) => { + return ParseStatus.mergeArray(status, results); + }); + } else { + return ParseStatus.mergeArray(status, items); } - }, - object: { - equal(value1, value2, propType) { - if (propType.ignore) { - return true; - } - const { - compare - } = propType; - const depth = Number.isInteger(compare) ? compare : compare ? 1 : 0; - return compare ? deepEqual(value1, value2, depth) : value1 === value2; + } + get items() { + return this._def.items; + } + rest(rest) { + return new _ZodTuple({ + ...this._def, + rest + }); + } + }; + ZodTuple.create = (schemas, params) => { + if (!Array.isArray(schemas)) { + throw new Error("You must pass an array of schemas to z.tuple([ ... ])"); + } + return new ZodTuple({ + items: schemas, + typeName: ZodFirstPartyTypeKind.ZodTuple, + rest: null, + ...processCreateParams(params) + }); + }; + var ZodRecord = class _ZodRecord extends ZodType { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.object) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType + }); + return INVALID2; + } + const pairs = []; + const keyType = this._def.keyType; + const valueType = this._def.valueType; + for (const key in ctx.data) { + pairs.push({ + key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)), + value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)) + }); } - }, - function: { - validate(value, propType) { - return propType.optional && !value || typeof value === "function"; - }, - equal(value1, value2, propType) { - const shouldIgnore = !propType.compare && propType.ignore !== false; - return shouldIgnore || value1 === value2; + if (ctx.common.async) { + return ParseStatus.mergeObjectAsync(status, pairs); + } else { + return ParseStatus.mergeObjectSync(status, pairs); } - }, - data: { - transform: (value, propType, component) => { - const { - dataTransform - } = component.props; - return dataTransform && value ? dataTransform(value) : value; + } + get element() { + return this._def.valueType; + } + static create(first, second, third) { + if (second instanceof ZodType) { + return new _ZodRecord({ + keyType: first, + valueType: second, + typeName: ZodFirstPartyTypeKind.ZodRecord, + ...processCreateParams(third) + }); } - }, - image: { - transform: (value, propType, component) => { - const context = component.context; - if (!context || !context.gl) { - return null; - } - return createTexture(component.id, context.gl, value, { - ...propType.parameters, - ...component.props.textureParameters + return new _ZodRecord({ + keyType: ZodString.create(), + valueType: first, + typeName: ZodFirstPartyTypeKind.ZodRecord, + ...processCreateParams(second) + }); + } + }; + var ZodMap = class extends ZodType { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.map) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.map, + received: ctx.parsedType }); - }, - release: (value, propType, component) => { - destroyTexture(component.id, value); + return INVALID2; + } + const keyType = this._def.keyType; + const valueType = this._def.valueType; + const pairs = [...ctx.data.entries()].map(([key, value], index) => { + return { + key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])), + value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])) + }; + }); + if (ctx.common.async) { + const finalMap = /* @__PURE__ */ new Map(); + return Promise.resolve().then(async () => { + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID2; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + }); + } else { + const finalMap = /* @__PURE__ */ new Map(); + for (const pair of pairs) { + const key = pair.key; + const value = pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID2; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; } } }; - function parsePropTypes2(propDefs) { - const propTypes = {}; - const defaultProps5 = {}; - const deprecatedProps = {}; - for (const [propName, propDef] of Object.entries(propDefs)) { - const deprecated = propDef === null || propDef === void 0 ? void 0 : propDef.deprecatedFor; - if (deprecated) { - deprecatedProps[propName] = Array.isArray(deprecated) ? deprecated : [deprecated]; + ZodMap.create = (keyType, valueType, params) => { + return new ZodMap({ + valueType, + keyType, + typeName: ZodFirstPartyTypeKind.ZodMap, + ...processCreateParams(params) + }); + }; + var ZodSet = class _ZodSet extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.set) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.set, + received: ctx.parsedType + }); + return INVALID2; + } + const def = this._def; + if (def.minSize !== null) { + if (ctx.data.size < def.minSize.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: def.minSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.minSize.message + }); + status.dirty(); + } + } + if (def.maxSize !== null) { + if (ctx.data.size > def.maxSize.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: def.maxSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.maxSize.message + }); + status.dirty(); + } + } + const valueType = this._def.valueType; + function finalizeSet(elements2) { + const parsedSet = /* @__PURE__ */ new Set(); + for (const element of elements2) { + if (element.status === "aborted") + return INVALID2; + if (element.status === "dirty") + status.dirty(); + parsedSet.add(element.value); + } + return { status: status.value, value: parsedSet }; + } + const elements = [...ctx.data.values()].map((item, i3) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i3))); + if (ctx.common.async) { + return Promise.all(elements).then((elements2) => finalizeSet(elements2)); } else { - const propType = parsePropType2(propName, propDef); - propTypes[propName] = propType; - defaultProps5[propName] = propType.value; + return finalizeSet(elements); } } - return { - propTypes, - defaultProps: defaultProps5, - deprecatedProps - }; - } - function parsePropType2(name, propDef) { - switch (getTypeOf2(propDef)) { - case "object": - return normalizePropDefinition(name, propDef); - case "array": - return normalizePropDefinition(name, { - type: "array", - value: propDef, - compare: false + min(minSize, message) { + return new _ZodSet({ + ...this._def, + minSize: { value: minSize, message: errorUtil.toString(message) } + }); + } + max(maxSize, message) { + return new _ZodSet({ + ...this._def, + maxSize: { value: maxSize, message: errorUtil.toString(message) } + }); + } + size(size, message) { + return this.min(size, message).max(size, message); + } + nonempty(message) { + return this.min(1, message); + } + }; + ZodSet.create = (valueType, params) => { + return new ZodSet({ + valueType, + minSize: null, + maxSize: null, + typeName: ZodFirstPartyTypeKind.ZodSet, + ...processCreateParams(params) + }); + }; + var ZodFunction = class _ZodFunction extends ZodType { + constructor() { + super(...arguments); + this.validate = this.implement; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.function) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.function, + received: ctx.parsedType }); - case "boolean": - return normalizePropDefinition(name, { - type: "boolean", - value: propDef + return INVALID2; + } + function makeArgsIssue(args, error2) { + return makeIssue({ + data: args, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + ctx.schemaErrorMap, + getErrorMap(), + errorMap + ].filter((x2) => !!x2), + issueData: { + code: ZodIssueCode.invalid_arguments, + argumentsError: error2 + } }); - case "number": - return normalizePropDefinition(name, { - type: "number", - value: propDef + } + function makeReturnsIssue(returns, error2) { + return makeIssue({ + data: returns, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + ctx.schemaErrorMap, + getErrorMap(), + errorMap + ].filter((x2) => !!x2), + issueData: { + code: ZodIssueCode.invalid_return_type, + returnTypeError: error2 + } }); - case "function": - return normalizePropDefinition(name, { - type: "function", - value: propDef, - compare: true + } + const params = { errorMap: ctx.common.contextualErrorMap }; + const fn = ctx.data; + if (this._def.returns instanceof ZodPromise) { + const me = this; + return OK(async function(...args) { + const error2 = new ZodError([]); + const parsedArgs = await me._def.args.parseAsync(args, params).catch((e2) => { + error2.addIssue(makeArgsIssue(args, e2)); + throw error2; + }); + const result = await Reflect.apply(fn, this, parsedArgs); + const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e2) => { + error2.addIssue(makeReturnsIssue(result, e2)); + throw error2; + }); + return parsedReturns; }); - default: - return { - name, - type: "unknown", - value: propDef - }; + } else { + const me = this; + return OK(function(...args) { + const parsedArgs = me._def.args.safeParse(args, params); + if (!parsedArgs.success) { + throw new ZodError([makeArgsIssue(args, parsedArgs.error)]); + } + const result = Reflect.apply(fn, this, parsedArgs.data); + const parsedReturns = me._def.returns.safeParse(result, params); + if (!parsedReturns.success) { + throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]); + } + return parsedReturns.data; + }); + } } - } - function normalizePropDefinition(name, propDef) { - if (!("type" in propDef)) { - if (!("value" in propDef)) { - return { - name, - type: "object", - value: propDef - }; + parameters() { + return this._def.args; + } + returnType() { + return this._def.returns; + } + args(...items) { + return new _ZodFunction({ + ...this._def, + args: ZodTuple.create(items).rest(ZodUnknown.create()) + }); + } + returns(returnType) { + return new _ZodFunction({ + ...this._def, + returns: returnType + }); + } + implement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + strictImplement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + static create(args, returns, params) { + return new _ZodFunction({ + args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()), + returns: returns || ZodUnknown.create(), + typeName: ZodFirstPartyTypeKind.ZodFunction, + ...processCreateParams(params) + }); + } + }; + var ZodLazy = class extends ZodType { + get schema() { + return this._def.getter(); + } + _parse(input) { + const { ctx } = this._processInputParams(input); + const lazySchema = this._def.getter(); + return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx }); + } + }; + ZodLazy.create = (getter, params) => { + return new ZodLazy({ + getter, + typeName: ZodFirstPartyTypeKind.ZodLazy, + ...processCreateParams(params) + }); + }; + var ZodLiteral = class extends ZodType { + _parse(input) { + if (input.data !== this._def.value) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_literal, + expected: this._def.value + }); + return INVALID2; } - return { - name, - type: getTypeOf2(propDef.value), - ...propDef - }; + return { status: "valid", value: input.data }; } - return { - name, - ...TYPE_DEFINITIONS2[propDef.type], - ...propDef - }; - } - function isArray3(value) { - return Array.isArray(value) || ArrayBuffer.isView(value); + get value() { + return this._def.value; + } + }; + ZodLiteral.create = (value, params) => { + return new ZodLiteral({ + value, + typeName: ZodFirstPartyTypeKind.ZodLiteral, + ...processCreateParams(params) + }); + }; + function createZodEnum(values, params) { + return new ZodEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodEnum, + ...processCreateParams(params) + }); } - function getTypeOf2(value) { - if (isArray3(value)) { - return "array"; + var ZodEnum = class _ZodEnum extends ZodType { + _parse(input) { + if (typeof input.data !== "string") { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext(ctx, { + expected: util.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode.invalid_type + }); + return INVALID2; + } + if (this._def.values.indexOf(input.data) === -1) { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_enum_value, + options: expectedValues + }); + return INVALID2; + } + return OK(input.data); } - if (value === null) { - return "null"; + get options() { + return this._def.values; } - return typeof value; - } - - // node_modules/@deck.gl/core/dist/esm/lifecycle/create-props.js - function createProps(component, propObjects) { - let extensions; - for (let i2 = propObjects.length - 1; i2 >= 0; i2--) { - const props = propObjects[i2]; - if ("extensions" in props) { - extensions = props.extensions; + get enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; } + return enumValues; } - const propsPrototype = getPropsPrototype(component.constructor, extensions); - const propsInstance = Object.create(propsPrototype); - propsInstance[COMPONENT_SYMBOL] = component; - propsInstance[ASYNC_ORIGINAL_SYMBOL] = {}; - propsInstance[ASYNC_RESOLVED_SYMBOL] = {}; - for (let i2 = 0; i2 < propObjects.length; ++i2) { - const props = propObjects[i2]; - for (const key in props) { - propsInstance[key] = props[key]; + get Values() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; } + return enumValues; } - Object.freeze(propsInstance); - return propsInstance; - } - var MergedDefaultPropsCacheKey = "_mergedDefaultProps"; - function getPropsPrototype(componentClass, extensions) { - let cacheKey = MergedDefaultPropsCacheKey; - if (extensions) { - for (const extension of extensions) { - const ExtensionClass = extension.constructor; - if (ExtensionClass) { - cacheKey += ":".concat(ExtensionClass.extensionName || ExtensionClass.name); - } + get Enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; } + return enumValues; } - const defaultProps5 = getOwnProperty(componentClass, cacheKey); - if (!defaultProps5) { - return componentClass[cacheKey] = createPropsPrototypeAndTypes(componentClass, extensions || []); + extract(values) { + return _ZodEnum.create(values); } - return defaultProps5; - } - function createPropsPrototypeAndTypes(componentClass, extensions) { - const parent = componentClass.prototype; - if (!parent) { - return null; + exclude(values) { + return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt))); } - const parentClass = Object.getPrototypeOf(componentClass); - const parentDefaultProps = getPropsPrototype(parentClass); - const componentDefaultProps = getOwnProperty(componentClass, "defaultProps") || {}; - const componentPropDefs = parsePropTypes2(componentDefaultProps); - const defaultProps5 = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps, componentPropDefs.defaultProps); - const propTypes = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps === null || parentDefaultProps === void 0 ? void 0 : parentDefaultProps[PROP_TYPES_SYMBOL], componentPropDefs.propTypes); - const deprecatedProps = Object.assign(/* @__PURE__ */ Object.create(null), parentDefaultProps === null || parentDefaultProps === void 0 ? void 0 : parentDefaultProps[DEPRECATED_PROPS_SYMBOL], componentPropDefs.deprecatedProps); - for (const extension of extensions) { - const extensionDefaultProps = getPropsPrototype(extension.constructor); - if (extensionDefaultProps) { - Object.assign(defaultProps5, extensionDefaultProps); - Object.assign(propTypes, extensionDefaultProps[PROP_TYPES_SYMBOL]); - Object.assign(deprecatedProps, extensionDefaultProps[DEPRECATED_PROPS_SYMBOL]); + }; + ZodEnum.create = createZodEnum; + var ZodNativeEnum = class extends ZodType { + _parse(input) { + const nativeEnumValues = util.getValidEnumValues(this._def.values); + const ctx = this._getOrReturnCtx(input); + if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) { + const expectedValues = util.objectValues(nativeEnumValues); + addIssueToContext(ctx, { + expected: util.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode.invalid_type + }); + return INVALID2; + } + if (nativeEnumValues.indexOf(input.data) === -1) { + const expectedValues = util.objectValues(nativeEnumValues); + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_enum_value, + options: expectedValues + }); + return INVALID2; } + return OK(input.data); } - createPropsPrototype(defaultProps5, componentClass); - addAsyncPropsToPropPrototype(defaultProps5, propTypes); - addDeprecatedPropsToPropPrototype(defaultProps5, deprecatedProps); - defaultProps5[PROP_TYPES_SYMBOL] = propTypes; - defaultProps5[DEPRECATED_PROPS_SYMBOL] = deprecatedProps; - if (extensions.length === 0 && !hasOwnProperty(componentClass, "_propTypes")) { - componentClass._propTypes = propTypes; + get enum() { + return this._def.values; } - return defaultProps5; - } - function createPropsPrototype(defaultProps5, componentClass) { - const id = getComponentName(componentClass); - Object.defineProperties(defaultProps5, { - id: { - writable: true, - value: id + }; + ZodNativeEnum.create = (values, params) => { + return new ZodNativeEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodNativeEnum, + ...processCreateParams(params) + }); + }; + var ZodPromise = class extends ZodType { + unwrap() { + return this._def.type; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.promise, + received: ctx.parsedType + }); + return INVALID2; } + const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data); + return OK(promisified.then((data) => { + return this._def.type.parseAsync(data, { + path: ctx.path, + errorMap: ctx.common.contextualErrorMap + }); + })); + } + }; + ZodPromise.create = (schema, params) => { + return new ZodPromise({ + type: schema, + typeName: ZodFirstPartyTypeKind.ZodPromise, + ...processCreateParams(params) }); - } - function addDeprecatedPropsToPropPrototype(defaultProps5, deprecatedProps) { - for (const propName in deprecatedProps) { - Object.defineProperty(defaultProps5, propName, { - enumerable: false, - set(newValue) { - const nameStr = "".concat(this.id, ": ").concat(propName); - for (const newPropName of deprecatedProps[propName]) { - if (!hasOwnProperty(this, newPropName)) { - this[newPropName] = newValue; - } + }; + var ZodEffects = class extends ZodType { + innerType() { + return this._def.schema; + } + sourceType() { + return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const effect = this._def.effect || null; + const checkCtx = { + addIssue: (arg) => { + addIssueToContext(ctx, arg); + if (arg.fatal) { + status.abort(); + } else { + status.dirty(); } - log_default.deprecated(nameStr, deprecatedProps[propName].join("/"))(); + }, + get path() { + return ctx.path; } - }); - } - } - function addAsyncPropsToPropPrototype(defaultProps5, propTypes) { - const defaultValues = {}; - const descriptors = {}; - for (const propName in propTypes) { - const propType = propTypes[propName]; - const { - name, - value - } = propType; - if (propType.async) { - defaultValues[name] = value; - descriptors[name] = getDescriptorForAsyncProp(name); - } - } - defaultProps5[ASYNC_DEFAULTS_SYMBOL] = defaultValues; - defaultProps5[ASYNC_ORIGINAL_SYMBOL] = {}; - Object.defineProperties(defaultProps5, descriptors); - } - function getDescriptorForAsyncProp(name) { - return { - enumerable: true, - set(newValue) { - if (typeof newValue === "string" || newValue instanceof Promise || isAsyncIterable2(newValue)) { - this[ASYNC_ORIGINAL_SYMBOL][name] = newValue; + }; + checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx); + if (effect.type === "preprocess") { + const processed = effect.transform(ctx.data, checkCtx); + if (ctx.common.issues.length) { + return { + status: "dirty", + value: ctx.data + }; + } + if (ctx.common.async) { + return Promise.resolve(processed).then((processed2) => { + return this._def.schema._parseAsync({ + data: processed2, + path: ctx.path, + parent: ctx + }); + }); } else { - this[ASYNC_RESOLVED_SYMBOL][name] = newValue; + return this._def.schema._parseSync({ + data: processed, + path: ctx.path, + parent: ctx + }); } - }, - get() { - if (this[ASYNC_RESOLVED_SYMBOL]) { - if (name in this[ASYNC_RESOLVED_SYMBOL]) { - const value = this[ASYNC_RESOLVED_SYMBOL][name]; - return value || this[ASYNC_DEFAULTS_SYMBOL][name]; + } + if (effect.type === "refinement") { + const executeRefinement = (acc) => { + const result = effect.refinement(acc, checkCtx); + if (ctx.common.async) { + return Promise.resolve(result); } - if (name in this[ASYNC_ORIGINAL_SYMBOL]) { - const state = this[COMPONENT_SYMBOL] && this[COMPONENT_SYMBOL].internalState; - if (state && state.hasAsyncProp(name)) { - return state.getAsyncProp(name) || this[ASYNC_DEFAULTS_SYMBOL][name]; - } + if (result instanceof Promise) { + throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead."); } + return acc; + }; + if (ctx.common.async === false) { + const inner = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inner.status === "aborted") + return INVALID2; + if (inner.status === "dirty") + status.dirty(); + executeRefinement(inner.value); + return { status: status.value, value: inner.value }; + } else { + return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => { + if (inner.status === "aborted") + return INVALID2; + if (inner.status === "dirty") + status.dirty(); + return executeRefinement(inner.value).then(() => { + return { status: status.value, value: inner.value }; + }); + }); } - return this[ASYNC_DEFAULTS_SYMBOL][name]; } - }; - } - function hasOwnProperty(object, prop) { - return Object.prototype.hasOwnProperty.call(object, prop); - } - function getOwnProperty(object, prop) { - return hasOwnProperty(object, prop) && object[prop]; - } - function getComponentName(componentClass) { - const componentName = componentClass.componentName; - if (!componentName) { - log_default.warn("".concat(componentClass.name, ".componentName not specified"))(); + if (effect.type === "transform") { + if (ctx.common.async === false) { + const base = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (!isValid(base)) + return base; + const result = effect.transform(base.value, checkCtx); + if (result instanceof Promise) { + throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`); + } + return { status: status.value, value: result }; + } else { + return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => { + if (!isValid(base)) + return base; + return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result })); + }); + } + } + util.assertNever(effect); } - return componentName || componentClass.name; - } - - // node_modules/@deck.gl/core/dist/esm/lifecycle/component.js - var counter = 0; - var Component = class { - constructor(...propObjects) { - _defineProperty(this, "id", void 0); - _defineProperty(this, "props", void 0); - _defineProperty(this, "count", void 0); - this.props = createProps(this, propObjects); - this.id = this.props.id; - this.count = counter++; + }; + ZodEffects.create = (schema, effect, params) => { + return new ZodEffects({ + schema, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect, + ...processCreateParams(params) + }); + }; + ZodEffects.createWithPreprocess = (preprocess, schema, params) => { + return new ZodEffects({ + schema, + effect: { type: "preprocess", transform: preprocess }, + typeName: ZodFirstPartyTypeKind.ZodEffects, + ...processCreateParams(params) + }); + }; + var ZodOptional = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType === ZodParsedType.undefined) { + return OK(void 0); + } + return this._def.innerType._parse(input); } - clone(newProps) { - const { - props - } = this; - const asyncProps = {}; - for (const key in props[ASYNC_DEFAULTS_SYMBOL]) { - if (key in props[ASYNC_RESOLVED_SYMBOL]) { - asyncProps[key] = props[ASYNC_RESOLVED_SYMBOL][key]; - } else if (key in props[ASYNC_ORIGINAL_SYMBOL]) { - asyncProps[key] = props[ASYNC_ORIGINAL_SYMBOL][key]; - } + unwrap() { + return this._def.innerType; + } + }; + ZodOptional.create = (type, params) => { + return new ZodOptional({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodOptional, + ...processCreateParams(params) + }); + }; + var ZodNullable = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType === ZodParsedType.null) { + return OK(null); } - return new this.constructor({ - ...props, - ...asyncProps, - ...newProps + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } + }; + ZodNullable.create = (type, params) => { + return new ZodNullable({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodNullable, + ...processCreateParams(params) + }); + }; + var ZodDefault = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + let data = ctx.data; + if (ctx.parsedType === ZodParsedType.undefined) { + data = this._def.defaultValue(); + } + return this._def.innerType._parse({ + data, + path: ctx.path, + parent: ctx }); } + removeDefault() { + return this._def.innerType; + } }; - _defineProperty(Component, "componentName", "Component"); - _defineProperty(Component, "defaultProps", {}); - - // node_modules/@deck.gl/core/dist/esm/lifecycle/component-state.js - var EMPTY_PROPS = Object.freeze({}); - var ComponentState = class { - constructor(component) { - _defineProperty(this, "component", void 0); - _defineProperty(this, "onAsyncPropUpdated", void 0); - _defineProperty(this, "asyncProps", void 0); - _defineProperty(this, "oldProps", void 0); - _defineProperty(this, "oldAsyncProps", void 0); - this.component = component; - this.asyncProps = {}; - this.onAsyncPropUpdated = () => { + ZodDefault.create = (type, params) => { + return new ZodDefault({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodDefault, + defaultValue: typeof params.default === "function" ? params.default : () => params.default, + ...processCreateParams(params) + }); + }; + var ZodCatch = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const newCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + } }; - this.oldProps = null; - this.oldAsyncProps = null; + const result = this._def.innerType._parse({ + data: newCtx.data, + path: newCtx.path, + parent: { + ...newCtx + } + }); + if (isAsync(result)) { + return result.then((result2) => { + return { + status: "valid", + value: result2.status === "valid" ? result2.value : this._def.catchValue({ + get error() { + return new ZodError(newCtx.common.issues); + }, + input: newCtx.data + }) + }; + }); + } else { + return { + status: "valid", + value: result.status === "valid" ? result.value : this._def.catchValue({ + get error() { + return new ZodError(newCtx.common.issues); + }, + input: newCtx.data + }) + }; + } } - finalize() { - for (const propName in this.asyncProps) { - const asyncProp = this.asyncProps[propName]; - if (asyncProp && asyncProp.type && asyncProp.type.release) { - asyncProp.type.release(asyncProp.resolvedValue, asyncProp.type, this.component); + removeCatch() { + return this._def.innerType; + } + }; + ZodCatch.create = (type, params) => { + return new ZodCatch({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodCatch, + catchValue: typeof params.catch === "function" ? params.catch : () => params.catch, + ...processCreateParams(params) + }); + }; + var ZodNaN = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.nan) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.nan, + received: ctx.parsedType + }); + return INVALID2; + } + return { status: "valid", value: input.data }; + } + }; + ZodNaN.create = (params) => { + return new ZodNaN({ + typeName: ZodFirstPartyTypeKind.ZodNaN, + ...processCreateParams(params) + }); + }; + var BRAND = Symbol("zod_brand"); + var ZodBranded = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const data = ctx.data; + return this._def.type._parse({ + data, + path: ctx.path, + parent: ctx + }); + } + unwrap() { + return this._def.type; + } + }; + var ZodPipeline = class _ZodPipeline extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.common.async) { + const handleAsync = async () => { + const inResult = await this._def.in._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inResult.status === "aborted") + return INVALID2; + if (inResult.status === "dirty") { + status.dirty(); + return DIRTY(inResult.value); + } else { + return this._def.out._parseAsync({ + data: inResult.value, + path: ctx.path, + parent: ctx + }); + } + }; + return handleAsync(); + } else { + const inResult = this._def.in._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inResult.status === "aborted") + return INVALID2; + if (inResult.status === "dirty") { + status.dirty(); + return { + status: "dirty", + value: inResult.value + }; + } else { + return this._def.out._parseSync({ + data: inResult.value, + path: ctx.path, + parent: ctx + }); + } + } + } + static create(a2, b2) { + return new _ZodPipeline({ + in: a2, + out: b2, + typeName: ZodFirstPartyTypeKind.ZodPipeline + }); + } + }; + var ZodReadonly = class extends ZodType { + _parse(input) { + const result = this._def.innerType._parse(input); + if (isValid(result)) { + result.value = Object.freeze(result.value); + } + return result; + } + }; + ZodReadonly.create = (type, params) => { + return new ZodReadonly({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodReadonly, + ...processCreateParams(params) + }); + }; + var late = { + object: ZodObject.lazycreate + }; + var ZodFirstPartyTypeKind; + (function(ZodFirstPartyTypeKind2) { + ZodFirstPartyTypeKind2["ZodString"] = "ZodString"; + ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber"; + ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN"; + ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt"; + ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean"; + ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate"; + ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol"; + ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined"; + ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull"; + ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny"; + ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown"; + ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever"; + ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid"; + ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray"; + ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject"; + ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion"; + ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion"; + ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection"; + ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple"; + ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord"; + ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap"; + ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet"; + ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction"; + ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy"; + ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral"; + ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum"; + ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects"; + ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum"; + ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional"; + ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable"; + ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault"; + ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch"; + ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise"; + ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded"; + ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline"; + ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly"; + })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {})); + var stringType = ZodString.create; + var numberType = ZodNumber.create; + var nanType = ZodNaN.create; + var bigIntType = ZodBigInt.create; + var booleanType = ZodBoolean.create; + var dateType = ZodDate.create; + var symbolType = ZodSymbol.create; + var undefinedType = ZodUndefined.create; + var nullType = ZodNull.create; + var anyType = ZodAny.create; + var unknownType = ZodUnknown.create; + var neverType = ZodNever.create; + var voidType = ZodVoid.create; + var arrayType = ZodArray.create; + var objectType = ZodObject.create; + var strictObjectType = ZodObject.strictCreate; + var unionType = ZodUnion.create; + var discriminatedUnionType = ZodDiscriminatedUnion.create; + var intersectionType = ZodIntersection.create; + var tupleType = ZodTuple.create; + var recordType = ZodRecord.create; + var mapType = ZodMap.create; + var setType = ZodSet.create; + var functionType = ZodFunction.create; + var lazyType = ZodLazy.create; + var literalType = ZodLiteral.create; + var enumType = ZodEnum.create; + var nativeEnumType = ZodNativeEnum.create; + var promiseType = ZodPromise.create; + var effectsType = ZodEffects.create; + var optionalType = ZodOptional.create; + var nullableType = ZodNullable.create; + var preprocessType = ZodEffects.createWithPreprocess; + var pipelineType = ZodPipeline.create; + var coerce = { + string: (arg) => ZodString.create({ ...arg, coerce: true }), + number: (arg) => ZodNumber.create({ ...arg, coerce: true }), + boolean: (arg) => ZodBoolean.create({ + ...arg, + coerce: true + }), + bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }), + date: (arg) => ZodDate.create({ ...arg, coerce: true }) + }; + + // node_modules/zarr/core.mjs + var registry2 = /* @__PURE__ */ new Map(); + function addCodec(id, importFn) { + registry2.set(id, importFn); + } + var IS_NODE = typeof process !== "undefined" && process.versions && process.versions.node; + var Float16Array = globalThis.Float16Array; + var eventemitter3 = { exports: {} }; + (function(module) { + var has = Object.prototype.hasOwnProperty, prefix = "~"; + function Events() { + } + if (Object.create) { + Events.prototype = /* @__PURE__ */ Object.create(null); + if (!new Events().__proto__) + prefix = false; + } + function EE(fn, context, once) { + this.fn = fn; + this.context = context; + this.once = once || false; + } + function addListener(emitter, event, fn, context, once) { + if (typeof fn !== "function") { + throw new TypeError("The listener must be a function"); + } + var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event; + if (!emitter._events[evt]) + emitter._events[evt] = listener, emitter._eventsCount++; + else if (!emitter._events[evt].fn) + emitter._events[evt].push(listener); + else + emitter._events[evt] = [emitter._events[evt], listener]; + return emitter; + } + function clearEvent(emitter, evt) { + if (--emitter._eventsCount === 0) + emitter._events = new Events(); + else + delete emitter._events[evt]; + } + function EventEmitter2() { + this._events = new Events(); + this._eventsCount = 0; + } + EventEmitter2.prototype.eventNames = function eventNames() { + var names = [], events, name; + if (this._eventsCount === 0) + return names; + for (name in events = this._events) { + if (has.call(events, name)) + names.push(prefix ? name.slice(1) : name); + } + if (Object.getOwnPropertySymbols) { + return names.concat(Object.getOwnPropertySymbols(events)); + } + return names; + }; + EventEmitter2.prototype.listeners = function listeners(event) { + var evt = prefix ? prefix + event : event, handlers = this._events[evt]; + if (!handlers) + return []; + if (handlers.fn) + return [handlers.fn]; + for (var i3 = 0, l2 = handlers.length, ee = new Array(l2); i3 < l2; i3++) { + ee[i3] = handlers[i3].fn; + } + return ee; + }; + EventEmitter2.prototype.listenerCount = function listenerCount(event) { + var evt = prefix ? prefix + event : event, listeners = this._events[evt]; + if (!listeners) + return 0; + if (listeners.fn) + return 1; + return listeners.length; + }; + EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) { + var evt = prefix ? prefix + event : event; + if (!this._events[evt]) + return false; + var listeners = this._events[evt], len2 = arguments.length, args, i3; + if (listeners.fn) { + if (listeners.once) + this.removeListener(event, listeners.fn, void 0, true); + switch (len2) { + case 1: + return listeners.fn.call(listeners.context), true; + case 2: + return listeners.fn.call(listeners.context, a1), true; + case 3: + return listeners.fn.call(listeners.context, a1, a2), true; + case 4: + return listeners.fn.call(listeners.context, a1, a2, a3), true; + case 5: + return listeners.fn.call(listeners.context, a1, a2, a3, a4), true; + case 6: + return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true; + } + for (i3 = 1, args = new Array(len2 - 1); i3 < len2; i3++) { + args[i3 - 1] = arguments[i3]; + } + listeners.fn.apply(listeners.context, args); + } else { + var length4 = listeners.length, j; + for (i3 = 0; i3 < length4; i3++) { + if (listeners[i3].once) + this.removeListener(event, listeners[i3].fn, void 0, true); + switch (len2) { + case 1: + listeners[i3].fn.call(listeners[i3].context); + break; + case 2: + listeners[i3].fn.call(listeners[i3].context, a1); + break; + case 3: + listeners[i3].fn.call(listeners[i3].context, a1, a2); + break; + case 4: + listeners[i3].fn.call(listeners[i3].context, a1, a2, a3); + break; + default: + if (!args) + for (j = 1, args = new Array(len2 - 1); j < len2; j++) { + args[j - 1] = arguments[j]; + } + listeners[i3].fn.apply(listeners[i3].context, args); + } + } + } + return true; + }; + EventEmitter2.prototype.on = function on(event, fn, context) { + return addListener(this, event, fn, context, false); + }; + EventEmitter2.prototype.once = function once(event, fn, context) { + return addListener(this, event, fn, context, true); + }; + EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) { + var evt = prefix ? prefix + event : event; + if (!this._events[evt]) + return this; + if (!fn) { + clearEvent(this, evt); + return this; + } + var listeners = this._events[evt]; + if (listeners.fn) { + if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) { + clearEvent(this, evt); + } + } else { + for (var i3 = 0, events = [], length4 = listeners.length; i3 < length4; i3++) { + if (listeners[i3].fn !== fn || once && !listeners[i3].once || context && listeners[i3].context !== context) { + events.push(listeners[i3]); + } } + if (events.length) + this._events[evt] = events.length === 1 ? events[0] : events; + else + clearEvent(this, evt); + } + return this; + }; + EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) { + var evt; + if (event) { + evt = prefix ? prefix + event : event; + if (this._events[evt]) + clearEvent(this, evt); + } else { + this._events = new Events(); + this._eventsCount = 0; } - this.asyncProps = {}; - this.component = null; - this.resetOldProps(); - } - getOldProps() { - return this.oldAsyncProps || this.oldProps || EMPTY_PROPS; - } - resetOldProps() { - this.oldAsyncProps = null; - this.oldProps = this.component ? this.component.props : null; + return this; + }; + EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener; + EventEmitter2.prototype.addListener = EventEmitter2.prototype.on; + EventEmitter2.prefixed = prefix; + EventEmitter2.EventEmitter = EventEmitter2; + { + module.exports = EventEmitter2; + } + })(eventemitter3); + var EventEmitter = eventemitter3.exports; + var TimeoutError = class extends Error { + constructor(message) { + super(message); + this.name = "TimeoutError"; } - hasAsyncProp(propName) { - return propName in this.asyncProps; + }; + var timeoutError = new TimeoutError(); + var HTTPMethod; + (function(HTTPMethod2) { + HTTPMethod2["HEAD"] = "HEAD"; + HTTPMethod2["GET"] = "GET"; + HTTPMethod2["PUT"] = "PUT"; + })(HTTPMethod || (HTTPMethod = {})); + var DEFAULT_METHODS = [HTTPMethod.HEAD, HTTPMethod.GET, HTTPMethod.PUT]; + + // node_modules/zarr/zarr.mjs + var Z_FIXED2 = 4; + var Z_BINARY2 = 0; + var Z_TEXT2 = 1; + var Z_UNKNOWN2 = 2; + function zero2(buf) { + let len2 = buf.length; + while (--len2 >= 0) { + buf[len2] = 0; + } + } + var STORED_BLOCK2 = 0; + var STATIC_TREES2 = 1; + var DYN_TREES2 = 2; + var MIN_MATCH2 = 3; + var MAX_MATCH2 = 258; + var LENGTH_CODES2 = 29; + var LITERALS2 = 256; + var L_CODES2 = LITERALS2 + 1 + LENGTH_CODES2; + var D_CODES2 = 30; + var BL_CODES2 = 19; + var HEAP_SIZE2 = 2 * L_CODES2 + 1; + var MAX_BITS2 = 15; + var Buf_size2 = 16; + var MAX_BL_BITS2 = 7; + var END_BLOCK2 = 256; + var REP_3_62 = 16; + var REPZ_3_102 = 17; + var REPZ_11_1382 = 18; + var extra_lbits2 = ( + /* extra bits for each length code */ + new Uint8Array([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]) + ); + var extra_dbits2 = ( + /* extra bits for each distance code */ + new Uint8Array([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]) + ); + var extra_blbits2 = ( + /* extra bits for each bit length code */ + new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]) + ); + var bl_order2 = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]); + var DIST_CODE_LEN2 = 512; + var static_ltree2 = new Array((L_CODES2 + 2) * 2); + zero2(static_ltree2); + var static_dtree2 = new Array(D_CODES2 * 2); + zero2(static_dtree2); + var _dist_code2 = new Array(DIST_CODE_LEN2); + zero2(_dist_code2); + var _length_code2 = new Array(MAX_MATCH2 - MIN_MATCH2 + 1); + zero2(_length_code2); + var base_length2 = new Array(LENGTH_CODES2); + zero2(base_length2); + var base_dist2 = new Array(D_CODES2); + zero2(base_dist2); + function StaticTreeDesc2(static_tree, extra_bits, extra_base, elems, max_length) { + this.static_tree = static_tree; + this.extra_bits = extra_bits; + this.extra_base = extra_base; + this.elems = elems; + this.max_length = max_length; + this.has_stree = static_tree && static_tree.length; + } + var static_l_desc2; + var static_d_desc2; + var static_bl_desc2; + function TreeDesc2(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; + this.max_code = 0; + this.stat_desc = stat_desc; + } + var d_code2 = (dist) => { + return dist < 256 ? _dist_code2[dist] : _dist_code2[256 + (dist >>> 7)]; + }; + var put_short2 = (s, w3) => { + s.pending_buf[s.pending++] = w3 & 255; + s.pending_buf[s.pending++] = w3 >>> 8 & 255; + }; + var send_bits2 = (s, value, length4) => { + if (s.bi_valid > Buf_size2 - length4) { + s.bi_buf |= value << s.bi_valid & 65535; + put_short2(s, s.bi_buf); + s.bi_buf = value >> Buf_size2 - s.bi_valid; + s.bi_valid += length4 - Buf_size2; + } else { + s.bi_buf |= value << s.bi_valid & 65535; + s.bi_valid += length4; } - getAsyncProp(propName) { - const asyncProp = this.asyncProps[propName]; - return asyncProp && asyncProp.resolvedValue; + }; + var send_code2 = (s, c2, tree) => { + send_bits2( + s, + tree[c2 * 2], + tree[c2 * 2 + 1] + /*.Len*/ + ); + }; + var bi_reverse2 = (code, len2) => { + let res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len2 > 0); + return res >>> 1; + }; + var bi_flush2 = (s) => { + if (s.bi_valid === 16) { + put_short2(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 255; + s.bi_buf >>= 8; + s.bi_valid -= 8; } - isAsyncPropLoading(propName) { - if (propName) { - const asyncProp = this.asyncProps[propName]; - return Boolean(asyncProp && asyncProp.pendingLoadCount > 0 && asyncProp.pendingLoadCount !== asyncProp.resolvedLoadCount); + }; + var gen_bitlen2 = (s, desc) => { + const tree = desc.dyn_tree; + const max_code = desc.max_code; + const stree = desc.stat_desc.static_tree; + const has_stree = desc.stat_desc.has_stree; + const extra = desc.stat_desc.extra_bits; + const base = desc.stat_desc.extra_base; + const max_length = desc.stat_desc.max_length; + let h; + let n2, m; + let bits; + let xbits; + let f2; + let overflow = 0; + for (bits = 0; bits <= MAX_BITS2; bits++) { + s.bl_count[bits] = 0; + } + tree[s.heap[s.heap_max] * 2 + 1] = 0; + for (h = s.heap_max + 1; h < HEAP_SIZE2; h++) { + n2 = s.heap[h]; + bits = tree[tree[n2 * 2 + 1] * 2 + 1] + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n2 * 2 + 1] = bits; + if (n2 > max_code) { + continue; } - for (const key in this.asyncProps) { - if (this.isAsyncPropLoading(key)) { - return true; - } + s.bl_count[bits]++; + xbits = 0; + if (n2 >= base) { + xbits = extra[n2 - base]; + } + f2 = tree[n2 * 2]; + s.opt_len += f2 * (bits + xbits); + if (has_stree) { + s.static_len += f2 * (stree[n2 * 2 + 1] + xbits); } - return false; } - reloadAsyncProp(propName, value) { - this._watchPromise(propName, Promise.resolve(value)); + if (overflow === 0) { + return; } - setAsyncProps(props) { - this.component = props[COMPONENT_SYMBOL] || this.component; - const resolvedValues = props[ASYNC_RESOLVED_SYMBOL] || {}; - const originalValues = props[ASYNC_ORIGINAL_SYMBOL] || props; - const defaultValues = props[ASYNC_DEFAULTS_SYMBOL] || {}; - for (const propName in resolvedValues) { - const value = resolvedValues[propName]; - this._createAsyncPropData(propName, defaultValues[propName]); - this._updateAsyncProp(propName, value); - resolvedValues[propName] = this.getAsyncProp(propName); + do { + bits = max_length - 1; + while (s.bl_count[bits] === 0) { + bits--; + } + s.bl_count[bits]--; + s.bl_count[bits + 1] += 2; + s.bl_count[max_length]--; + overflow -= 2; + } while (overflow > 0); + for (bits = max_length; bits !== 0; bits--) { + n2 = s.bl_count[bits]; + while (n2 !== 0) { + m = s.heap[--h]; + if (m > max_code) { + continue; + } + if (tree[m * 2 + 1] !== bits) { + s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2]; + tree[m * 2 + 1] = bits; + } + n2--; } - for (const propName in originalValues) { - const value = originalValues[propName]; - this._createAsyncPropData(propName, defaultValues[propName]); - this._updateAsyncProp(propName, value); + } + }; + var gen_codes2 = (tree, max_code, bl_count) => { + const next_code = new Array(MAX_BITS2 + 1); + let code = 0; + let bits; + let n2; + for (bits = 1; bits <= MAX_BITS2; bits++) { + next_code[bits] = code = code + bl_count[bits - 1] << 1; + } + for (n2 = 0; n2 <= max_code; n2++) { + let len2 = tree[n2 * 2 + 1]; + if (len2 === 0) { + continue; } + tree[n2 * 2] = bi_reverse2(next_code[len2]++, len2); } - _fetch(propName, url) { - return null; + }; + var tr_static_init2 = () => { + let n2; + let bits; + let length4; + let code; + let dist; + const bl_count = new Array(MAX_BITS2 + 1); + length4 = 0; + for (code = 0; code < LENGTH_CODES2 - 1; code++) { + base_length2[code] = length4; + for (n2 = 0; n2 < 1 << extra_lbits2[code]; n2++) { + _length_code2[length4++] = code; + } + } + _length_code2[length4 - 1] = code; + dist = 0; + for (code = 0; code < 16; code++) { + base_dist2[code] = dist; + for (n2 = 0; n2 < 1 << extra_dbits2[code]; n2++) { + _dist_code2[dist++] = code; + } + } + dist >>= 7; + for (; code < D_CODES2; code++) { + base_dist2[code] = dist << 7; + for (n2 = 0; n2 < 1 << extra_dbits2[code] - 7; n2++) { + _dist_code2[256 + dist++] = code; + } + } + for (bits = 0; bits <= MAX_BITS2; bits++) { + bl_count[bits] = 0; + } + n2 = 0; + while (n2 <= 143) { + static_ltree2[n2 * 2 + 1] = 8; + n2++; + bl_count[8]++; + } + while (n2 <= 255) { + static_ltree2[n2 * 2 + 1] = 9; + n2++; + bl_count[9]++; + } + while (n2 <= 279) { + static_ltree2[n2 * 2 + 1] = 7; + n2++; + bl_count[7]++; + } + while (n2 <= 287) { + static_ltree2[n2 * 2 + 1] = 8; + n2++; + bl_count[8]++; + } + gen_codes2(static_ltree2, L_CODES2 + 1, bl_count); + for (n2 = 0; n2 < D_CODES2; n2++) { + static_dtree2[n2 * 2 + 1] = 5; + static_dtree2[n2 * 2] = bi_reverse2(n2, 5); + } + static_l_desc2 = new StaticTreeDesc2(static_ltree2, extra_lbits2, LITERALS2 + 1, L_CODES2, MAX_BITS2); + static_d_desc2 = new StaticTreeDesc2(static_dtree2, extra_dbits2, 0, D_CODES2, MAX_BITS2); + static_bl_desc2 = new StaticTreeDesc2(new Array(0), extra_blbits2, 0, BL_CODES2, MAX_BL_BITS2); + }; + var init_block2 = (s) => { + let n2; + for (n2 = 0; n2 < L_CODES2; n2++) { + s.dyn_ltree[n2 * 2] = 0; } - _onResolve(propName, value) { + for (n2 = 0; n2 < D_CODES2; n2++) { + s.dyn_dtree[n2 * 2] = 0; } - _onError(propName, error2) { + for (n2 = 0; n2 < BL_CODES2; n2++) { + s.bl_tree[n2 * 2] = 0; } - _updateAsyncProp(propName, value) { - if (!this._didAsyncInputValueChange(propName, value)) { - return; - } - if (typeof value === "string") { - value = this._fetch(propName, value); + s.dyn_ltree[END_BLOCK2 * 2] = 1; + s.opt_len = s.static_len = 0; + s.last_lit = s.matches = 0; + }; + var bi_windup2 = (s) => { + if (s.bi_valid > 8) { + put_short2(s, s.bi_buf); + } else if (s.bi_valid > 0) { + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; + }; + var copy_block = (s, buf, len2, header) => { + bi_windup2(s); + if (header) { + put_short2(s, len2); + put_short2(s, ~len2); + } + s.pending_buf.set(s.window.subarray(buf, buf + len2), s.pending); + s.pending += len2; + }; + var smaller2 = (tree, n2, m, depth) => { + const _n2 = n2 * 2; + const _m2 = m * 2; + return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n2] <= depth[m]; + }; + var pqdownheap2 = (s, tree, k) => { + const v2 = s.heap[k]; + let j = k << 1; + while (j <= s.heap_len) { + if (j < s.heap_len && smaller2(tree, s.heap[j + 1], s.heap[j], s.depth)) { + j++; + } + if (smaller2(tree, v2, s.heap[j], s.depth)) { + break; } - if (value instanceof Promise) { - this._watchPromise(propName, value); - return; + s.heap[k] = s.heap[j]; + k = j; + j <<= 1; + } + s.heap[k] = v2; + }; + var compress_block2 = (s, ltree, dtree) => { + let dist; + let lc; + let lx = 0; + let code; + let extra; + if (s.last_lit !== 0) { + do { + dist = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1]; + lc = s.pending_buf[s.l_buf + lx]; + lx++; + if (dist === 0) { + send_code2(s, lc, ltree); + } else { + code = _length_code2[lc]; + send_code2(s, code + LITERALS2 + 1, ltree); + extra = extra_lbits2[code]; + if (extra !== 0) { + lc -= base_length2[code]; + send_bits2(s, lc, extra); + } + dist--; + code = d_code2(dist); + send_code2(s, code, dtree); + extra = extra_dbits2[code]; + if (extra !== 0) { + dist -= base_dist2[code]; + send_bits2(s, dist, extra); + } + } + } while (lx < s.last_lit); + } + send_code2(s, END_BLOCK2, ltree); + }; + var build_tree2 = (s, desc) => { + const tree = desc.dyn_tree; + const stree = desc.stat_desc.static_tree; + const has_stree = desc.stat_desc.has_stree; + const elems = desc.stat_desc.elems; + let n2, m; + let max_code = -1; + let node; + s.heap_len = 0; + s.heap_max = HEAP_SIZE2; + for (n2 = 0; n2 < elems; n2++) { + if (tree[n2 * 2] !== 0) { + s.heap[++s.heap_len] = max_code = n2; + s.depth[n2] = 0; + } else { + tree[n2 * 2 + 1] = 0; + } + } + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0; + tree[node * 2] = 1; + s.depth[node] = 0; + s.opt_len--; + if (has_stree) { + s.static_len -= stree[node * 2 + 1]; + } + } + desc.max_code = max_code; + for (n2 = s.heap_len >> 1; n2 >= 1; n2--) { + pqdownheap2(s, tree, n2); + } + node = elems; + do { + n2 = s.heap[ + 1 + /*SMALLEST*/ + ]; + s.heap[ + 1 + /*SMALLEST*/ + ] = s.heap[s.heap_len--]; + pqdownheap2( + s, + tree, + 1 + /*SMALLEST*/ + ); + m = s.heap[ + 1 + /*SMALLEST*/ + ]; + s.heap[--s.heap_max] = n2; + s.heap[--s.heap_max] = m; + tree[node * 2] = tree[n2 * 2] + tree[m * 2]; + s.depth[node] = (s.depth[n2] >= s.depth[m] ? s.depth[n2] : s.depth[m]) + 1; + tree[n2 * 2 + 1] = tree[m * 2 + 1] = node; + s.heap[ + 1 + /*SMALLEST*/ + ] = node++; + pqdownheap2( + s, + tree, + 1 + /*SMALLEST*/ + ); + } while (s.heap_len >= 2); + s.heap[--s.heap_max] = s.heap[ + 1 + /*SMALLEST*/ + ]; + gen_bitlen2(s, desc); + gen_codes2(tree, max_code, s.bl_count); + }; + var scan_tree2 = (s, tree, max_code) => { + let n2; + let prevlen = -1; + let curlen; + let nextlen = tree[0 * 2 + 1]; + let count2 = 0; + let max_count = 7; + let min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code + 1) * 2 + 1] = 65535; + for (n2 = 0; n2 <= max_code; n2++) { + curlen = nextlen; + nextlen = tree[(n2 + 1) * 2 + 1]; + if (++count2 < max_count && curlen === nextlen) { + continue; + } else if (count2 < min_count) { + s.bl_tree[curlen * 2] += count2; + } else if (curlen !== 0) { + if (curlen !== prevlen) { + s.bl_tree[curlen * 2]++; + } + s.bl_tree[REP_3_62 * 2]++; + } else if (count2 <= 10) { + s.bl_tree[REPZ_3_102 * 2]++; + } else { + s.bl_tree[REPZ_11_1382 * 2]++; + } + count2 = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; } - if (isAsyncIterable2(value)) { - this._resolveAsyncIterable(propName, value); - return; + } + }; + var send_tree2 = (s, tree, max_code) => { + let n2; + let prevlen = -1; + let curlen; + let nextlen = tree[0 * 2 + 1]; + let count2 = 0; + let max_count = 7; + let min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + for (n2 = 0; n2 <= max_code; n2++) { + curlen = nextlen; + nextlen = tree[(n2 + 1) * 2 + 1]; + if (++count2 < max_count && curlen === nextlen) { + continue; + } else if (count2 < min_count) { + do { + send_code2(s, curlen, s.bl_tree); + } while (--count2 !== 0); + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code2(s, curlen, s.bl_tree); + count2--; + } + send_code2(s, REP_3_62, s.bl_tree); + send_bits2(s, count2 - 3, 2); + } else if (count2 <= 10) { + send_code2(s, REPZ_3_102, s.bl_tree); + send_bits2(s, count2 - 3, 3); + } else { + send_code2(s, REPZ_11_1382, s.bl_tree); + send_bits2(s, count2 - 11, 7); + } + count2 = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; } - this._setPropValue(propName, value); } - _freezeAsyncOldProps() { - if (!this.oldAsyncProps && this.oldProps) { - this.oldAsyncProps = Object.create(this.oldProps); - for (const propName in this.asyncProps) { - Object.defineProperty(this.oldAsyncProps, propName, { - enumerable: true, - value: this.oldProps[propName] - }); - } + }; + var build_bl_tree2 = (s) => { + let max_blindex; + scan_tree2(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree2(s, s.dyn_dtree, s.d_desc.max_code); + build_tree2(s, s.bl_desc); + for (max_blindex = BL_CODES2 - 1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order2[max_blindex] * 2 + 1] !== 0) { + break; } } - _didAsyncInputValueChange(propName, value) { - const asyncProp = this.asyncProps[propName]; - if (value === asyncProp.resolvedValue || value === asyncProp.lastValue) { - return false; + s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + return max_blindex; + }; + var send_all_trees2 = (s, lcodes, dcodes, blcodes) => { + let rank3; + send_bits2(s, lcodes - 257, 5); + send_bits2(s, dcodes - 1, 5); + send_bits2(s, blcodes - 4, 4); + for (rank3 = 0; rank3 < blcodes; rank3++) { + send_bits2(s, s.bl_tree[bl_order2[rank3] * 2 + 1], 3); + } + send_tree2(s, s.dyn_ltree, lcodes - 1); + send_tree2(s, s.dyn_dtree, dcodes - 1); + }; + var detect_data_type2 = (s) => { + let black_mask = 4093624447; + let n2; + for (n2 = 0; n2 <= 31; n2++, black_mask >>>= 1) { + if (black_mask & 1 && s.dyn_ltree[n2 * 2] !== 0) { + return Z_BINARY2; } - asyncProp.lastValue = value; - return true; } - _setPropValue(propName, value) { - this._freezeAsyncOldProps(); - const asyncProp = this.asyncProps[propName]; - if (asyncProp) { - value = this._postProcessValue(asyncProp, value); - asyncProp.resolvedValue = value; - asyncProp.pendingLoadCount++; - asyncProp.resolvedLoadCount = asyncProp.pendingLoadCount; + if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 || s.dyn_ltree[13 * 2] !== 0) { + return Z_TEXT2; + } + for (n2 = 32; n2 < LITERALS2; n2++) { + if (s.dyn_ltree[n2 * 2] !== 0) { + return Z_TEXT2; } } - _setAsyncPropValue(propName, value, loadCount) { - const asyncProp = this.asyncProps[propName]; - if (asyncProp && loadCount >= asyncProp.resolvedLoadCount && value !== void 0) { - this._freezeAsyncOldProps(); - asyncProp.resolvedValue = value; - asyncProp.resolvedLoadCount = loadCount; - this.onAsyncPropUpdated(propName, value); + return Z_BINARY2; + }; + var static_init_done2 = false; + var _tr_init2 = (s) => { + if (!static_init_done2) { + tr_static_init2(); + static_init_done2 = true; + } + s.l_desc = new TreeDesc2(s.dyn_ltree, static_l_desc2); + s.d_desc = new TreeDesc2(s.dyn_dtree, static_d_desc2); + s.bl_desc = new TreeDesc2(s.bl_tree, static_bl_desc2); + s.bi_buf = 0; + s.bi_valid = 0; + init_block2(s); + }; + var _tr_stored_block2 = (s, buf, stored_len, last) => { + send_bits2(s, (STORED_BLOCK2 << 1) + (last ? 1 : 0), 3); + copy_block(s, buf, stored_len, true); + }; + var _tr_align2 = (s) => { + send_bits2(s, STATIC_TREES2 << 1, 3); + send_code2(s, END_BLOCK2, static_ltree2); + bi_flush2(s); + }; + var _tr_flush_block2 = (s, buf, stored_len, last) => { + let opt_lenb, static_lenb; + let max_blindex = 0; + if (s.level > 0) { + if (s.strm.data_type === Z_UNKNOWN2) { + s.strm.data_type = detect_data_type2(s); + } + build_tree2(s, s.l_desc); + build_tree2(s, s.d_desc); + max_blindex = build_bl_tree2(s); + opt_lenb = s.opt_len + 3 + 7 >>> 3; + static_lenb = s.static_len + 3 + 7 >>> 3; + if (static_lenb <= opt_lenb) { + opt_lenb = static_lenb; } + } else { + opt_lenb = static_lenb = stored_len + 5; } - _watchPromise(propName, promise) { - const asyncProp = this.asyncProps[propName]; - if (asyncProp) { - asyncProp.pendingLoadCount++; - const loadCount = asyncProp.pendingLoadCount; - promise.then((data) => { - if (!this.component) { - return; - } - data = this._postProcessValue(asyncProp, data); - this._setAsyncPropValue(propName, data, loadCount); - this._onResolve(propName, data); - }).catch((error2) => { - this._onError(propName, error2); - }); + if (stored_len + 4 <= opt_lenb && buf !== -1) { + _tr_stored_block2(s, buf, stored_len, last); + } else if (s.strategy === Z_FIXED2 || static_lenb === opt_lenb) { + send_bits2(s, (STATIC_TREES2 << 1) + (last ? 1 : 0), 3); + compress_block2(s, static_ltree2, static_dtree2); + } else { + send_bits2(s, (DYN_TREES2 << 1) + (last ? 1 : 0), 3); + send_all_trees2(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1); + compress_block2(s, s.dyn_ltree, s.dyn_dtree); + } + init_block2(s); + if (last) { + bi_windup2(s); + } + }; + var _tr_tally2 = (s, dist, lc) => { + s.pending_buf[s.d_buf + s.last_lit * 2] = dist >>> 8 & 255; + s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 255; + s.pending_buf[s.l_buf + s.last_lit] = lc & 255; + s.last_lit++; + if (dist === 0) { + s.dyn_ltree[lc * 2]++; + } else { + s.matches++; + dist--; + s.dyn_ltree[(_length_code2[lc] + LITERALS2 + 1) * 2]++; + s.dyn_dtree[d_code2(dist) * 2]++; + } + return s.last_lit === s.lit_bufsize - 1; + }; + var _tr_init_12 = _tr_init2; + var _tr_stored_block_12 = _tr_stored_block2; + var _tr_flush_block_12 = _tr_flush_block2; + var _tr_tally_12 = _tr_tally2; + var _tr_align_12 = _tr_align2; + var trees2 = { + _tr_init: _tr_init_12, + _tr_stored_block: _tr_stored_block_12, + _tr_flush_block: _tr_flush_block_12, + _tr_tally: _tr_tally_12, + _tr_align: _tr_align_12 + }; + var adler322 = (adler, buf, len2, pos) => { + let s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n2 = 0; + while (len2 !== 0) { + n2 = len2 > 2e3 ? 2e3 : len2; + len2 -= n2; + do { + s1 = s1 + buf[pos++] | 0; + s2 = s2 + s1 | 0; + } while (--n2); + s1 %= 65521; + s2 %= 65521; + } + return s1 | s2 << 16 | 0; + }; + var adler32_12 = adler322; + var makeTable2 = () => { + let c2, table = []; + for (var n2 = 0; n2 < 256; n2++) { + c2 = n2; + for (var k = 0; k < 8; k++) { + c2 = c2 & 1 ? 3988292384 ^ c2 >>> 1 : c2 >>> 1; } + table[n2] = c2; } - async _resolveAsyncIterable(propName, iterable) { - if (propName !== "data") { - this._setPropValue(propName, iterable); - return; + return table; + }; + var crcTable2 = new Uint32Array(makeTable2()); + var crc322 = (crc, buf, len2, pos) => { + const t2 = crcTable2; + const end = pos + len2; + crc ^= -1; + for (let i3 = pos; i3 < end; i3++) { + crc = crc >>> 8 ^ t2[(crc ^ buf[i3]) & 255]; + } + return crc ^ -1; + }; + var crc32_12 = crc322; + var messages2 = { + 2: "need dictionary", + /* Z_NEED_DICT 2 */ + 1: "stream end", + /* Z_STREAM_END 1 */ + 0: "", + /* Z_OK 0 */ + "-1": "file error", + /* Z_ERRNO (-1) */ + "-2": "stream error", + /* Z_STREAM_ERROR (-2) */ + "-3": "data error", + /* Z_DATA_ERROR (-3) */ + "-4": "insufficient memory", + /* Z_MEM_ERROR (-4) */ + "-5": "buffer error", + /* Z_BUF_ERROR (-5) */ + "-6": "incompatible version" + /* Z_VERSION_ERROR (-6) */ + }; + var constants2 = { + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + /* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + //Z_VERSION_ERROR: -6, + /* compression levels */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + /* Possible values of the data_type field (though see inflate()) */ + Z_BINARY: 0, + Z_TEXT: 1, + //Z_ASCII: 1, // = Z_TEXT (deprecated) + Z_UNKNOWN: 2, + /* The deflate compression method */ + Z_DEFLATED: 8 + //Z_NULL: null // Use -1 or null inline, depending on var type + }; + var { _tr_init: _tr_init$12, _tr_stored_block: _tr_stored_block$12, _tr_flush_block: _tr_flush_block$12, _tr_tally: _tr_tally$12, _tr_align: _tr_align$12 } = trees2; + var { + Z_NO_FLUSH: Z_NO_FLUSH2, + Z_PARTIAL_FLUSH: Z_PARTIAL_FLUSH2, + Z_FULL_FLUSH: Z_FULL_FLUSH2, + Z_FINISH: Z_FINISH2, + Z_BLOCK: Z_BLOCK2, + Z_OK: Z_OK2, + Z_STREAM_END: Z_STREAM_END2, + Z_STREAM_ERROR: Z_STREAM_ERROR2, + Z_DATA_ERROR: Z_DATA_ERROR2, + Z_BUF_ERROR: Z_BUF_ERROR2, + Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION2, + Z_FILTERED: Z_FILTERED2, + Z_HUFFMAN_ONLY: Z_HUFFMAN_ONLY2, + Z_RLE: Z_RLE2, + Z_FIXED: Z_FIXED$12, + Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY2, + Z_UNKNOWN: Z_UNKNOWN$12, + Z_DEFLATED: Z_DEFLATED2 + } = constants2; + var MAX_MEM_LEVEL2 = 9; + var MAX_WBITS2 = 15; + var DEF_MEM_LEVEL2 = 8; + var LENGTH_CODES$12 = 29; + var LITERALS$12 = 256; + var L_CODES$12 = LITERALS$12 + 1 + LENGTH_CODES$12; + var D_CODES$12 = 30; + var BL_CODES$12 = 19; + var HEAP_SIZE$12 = 2 * L_CODES$12 + 1; + var MAX_BITS$12 = 15; + var MIN_MATCH$12 = 3; + var MAX_MATCH$12 = 258; + var MIN_LOOKAHEAD2 = MAX_MATCH$12 + MIN_MATCH$12 + 1; + var PRESET_DICT2 = 32; + var INIT_STATE2 = 42; + var EXTRA_STATE2 = 69; + var NAME_STATE2 = 73; + var COMMENT_STATE2 = 91; + var HCRC_STATE2 = 103; + var BUSY_STATE2 = 113; + var FINISH_STATE2 = 666; + var BS_NEED_MORE2 = 1; + var BS_BLOCK_DONE2 = 2; + var BS_FINISH_STARTED2 = 3; + var BS_FINISH_DONE2 = 4; + var OS_CODE2 = 3; + var err2 = (strm, errorCode) => { + strm.msg = messages2[errorCode]; + return errorCode; + }; + var rank2 = (f2) => { + return (f2 << 1) - (f2 > 4 ? 9 : 0); + }; + var zero$12 = (buf) => { + let len2 = buf.length; + while (--len2 >= 0) { + buf[len2] = 0; + } + }; + var HASH_ZLIB2 = (s, prev, data) => (prev << s.hash_shift ^ data) & s.hash_mask; + var HASH2 = HASH_ZLIB2; + var flush_pending2 = (strm) => { + const s = strm.state; + let len2 = s.pending; + if (len2 > strm.avail_out) { + len2 = strm.avail_out; + } + if (len2 === 0) { + return; + } + strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len2), strm.next_out); + strm.next_out += len2; + s.pending_out += len2; + strm.total_out += len2; + strm.avail_out -= len2; + s.pending -= len2; + if (s.pending === 0) { + s.pending_out = 0; + } + }; + var flush_block_only2 = (s, last) => { + _tr_flush_block$12(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last); + s.block_start = s.strstart; + flush_pending2(s.strm); + }; + var put_byte2 = (s, b2) => { + s.pending_buf[s.pending++] = b2; + }; + var putShortMSB2 = (s, b2) => { + s.pending_buf[s.pending++] = b2 >>> 8 & 255; + s.pending_buf[s.pending++] = b2 & 255; + }; + var read_buf2 = (strm, buf, start, size) => { + let len2 = strm.avail_in; + if (len2 > size) { + len2 = size; + } + if (len2 === 0) { + return 0; + } + strm.avail_in -= len2; + buf.set(strm.input.subarray(strm.next_in, strm.next_in + len2), start); + if (strm.state.wrap === 1) { + strm.adler = adler32_12(strm.adler, buf, len2, start); + } else if (strm.state.wrap === 2) { + strm.adler = crc32_12(strm.adler, buf, len2, start); + } + strm.next_in += len2; + strm.total_in += len2; + return len2; + }; + var longest_match2 = (s, cur_match) => { + let chain_length = s.max_chain_length; + let scan = s.strstart; + let match; + let len2; + let best_len = s.prev_length; + let nice_match = s.nice_match; + const limit = s.strstart > s.w_size - MIN_LOOKAHEAD2 ? s.strstart - (s.w_size - MIN_LOOKAHEAD2) : 0; + const _win = s.window; + const wmask = s.w_mask; + const prev = s.prev; + const strend = s.strstart + MAX_MATCH$12; + let scan_end1 = _win[scan + best_len - 1]; + let scan_end = _win[scan + best_len]; + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + if (nice_match > s.lookahead) { + nice_match = s.lookahead; + } + do { + match = cur_match; + if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) { + continue; } - const asyncProp = this.asyncProps[propName]; - if (!asyncProp) { - return; + scan += 2; + match++; + do { + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend); + len2 = MAX_MATCH$12 - (strend - scan); + scan = strend - MAX_MATCH$12; + if (len2 > best_len) { + s.match_start = cur_match; + best_len = len2; + if (len2 >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; } - asyncProp.pendingLoadCount++; - const loadCount = asyncProp.pendingLoadCount; - let data = []; - let count2 = 0; - for await (const chunk of iterable) { - if (!this.component) { - return; + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; + }; + var fill_window2 = (s) => { + const _w_size = s.w_size; + let p2, n2, m, more, str; + do { + more = s.window_size - s.lookahead - s.strstart; + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD2)) { + s.window.set(s.window.subarray(_w_size, _w_size + _w_size), 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + s.block_start -= _w_size; + n2 = s.hash_size; + p2 = n2; + do { + m = s.head[--p2]; + s.head[p2] = m >= _w_size ? m - _w_size : 0; + } while (--n2); + n2 = _w_size; + p2 = n2; + do { + m = s.prev[--p2]; + s.prev[p2] = m >= _w_size ? m - _w_size : 0; + } while (--n2); + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + n2 = read_buf2(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n2; + if (s.lookahead + s.insert >= MIN_MATCH$12) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + s.ins_h = HASH2(s, s.ins_h, s.window[str + 1]); + while (s.insert) { + s.ins_h = HASH2(s, s.ins_h, s.window[str + MIN_MATCH$12 - 1]); + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH$12) { + break; + } } - const { - dataTransform - } = this.component.props; - if (dataTransform) { - data = dataTransform(chunk, data); - } else { - data = data.concat(chunk); + } + } while (s.lookahead < MIN_LOOKAHEAD2 && s.strm.avail_in !== 0); + }; + var deflate_stored2 = (s, flush) => { + let max_block_size = 65535; + if (max_block_size > s.pending_buf_size - 5) { + max_block_size = s.pending_buf_size - 5; + } + for (; ; ) { + if (s.lookahead <= 1) { + fill_window2(s); + if (s.lookahead === 0 && flush === Z_NO_FLUSH2) { + return BS_NEED_MORE2; + } + if (s.lookahead === 0) { + break; } - Object.defineProperty(data, "__diff", { - enumerable: false, - value: [{ - startRow: count2, - endRow: data.length - }] - }); - count2 = data.length; - this._setAsyncPropValue(propName, data, loadCount); } - this._onResolve(propName, data); - } - _postProcessValue(asyncProp, value) { - const propType = asyncProp.type; - if (propType && this.component) { - if (propType.release) { - propType.release(asyncProp.resolvedValue, propType, this.component); + s.strstart += s.lookahead; + s.lookahead = 0; + const max_start = s.block_start + max_block_size; + if (s.strstart === 0 || s.strstart >= max_start) { + s.lookahead = s.strstart - max_start; + s.strstart = max_start; + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; } - if (propType.transform) { - return propType.transform(value, propType, this.component); + } + if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD2) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; } } - return value; } - _createAsyncPropData(propName, defaultValue) { - const asyncProp = this.asyncProps[propName]; - if (!asyncProp) { - const propTypes = this.component && this.component.props[PROP_TYPES_SYMBOL]; - this.asyncProps[propName] = { - type: propTypes && propTypes[propName], - lastValue: null, - resolvedValue: defaultValue, - pendingLoadCount: 0, - resolvedLoadCount: 0 - }; + s.insert = 0; + if (flush === Z_FINISH2) { + flush_block_only2(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED2; } + return BS_FINISH_DONE2; } + if (s.strstart > s.block_start) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; + } + } + return BS_NEED_MORE2; }; - - // node_modules/@deck.gl/core/dist/esm/lib/layer-state.js - var LayerState = class extends ComponentState { - constructor({ - attributeManager, - layer - }) { - super(layer); - _defineProperty(this, "attributeManager", void 0); - _defineProperty(this, "needsRedraw", void 0); - _defineProperty(this, "needsUpdate", void 0); - _defineProperty(this, "subLayers", void 0); - _defineProperty(this, "usesPickingColorCache", void 0); - _defineProperty(this, "hasPickingBuffer", void 0); - _defineProperty(this, "changeFlags", void 0); - _defineProperty(this, "viewport", void 0); - _defineProperty(this, "uniformTransitions", void 0); - _defineProperty(this, "propsInTransition", void 0); - this.attributeManager = attributeManager; - this.needsRedraw = true; - this.needsUpdate = true; - this.subLayers = null; - this.usesPickingColorCache = false; + var deflate_fast2 = (s, flush) => { + let hash_head; + let bflush; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD2) { + fill_window2(s); + if (s.lookahead < MIN_LOOKAHEAD2 && flush === Z_NO_FLUSH2) { + return BS_NEED_MORE2; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH$12) { + s.ins_h = HASH2(s, s.ins_h, s.window[s.strstart + MIN_MATCH$12 - 1]); + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD2) { + s.match_length = longest_match2(s, hash_head); + } + if (s.match_length >= MIN_MATCH$12) { + bflush = _tr_tally$12(s, s.strstart - s.match_start, s.match_length - MIN_MATCH$12); + s.lookahead -= s.match_length; + if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH$12) { + s.match_length--; + do { + s.strstart++; + s.ins_h = HASH2(s, s.ins_h, s.window[s.strstart + MIN_MATCH$12 - 1]); + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } while (--s.match_length !== 0); + s.strstart++; + } else { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + s.ins_h = HASH2(s, s.ins_h, s.window[s.strstart + 1]); + } + } else { + bflush = _tr_tally$12(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; + } + } } - get layer() { - return this.component; + s.insert = s.strstart < MIN_MATCH$12 - 1 ? s.strstart : MIN_MATCH$12 - 1; + if (flush === Z_FINISH2) { + flush_block_only2(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED2; + } + return BS_FINISH_DONE2; } - _fetch(propName, url) { - const layer = this.layer; - const fetch2 = layer === null || layer === void 0 ? void 0 : layer.props.fetch; - if (fetch2) { - return fetch2(url, { - propName, - layer - }); + if (s.last_lit) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; } - return super._fetch(propName, url); } - _onResolve(propName, value) { - const layer = this.layer; - if (layer) { - const onDataLoad = layer.props.onDataLoad; - if (propName === "data" && onDataLoad) { - onDataLoad(value, { - propName, - layer - }); + return BS_BLOCK_DONE2; + }; + var deflate_slow2 = (s, flush) => { + let hash_head; + let bflush; + let max_insert; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD2) { + fill_window2(s); + if (s.lookahead < MIN_LOOKAHEAD2 && flush === Z_NO_FLUSH2) { + return BS_NEED_MORE2; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH$12) { + s.ins_h = HASH2(s, s.ins_h, s.window[s.strstart + MIN_MATCH$12 - 1]); + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH$12 - 1; + if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD2) { + s.match_length = longest_match2(s, hash_head); + if (s.match_length <= 5 && (s.strategy === Z_FILTERED2 || s.match_length === MIN_MATCH$12 && s.strstart - s.match_start > 4096)) { + s.match_length = MIN_MATCH$12 - 1; + } + } + if (s.prev_length >= MIN_MATCH$12 && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH$12; + bflush = _tr_tally$12(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH$12); + s.lookahead -= s.prev_length - 1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + s.ins_h = HASH2(s, s.ins_h, s.window[s.strstart + MIN_MATCH$12 - 1]); + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH$12 - 1; + s.strstart++; + if (bflush) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; + } + } + } else if (s.match_available) { + bflush = _tr_tally$12(s, 0, s.window[s.strstart - 1]); + if (bflush) { + flush_block_only2(s, false); } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; + } + } else { + s.match_available = 1; + s.strstart++; + s.lookahead--; } } - _onError(propName, error2) { - const layer = this.layer; - if (layer) { - layer.raiseError(error2, "loading ".concat(propName, " of ").concat(this.layer)); + if (s.match_available) { + bflush = _tr_tally$12(s, 0, s.window[s.strstart - 1]); + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH$12 - 1 ? s.strstart : MIN_MATCH$12 - 1; + if (flush === Z_FINISH2) { + flush_block_only2(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED2; + } + return BS_FINISH_DONE2; + } + if (s.last_lit) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; } } + return BS_BLOCK_DONE2; }; - - // node_modules/@deck.gl/core/dist/esm/lib/layer.js - var TRACE_CHANGE_FLAG = "layer.changeFlag"; - var TRACE_INITIALIZE = "layer.initialize"; - var TRACE_UPDATE = "layer.update"; - var TRACE_FINALIZE = "layer.finalize"; - var TRACE_MATCHED = "layer.matched"; - var MAX_PICKING_COLOR_CACHE_SIZE = 2 ** 24 - 1; - var EMPTY_ARRAY2 = Object.freeze([]); - var areViewportsEqual = memoize(({ - oldViewport, - viewport - }) => { - return oldViewport.equals(viewport); - }); - var pickingColorCache = new Uint8ClampedArray(0); - var defaultProps2 = { - data: { - type: "data", - value: EMPTY_ARRAY2, - async: true - }, - dataComparator: { - type: "function", - value: null, - optional: true - }, - _dataDiff: { - type: "function", - value: (data) => data && data.__diff, - optional: true - }, - dataTransform: { - type: "function", - value: null, - optional: true - }, - onDataLoad: { - type: "function", - value: null, - optional: true - }, - onError: { - type: "function", - value: null, - optional: true - }, - fetch: { - type: "function", - value: (url, { - propName, - layer, - loaders, - loadOptions, - signal - }) => { - const { - resourceManager - } = layer.context; - loadOptions = loadOptions || layer.getLoadOptions(); - loaders = loaders || layer.props.loaders; - if (signal) { - var _loadOptions; - loadOptions = { - ...loadOptions, - fetch: { - ...(_loadOptions = loadOptions) === null || _loadOptions === void 0 ? void 0 : _loadOptions.fetch, - signal - } - }; + var deflate_rle2 = (s, flush) => { + let bflush; + let prev; + let scan, strend; + const _win = s.window; + for (; ; ) { + if (s.lookahead <= MAX_MATCH$12) { + fill_window2(s); + if (s.lookahead <= MAX_MATCH$12 && flush === Z_NO_FLUSH2) { + return BS_NEED_MORE2; + } + if (s.lookahead === 0) { + break; } - let inResourceManager = resourceManager.contains(url); - if (!inResourceManager && !loadOptions) { - resourceManager.add({ - resourceId: url, - data: load(url, loaders), - persistent: false - }); - inResourceManager = true; + } + s.match_length = 0; + if (s.lookahead >= MIN_MATCH$12 && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH$12; + do { + } while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend); + s.match_length = MAX_MATCH$12 - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } } - if (inResourceManager) { - return resourceManager.subscribe({ - resourceId: url, - onChange: (data) => { - var _layer$internalState; - return (_layer$internalState = layer.internalState) === null || _layer$internalState === void 0 ? void 0 : _layer$internalState.reloadAsyncProp(propName, data); - }, - consumerId: layer.id, - requestId: propName - }); + } + if (s.match_length >= MIN_MATCH$12) { + bflush = _tr_tally$12(s, 1, s.match_length - MIN_MATCH$12); + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + bflush = _tr_tally$12(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; } - return load(url, loaders, loadOptions); } - }, - updateTriggers: {}, - visible: true, - pickable: false, - opacity: { - type: "number", - min: 0, - max: 1, - value: 1 - }, - operation: "draw", - onHover: { - type: "function", - value: null, - optional: true - }, - onClick: { - type: "function", - value: null, - optional: true - }, - onDragStart: { - type: "function", - value: null, - optional: true - }, - onDrag: { - type: "function", - value: null, - optional: true - }, - onDragEnd: { - type: "function", - value: null, - optional: true - }, - coordinateSystem: COORDINATE_SYSTEM.DEFAULT, - coordinateOrigin: { - type: "array", - value: [0, 0, 0], - compare: true - }, - modelMatrix: { - type: "array", - value: null, - compare: true, - optional: true - }, - wrapLongitude: false, - positionFormat: "XYZ", - colorFormat: "RGBA", - parameters: { - type: "object", - value: {}, - optional: true, - compare: 2 - }, - loadOptions: { - type: "object", - value: null, - optional: true, - ignore: true - }, - transitions: null, - extensions: [], - loaders: { - type: "array", - value: [], - optional: true, - ignore: true - }, - getPolygonOffset: { - type: "function", - value: ({ - layerIndex - }) => [0, -layerIndex * 100] - }, - highlightedObjectIndex: null, - autoHighlight: false, - highlightColor: { - type: "accessor", - value: [0, 0, 128, 128] } + s.insert = 0; + if (flush === Z_FINISH2) { + flush_block_only2(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED2; + } + return BS_FINISH_DONE2; + } + if (s.last_lit) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; + } + } + return BS_BLOCK_DONE2; }; - var Layer = class extends Component { - constructor(...args) { - super(...args); - _defineProperty(this, "internalState", null); - _defineProperty(this, "lifecycle", LIFECYCLE.NO_STATE); - _defineProperty(this, "context", void 0); - _defineProperty(this, "state", void 0); - _defineProperty(this, "parent", null); + var deflate_huff2 = (s, flush) => { + let bflush; + for (; ; ) { + if (s.lookahead === 0) { + fill_window2(s); + if (s.lookahead === 0) { + if (flush === Z_NO_FLUSH2) { + return BS_NEED_MORE2; + } + break; + } + } + s.match_length = 0; + bflush = _tr_tally$12(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; + } + } } - static get componentName() { - return Object.prototype.hasOwnProperty.call(this, "layerName") ? this.layerName : ""; + s.insert = 0; + if (flush === Z_FINISH2) { + flush_block_only2(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED2; + } + return BS_FINISH_DONE2; } - get root() { - let layer = this; - while (layer.parent) { - layer = layer.parent; + if (s.last_lit) { + flush_block_only2(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE2; } - return layer; } - toString() { - const className = this.constructor.layerName || this.constructor.name; - return "".concat(className, "({id: '").concat(this.props.id, "'})"); + return BS_BLOCK_DONE2; + }; + function Config2(good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; + } + var configuration_table2 = [ + /* good lazy nice chain */ + new Config2(0, 0, 0, 0, deflate_stored2), + /* 0 store only */ + new Config2(4, 4, 8, 4, deflate_fast2), + /* 1 max speed, no lazy matches */ + new Config2(4, 5, 16, 8, deflate_fast2), + /* 2 */ + new Config2(4, 6, 32, 32, deflate_fast2), + /* 3 */ + new Config2(4, 4, 16, 16, deflate_slow2), + /* 4 lazy matches */ + new Config2(8, 16, 32, 32, deflate_slow2), + /* 5 */ + new Config2(8, 16, 128, 128, deflate_slow2), + /* 6 */ + new Config2(8, 32, 128, 256, deflate_slow2), + /* 7 */ + new Config2(32, 128, 258, 1024, deflate_slow2), + /* 8 */ + new Config2(32, 258, 258, 4096, deflate_slow2) + /* 9 max compression */ + ]; + var lm_init2 = (s) => { + s.window_size = 2 * s.w_size; + zero$12(s.head); + s.max_lazy_match = configuration_table2[s.level].max_lazy; + s.good_match = configuration_table2[s.level].good_length; + s.nice_match = configuration_table2[s.level].nice_length; + s.max_chain_length = configuration_table2[s.level].max_chain; + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH$12 - 1; + s.match_available = 0; + s.ins_h = 0; + }; + function DeflateState2() { + this.strm = null; + this.status = 0; + this.pending_buf = null; + this.pending_buf_size = 0; + this.pending_out = 0; + this.pending = 0; + this.wrap = 0; + this.gzhead = null; + this.gzindex = 0; + this.method = Z_DEFLATED2; + this.last_flush = -1; + this.w_size = 0; + this.w_bits = 0; + this.w_mask = 0; + this.window = null; + this.window_size = 0; + this.prev = null; + this.head = null; + this.ins_h = 0; + this.hash_size = 0; + this.hash_bits = 0; + this.hash_mask = 0; + this.hash_shift = 0; + this.block_start = 0; + this.match_length = 0; + this.prev_match = 0; + this.match_available = 0; + this.strstart = 0; + this.match_start = 0; + this.lookahead = 0; + this.prev_length = 0; + this.max_chain_length = 0; + this.max_lazy_match = 0; + this.level = 0; + this.strategy = 0; + this.good_match = 0; + this.nice_match = 0; + this.dyn_ltree = new Uint16Array(HEAP_SIZE$12 * 2); + this.dyn_dtree = new Uint16Array((2 * D_CODES$12 + 1) * 2); + this.bl_tree = new Uint16Array((2 * BL_CODES$12 + 1) * 2); + zero$12(this.dyn_ltree); + zero$12(this.dyn_dtree); + zero$12(this.bl_tree); + this.l_desc = null; + this.d_desc = null; + this.bl_desc = null; + this.bl_count = new Uint16Array(MAX_BITS$12 + 1); + this.heap = new Uint16Array(2 * L_CODES$12 + 1); + zero$12(this.heap); + this.heap_len = 0; + this.heap_max = 0; + this.depth = new Uint16Array(2 * L_CODES$12 + 1); + zero$12(this.depth); + this.l_buf = 0; + this.lit_bufsize = 0; + this.last_lit = 0; + this.d_buf = 0; + this.opt_len = 0; + this.static_len = 0; + this.matches = 0; + this.insert = 0; + this.bi_buf = 0; + this.bi_valid = 0; + } + var deflateResetKeep2 = (strm) => { + if (!strm || !strm.state) { + return err2(strm, Z_STREAM_ERROR2); + } + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN$12; + const s = strm.state; + s.pending = 0; + s.pending_out = 0; + if (s.wrap < 0) { + s.wrap = -s.wrap; + } + s.status = s.wrap ? INIT_STATE2 : BUSY_STATE2; + strm.adler = s.wrap === 2 ? 0 : 1; + s.last_flush = Z_NO_FLUSH2; + _tr_init$12(s); + return Z_OK2; + }; + var deflateReset2 = (strm) => { + const ret = deflateResetKeep2(strm); + if (ret === Z_OK2) { + lm_init2(strm.state); } - project(xyz) { - assert10(this.internalState); - const viewport = this.internalState.viewport || this.context.viewport; - const worldPosition = getWorldPosition(xyz, { - viewport, - modelMatrix: this.props.modelMatrix, - coordinateOrigin: this.props.coordinateOrigin, - coordinateSystem: this.props.coordinateSystem - }); - const [x2, y2, z] = worldToPixels(worldPosition, viewport.pixelProjectionMatrix); - return xyz.length === 2 ? [x2, y2] : [x2, y2, z]; + return ret; + }; + var deflateSetHeader2 = (strm, head) => { + if (!strm || !strm.state) { + return Z_STREAM_ERROR2; } - unproject(xy) { - assert10(this.internalState); - const viewport = this.internalState.viewport || this.context.viewport; - return viewport.unproject(xy); + if (strm.state.wrap !== 2) { + return Z_STREAM_ERROR2; } - projectPosition(xyz, params) { - assert10(this.internalState); - const viewport = this.internalState.viewport || this.context.viewport; - return projectPosition(xyz, { - viewport, - modelMatrix: this.props.modelMatrix, - coordinateOrigin: this.props.coordinateOrigin, - coordinateSystem: this.props.coordinateSystem, - ...params - }); + strm.state.gzhead = head; + return Z_OK2; + }; + var deflateInit22 = (strm, level, method, windowBits, memLevel, strategy) => { + if (!strm) { + return Z_STREAM_ERROR2; + } + let wrap = 1; + if (level === Z_DEFAULT_COMPRESSION2) { + level = 6; + } + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else if (windowBits > 15) { + wrap = 2; + windowBits -= 16; + } + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL2 || method !== Z_DEFLATED2 || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED$12) { + return err2(strm, Z_STREAM_ERROR2); + } + if (windowBits === 8) { + windowBits = 9; + } + const s = new DeflateState2(); + strm.state = s; + s.strm = strm; + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH$12 - 1) / MIN_MATCH$12); + s.window = new Uint8Array(s.w_size * 2); + s.head = new Uint16Array(s.hash_size); + s.prev = new Uint16Array(s.w_size); + s.lit_bufsize = 1 << memLevel + 6; + s.pending_buf_size = s.lit_bufsize * 4; + s.pending_buf = new Uint8Array(s.pending_buf_size); + s.d_buf = 1 * s.lit_bufsize; + s.l_buf = (1 + 2) * s.lit_bufsize; + s.level = level; + s.strategy = strategy; + s.method = method; + return deflateReset2(strm); + }; + var deflateInit3 = (strm, level) => { + return deflateInit22(strm, level, Z_DEFLATED2, MAX_WBITS2, DEF_MEM_LEVEL2, Z_DEFAULT_STRATEGY2); + }; + var deflate2 = (strm, flush) => { + let beg, val; + if (!strm || !strm.state || flush > Z_BLOCK2 || flush < 0) { + return strm ? err2(strm, Z_STREAM_ERROR2) : Z_STREAM_ERROR2; + } + const s = strm.state; + if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE2 && flush !== Z_FINISH2) { + return err2(strm, strm.avail_out === 0 ? Z_BUF_ERROR2 : Z_STREAM_ERROR2); + } + s.strm = strm; + const old_flush = s.last_flush; + s.last_flush = flush; + if (s.status === INIT_STATE2) { + if (s.wrap === 2) { + strm.adler = 0; + put_byte2(s, 31); + put_byte2(s, 139); + put_byte2(s, 8); + if (!s.gzhead) { + put_byte2(s, 0); + put_byte2(s, 0); + put_byte2(s, 0); + put_byte2(s, 0); + put_byte2(s, 0); + put_byte2(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY2 || s.level < 2 ? 4 : 0); + put_byte2(s, OS_CODE2); + s.status = BUSY_STATE2; + } else { + put_byte2( + s, + (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16) + ); + put_byte2(s, s.gzhead.time & 255); + put_byte2(s, s.gzhead.time >> 8 & 255); + put_byte2(s, s.gzhead.time >> 16 & 255); + put_byte2(s, s.gzhead.time >> 24 & 255); + put_byte2(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY2 || s.level < 2 ? 4 : 0); + put_byte2(s, s.gzhead.os & 255); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte2(s, s.gzhead.extra.length & 255); + put_byte2(s, s.gzhead.extra.length >> 8 & 255); + } + if (s.gzhead.hcrc) { + strm.adler = crc32_12(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE2; + } + } else { + let header = Z_DEFLATED2 + (s.w_bits - 8 << 4) << 8; + let level_flags = -1; + if (s.strategy >= Z_HUFFMAN_ONLY2 || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= level_flags << 6; + if (s.strstart !== 0) { + header |= PRESET_DICT2; + } + header += 31 - header % 31; + s.status = BUSY_STATE2; + putShortMSB2(s, header); + if (s.strstart !== 0) { + putShortMSB2(s, strm.adler >>> 16); + putShortMSB2(s, strm.adler & 65535); + } + strm.adler = 1; + } } - get isComposite() { - return false; + if (s.status === EXTRA_STATE2) { + if (s.gzhead.extra) { + beg = s.pending; + while (s.gzindex < (s.gzhead.extra.length & 65535)) { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_12(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending2(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + break; + } + } + put_byte2(s, s.gzhead.extra[s.gzindex] & 255); + s.gzindex++; + } + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_12(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (s.gzindex === s.gzhead.extra.length) { + s.gzindex = 0; + s.status = NAME_STATE2; + } + } else { + s.status = NAME_STATE2; + } } - setState(partialState) { - this.setChangeFlags({ - stateChanged: true - }); - Object.assign(this.state, partialState); - this.setNeedsRedraw(); + if (s.status === NAME_STATE2) { + if (s.gzhead.name) { + beg = s.pending; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_12(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending2(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte2(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_12(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.gzindex = 0; + s.status = COMMENT_STATE2; + } + } else { + s.status = COMMENT_STATE2; + } } - setNeedsRedraw() { - if (this.internalState) { - this.internalState.needsRedraw = true; + if (s.status === COMMENT_STATE2) { + if (s.gzhead.comment) { + beg = s.pending; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_12(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending2(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte2(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32_12(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.status = HCRC_STATE2; + } + } else { + s.status = HCRC_STATE2; } } - setNeedsUpdate() { - if (this.internalState) { - this.context.layerManager.setNeedsUpdate(String(this)); - this.internalState.needsUpdate = true; + if (s.status === HCRC_STATE2) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending2(strm); + } + if (s.pending + 2 <= s.pending_buf_size) { + put_byte2(s, strm.adler & 255); + put_byte2(s, strm.adler >> 8 & 255); + strm.adler = 0; + s.status = BUSY_STATE2; + } + } else { + s.status = BUSY_STATE2; + } + } + if (s.pending !== 0) { + flush_pending2(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK2; + } + } else if (strm.avail_in === 0 && rank2(flush) <= rank2(old_flush) && flush !== Z_FINISH2) { + return err2(strm, Z_BUF_ERROR2); + } + if (s.status === FINISH_STATE2 && strm.avail_in !== 0) { + return err2(strm, Z_BUF_ERROR2); + } + if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH2 && s.status !== FINISH_STATE2) { + let bstate = s.strategy === Z_HUFFMAN_ONLY2 ? deflate_huff2(s, flush) : s.strategy === Z_RLE2 ? deflate_rle2(s, flush) : configuration_table2[s.level].func(s, flush); + if (bstate === BS_FINISH_STARTED2 || bstate === BS_FINISH_DONE2) { + s.status = FINISH_STATE2; + } + if (bstate === BS_NEED_MORE2 || bstate === BS_FINISH_STARTED2) { + if (strm.avail_out === 0) { + s.last_flush = -1; + } + return Z_OK2; + } + if (bstate === BS_BLOCK_DONE2) { + if (flush === Z_PARTIAL_FLUSH2) { + _tr_align$12(s); + } else if (flush !== Z_BLOCK2) { + _tr_stored_block$12(s, 0, 0, false); + if (flush === Z_FULL_FLUSH2) { + zero$12(s.head); + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending2(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK2; + } } } - get isLoaded() { - return this.internalState ? !this.internalState.isAsyncPropLoading() : false; + if (flush !== Z_FINISH2) { + return Z_OK2; } - get wrapLongitude() { - return this.props.wrapLongitude; + if (s.wrap <= 0) { + return Z_STREAM_END2; } - isPickable() { - return this.props.pickable && this.props.visible; + if (s.wrap === 2) { + put_byte2(s, strm.adler & 255); + put_byte2(s, strm.adler >> 8 & 255); + put_byte2(s, strm.adler >> 16 & 255); + put_byte2(s, strm.adler >> 24 & 255); + put_byte2(s, strm.total_in & 255); + put_byte2(s, strm.total_in >> 8 & 255); + put_byte2(s, strm.total_in >> 16 & 255); + put_byte2(s, strm.total_in >> 24 & 255); + } else { + putShortMSB2(s, strm.adler >>> 16); + putShortMSB2(s, strm.adler & 65535); } - getModels() { - return this.state && (this.state.models || this.state.model && [this.state.model]) || []; + flush_pending2(strm); + if (s.wrap > 0) { + s.wrap = -s.wrap; } - setModuleParameters(moduleParameters) { - for (const model of this.getModels()) { - model.updateModuleSettings(moduleParameters); - } + return s.pending !== 0 ? Z_OK2 : Z_STREAM_END2; + }; + var deflateEnd2 = (strm) => { + if (!strm || !strm.state) { + return Z_STREAM_ERROR2; } - getAttributeManager() { - return this.internalState && this.internalState.attributeManager; + const status = strm.state.status; + if (status !== INIT_STATE2 && status !== EXTRA_STATE2 && status !== NAME_STATE2 && status !== COMMENT_STATE2 && status !== HCRC_STATE2 && status !== BUSY_STATE2 && status !== FINISH_STATE2) { + return err2(strm, Z_STREAM_ERROR2); } - getCurrentLayer() { - return this.internalState && this.internalState.layer; + strm.state = null; + return status === BUSY_STATE2 ? err2(strm, Z_DATA_ERROR2) : Z_OK2; + }; + var deflateSetDictionary2 = (strm, dictionary) => { + let dictLength = dictionary.length; + if (!strm || !strm.state) { + return Z_STREAM_ERROR2; + } + const s = strm.state; + const wrap = s.wrap; + if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE2 || s.lookahead) { + return Z_STREAM_ERROR2; + } + if (wrap === 1) { + strm.adler = adler32_12(strm.adler, dictionary, dictLength, 0); + } + s.wrap = 0; + if (dictLength >= s.w_size) { + if (wrap === 0) { + zero$12(s.head); + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + let tmpDict = new Uint8Array(s.w_size); + tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0); + dictionary = tmpDict; + dictLength = s.w_size; + } + const avail = strm.avail_in; + const next = strm.next_in; + const input = strm.input; + strm.avail_in = dictLength; + strm.next_in = 0; + strm.input = dictionary; + fill_window2(s); + while (s.lookahead >= MIN_MATCH$12) { + let str = s.strstart; + let n2 = s.lookahead - (MIN_MATCH$12 - 1); + do { + s.ins_h = HASH2(s, s.ins_h, s.window[str + MIN_MATCH$12 - 1]); + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + } while (--n2); + s.strstart = str; + s.lookahead = MIN_MATCH$12 - 1; + fill_window2(s); + } + s.strstart += s.lookahead; + s.block_start = s.strstart; + s.insert = s.lookahead; + s.lookahead = 0; + s.match_length = s.prev_length = MIN_MATCH$12 - 1; + s.match_available = 0; + strm.next_in = next; + strm.input = input; + strm.avail_in = avail; + s.wrap = wrap; + return Z_OK2; + }; + var deflateInit_12 = deflateInit3; + var deflateInit2_12 = deflateInit22; + var deflateReset_12 = deflateReset2; + var deflateResetKeep_12 = deflateResetKeep2; + var deflateSetHeader_12 = deflateSetHeader2; + var deflate_22 = deflate2; + var deflateEnd_12 = deflateEnd2; + var deflateSetDictionary_12 = deflateSetDictionary2; + var deflateInfo2 = "pako deflate (from Nodeca project)"; + var deflate_1 = { + deflateInit: deflateInit_12, + deflateInit2: deflateInit2_12, + deflateReset: deflateReset_12, + deflateResetKeep: deflateResetKeep_12, + deflateSetHeader: deflateSetHeader_12, + deflate: deflate_22, + deflateEnd: deflateEnd_12, + deflateSetDictionary: deflateSetDictionary_12, + deflateInfo: deflateInfo2 + }; + var _has2 = (obj, key) => { + return Object.prototype.hasOwnProperty.call(obj, key); + }; + var assign2 = function(obj) { + const sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + const source = sources.shift(); + if (!source) { + continue; + } + if (typeof source !== "object") { + throw new TypeError(source + "must be non-object"); + } + for (const p2 in source) { + if (_has2(source, p2)) { + obj[p2] = source[p2]; + } + } } - getLoadOptions() { - return this.props.loadOptions; + return obj; + }; + var flattenChunks2 = (chunks) => { + let len2 = 0; + for (let i3 = 0, l2 = chunks.length; i3 < l2; i3++) { + len2 += chunks[i3].length; } - use64bitPositions() { - const { - coordinateSystem - } = this.props; - return coordinateSystem === COORDINATE_SYSTEM.DEFAULT || coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN; + const result = new Uint8Array(len2); + for (let i3 = 0, pos = 0, l2 = chunks.length; i3 < l2; i3++) { + let chunk = chunks[i3]; + result.set(chunk, pos); + pos += chunk.length; } - onHover(info, pickingEvent) { - if (this.props.onHover) { - return this.props.onHover(info, pickingEvent) || false; + return result; + }; + var common2 = { + assign: assign2, + flattenChunks: flattenChunks2 + }; + var STR_APPLY_UIA_OK2 = true; + try { + String.fromCharCode.apply(null, new Uint8Array(1)); + } catch (__) { + STR_APPLY_UIA_OK2 = false; + } + var _utf8len2 = new Uint8Array(256); + for (let q = 0; q < 256; q++) { + _utf8len2[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1; + } + _utf8len2[254] = _utf8len2[254] = 1; + var string2buf2 = (str) => { + let buf, c2, c22, m_pos, i3, str_len = str.length, buf_len = 0; + for (m_pos = 0; m_pos < str_len; m_pos++) { + c2 = str.charCodeAt(m_pos); + if ((c2 & 64512) === 55296 && m_pos + 1 < str_len) { + c22 = str.charCodeAt(m_pos + 1); + if ((c22 & 64512) === 56320) { + c2 = 65536 + (c2 - 55296 << 10) + (c22 - 56320); + m_pos++; + } + } + buf_len += c2 < 128 ? 1 : c2 < 2048 ? 2 : c2 < 65536 ? 3 : 4; + } + buf = new Uint8Array(buf_len); + for (i3 = 0, m_pos = 0; i3 < buf_len; m_pos++) { + c2 = str.charCodeAt(m_pos); + if ((c2 & 64512) === 55296 && m_pos + 1 < str_len) { + c22 = str.charCodeAt(m_pos + 1); + if ((c22 & 64512) === 56320) { + c2 = 65536 + (c2 - 55296 << 10) + (c22 - 56320); + m_pos++; + } + } + if (c2 < 128) { + buf[i3++] = c2; + } else if (c2 < 2048) { + buf[i3++] = 192 | c2 >>> 6; + buf[i3++] = 128 | c2 & 63; + } else if (c2 < 65536) { + buf[i3++] = 224 | c2 >>> 12; + buf[i3++] = 128 | c2 >>> 6 & 63; + buf[i3++] = 128 | c2 & 63; + } else { + buf[i3++] = 240 | c2 >>> 18; + buf[i3++] = 128 | c2 >>> 12 & 63; + buf[i3++] = 128 | c2 >>> 6 & 63; + buf[i3++] = 128 | c2 & 63; } - return false; } - onClick(info, pickingEvent) { - if (this.props.onClick) { - return this.props.onClick(info, pickingEvent) || false; + return buf; + }; + var buf2binstring2 = (buf, len2) => { + if (len2 < 65534) { + if (buf.subarray && STR_APPLY_UIA_OK2) { + return String.fromCharCode.apply(null, buf.length === len2 ? buf : buf.subarray(0, len2)); } - return false; - } - nullPickingColor() { - return [0, 0, 0]; - } - encodePickingColor(i2, target = []) { - target[0] = i2 + 1 & 255; - target[1] = i2 + 1 >> 8 & 255; - target[2] = i2 + 1 >> 8 >> 8 & 255; - return target; } - decodePickingColor(color) { - assert10(color instanceof Uint8Array); - const [i1, i2, i3] = color; - const index = i1 + i2 * 256 + i3 * 65536 - 1; - return index; + let result = ""; + for (let i3 = 0; i3 < len2; i3++) { + result += String.fromCharCode(buf[i3]); } - getNumInstances() { - if (Number.isFinite(this.props.numInstances)) { - return this.props.numInstances; + return result; + }; + var buf2string2 = (buf, max) => { + let i3, out; + const len2 = max || buf.length; + const utf16buf = new Array(len2 * 2); + for (out = 0, i3 = 0; i3 < len2; ) { + let c2 = buf[i3++]; + if (c2 < 128) { + utf16buf[out++] = c2; + continue; } - if (this.state && this.state.numInstances !== void 0) { - return this.state.numInstances; + let c_len = _utf8len2[c2]; + if (c_len > 4) { + utf16buf[out++] = 65533; + i3 += c_len - 1; + continue; } - return count(this.props.data); - } - getStartIndices() { - if (this.props.startIndices) { - return this.props.startIndices; + c2 &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7; + while (c_len > 1 && i3 < len2) { + c2 = c2 << 6 | buf[i3++] & 63; + c_len--; } - if (this.state && this.state.startIndices) { - return this.state.startIndices; + if (c_len > 1) { + utf16buf[out++] = 65533; + continue; + } + if (c2 < 65536) { + utf16buf[out++] = c2; + } else { + c2 -= 65536; + utf16buf[out++] = 55296 | c2 >> 10 & 1023; + utf16buf[out++] = 56320 | c2 & 1023; } - return null; } - getBounds() { - var _this$getAttributeMan; - return (_this$getAttributeMan = this.getAttributeManager()) === null || _this$getAttributeMan === void 0 ? void 0 : _this$getAttributeMan.getBounds(["positions", "instancePositions"]); + return buf2binstring2(utf16buf, out); + }; + var utf8border2 = (buf, max) => { + max = max || buf.length; + if (max > buf.length) { + max = buf.length; } - getShaders(shaders) { - for (const extension of this.props.extensions) { - shaders = mergeShaders(shaders, extension.getShaders.call(this, extension)); + let pos = max - 1; + while (pos >= 0 && (buf[pos] & 192) === 128) { + pos--; + } + if (pos < 0) { + return max; + } + if (pos === 0) { + return max; + } + return pos + _utf8len2[buf[pos]] > max ? pos : max; + }; + var strings2 = { + string2buf: string2buf2, + buf2string: buf2string2, + utf8border: utf8border2 + }; + function ZStream2() { + this.input = null; + this.next_in = 0; + this.avail_in = 0; + this.total_in = 0; + this.output = null; + this.next_out = 0; + this.avail_out = 0; + this.total_out = 0; + this.msg = ""; + this.state = null; + this.data_type = 2; + this.adler = 0; + } + var zstream2 = ZStream2; + var toString2 = Object.prototype.toString; + var { + Z_NO_FLUSH: Z_NO_FLUSH$12, + Z_SYNC_FLUSH: Z_SYNC_FLUSH2, + Z_FULL_FLUSH: Z_FULL_FLUSH$12, + Z_FINISH: Z_FINISH$12, + Z_OK: Z_OK$12, + Z_STREAM_END: Z_STREAM_END$12, + Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$12, + Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$12, + Z_DEFLATED: Z_DEFLATED$12 + } = constants2; + function Deflate2(options) { + this.options = common2.assign({ + level: Z_DEFAULT_COMPRESSION$12, + method: Z_DEFLATED$12, + chunkSize: 16384, + windowBits: 15, + memLevel: 8, + strategy: Z_DEFAULT_STRATEGY$12 + }, options || {}); + let opt = this.options; + if (opt.raw && opt.windowBits > 0) { + opt.windowBits = -opt.windowBits; + } else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) { + opt.windowBits += 16; + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new zstream2(); + this.strm.avail_out = 0; + let status = deflate_1.deflateInit2( + this.strm, + opt.level, + opt.method, + opt.windowBits, + opt.memLevel, + opt.strategy + ); + if (status !== Z_OK$12) { + throw new Error(messages2[status]); + } + if (opt.header) { + deflate_1.deflateSetHeader(this.strm, opt.header); + } + if (opt.dictionary) { + let dict; + if (typeof opt.dictionary === "string") { + dict = strings2.string2buf(opt.dictionary); + } else if (toString2.call(opt.dictionary) === "[object ArrayBuffer]") { + dict = new Uint8Array(opt.dictionary); + } else { + dict = opt.dictionary; } - return shaders; + status = deflate_1.deflateSetDictionary(this.strm, dict); + if (status !== Z_OK$12) { + throw new Error(messages2[status]); + } + this._dict_set = true; } - shouldUpdateState(params) { - return params.changeFlags.propsOrDataChanged; + } + Deflate2.prototype.push = function(data, flush_mode) { + const strm = this.strm; + const chunkSize = this.options.chunkSize; + let status, _flush_mode; + if (this.ended) { + return false; } - updateState(params) { - const attributeManager = this.getAttributeManager(); - const { - dataChanged - } = params.changeFlags; - if (dataChanged && attributeManager) { - if (Array.isArray(dataChanged)) { - for (const dataRange of dataChanged) { - attributeManager.invalidateAll(dataRange); - } - } else { - attributeManager.invalidateAll(); + if (flush_mode === ~~flush_mode) + _flush_mode = flush_mode; + else + _flush_mode = flush_mode === true ? Z_FINISH$12 : Z_NO_FLUSH$12; + if (typeof data === "string") { + strm.input = strings2.string2buf(data); + } else if (toString2.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + for (; ; ) { + if (strm.avail_out === 0) { + strm.output = new Uint8Array(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + if ((_flush_mode === Z_SYNC_FLUSH2 || _flush_mode === Z_FULL_FLUSH$12) && strm.avail_out <= 6) { + this.onData(strm.output.subarray(0, strm.next_out)); + strm.avail_out = 0; + continue; + } + status = deflate_1.deflate(strm, _flush_mode); + if (status === Z_STREAM_END$12) { + if (strm.next_out > 0) { + this.onData(strm.output.subarray(0, strm.next_out)); } + status = deflate_1.deflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === Z_OK$12; } - if (attributeManager) { - const { - props - } = params; - const hasPickingBuffer = this.internalState.hasPickingBuffer; - const needsPickingBuffer = Number.isInteger(props.highlightedObjectIndex) || props.pickable || props.extensions.some((extension) => extension.getNeedsPickingBuffer.call(this, extension)); - if (hasPickingBuffer !== needsPickingBuffer) { - this.internalState.hasPickingBuffer = needsPickingBuffer; - const { - pickingColors, - instancePickingColors - } = attributeManager.attributes; - const pickingColorsAttribute = pickingColors || instancePickingColors; - if (pickingColorsAttribute) { - if (needsPickingBuffer && pickingColorsAttribute.constant) { - pickingColorsAttribute.constant = false; - attributeManager.invalidate(pickingColorsAttribute.id); - } - if (!pickingColorsAttribute.value && !needsPickingBuffer) { - pickingColorsAttribute.constant = true; - pickingColorsAttribute.value = [0, 0, 0]; + if (strm.avail_out === 0) { + this.onData(strm.output); + continue; + } + if (_flush_mode > 0 && strm.next_out > 0) { + this.onData(strm.output.subarray(0, strm.next_out)); + strm.avail_out = 0; + continue; + } + if (strm.avail_in === 0) + break; + } + return true; + }; + Deflate2.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Deflate2.prototype.onEnd = function(status) { + if (status === Z_OK$12) { + this.result = common2.flattenChunks(this.chunks); + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + function deflate$12(input, options) { + const deflator = new Deflate2(options); + deflator.push(input, true); + if (deflator.err) { + throw deflator.msg || messages2[deflator.err]; + } + return deflator.result; + } + function deflateRaw2(input, options) { + options = options || {}; + options.raw = true; + return deflate$12(input, options); + } + function gzip2(input, options) { + options = options || {}; + options.gzip = true; + return deflate$12(input, options); + } + var Deflate_1 = Deflate2; + var deflate_2$12 = deflate$12; + var deflateRaw_1 = deflateRaw2; + var gzip_1 = gzip2; + var constants$12 = constants2; + var deflate_1$12 = { + Deflate: Deflate_1, + deflate: deflate_2$12, + deflateRaw: deflateRaw_1, + gzip: gzip_1, + constants: constants$12 + }; + var BAD2 = 30; + var TYPE2 = 12; + var inffast2 = function inflate_fast2(strm, start) { + let _in; + let last; + let _out; + let beg; + let end; + let dmax; + let wsize; + let whave; + let wnext; + let s_window; + let hold; + let bits; + let lcode; + let dcode; + let lmask; + let dmask; + let here; + let op; + let len2; + let dist; + let from; + let from_source; + let input, output; + const state = strm.state; + _in = strm.next_in; + input = strm.input; + last = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); + dmax = state.dmax; + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = lcode[hold & lmask]; + dolen: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op === 0) { + output[_out++] = here & 65535; + } else if (op & 16) { + len2 = here & 65535; + op &= 15; + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len2 += hold & (1 << op) - 1; + hold >>>= op; + bits -= op; + } + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + dodist: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op & 16) { + dist = here & 65535; + op &= 15; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & (1 << op) - 1; + if (dist > dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD2; + break top; + } + hold >>>= op; + bits -= op; + op = _out - beg; + if (dist > op) { + op = dist - op; + if (op > whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD2; + break top; + } + } + from = 0; + from_source = s_window; + if (wnext === 0) { + from += wsize - op; + if (op < len2) { + len2 -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } else if (wnext < op) { + from += wsize + wnext - op; + op -= wnext; + if (op < len2) { + len2 -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len2) { + op = wnext; + len2 -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + } else { + from += wnext - op; + if (op < len2) { + len2 -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + while (len2 > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len2 -= 3; + } + if (len2) { + output[_out++] = from_source[from++]; + if (len2 > 1) { + output[_out++] = from_source[from++]; + } + } + } else { + from = _out - dist; + do { + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len2 -= 3; + } while (len2 > 2); + if (len2) { + output[_out++] = output[from++]; + if (len2 > 1) { + output[_out++] = output[from++]; + } + } + } + } else if ((op & 64) === 0) { + here = dcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dodist; + } else { + strm.msg = "invalid distance code"; + state.mode = BAD2; + break top; + } + break; + } + } else if ((op & 64) === 0) { + here = lcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dolen; + } else if (op & 32) { + state.mode = TYPE2; + break top; + } else { + strm.msg = "invalid literal/length code"; + state.mode = BAD2; + break top; } + break; } - } + } while (_in < last && _out < end); + len2 = bits >> 3; + _in -= len2; + bits -= len2 << 3; + hold &= (1 << bits) - 1; + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last); + strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end); + state.hold = hold; + state.bits = bits; + return; + }; + var MAXBITS2 = 15; + var ENOUGH_LENS2 = 852; + var ENOUGH_DISTS2 = 592; + var CODES2 = 0; + var LENS2 = 1; + var DISTS2 = 2; + var lbase2 = new Uint16Array([ + /* Length codes 257..285 base */ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 13, + 15, + 17, + 19, + 23, + 27, + 31, + 35, + 43, + 51, + 59, + 67, + 83, + 99, + 115, + 131, + 163, + 195, + 227, + 258, + 0, + 0 + ]); + var lext2 = new Uint8Array([ + /* Length codes 257..285 extra */ + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 17, + 17, + 17, + 17, + 18, + 18, + 18, + 18, + 19, + 19, + 19, + 19, + 20, + 20, + 20, + 20, + 21, + 21, + 21, + 21, + 16, + 72, + 78 + ]); + var dbase2 = new Uint16Array([ + /* Distance codes 0..29 base */ + 1, + 2, + 3, + 4, + 5, + 7, + 9, + 13, + 17, + 25, + 33, + 49, + 65, + 97, + 129, + 193, + 257, + 385, + 513, + 769, + 1025, + 1537, + 2049, + 3073, + 4097, + 6145, + 8193, + 12289, + 16385, + 24577, + 0, + 0 + ]); + var dext2 = new Uint8Array([ + /* Distance codes 0..29 extra */ + 16, + 16, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 64, + 64 + ]); + var inflate_table2 = (type, lens2, lens_index, codes, table, table_index, work, opts) => { + const bits = opts.bits; + let len2 = 0; + let sym = 0; + let min = 0, max = 0; + let root = 0; + let curr = 0; + let drop = 0; + let left = 0; + let used = 0; + let huff = 0; + let incr; + let fill; + let low; + let mask; + let next; + let base = null; + let base_index = 0; + let end; + const count2 = new Uint16Array(MAXBITS2 + 1); + const offs = new Uint16Array(MAXBITS2 + 1); + let extra = null; + let extra_index = 0; + let here_bits, here_op, here_val; + for (len2 = 0; len2 <= MAXBITS2; len2++) { + count2[len2] = 0; + } + for (sym = 0; sym < codes; sym++) { + count2[lens2[lens_index + sym]]++; + } + root = bits; + for (max = MAXBITS2; max >= 1; max--) { + if (count2[max] !== 0) { + break; } } - finalizeState(context) { - for (const model of this.getModels()) { - model.delete(); - } - const attributeManager = this.getAttributeManager(); - if (attributeManager) { - attributeManager.finalize(); - } - if (this.context) { - this.context.resourceManager.unsubscribe({ - consumerId: this.id - }); + if (root > max) { + root = max; + } + if (max === 0) { + table[table_index++] = 1 << 24 | 64 << 16 | 0; + table[table_index++] = 1 << 24 | 64 << 16 | 0; + opts.bits = 1; + return 0; + } + for (min = 1; min < max; min++) { + if (count2[min] !== 0) { + break; } - if (this.internalState) { - this.internalState.uniformTransitions.clear(); - this.internalState.finalize(); + } + if (root < min) { + root = min; + } + left = 1; + for (len2 = 1; len2 <= MAXBITS2; len2++) { + left <<= 1; + left -= count2[len2]; + if (left < 0) { + return -1; } } - draw(opts) { - for (const model of this.getModels()) { - model.draw(opts); + if (left > 0 && (type === CODES2 || max !== 1)) { + return -1; + } + offs[1] = 0; + for (len2 = 1; len2 < MAXBITS2; len2++) { + offs[len2 + 1] = offs[len2] + count2[len2]; + } + for (sym = 0; sym < codes; sym++) { + if (lens2[lens_index + sym] !== 0) { + work[offs[lens2[lens_index + sym]]++] = sym; } } - getPickingInfo({ - info, - mode, - sourceLayer - }) { - const { - index - } = info; - if (index >= 0) { - if (Array.isArray(this.props.data)) { - info.object = this.props.data[index]; + if (type === CODES2) { + base = extra = work; + end = 19; + } else if (type === LENS2) { + base = lbase2; + base_index -= 257; + extra = lext2; + extra_index -= 257; + end = 256; + } else { + base = dbase2; + extra = dext2; + end = -1; + } + huff = 0; + sym = 0; + len2 = min; + next = table_index; + curr = root; + drop = 0; + low = -1; + used = 1 << root; + mask = used - 1; + if (type === LENS2 && used > ENOUGH_LENS2 || type === DISTS2 && used > ENOUGH_DISTS2) { + return 1; + } + for (; ; ) { + here_bits = len2 - drop; + if (work[sym] < end) { + here_op = 0; + here_val = work[sym]; + } else if (work[sym] > end) { + here_op = extra[extra_index + work[sym]]; + here_val = base[base_index + work[sym]]; + } else { + here_op = 32 + 64; + here_val = 0; + } + incr = 1 << len2 - drop; + fill = 1 << curr; + min = fill; + do { + fill -= incr; + table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0; + } while (fill !== 0); + incr = 1 << len2 - 1; + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + sym++; + if (--count2[len2] === 0) { + if (len2 === max) { + break; } + len2 = lens2[lens_index + work[sym]]; + } + if (len2 > root && (huff & mask) !== low) { + if (drop === 0) { + drop = root; + } + next += min; + curr = len2 - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count2[curr + drop]; + if (left <= 0) { + break; + } + curr++; + left <<= 1; + } + used += 1 << curr; + if (type === LENS2 && used > ENOUGH_LENS2 || type === DISTS2 && used > ENOUGH_DISTS2) { + return 1; + } + low = huff & mask; + table[low] = root << 24 | curr << 16 | next - table_index | 0; } - return info; } - raiseError(error2, message) { - var _this$props$onError, _this$props; - if (message) { - error2 = new Error("".concat(message, ": ").concat(error2.message), { - cause: error2 - }); + if (huff !== 0) { + table[next + huff] = len2 - drop << 24 | 64 << 16 | 0; + } + opts.bits = root; + return 0; + }; + var inftrees2 = inflate_table2; + var CODES$12 = 0; + var LENS$12 = 1; + var DISTS$12 = 2; + var { + Z_FINISH: Z_FINISH$22, + Z_BLOCK: Z_BLOCK$12, + Z_TREES: Z_TREES2, + Z_OK: Z_OK$22, + Z_STREAM_END: Z_STREAM_END$22, + Z_NEED_DICT: Z_NEED_DICT2, + Z_STREAM_ERROR: Z_STREAM_ERROR$12, + Z_DATA_ERROR: Z_DATA_ERROR$12, + Z_MEM_ERROR: Z_MEM_ERROR2, + Z_BUF_ERROR: Z_BUF_ERROR$12, + Z_DEFLATED: Z_DEFLATED$22 + } = constants2; + var HEAD2 = 1; + var FLAGS2 = 2; + var TIME2 = 3; + var OS2 = 4; + var EXLEN2 = 5; + var EXTRA2 = 6; + var NAME2 = 7; + var COMMENT2 = 8; + var HCRC2 = 9; + var DICTID2 = 10; + var DICT2 = 11; + var TYPE$12 = 12; + var TYPEDO2 = 13; + var STORED2 = 14; + var COPY_2 = 15; + var COPY2 = 16; + var TABLE2 = 17; + var LENLENS2 = 18; + var CODELENS2 = 19; + var LEN_2 = 20; + var LEN2 = 21; + var LENEXT2 = 22; + var DIST2 = 23; + var DISTEXT2 = 24; + var MATCH2 = 25; + var LIT2 = 26; + var CHECK2 = 27; + var LENGTH2 = 28; + var DONE2 = 29; + var BAD$12 = 30; + var MEM2 = 31; + var SYNC2 = 32; + var ENOUGH_LENS$12 = 852; + var ENOUGH_DISTS$12 = 592; + var MAX_WBITS$12 = 15; + var DEF_WBITS2 = MAX_WBITS$12; + var zswap322 = (q) => { + return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24); + }; + function InflateState2() { + this.mode = 0; + this.last = false; + this.wrap = 0; + this.havedict = false; + this.flags = 0; + this.dmax = 0; + this.check = 0; + this.total = 0; + this.head = null; + this.wbits = 0; + this.wsize = 0; + this.whave = 0; + this.wnext = 0; + this.window = null; + this.hold = 0; + this.bits = 0; + this.length = 0; + this.offset = 0; + this.extra = 0; + this.lencode = null; + this.distcode = null; + this.lenbits = 0; + this.distbits = 0; + this.ncode = 0; + this.nlen = 0; + this.ndist = 0; + this.have = 0; + this.next = null; + this.lens = new Uint16Array(320); + this.work = new Uint16Array(288); + this.lendyn = null; + this.distdyn = null; + this.sane = 0; + this.back = 0; + this.was = 0; + } + var inflateResetKeep2 = (strm) => { + if (!strm || !strm.state) { + return Z_STREAM_ERROR$12; + } + const state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ""; + if (state.wrap) { + strm.adler = state.wrap & 1; + } + state.mode = HEAD2; + state.last = 0; + state.havedict = 0; + state.dmax = 32768; + state.head = null; + state.hold = 0; + state.bits = 0; + state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS$12); + state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS$12); + state.sane = 1; + state.back = -1; + return Z_OK$22; + }; + var inflateReset3 = (strm) => { + if (!strm || !strm.state) { + return Z_STREAM_ERROR$12; + } + const state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep2(strm); + }; + var inflateReset22 = (strm, windowBits) => { + let wrap; + if (!strm || !strm.state) { + return Z_STREAM_ERROR$12; + } + const state = strm.state; + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else { + wrap = (windowBits >> 4) + 1; + if (windowBits < 48) { + windowBits &= 15; } - if (!((_this$props$onError = (_this$props = this.props).onError) !== null && _this$props$onError !== void 0 && _this$props$onError.call(_this$props, error2))) { - var _this$context, _this$context$onError; - (_this$context = this.context) === null || _this$context === void 0 ? void 0 : (_this$context$onError = _this$context.onError) === null || _this$context$onError === void 0 ? void 0 : _this$context$onError.call(_this$context, error2, this); + } + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR$12; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset3(strm); + }; + var inflateInit22 = (strm, windowBits) => { + if (!strm) { + return Z_STREAM_ERROR$12; + } + const state = new InflateState2(); + strm.state = state; + state.window = null; + const ret = inflateReset22(strm, windowBits); + if (ret !== Z_OK$22) { + strm.state = null; + } + return ret; + }; + var inflateInit3 = (strm) => { + return inflateInit22(strm, DEF_WBITS2); + }; + var virgin2 = true; + var lenfix2; + var distfix2; + var fixedtables2 = (state) => { + if (virgin2) { + lenfix2 = new Int32Array(512); + distfix2 = new Int32Array(32); + let sym = 0; + while (sym < 144) { + state.lens[sym++] = 8; + } + while (sym < 256) { + state.lens[sym++] = 9; + } + while (sym < 280) { + state.lens[sym++] = 7; + } + while (sym < 288) { + state.lens[sym++] = 8; + } + inftrees2(LENS$12, state.lens, 0, 288, lenfix2, 0, state.work, { bits: 9 }); + sym = 0; + while (sym < 32) { + state.lens[sym++] = 5; + } + inftrees2(DISTS$12, state.lens, 0, 32, distfix2, 0, state.work, { bits: 5 }); + virgin2 = false; + } + state.lencode = lenfix2; + state.lenbits = 9; + state.distcode = distfix2; + state.distbits = 5; + }; + var updatewindow2 = (strm, src, end, copy3) => { + let dist; + const state = strm.state; + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + state.window = new Uint8Array(state.wsize); + } + if (copy3 >= state.wsize) { + state.window.set(src.subarray(end - state.wsize, end), 0); + state.wnext = 0; + state.whave = state.wsize; + } else { + dist = state.wsize - state.wnext; + if (dist > copy3) { + dist = copy3; + } + state.window.set(src.subarray(end - copy3, end - copy3 + dist), state.wnext); + copy3 -= dist; + if (copy3) { + state.window.set(src.subarray(end - copy3, end), 0); + state.wnext = copy3; + state.whave = state.wsize; + } else { + state.wnext += dist; + if (state.wnext === state.wsize) { + state.wnext = 0; + } + if (state.whave < state.wsize) { + state.whave += dist; + } } } - getNeedsRedraw(opts = { - clearRedrawFlags: false - }) { - return this._getNeedsRedraw(opts); + return 0; + }; + var inflate2 = (strm, flush) => { + let state; + let input, output; + let next; + let put; + let have, left; + let hold; + let bits; + let _in, _out; + let copy3; + let from; + let from_source; + let here = 0; + let here_bits, here_op, here_val; + let last_bits, last_op, last_val; + let len2; + let ret; + const hbuf = new Uint8Array(4); + let opts; + let n2; + const order = ( + /* permutation of code lengths */ + new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]) + ); + if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) { + return Z_STREAM_ERROR$12; + } + state = strm.state; + if (state.mode === TYPE$12) { + state.mode = TYPEDO2; + } + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + _in = have; + _out = left; + ret = Z_OK$22; + inf_leave: + for (; ; ) { + switch (state.mode) { + case HEAD2: + if (state.wrap === 0) { + state.mode = TYPEDO2; + break; + } + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.wrap & 2 && hold === 35615) { + state.check = 0; + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32_12(state.check, hbuf, 2, 0); + hold = 0; + bits = 0; + state.mode = FLAGS2; + break; + } + state.flags = 0; + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || /* check if zlib header allowed */ + (((hold & 255) << 8) + (hold >> 8)) % 31) { + strm.msg = "incorrect header check"; + state.mode = BAD$12; + break; + } + if ((hold & 15) !== Z_DEFLATED$22) { + strm.msg = "unknown compression method"; + state.mode = BAD$12; + break; + } + hold >>>= 4; + bits -= 4; + len2 = (hold & 15) + 8; + if (state.wbits === 0) { + state.wbits = len2; + } else if (len2 > state.wbits) { + strm.msg = "invalid window size"; + state.mode = BAD$12; + break; + } + state.dmax = 1 << state.wbits; + strm.adler = state.check = 1; + state.mode = hold & 512 ? DICTID2 : TYPE$12; + hold = 0; + bits = 0; + break; + case FLAGS2: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.flags = hold; + if ((state.flags & 255) !== Z_DEFLATED$22) { + strm.msg = "unknown compression method"; + state.mode = BAD$12; + break; + } + if (state.flags & 57344) { + strm.msg = "unknown header flags set"; + state.mode = BAD$12; + break; + } + if (state.head) { + state.head.text = hold >> 8 & 1; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32_12(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = TIME2; + case TIME2: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.time = hold; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + hbuf[2] = hold >>> 16 & 255; + hbuf[3] = hold >>> 24 & 255; + state.check = crc32_12(state.check, hbuf, 4, 0); + } + hold = 0; + bits = 0; + state.mode = OS2; + case OS2: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.xflags = hold & 255; + state.head.os = hold >> 8; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32_12(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = EXLEN2; + case EXLEN2: + if (state.flags & 1024) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32_12(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + } else if (state.head) { + state.head.extra = null; + } + state.mode = EXTRA2; + case EXTRA2: + if (state.flags & 1024) { + copy3 = state.length; + if (copy3 > have) { + copy3 = have; + } + if (copy3) { + if (state.head) { + len2 = state.head.extra_len - state.length; + if (!state.head.extra) { + state.head.extra = new Uint8Array(state.head.extra_len); + } + state.head.extra.set( + input.subarray( + next, + // extra field is limited to 65536 bytes + // - no need for additional size check + next + copy3 + ), + /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ + len2 + ); + } + if (state.flags & 512) { + state.check = crc32_12(state.check, input, copy3, next); + } + have -= copy3; + next += copy3; + state.length -= copy3; + } + if (state.length) { + break inf_leave; + } + } + state.length = 0; + state.mode = NAME2; + case NAME2: + if (state.flags & 2048) { + if (have === 0) { + break inf_leave; + } + copy3 = 0; + do { + len2 = input[next + copy3++]; + if (state.head && len2 && state.length < 65536) { + state.head.name += String.fromCharCode(len2); + } + } while (len2 && copy3 < have); + if (state.flags & 512) { + state.check = crc32_12(state.check, input, copy3, next); + } + have -= copy3; + next += copy3; + if (len2) { + break inf_leave; + } + } else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT2; + case COMMENT2: + if (state.flags & 4096) { + if (have === 0) { + break inf_leave; + } + copy3 = 0; + do { + len2 = input[next + copy3++]; + if (state.head && len2 && state.length < 65536) { + state.head.comment += String.fromCharCode(len2); + } + } while (len2 && copy3 < have); + if (state.flags & 512) { + state.check = crc32_12(state.check, input, copy3, next); + } + have -= copy3; + next += copy3; + if (len2) { + break inf_leave; + } + } else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC2; + case HCRC2: + if (state.flags & 512) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (hold !== (state.check & 65535)) { + strm.msg = "header crc mismatch"; + state.mode = BAD$12; + break; + } + hold = 0; + bits = 0; + } + if (state.head) { + state.head.hcrc = state.flags >> 9 & 1; + state.head.done = true; + } + strm.adler = state.check = 0; + state.mode = TYPE$12; + break; + case DICTID2: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + strm.adler = state.check = zswap322(hold); + hold = 0; + bits = 0; + state.mode = DICT2; + case DICT2: + if (state.havedict === 0) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + return Z_NEED_DICT2; + } + strm.adler = state.check = 1; + state.mode = TYPE$12; + case TYPE$12: + if (flush === Z_BLOCK$12 || flush === Z_TREES2) { + break inf_leave; + } + case TYPEDO2: + if (state.last) { + hold >>>= bits & 7; + bits -= bits & 7; + state.mode = CHECK2; + break; + } + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.last = hold & 1; + hold >>>= 1; + bits -= 1; + switch (hold & 3) { + case 0: + state.mode = STORED2; + break; + case 1: + fixedtables2(state); + state.mode = LEN_2; + if (flush === Z_TREES2) { + hold >>>= 2; + bits -= 2; + break inf_leave; + } + break; + case 2: + state.mode = TABLE2; + break; + case 3: + strm.msg = "invalid block type"; + state.mode = BAD$12; + } + hold >>>= 2; + bits -= 2; + break; + case STORED2: + hold >>>= bits & 7; + bits -= bits & 7; + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((hold & 65535) !== (hold >>> 16 ^ 65535)) { + strm.msg = "invalid stored block lengths"; + state.mode = BAD$12; + break; + } + state.length = hold & 65535; + hold = 0; + bits = 0; + state.mode = COPY_2; + if (flush === Z_TREES2) { + break inf_leave; + } + case COPY_2: + state.mode = COPY2; + case COPY2: + copy3 = state.length; + if (copy3) { + if (copy3 > have) { + copy3 = have; + } + if (copy3 > left) { + copy3 = left; + } + if (copy3 === 0) { + break inf_leave; + } + output.set(input.subarray(next, next + copy3), put); + have -= copy3; + next += copy3; + left -= copy3; + put += copy3; + state.length -= copy3; + break; + } + state.mode = TYPE$12; + break; + case TABLE2: + while (bits < 14) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.nlen = (hold & 31) + 257; + hold >>>= 5; + bits -= 5; + state.ndist = (hold & 31) + 1; + hold >>>= 5; + bits -= 5; + state.ncode = (hold & 15) + 4; + hold >>>= 4; + bits -= 4; + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = "too many length or distance symbols"; + state.mode = BAD$12; + break; + } + state.have = 0; + state.mode = LENLENS2; + case LENLENS2: + while (state.have < state.ncode) { + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.lens[order[state.have++]] = hold & 7; + hold >>>= 3; + bits -= 3; + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + state.lencode = state.lendyn; + state.lenbits = 7; + opts = { bits: state.lenbits }; + ret = inftrees2(CODES$12, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid code lengths set"; + state.mode = BAD$12; + break; + } + state.have = 0; + state.mode = CODELENS2; + case CODELENS2: + while (state.have < state.nlen + state.ndist) { + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_val < 16) { + hold >>>= here_bits; + bits -= here_bits; + state.lens[state.have++] = here_val; + } else { + if (here_val === 16) { + n2 = here_bits + 2; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + if (state.have === 0) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD$12; + break; + } + len2 = state.lens[state.have - 1]; + copy3 = 3 + (hold & 3); + hold >>>= 2; + bits -= 2; + } else if (here_val === 17) { + n2 = here_bits + 3; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len2 = 0; + copy3 = 3 + (hold & 7); + hold >>>= 3; + bits -= 3; + } else { + n2 = here_bits + 7; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len2 = 0; + copy3 = 11 + (hold & 127); + hold >>>= 7; + bits -= 7; + } + if (state.have + copy3 > state.nlen + state.ndist) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD$12; + break; + } + while (copy3--) { + state.lens[state.have++] = len2; + } + } + } + if (state.mode === BAD$12) { + break; + } + if (state.lens[256] === 0) { + strm.msg = "invalid code -- missing end-of-block"; + state.mode = BAD$12; + break; + } + state.lenbits = 9; + opts = { bits: state.lenbits }; + ret = inftrees2(LENS$12, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid literal/lengths set"; + state.mode = BAD$12; + break; + } + state.distbits = 6; + state.distcode = state.distdyn; + opts = { bits: state.distbits }; + ret = inftrees2(DISTS$12, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + state.distbits = opts.bits; + if (ret) { + strm.msg = "invalid distances set"; + state.mode = BAD$12; + break; + } + state.mode = LEN_2; + if (flush === Z_TREES2) { + break inf_leave; + } + case LEN_2: + state.mode = LEN2; + case LEN2: + if (have >= 6 && left >= 258) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + inffast2(strm, _out); + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + if (state.mode === TYPE$12) { + state.back = -1; + } + break; + } + state.back = 0; + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_op && (here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + state.mode = LIT2; + break; + } + if (here_op & 32) { + state.back = -1; + state.mode = TYPE$12; + break; + } + if (here_op & 64) { + strm.msg = "invalid literal/length code"; + state.mode = BAD$12; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT2; + case LENEXT2: + if (state.extra) { + n2 = state.extra; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + state.was = state.length; + state.mode = DIST2; + case DIST2: + for (; ; ) { + here = state.distcode[hold & (1 << state.distbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + if (here_op & 64) { + strm.msg = "invalid distance code"; + state.mode = BAD$12; + break; + } + state.offset = here_val; + state.extra = here_op & 15; + state.mode = DISTEXT2; + case DISTEXT2: + if (state.extra) { + n2 = state.extra; + while (bits < n2) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.offset += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + if (state.offset > state.dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD$12; + break; + } + state.mode = MATCH2; + case MATCH2: + if (left === 0) { + break inf_leave; + } + copy3 = _out - left; + if (state.offset > copy3) { + copy3 = state.offset - copy3; + if (copy3 > state.whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD$12; + break; + } + } + if (copy3 > state.wnext) { + copy3 -= state.wnext; + from = state.wsize - copy3; + } else { + from = state.wnext - copy3; + } + if (copy3 > state.length) { + copy3 = state.length; + } + from_source = state.window; + } else { + from_source = output; + from = put - state.offset; + copy3 = state.length; + } + if (copy3 > left) { + copy3 = left; + } + left -= copy3; + state.length -= copy3; + do { + output[put++] = from_source[from++]; + } while (--copy3); + if (state.length === 0) { + state.mode = LEN2; + } + break; + case LIT2: + if (left === 0) { + break inf_leave; + } + output[put++] = state.length; + left--; + state.mode = LEN2; + break; + case CHECK2: + if (state.wrap) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold |= input[next++] << bits; + bits += 8; + } + _out -= left; + strm.total_out += _out; + state.total += _out; + if (_out) { + strm.adler = state.check = /*UPDATE(state.check, put - _out, _out);*/ + state.flags ? crc32_12(state.check, output, _out, put - _out) : adler32_12(state.check, output, _out, put - _out); + } + _out = left; + if ((state.flags ? hold : zswap322(hold)) !== state.check) { + strm.msg = "incorrect data check"; + state.mode = BAD$12; + break; + } + hold = 0; + bits = 0; + } + state.mode = LENGTH2; + case LENGTH2: + if (state.wrap && state.flags) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (hold !== (state.total & 4294967295)) { + strm.msg = "incorrect length check"; + state.mode = BAD$12; + break; + } + hold = 0; + bits = 0; + } + state.mode = DONE2; + case DONE2: + ret = Z_STREAM_END$22; + break inf_leave; + case BAD$12: + ret = Z_DATA_ERROR$12; + break inf_leave; + case MEM2: + return Z_MEM_ERROR2; + case SYNC2: + default: + return Z_STREAM_ERROR$12; + } + } + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + if (state.wsize || _out !== strm.avail_out && state.mode < BAD$12 && (state.mode < CHECK2 || flush !== Z_FINISH$22)) { + if (updatewindow2(strm, strm.output, strm.next_out, _out - strm.avail_out)) + ; + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap && _out) { + strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/ + state.flags ? crc32_12(state.check, output, _out, strm.next_out - _out) : adler32_12(state.check, output, _out, strm.next_out - _out); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE$12 ? 128 : 0) + (state.mode === LEN_2 || state.mode === COPY_2 ? 256 : 0); + if ((_in === 0 && _out === 0 || flush === Z_FINISH$22) && ret === Z_OK$22) { + ret = Z_BUF_ERROR$12; + } + return ret; + }; + var inflateEnd2 = (strm) => { + if (!strm || !strm.state) { + return Z_STREAM_ERROR$12; + } + let state = strm.state; + if (state.window) { + state.window = null; } - needsUpdate() { - if (!this.internalState) { - return false; - } - return this.internalState.needsUpdate || this.hasUniformTransition() || this.shouldUpdateState(this._getUpdateParams()); + strm.state = null; + return Z_OK$22; + }; + var inflateGetHeader2 = (strm, head) => { + if (!strm || !strm.state) { + return Z_STREAM_ERROR$12; } - hasUniformTransition() { - var _this$internalState; - return ((_this$internalState = this.internalState) === null || _this$internalState === void 0 ? void 0 : _this$internalState.uniformTransitions.active) || false; + const state = strm.state; + if ((state.wrap & 2) === 0) { + return Z_STREAM_ERROR$12; } - activateViewport(viewport) { - if (!this.internalState) { - return; + state.head = head; + head.done = false; + return Z_OK$22; + }; + var inflateSetDictionary2 = (strm, dictionary) => { + const dictLength = dictionary.length; + let state; + let dictid; + let ret; + if (!strm || !strm.state) { + return Z_STREAM_ERROR$12; + } + state = strm.state; + if (state.wrap !== 0 && state.mode !== DICT2) { + return Z_STREAM_ERROR$12; + } + if (state.mode === DICT2) { + dictid = 1; + dictid = adler32_12(dictid, dictionary, dictLength, 0); + if (dictid !== state.check) { + return Z_DATA_ERROR$12; + } + } + ret = updatewindow2(strm, dictionary, dictLength, dictLength); + if (ret) { + state.mode = MEM2; + return Z_MEM_ERROR2; + } + state.havedict = 1; + return Z_OK$22; + }; + var inflateReset_12 = inflateReset3; + var inflateReset2_12 = inflateReset22; + var inflateResetKeep_12 = inflateResetKeep2; + var inflateInit_12 = inflateInit3; + var inflateInit2_12 = inflateInit22; + var inflate_22 = inflate2; + var inflateEnd_12 = inflateEnd2; + var inflateGetHeader_12 = inflateGetHeader2; + var inflateSetDictionary_12 = inflateSetDictionary2; + var inflateInfo2 = "pako inflate (from Nodeca project)"; + var inflate_12 = { + inflateReset: inflateReset_12, + inflateReset2: inflateReset2_12, + inflateResetKeep: inflateResetKeep_12, + inflateInit: inflateInit_12, + inflateInit2: inflateInit2_12, + inflate: inflate_22, + inflateEnd: inflateEnd_12, + inflateGetHeader: inflateGetHeader_12, + inflateSetDictionary: inflateSetDictionary_12, + inflateInfo: inflateInfo2 + }; + function GZheader2() { + this.text = 0; + this.time = 0; + this.xflags = 0; + this.os = 0; + this.extra = null; + this.extra_len = 0; + this.name = ""; + this.comment = ""; + this.hcrc = 0; + this.done = false; + } + var gzheader2 = GZheader2; + var toString$12 = Object.prototype.toString; + var { + Z_NO_FLUSH: Z_NO_FLUSH$22, + Z_FINISH: Z_FINISH$32, + Z_OK: Z_OK$32, + Z_STREAM_END: Z_STREAM_END$32, + Z_NEED_DICT: Z_NEED_DICT$12, + Z_STREAM_ERROR: Z_STREAM_ERROR$22, + Z_DATA_ERROR: Z_DATA_ERROR$22, + Z_MEM_ERROR: Z_MEM_ERROR$12 + } = constants2; + function Inflate2(options) { + this.options = common2.assign({ + chunkSize: 1024 * 64, + windowBits: 15, + to: "" + }, options || {}); + const opt = this.options; + if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) { + opt.windowBits = -opt.windowBits; + if (opt.windowBits === 0) { + opt.windowBits = -15; + } + } + if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) { + opt.windowBits += 32; + } + if (opt.windowBits > 15 && opt.windowBits < 48) { + if ((opt.windowBits & 15) === 0) { + opt.windowBits |= 15; + } + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new zstream2(); + this.strm.avail_out = 0; + let status = inflate_12.inflateInit2( + this.strm, + opt.windowBits + ); + if (status !== Z_OK$32) { + throw new Error(messages2[status]); + } + this.header = new gzheader2(); + inflate_12.inflateGetHeader(this.strm, this.header); + if (opt.dictionary) { + if (typeof opt.dictionary === "string") { + opt.dictionary = strings2.string2buf(opt.dictionary); + } else if (toString$12.call(opt.dictionary) === "[object ArrayBuffer]") { + opt.dictionary = new Uint8Array(opt.dictionary); + } + if (opt.raw) { + status = inflate_12.inflateSetDictionary(this.strm, opt.dictionary); + if (status !== Z_OK$32) { + throw new Error(messages2[status]); + } + } + } + } + Inflate2.prototype.push = function(data, flush_mode) { + const strm = this.strm; + const chunkSize = this.options.chunkSize; + const dictionary = this.options.dictionary; + let status, _flush_mode, last_avail_out; + if (this.ended) + return false; + if (flush_mode === ~~flush_mode) + _flush_mode = flush_mode; + else + _flush_mode = flush_mode === true ? Z_FINISH$32 : Z_NO_FLUSH$22; + if (toString$12.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + for (; ; ) { + if (strm.avail_out === 0) { + strm.output = new Uint8Array(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status = inflate_12.inflate(strm, _flush_mode); + if (status === Z_NEED_DICT$12 && dictionary) { + status = inflate_12.inflateSetDictionary(strm, dictionary); + if (status === Z_OK$32) { + status = inflate_12.inflate(strm, _flush_mode); + } else if (status === Z_DATA_ERROR$22) { + status = Z_NEED_DICT$12; + } + } + while (strm.avail_in > 0 && status === Z_STREAM_END$32 && strm.state.wrap > 0 && data[strm.next_in] !== 0) { + inflate_12.inflateReset(strm); + status = inflate_12.inflate(strm, _flush_mode); + } + switch (status) { + case Z_STREAM_ERROR$22: + case Z_DATA_ERROR$22: + case Z_NEED_DICT$12: + case Z_MEM_ERROR$12: + this.onEnd(status); + this.ended = true; + return false; } - const oldViewport = this.internalState.viewport; - this.internalState.viewport = viewport; - if (!oldViewport || !areViewportsEqual({ - oldViewport, - viewport - })) { - this.setChangeFlags({ - viewportChanged: true - }); - if (this.isComposite) { - if (this.needsUpdate()) { - this.setNeedsUpdate(); + last_avail_out = strm.avail_out; + if (strm.next_out) { + if (strm.avail_out === 0 || status === Z_STREAM_END$32) { + if (this.options.to === "string") { + let next_out_utf8 = strings2.utf8border(strm.output, strm.next_out); + let tail = strm.next_out - next_out_utf8; + let utf8str = strings2.buf2string(strm.output, next_out_utf8); + strm.next_out = tail; + strm.avail_out = chunkSize - tail; + if (tail) + strm.output.set(strm.output.subarray(next_out_utf8, next_out_utf8 + tail), 0); + this.onData(utf8str); + } else { + this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out)); } - } else { - this._update(); } } - } - invalidateAttribute(name = "all") { - const attributeManager = this.getAttributeManager(); - if (!attributeManager) { - return; + if (status === Z_OK$32 && last_avail_out === 0) + continue; + if (status === Z_STREAM_END$32) { + status = inflate_12.inflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return true; } - if (name === "all") { - attributeManager.invalidateAll(); + if (strm.avail_in === 0) + break; + } + return true; + }; + Inflate2.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Inflate2.prototype.onEnd = function(status) { + if (status === Z_OK$32) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); } else { - attributeManager.invalidate(name); + this.result = common2.flattenChunks(this.chunks); } } - updateAttributes(changedAttributes) { - for (const model of this.getModels()) { - this._setModelAttributes(model, changedAttributes); + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + function inflate$12(input, options) { + const inflator = new Inflate2(options); + inflator.push(input); + if (inflator.err) + throw inflator.msg || messages2[inflator.err]; + return inflator.result; + } + function inflateRaw2(input, options) { + options = options || {}; + options.raw = true; + return inflate$12(input, options); + } + var Inflate_1 = Inflate2; + var inflate_2$12 = inflate$12; + var inflateRaw_1 = inflateRaw2; + var ungzip2 = inflate$12; + var constants$22 = constants2; + var inflate_1$12 = { + Inflate: Inflate_1, + inflate: inflate_2$12, + inflateRaw: inflateRaw_1, + ungzip: ungzip2, + constants: constants$22 + }; + var { Deflate: Deflate$12, deflate: deflate$22, deflateRaw: deflateRaw$12, gzip: gzip$12 } = deflate_1$12; + var { Inflate: Inflate$12, inflate: inflate$22, inflateRaw: inflateRaw$12, ungzip: ungzip$12 } = inflate_1$12; + var Deflate_1$12 = Deflate$12; + var deflate_1$22 = deflate$22; + var deflateRaw_1$12 = deflateRaw$12; + var gzip_1$12 = gzip$12; + var Inflate_1$12 = Inflate$12; + var inflate_1$22 = inflate$22; + var inflateRaw_1$12 = inflateRaw$12; + var ungzip_1 = ungzip$12; + var constants_1 = constants2; + var pako = { + Deflate: Deflate_1$12, + deflate: deflate_1$22, + deflateRaw: deflateRaw_1$12, + gzip: gzip_1$12, + Inflate: Inflate_1$12, + inflate: inflate_1$22, + inflateRaw: inflateRaw_1$12, + ungzip: ungzip_1, + constants: constants_1 + }; + var _a$2; + var GZip = (_a$2 = class { + constructor(level = 1) { + if (level < 0 || level > 9) { + throw new Error("Invalid gzip compression level, it should be between 0 and 9"); } + this.level = level; } - _updateAttributes() { - const attributeManager = this.getAttributeManager(); - if (!attributeManager) { - return; - } - const props = this.props; - const numInstances = this.getNumInstances(); - const startIndices = this.getStartIndices(); - attributeManager.update({ - data: props.data, - numInstances, - startIndices, - props, - transitions: props.transitions, - buffers: props.data.attributes, - context: this - }); - const changedAttributes = attributeManager.getChangedAttributes({ - clearChangedFlags: true - }); - this.updateAttributes(changedAttributes); + static fromConfig({ level }) { + return new _a$2(level); } - _updateAttributeTransition() { - const attributeManager = this.getAttributeManager(); - if (attributeManager) { - attributeManager.updateTransition(); - } + encode(data) { + const gzipped = pako.gzip(data, { level: this.level }); + return gzipped; } - _updateUniformTransition() { - const { - uniformTransitions - } = this.internalState; - if (uniformTransitions.active) { - const propsInTransition = uniformTransitions.update(); - const props = Object.create(this.props); - for (const key in propsInTransition) { - Object.defineProperty(props, key, { - value: propsInTransition[key] - }); - } - return props; + decode(data, out) { + const uncompressed = pako.ungzip(data); + if (out !== void 0) { + out.set(uncompressed); + return out; } - return this.props; + return uncompressed; } - calculateInstancePickingColors(attribute, { - numInstances - }) { - if (attribute.constant) { - return; - } - const cacheSize = Math.floor(pickingColorCache.length / 3); - this.internalState.usesPickingColorCache = true; - if (cacheSize < numInstances) { - if (numInstances > MAX_PICKING_COLOR_CACHE_SIZE) { - log_default.warn("Layer has too many data objects. Picking might not be able to distinguish all objects.")(); - } - pickingColorCache = typed_array_manager_default.allocate(pickingColorCache, numInstances, { - size: 3, - copy: true, - maxCount: Math.max(numInstances, MAX_PICKING_COLOR_CACHE_SIZE) - }); - const newCacheSize = Math.floor(pickingColorCache.length / 3); - const pickingColor = []; - for (let i2 = cacheSize; i2 < newCacheSize; i2++) { - this.encodePickingColor(i2, pickingColor); - pickingColorCache[i2 * 3 + 0] = pickingColor[0]; - pickingColorCache[i2 * 3 + 1] = pickingColor[1]; - pickingColorCache[i2 * 3 + 2] = pickingColor[2]; - } + }, _a$2.codecId = "gzip", _a$2); + var GZip$1 = GZip; + var _a$1; + var Zlib = (_a$1 = class { + constructor(level = 1) { + if (level < -1 || level > 9) { + throw new Error("Invalid zlib compression level, it should be between -1 and 9"); } - attribute.value = pickingColorCache.subarray(0, numInstances * 3); - } - _setModelAttributes(model, changedAttributes) { - const attributeManager = this.getAttributeManager(); - const excludeAttributes = model.userData.excludeAttributes || {}; - const shaderAttributes = attributeManager.getShaderAttributes(changedAttributes, excludeAttributes); - model.setAttributes(shaderAttributes); + this.level = level; } - disablePickingIndex(objectIndex) { - const data = this.props.data; - if (!("attributes" in data)) { - this._disablePickingIndex(objectIndex); - return; - } - const { - pickingColors, - instancePickingColors - } = this.getAttributeManager().attributes; - const colors = pickingColors || instancePickingColors; - const externalColorAttribute = colors && data.attributes && data.attributes[colors.id]; - if (externalColorAttribute && externalColorAttribute.value) { - const values = externalColorAttribute.value; - const objectColor = this.encodePickingColor(objectIndex); - for (let index = 0; index < data.length; index++) { - const i2 = colors.getVertexOffset(index); - if (values[i2] === objectColor[0] && values[i2 + 1] === objectColor[1] && values[i2 + 2] === objectColor[2]) { - this._disablePickingIndex(index); - } - } - } else { - this._disablePickingIndex(objectIndex); - } + static fromConfig({ level }) { + return new _a$1(level); } - _disablePickingIndex(objectIndex) { - const { - pickingColors, - instancePickingColors - } = this.getAttributeManager().attributes; - const colors = pickingColors || instancePickingColors; - if (!colors) { - return; - } - const start = colors.getVertexOffset(objectIndex); - const end = colors.getVertexOffset(objectIndex + 1); - colors.buffer.subData({ - data: new Uint8Array(end - start), - offset: start - }); + encode(data) { + const gzipped = pako.deflate(data, { level: this.level }); + return gzipped; } - restorePickingColors() { - const { - pickingColors, - instancePickingColors - } = this.getAttributeManager().attributes; - const colors = pickingColors || instancePickingColors; - if (!colors) { - return; - } - if (this.internalState.usesPickingColorCache && colors.value.buffer !== pickingColorCache.buffer) { - colors.value = pickingColorCache.subarray(0, colors.value.length); + decode(data, out) { + const uncompressed = pako.inflate(data); + if (out !== void 0) { + out.set(uncompressed); + return out; } - colors.updateSubBuffer({ - startOffset: 0 + return uncompressed; + } + }, _a$1.codecId = "zlib", _a$1); + var Zlib$1 = Zlib; + var blosc_codec = function() { + typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0; + return function(blosc_codec2) { + blosc_codec2 = blosc_codec2 || {}; + var f2; + f2 || (f2 = typeof blosc_codec2 !== "undefined" ? blosc_codec2 : {}); + var aa, ba; + f2.ready = new Promise(function(a2, b2) { + aa = a2; + ba = b2; }); - } - _initialize() { - assert10(!this.internalState); - assert10(Number.isFinite(this.props.coordinateSystem)); - debug(TRACE_INITIALIZE, this); - const attributeManager = this._getAttributeManager(); - if (attributeManager) { - attributeManager.addInstanced({ - instancePickingColors: { - type: 5121, - size: 3, - noAlloc: true, - update: this.calculateInstancePickingColors + var r2 = {}, t2; + for (t2 in f2) + f2.hasOwnProperty(t2) && (r2[t2] = f2[t2]); + var ca = "./this.program", da = f2.print || console.log.bind(console), u2 = f2.printErr || console.warn.bind(console); + for (t2 in r2) + r2.hasOwnProperty(t2) && (f2[t2] = r2[t2]); + r2 = null; + f2.thisProgram && (ca = f2.thisProgram); + var v2; + f2.wasmBinary && (v2 = f2.wasmBinary); + f2.noExitRuntime && f2.noExitRuntime; + typeof WebAssembly !== "object" && w3("no native wasm support detected"); + var y2, ea = false, fa = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : void 0; + function ha(a2, b2, c2) { + var d2 = b2 + c2; + for (c2 = b2; a2[c2] && !(c2 >= d2); ) + ++c2; + if (16 < c2 - b2 && a2.subarray && fa) + return fa.decode(a2.subarray(b2, c2)); + for (d2 = ""; b2 < c2; ) { + var e2 = a2[b2++]; + if (e2 & 128) { + var g3 = a2[b2++] & 63; + if ((e2 & 224) == 192) + d2 += String.fromCharCode((e2 & 31) << 6 | g3); + else { + var k = a2[b2++] & 63; + e2 = (e2 & 240) == 224 ? (e2 & 15) << 12 | g3 << 6 | k : (e2 & 7) << 18 | g3 << 12 | k << 6 | a2[b2++] & 63; + 65536 > e2 ? d2 += String.fromCharCode(e2) : (e2 -= 65536, d2 += String.fromCharCode(55296 | e2 >> 10, 56320 | e2 & 1023)); + } + } else + d2 += String.fromCharCode(e2); + } + return d2; + } + function ia(a2, b2, c2) { + var d2 = z; + if (0 < c2) { + c2 = b2 + c2 - 1; + for (var e2 = 0; e2 < a2.length; ++e2) { + var g3 = a2.charCodeAt(e2); + if (55296 <= g3 && 57343 >= g3) { + var k = a2.charCodeAt(++e2); + g3 = 65536 + ((g3 & 1023) << 10) | k & 1023; + } + if (127 >= g3) { + if (b2 >= c2) + break; + d2[b2++] = g3; + } else { + if (2047 >= g3) { + if (b2 + 1 >= c2) + break; + d2[b2++] = 192 | g3 >> 6; + } else { + if (65535 >= g3) { + if (b2 + 2 >= c2) + break; + d2[b2++] = 224 | g3 >> 12; + } else { + if (b2 + 3 >= c2) + break; + d2[b2++] = 240 | g3 >> 18; + d2[b2++] = 128 | g3 >> 12 & 63; + } + d2[b2++] = 128 | g3 >> 6 & 63; + } + d2[b2++] = 128 | g3 & 63; + } } - }); - } - this.internalState = new LayerState({ - attributeManager, - layer: this - }); - this._clearChangeFlags(); - this.state = {}; - Object.defineProperty(this.state, "attributeManager", { - get: () => { - log_default.deprecated("layer.state.attributeManager", "layer.getAttributeManager()")(); - return attributeManager; - } - }); - this.internalState.uniformTransitions = new UniformTransitionManager(this.context.timeline); - this.internalState.onAsyncPropUpdated = this._onAsyncPropUpdated.bind(this); - this.internalState.setAsyncProps(this.props); - this.initializeState(this.context); - for (const extension of this.props.extensions) { - extension.initializeState.call(this, this.context, extension); - } - this.setChangeFlags({ - dataChanged: "init", - propsChanged: "init", - viewportChanged: true, - extensionsChanged: true - }); - this._update(); - } - _transferState(oldLayer) { - debug(TRACE_MATCHED, this, this === oldLayer); - const { - state, - internalState - } = oldLayer; - if (this === oldLayer) { - return; - } - this.internalState = internalState; - this.state = state; - this.internalState.setAsyncProps(this.props); - this._diffProps(this.props, this.internalState.getOldProps()); - } - _update() { - const stateNeedsUpdate = this.needsUpdate(); - debug(TRACE_UPDATE, this, stateNeedsUpdate); - if (!stateNeedsUpdate) { - return; - } - const currentProps = this.props; - const context = this.context; - const internalState = this.internalState; - const currentViewport = context.viewport; - const propsInTransition = this._updateUniformTransition(); - internalState.propsInTransition = propsInTransition; - context.viewport = internalState.viewport || currentViewport; - this.props = propsInTransition; - try { - const updateParams = this._getUpdateParams(); - const oldModels = this.getModels(); - if (context.gl) { - this.updateState(updateParams); - } else { - try { - this.updateState(updateParams); - } catch (error2) { + d2[b2] = 0; + } + } + var ja = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : void 0; + function ka(a2, b2) { + var c2 = a2 >> 1; + for (var d2 = c2 + b2 / 2; !(c2 >= d2) && A2[c2]; ) + ++c2; + c2 <<= 1; + if (32 < c2 - a2 && ja) + return ja.decode(z.subarray(a2, c2)); + c2 = 0; + for (d2 = ""; ; ) { + var e2 = C2[a2 + 2 * c2 >> 1]; + if (e2 == 0 || c2 == b2 / 2) + return d2; + ++c2; + d2 += String.fromCharCode(e2); + } + } + function la(a2, b2, c2) { + c2 === void 0 && (c2 = 2147483647); + if (2 > c2) + return 0; + c2 -= 2; + var d2 = b2; + c2 = c2 < 2 * a2.length ? c2 / 2 : a2.length; + for (var e2 = 0; e2 < c2; ++e2) + C2[b2 >> 1] = a2.charCodeAt(e2), b2 += 2; + C2[b2 >> 1] = 0; + return b2 - d2; + } + function ma(a2) { + return 2 * a2.length; + } + function na(a2, b2) { + for (var c2 = 0, d2 = ""; !(c2 >= b2 / 4); ) { + var e2 = D2[a2 + 4 * c2 >> 2]; + if (e2 == 0) + break; + ++c2; + 65536 <= e2 ? (e2 -= 65536, d2 += String.fromCharCode(55296 | e2 >> 10, 56320 | e2 & 1023)) : d2 += String.fromCharCode(e2); + } + return d2; + } + function oa(a2, b2, c2) { + c2 === void 0 && (c2 = 2147483647); + if (4 > c2) + return 0; + var d2 = b2; + c2 = d2 + c2 - 4; + for (var e2 = 0; e2 < a2.length; ++e2) { + var g3 = a2.charCodeAt(e2); + if (55296 <= g3 && 57343 >= g3) { + var k = a2.charCodeAt(++e2); + g3 = 65536 + ((g3 & 1023) << 10) | k & 1023; } + D2[b2 >> 2] = g3; + b2 += 4; + if (b2 + 4 > c2) + break; } - for (const extension of this.props.extensions) { - extension.updateState.call(this, updateParams, extension); + D2[b2 >> 2] = 0; + return b2 - d2; + } + function pa(a2) { + for (var b2 = 0, c2 = 0; c2 < a2.length; ++c2) { + var d2 = a2.charCodeAt(c2); + 55296 <= d2 && 57343 >= d2 && ++c2; + b2 += 4; + } + return b2; + } + var E3, F, z, C2, A2, D2, G2, qa, ra; + function sa(a2) { + E3 = a2; + f2.HEAP8 = F = new Int8Array(a2); + f2.HEAP16 = C2 = new Int16Array(a2); + f2.HEAP32 = D2 = new Int32Array(a2); + f2.HEAPU8 = z = new Uint8Array(a2); + f2.HEAPU16 = A2 = new Uint16Array(a2); + f2.HEAPU32 = G2 = new Uint32Array(a2); + f2.HEAPF32 = qa = new Float32Array(a2); + f2.HEAPF64 = ra = new Float64Array(a2); + } + var ta = f2.INITIAL_MEMORY || 16777216; + f2.wasmMemory ? y2 = f2.wasmMemory : y2 = new WebAssembly.Memory({ initial: ta / 65536, maximum: 32768 }); + y2 && (E3 = y2.buffer); + ta = E3.byteLength; + sa(E3); + var I2, ua = [], va = [], wa = [], xa = []; + function ya() { + var a2 = f2.preRun.shift(); + ua.unshift(a2); + } + var J = 0, K = null; + f2.preloadedImages = {}; + f2.preloadedAudios = {}; + function w3(a2) { + if (f2.onAbort) + f2.onAbort(a2); + u2(a2); + ea = true; + a2 = new WebAssembly.RuntimeError("abort(" + a2 + "). Build with -s ASSERTIONS=1 for more info."); + ba(a2); + throw a2; + } + function Aa(a2) { + var b2 = L; + return String.prototype.startsWith ? b2.startsWith(a2) : b2.indexOf(a2) === 0; + } + function Ba() { + return Aa("data:application/octet-stream;base64,"); + } + var L = "blosc_codec.wasm"; + if (!Ba()) { + var Ca = L; + L = f2.locateFile ? f2.locateFile(Ca, "") : "" + Ca; + } + function Da() { + try { + if (v2) + return new Uint8Array(v2); + throw "both async and sync fetching of the wasm failed"; + } catch (a2) { + w3(a2); + } + } + function N2(a2) { + for (; 0 < a2.length; ) { + var b2 = a2.shift(); + if (typeof b2 == "function") + b2(f2); + else { + var c2 = b2.T; + typeof c2 === "number" ? b2.O === void 0 ? I2.get(c2)() : I2.get(c2)(b2.O) : c2(b2.O === void 0 ? null : b2.O); + } } - const modelChanged = this.getModels()[0] !== oldModels[0]; - this._postUpdate(updateParams, modelChanged); - } finally { - context.viewport = currentViewport; - this.props = currentProps; - this._clearChangeFlags(); - internalState.needsUpdate = false; - internalState.resetOldProps(); } - } - _finalize() { - debug(TRACE_FINALIZE, this); - this.finalizeState(this.context); - for (const extension of this.props.extensions) { - extension.finalizeState.call(this, this.context, extension); + function Ea(a2) { + this.N = a2 - 16; + this.$ = function(b2) { + D2[this.N + 8 >> 2] = b2; + }; + this.X = function(b2) { + D2[this.N + 0 >> 2] = b2; + }; + this.Y = function() { + D2[this.N + 4 >> 2] = 0; + }; + this.W = function() { + F[this.N + 12 >> 0] = 0; + }; + this.Z = function() { + F[this.N + 13 >> 0] = 0; + }; + this.V = function(b2, c2) { + this.$(b2); + this.X(c2); + this.Y(); + this.W(); + this.Z(); + }; } - } - _drawLayer({ - moduleParameters = null, - uniforms = {}, - parameters = {} - }) { - this._updateAttributeTransition(); - const currentProps = this.props; - const context = this.context; - this.props = this.internalState.propsInTransition || currentProps; - const opacity = this.props.opacity; - uniforms.opacity = Math.pow(opacity, 1 / 2.2); - try { - if (moduleParameters) { - this.setModuleParameters(moduleParameters); - } - const { - getPolygonOffset - } = this.props; - const offsets = getPolygonOffset && getPolygonOffset(uniforms) || [0, 0]; - setParameters(context.gl, { - polygonOffset: offsets + function Fa(a2) { + switch (a2) { + case 1: + return 0; + case 2: + return 1; + case 4: + return 2; + case 8: + return 3; + default: + throw new TypeError("Unknown type size: " + a2); + } + } + var Ga = void 0; + function P(a2) { + for (var b2 = ""; z[a2]; ) + b2 += Ga[z[a2++]]; + return b2; + } + var Q2 = {}, R = {}, S = {}; + function Ha(a2) { + if (a2 === void 0) + return "_unknown"; + a2 = a2.replace(/[^a-zA-Z0-9_]/g, "$"); + var b2 = a2.charCodeAt(0); + return 48 <= b2 && 57 >= b2 ? "_" + a2 : a2; + } + function Ia(a2, b2) { + a2 = Ha(a2); + return new Function("body", "return function " + a2 + '() {\n "use strict"; return body.apply(this, arguments);\n};\n')(b2); + } + function Ja(a2) { + var b2 = Error, c2 = Ia(a2, function(d2) { + this.name = a2; + this.message = d2; + d2 = Error(d2).stack; + d2 !== void 0 && (this.stack = this.toString() + "\n" + d2.replace(/^Error(:[^\n]*)?\n/, "")); }); - withParameters(context.gl, parameters, () => { - const opts = { - moduleParameters, - uniforms, - parameters, - context - }; - for (const extension of this.props.extensions) { - extension.draw.call(this, opts, extension); - } - this.draw(opts); + c2.prototype = Object.create(b2.prototype); + c2.prototype.constructor = c2; + c2.prototype.toString = function() { + return this.message === void 0 ? this.name : this.name + ": " + this.message; + }; + return c2; + } + var Ka = void 0; + function T(a2) { + throw new Ka(a2); + } + var La = void 0; + function Ma(a2, b2) { + function c2(h) { + h = b2(h); + if (h.length !== d2.length) + throw new La("Mismatched type converter count"); + for (var l2 = 0; l2 < d2.length; ++l2) + U(d2[l2], h[l2]); + } + var d2 = []; + d2.forEach(function(h) { + S[h] = a2; }); - } finally { - this.props = currentProps; - } - } - getChangeFlags() { - var _this$internalState2; - return (_this$internalState2 = this.internalState) === null || _this$internalState2 === void 0 ? void 0 : _this$internalState2.changeFlags; - } - setChangeFlags(flags) { - if (!this.internalState) { - return; - } - const { - changeFlags - } = this.internalState; - for (const key in flags) { - if (flags[key]) { - let flagChanged = false; - switch (key) { - case "dataChanged": - const dataChangedReason = flags[key]; - const prevDataChangedReason = changeFlags[key]; - if (dataChangedReason && Array.isArray(prevDataChangedReason)) { - changeFlags.dataChanged = Array.isArray(dataChangedReason) ? prevDataChangedReason.concat(dataChangedReason) : dataChangedReason; - flagChanged = true; - } - default: - if (!changeFlags[key]) { - changeFlags[key] = flags[key]; - flagChanged = true; - } - } - if (flagChanged) { - debug(TRACE_CHANGE_FLAG, this, key, flags); - } + var e2 = Array(a2.length), g3 = [], k = 0; + a2.forEach(function(h, l2) { + R.hasOwnProperty(h) ? e2[l2] = R[h] : (g3.push(h), Q2.hasOwnProperty(h) || (Q2[h] = []), Q2[h].push(function() { + e2[l2] = R[h]; + ++k; + k === g3.length && c2(e2); + })); + }); + g3.length === 0 && c2(e2); + } + function U(a2, b2, c2) { + c2 = c2 || {}; + if (!("argPackAdvance" in b2)) + throw new TypeError("registerType registeredInstance requires argPackAdvance"); + var d2 = b2.name; + a2 || T('type "' + d2 + '" must have a positive integer typeid pointer'); + if (R.hasOwnProperty(a2)) { + if (c2.U) + return; + T("Cannot register type '" + d2 + "' twice"); } + R[a2] = b2; + delete S[a2]; + Q2.hasOwnProperty(a2) && (b2 = Q2[a2], delete Q2[a2], b2.forEach(function(e2) { + e2(); + })); } - const propsOrDataChanged = Boolean(changeFlags.dataChanged || changeFlags.updateTriggersChanged || changeFlags.propsChanged || changeFlags.extensionsChanged); - changeFlags.propsOrDataChanged = propsOrDataChanged; - changeFlags.somethingChanged = propsOrDataChanged || changeFlags.viewportChanged || changeFlags.stateChanged; - } - _clearChangeFlags() { - this.internalState.changeFlags = { - dataChanged: false, - propsChanged: false, - updateTriggersChanged: false, - viewportChanged: false, - stateChanged: false, - extensionsChanged: false, - propsOrDataChanged: false, - somethingChanged: false - }; - } - _diffProps(newProps, oldProps) { - const changeFlags = diffProps(newProps, oldProps); - if (changeFlags.updateTriggersChanged) { - for (const key in changeFlags.updateTriggersChanged) { - if (changeFlags.updateTriggersChanged[key]) { - this.invalidateAttribute(key); - } + var Na = [], V = [{}, { value: void 0 }, { value: null }, { value: true }, { value: false }]; + function Qa(a2) { + 4 < a2 && --V[a2].P === 0 && (V[a2] = void 0, Na.push(a2)); + } + function Ra(a2) { + switch (a2) { + case void 0: + return 1; + case null: + return 2; + case true: + return 3; + case false: + return 4; + default: + var b2 = Na.length ? Na.pop() : V.length; + V[b2] = { P: 1, value: a2 }; + return b2; } } - if (changeFlags.transitionsChanged) { - for (const key in changeFlags.transitionsChanged) { - var _newProps$transitions; - this.internalState.uniformTransitions.add(key, oldProps[key], newProps[key], (_newProps$transitions = newProps.transitions) === null || _newProps$transitions === void 0 ? void 0 : _newProps$transitions[key]); - } + function Sa(a2) { + return this.fromWireType(G2[a2 >> 2]); } - return this.setChangeFlags(changeFlags); - } - validateProps() { - validateProps(this.props); - } - updateAutoHighlight(info) { - if (this.props.autoHighlight && !Number.isInteger(this.props.highlightedObjectIndex)) { - this._updateAutoHighlight(info); + function Ta(a2) { + if (a2 === null) + return "null"; + var b2 = typeof a2; + return b2 === "object" || b2 === "array" || b2 === "function" ? a2.toString() : "" + a2; } - } - _updateAutoHighlight(info) { - const pickingModuleParameters = { - pickingSelectedColor: info.picked ? info.color : null - }; - const { - highlightColor - } = this.props; - if (info.picked && typeof highlightColor === "function") { - pickingModuleParameters.pickingHighlightColor = highlightColor(info); + function Ua(a2, b2) { + switch (b2) { + case 2: + return function(c2) { + return this.fromWireType(qa[c2 >> 2]); + }; + case 3: + return function(c2) { + return this.fromWireType(ra[c2 >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + a2); + } } - this.setModuleParameters(pickingModuleParameters); - this.setNeedsRedraw(); - } - _getAttributeManager() { - const context = this.context; - return new AttributeManager(context.gl, { - id: this.props.id, - stats: context.stats, - timeline: context.timeline - }); - } - _postUpdate(updateParams, forceUpdate) { - const { - props, - oldProps - } = updateParams; - this.setNeedsRedraw(); - this._updateAttributes(); - const { - model - } = this.state; - model === null || model === void 0 ? void 0 : model.setInstanceCount(this.getNumInstances()); - const { - autoHighlight, - highlightedObjectIndex, - highlightColor - } = props; - if (forceUpdate || oldProps.autoHighlight !== autoHighlight || oldProps.highlightedObjectIndex !== highlightedObjectIndex || oldProps.highlightColor !== highlightColor) { - const parameters = {}; - if (!autoHighlight) { - parameters.pickingSelectedColor = null; + function Va(a2) { + var b2 = Function; + if (!(b2 instanceof Function)) + throw new TypeError("new_ called with constructor type " + typeof b2 + " which is not a function"); + var c2 = Ia(b2.name || "unknownFunctionName", function() { + }); + c2.prototype = b2.prototype; + c2 = new c2(); + a2 = b2.apply(c2, a2); + return a2 instanceof Object ? a2 : c2; + } + function Wa(a2) { + for (; a2.length; ) { + var b2 = a2.pop(); + a2.pop()(b2); + } + } + function Xa(a2, b2) { + var c2 = f2; + if (c2[a2].L === void 0) { + var d2 = c2[a2]; + c2[a2] = function() { + c2[a2].L.hasOwnProperty(arguments.length) || T("Function '" + b2 + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + c2[a2].L + ")!"); + return c2[a2].L[arguments.length].apply(this, arguments); + }; + c2[a2].L = []; + c2[a2].L[d2.S] = d2; + } + } + function Ya(a2, b2, c2) { + f2.hasOwnProperty(a2) ? ((c2 === void 0 || f2[a2].L !== void 0 && f2[a2].L[c2] !== void 0) && T("Cannot register public name '" + a2 + "' twice"), Xa(a2, a2), f2.hasOwnProperty(c2) && T("Cannot register multiple overloads of a function with the same number of arguments (" + c2 + ")!"), f2[a2].L[c2] = b2) : (f2[a2] = b2, c2 !== void 0 && (f2[a2].ba = c2)); + } + function Za(a2, b2) { + for (var c2 = [], d2 = 0; d2 < a2; d2++) + c2.push(D2[(b2 >> 2) + d2]); + return c2; + } + function $a(a2, b2) { + 0 <= a2.indexOf("j") || w3("Assertion failed: getDynCaller should only be called with i64 sigs"); + var c2 = []; + return function() { + c2.length = arguments.length; + for (var d2 = 0; d2 < arguments.length; d2++) + c2[d2] = arguments[d2]; + var e2; + a2.indexOf("j") != -1 ? e2 = c2 && c2.length ? f2["dynCall_" + a2].apply(null, [b2].concat(c2)) : f2["dynCall_" + a2].call(null, b2) : e2 = I2.get(b2).apply(null, c2); + return e2; + }; + } + function ab(a2, b2) { + a2 = P(a2); + var c2 = a2.indexOf("j") != -1 ? $a(a2, b2) : I2.get(b2); + typeof c2 !== "function" && T("unknown function pointer with signature " + a2 + ": " + b2); + return c2; + } + var bb = void 0; + function cb(a2) { + a2 = db(a2); + var b2 = P(a2); + W(a2); + return b2; + } + function eb(a2, b2) { + function c2(g3) { + e2[g3] || R[g3] || (S[g3] ? S[g3].forEach(c2) : (d2.push(g3), e2[g3] = true)); + } + var d2 = [], e2 = {}; + b2.forEach(c2); + throw new bb(a2 + ": " + d2.map(cb).join([", "])); + } + function fb(a2, b2, c2) { + switch (b2) { + case 0: + return c2 ? function(d2) { + return F[d2]; + } : function(d2) { + return z[d2]; + }; + case 1: + return c2 ? function(d2) { + return C2[d2 >> 1]; + } : function(d2) { + return A2[d2 >> 1]; + }; + case 2: + return c2 ? function(d2) { + return D2[d2 >> 2]; + } : function(d2) { + return G2[d2 >> 2]; + }; + default: + throw new TypeError("Unknown integer type: " + a2); + } + } + var gb = {}; + function hb() { + if (!ib) { + var a2 = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: ca || "./this.program" }, b2; + for (b2 in gb) + a2[b2] = gb[b2]; + var c2 = []; + for (b2 in a2) + c2.push(b2 + "=" + a2[b2]); + ib = c2; + } + return ib; + } + for (var ib, jb = [null, [], []], kb = Array(256), X = 0; 256 > X; ++X) + kb[X] = String.fromCharCode(X); + Ga = kb; + Ka = f2.BindingError = Ja("BindingError"); + La = f2.InternalError = Ja("InternalError"); + f2.count_emval_handles = function() { + for (var a2 = 0, b2 = 5; b2 < V.length; ++b2) + V[b2] !== void 0 && ++a2; + return a2; + }; + f2.get_first_emval = function() { + for (var a2 = 5; a2 < V.length; ++a2) + if (V[a2] !== void 0) + return V[a2]; + return null; + }; + bb = f2.UnboundTypeError = Ja("UnboundTypeError"); + va.push({ T: function() { + lb(); + } }); + var mb = { p: function(a2) { + return Y(a2 + 16) + 16; + }, o: function(a2, b2, c2) { + new Ea(a2).V(b2, c2); + throw a2; + }, z: function(a2, b2, c2, d2, e2) { + var g3 = Fa(c2); + b2 = P(b2); + U(a2, { name: b2, fromWireType: function(k) { + return !!k; + }, toWireType: function(k, h) { + return h ? d2 : e2; + }, argPackAdvance: 8, readValueFromPointer: function(k) { + if (c2 === 1) + var h = F; + else if (c2 === 2) + h = C2; + else if (c2 === 4) + h = D2; + else + throw new TypeError("Unknown boolean type size: " + b2); + return this.fromWireType(h[k >> g3]); + }, M: null }); + }, y: function(a2, b2) { + b2 = P(b2); + U(a2, { name: b2, fromWireType: function(c2) { + var d2 = V[c2].value; + Qa(c2); + return d2; + }, toWireType: function(c2, d2) { + return Ra(d2); + }, argPackAdvance: 8, readValueFromPointer: Sa, M: null }); + }, h: function(a2, b2, c2) { + c2 = Fa(c2); + b2 = P(b2); + U(a2, { name: b2, fromWireType: function(d2) { + return d2; + }, toWireType: function(d2, e2) { + if (typeof e2 !== "number" && typeof e2 !== "boolean") + throw new TypeError('Cannot convert "' + Ta(e2) + '" to ' + this.name); + return e2; + }, argPackAdvance: 8, readValueFromPointer: Ua(b2, c2), M: null }); + }, e: function(a2, b2, c2, d2, e2, g3) { + var k = Za(b2, c2); + a2 = P(a2); + e2 = ab(d2, e2); + Ya(a2, function() { + eb("Cannot call " + a2 + " due to unbound types", k); + }, b2 - 1); + Ma(k, function(h) { + var l2 = a2, n2 = a2; + h = [h[0], null].concat(h.slice(1)); + var p2 = e2, q = h.length; + 2 > q && T("argTypes array size mismatch! Must at least get return value and 'this' types!"); + for (var x2 = h[1] !== null && false, B2 = false, m = 1; m < h.length; ++m) + if (h[m] !== null && h[m].M === void 0) { + B2 = true; + break; + } + var Oa = h[0].name !== "void", H = "", M = ""; + for (m = 0; m < q - 2; ++m) + H += (m !== 0 ? ", " : "") + "arg" + m, M += (m !== 0 ? ", " : "") + "arg" + m + "Wired"; + n2 = "return function " + Ha(n2) + "(" + H + ") {\nif (arguments.length !== " + (q - 2) + ") {\nthrowBindingError('function " + n2 + " called with ' + arguments.length + ' arguments, expected " + (q - 2) + " args!');\n}\n"; + B2 && (n2 += "var destructors = [];\n"); + var Pa = B2 ? "destructors" : "null"; + H = "throwBindingError invoker fn runDestructors retType classParam".split(" "); + p2 = [T, p2, g3, Wa, h[0], h[1]]; + x2 && (n2 += "var thisWired = classParam.toWireType(" + Pa + ", this);\n"); + for (m = 0; m < q - 2; ++m) + n2 += "var arg" + m + "Wired = argType" + m + ".toWireType(" + Pa + ", arg" + m + "); // " + h[m + 2].name + "\n", H.push("argType" + m), p2.push(h[m + 2]); + x2 && (M = "thisWired" + (0 < M.length ? ", " : "") + M); + n2 += (Oa ? "var rv = " : "") + "invoker(fn" + (0 < M.length ? ", " : "") + M + ");\n"; + if (B2) + n2 += "runDestructors(destructors);\n"; + else + for (m = x2 ? 1 : 2; m < h.length; ++m) + q = m === 1 ? "thisWired" : "arg" + (m - 2) + "Wired", h[m].M !== null && (n2 += q + "_dtor(" + q + "); // " + h[m].name + "\n", H.push(q + "_dtor"), p2.push(h[m].M)); + Oa && (n2 += "var ret = retType.fromWireType(rv);\nreturn ret;\n"); + H.push(n2 + "}\n"); + h = Va(H).apply(null, p2); + m = b2 - 1; + if (!f2.hasOwnProperty(l2)) + throw new La("Replacing nonexistant public symbol"); + f2[l2].L !== void 0 && m !== void 0 ? f2[l2].L[m] = h : (f2[l2] = h, f2[l2].S = m); + return []; + }); + }, c: function(a2, b2, c2, d2, e2) { + function g3(n2) { + return n2; + } + b2 = P(b2); + e2 === -1 && (e2 = 4294967295); + var k = Fa(c2); + if (d2 === 0) { + var h = 32 - 8 * c2; + g3 = function(n2) { + return n2 << h >>> h; + }; } - if (Array.isArray(highlightColor)) { - parameters.pickingHighlightColor = highlightColor; + var l2 = b2.indexOf("unsigned") != -1; + U(a2, { name: b2, fromWireType: g3, toWireType: function(n2, p2) { + if (typeof p2 !== "number" && typeof p2 !== "boolean") + throw new TypeError('Cannot convert "' + Ta(p2) + '" to ' + this.name); + if (p2 < d2 || p2 > e2) + throw new TypeError('Passing a number "' + Ta(p2) + '" from JS side to C/C++ side to an argument of type "' + b2 + '", which is outside the valid range [' + d2 + ", " + e2 + "]!"); + return l2 ? p2 >>> 0 : p2 | 0; + }, argPackAdvance: 8, readValueFromPointer: fb(b2, k, d2 !== 0), M: null }); + }, b: function(a2, b2, c2) { + function d2(g3) { + g3 >>= 2; + var k = G2; + return new e2(E3, k[g3 + 1], k[g3]); + } + var e2 = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array][b2]; + c2 = P(c2); + U(a2, { name: c2, fromWireType: d2, argPackAdvance: 8, readValueFromPointer: d2 }, { U: true }); + }, i: function(a2, b2) { + b2 = P(b2); + var c2 = b2 === "std::string"; + U(a2, { name: b2, fromWireType: function(d2) { + var e2 = G2[d2 >> 2]; + if (c2) + for (var g3 = d2 + 4, k = 0; k <= e2; ++k) { + var h = d2 + 4 + k; + if (k == e2 || z[h] == 0) { + g3 = g3 ? ha(z, g3, h - g3) : ""; + if (l2 === void 0) + var l2 = g3; + else + l2 += String.fromCharCode(0), l2 += g3; + g3 = h + 1; + } + } + else { + l2 = Array(e2); + for (k = 0; k < e2; ++k) + l2[k] = String.fromCharCode(z[d2 + 4 + k]); + l2 = l2.join(""); + } + W(d2); + return l2; + }, toWireType: function(d2, e2) { + e2 instanceof ArrayBuffer && (e2 = new Uint8Array(e2)); + var g3 = typeof e2 === "string"; + g3 || e2 instanceof Uint8Array || e2 instanceof Uint8ClampedArray || e2 instanceof Int8Array || T("Cannot pass non-string to std::string"); + var k = (c2 && g3 ? function() { + for (var n2 = 0, p2 = 0; p2 < e2.length; ++p2) { + var q = e2.charCodeAt(p2); + 55296 <= q && 57343 >= q && (q = 65536 + ((q & 1023) << 10) | e2.charCodeAt(++p2) & 1023); + 127 >= q ? ++n2 : n2 = 2047 >= q ? n2 + 2 : 65535 >= q ? n2 + 3 : n2 + 4; + } + return n2; + } : function() { + return e2.length; + })(), h = Y(4 + k + 1); + G2[h >> 2] = k; + if (c2 && g3) + ia(e2, h + 4, k + 1); + else if (g3) + for (g3 = 0; g3 < k; ++g3) { + var l2 = e2.charCodeAt(g3); + 255 < l2 && (W(h), T("String has UTF-16 code units that do not fit in 8 bits")); + z[h + 4 + g3] = l2; + } + else + for (g3 = 0; g3 < k; ++g3) + z[h + 4 + g3] = e2[g3]; + d2 !== null && d2.push(W, h); + return h; + }, argPackAdvance: 8, readValueFromPointer: Sa, M: function(d2) { + W(d2); + } }); + }, d: function(a2, b2, c2) { + c2 = P(c2); + if (b2 === 2) { + var d2 = ka; + var e2 = la; + var g3 = ma; + var k = function() { + return A2; + }; + var h = 1; + } else + b2 === 4 && (d2 = na, e2 = oa, g3 = pa, k = function() { + return G2; + }, h = 2); + U(a2, { name: c2, fromWireType: function(l2) { + for (var n2 = G2[l2 >> 2], p2 = k(), q, x2 = l2 + 4, B2 = 0; B2 <= n2; ++B2) { + var m = l2 + 4 + B2 * b2; + if (B2 == n2 || p2[m >> h] == 0) + x2 = d2(x2, m - x2), q === void 0 ? q = x2 : (q += String.fromCharCode(0), q += x2), x2 = m + b2; + } + W(l2); + return q; + }, toWireType: function(l2, n2) { + typeof n2 !== "string" && T("Cannot pass non-string to C++ string type " + c2); + var p2 = g3(n2), q = Y(4 + p2 + b2); + G2[q >> 2] = p2 >> h; + e2(n2, q + 4, p2 + b2); + l2 !== null && l2.push(W, q); + return q; + }, argPackAdvance: 8, readValueFromPointer: Sa, M: function(l2) { + W(l2); + } }); + }, A: function(a2, b2) { + b2 = P(b2); + U(a2, { + aa: true, + name: b2, + argPackAdvance: 0, + fromWireType: function() { + }, + toWireType: function() { + } + }); + }, n: Qa, x: function(a2) { + 4 < a2 && (V[a2].P += 1); + }, C: function(a2, b2) { + var c2 = R[a2]; + c2 === void 0 && T("_emval_take_value has unknown type " + cb(a2)); + a2 = c2.readValueFromPointer(b2); + return Ra(a2); + }, t: function() { + w3(); + }, r: function(a2, b2, c2) { + z.copyWithin(a2, b2, b2 + c2); + }, s: function(a2) { + a2 >>>= 0; + var b2 = z.length; + if (2147483648 < a2) + return false; + for (var c2 = 1; 4 >= c2; c2 *= 2) { + var d2 = b2 * (1 + 0.2 / c2); + d2 = Math.min(d2, a2 + 100663296); + d2 = Math.max(16777216, a2, d2); + 0 < d2 % 65536 && (d2 += 65536 - d2 % 65536); + a: { + try { + y2.grow(Math.min(2147483648, d2) - E3.byteLength + 65535 >>> 16); + sa(y2.buffer); + var e2 = 1; + break a; + } catch (g3) { + } + e2 = void 0; + } + if (e2) + return true; } - if (forceUpdate || highlightedObjectIndex !== oldProps.highlightedObjectIndex) { - parameters.pickingSelectedColor = Number.isFinite(highlightedObjectIndex) && highlightedObjectIndex >= 0 ? this.encodePickingColor(highlightedObjectIndex) : null; + return false; + }, u: function(a2, b2) { + var c2 = 0; + hb().forEach(function(d2, e2) { + var g3 = b2 + c2; + e2 = D2[a2 + 4 * e2 >> 2] = g3; + for (g3 = 0; g3 < d2.length; ++g3) + F[e2++ >> 0] = d2.charCodeAt(g3); + F[e2 >> 0] = 0; + c2 += d2.length + 1; + }); + return 0; + }, v: function(a2, b2) { + var c2 = hb(); + D2[a2 >> 2] = c2.length; + var d2 = 0; + c2.forEach(function(e2) { + d2 += e2.length + 1; + }); + D2[b2 >> 2] = d2; + return 0; + }, w: function() { + return 0; + }, q: function() { + }, g: function(a2, b2, c2, d2) { + for (var e2 = 0, g3 = 0; g3 < c2; g3++) { + for (var k = D2[b2 + 8 * g3 >> 2], h = D2[b2 + (8 * g3 + 4) >> 2], l2 = 0; l2 < h; l2++) { + var n2 = z[k + l2], p2 = jb[a2]; + n2 === 0 || n2 === 10 ? ((a2 === 1 ? da : u2)(ha(p2, 0)), p2.length = 0) : p2.push(n2); + } + e2 += h; } - this.setModuleParameters(parameters); - } - } - _getUpdateParams() { - return { - props: this.props, - oldProps: this.internalState.getOldProps(), - context: this.context, - changeFlags: this.internalState.changeFlags + D2[d2 >> 2] = e2; + return 0; + }, a: y2, l: function() { + return 0; + }, k: function() { + return 0; + }, j: function() { + }, B: function() { + return 6; + }, m: function() { + }, f: function() { + } }; + (function() { + function a2(e2) { + f2.asm = e2.exports; + I2 = f2.asm.D; + J--; + f2.monitorRunDependencies && f2.monitorRunDependencies(J); + J == 0 && (K && (e2 = K, K = null, e2())); + } + function b2(e2) { + a2(e2.instance); + } + function c2(e2) { + return Promise.resolve().then(Da).then(function(g3) { + return WebAssembly.instantiate(g3, d2); + }).then(e2, function(g3) { + u2("failed to asynchronously prepare wasm: " + g3); + w3(g3); + }); + } + var d2 = { a: mb }; + J++; + f2.monitorRunDependencies && f2.monitorRunDependencies(J); + if (f2.instantiateWasm) + try { + return f2.instantiateWasm(d2, a2); + } catch (e2) { + return u2("Module.instantiateWasm callback failed with error: " + e2), false; + } + (function() { + return v2 || typeof WebAssembly.instantiateStreaming !== "function" || Ba() || Aa("file://") || typeof fetch !== "function" ? c2(b2) : fetch(L, { credentials: "same-origin" }).then(function(e2) { + return WebAssembly.instantiateStreaming(e2, d2).then(b2, function(g3) { + u2("wasm streaming compile failed: " + g3); + u2("falling back to ArrayBuffer instantiation"); + return c2(b2); + }); + }); + })().catch(ba); + return {}; + })(); + var lb = f2.___wasm_call_ctors = function() { + return (lb = f2.___wasm_call_ctors = f2.asm.E).apply(null, arguments); + }, Y = f2._malloc = function() { + return (Y = f2._malloc = f2.asm.F).apply(null, arguments); + }, W = f2._free = function() { + return (W = f2._free = f2.asm.G).apply(null, arguments); + }, db = f2.___getTypeName = function() { + return (db = f2.___getTypeName = f2.asm.H).apply(null, arguments); + }; + f2.___embind_register_native_and_builtin_types = function() { + return (f2.___embind_register_native_and_builtin_types = f2.asm.I).apply(null, arguments); }; + f2.dynCall_jiiiii = function() { + return (f2.dynCall_jiiiii = f2.asm.J).apply(null, arguments); + }; + f2.dynCall_jiji = function() { + return (f2.dynCall_jiji = f2.asm.K).apply(null, arguments); + }; + var Z; + K = function nb() { + Z || ob(); + Z || (K = nb); + }; + function ob() { + function a2() { + if (!Z && (Z = true, f2.calledRun = true, !ea)) { + N2(va); + N2(wa); + aa(f2); + if (f2.onRuntimeInitialized) + f2.onRuntimeInitialized(); + if (f2.postRun) + for (typeof f2.postRun == "function" && (f2.postRun = [f2.postRun]); f2.postRun.length; ) { + var b2 = f2.postRun.shift(); + xa.unshift(b2); + } + N2(xa); + } + } + if (!(0 < J)) { + if (f2.preRun) + for (typeof f2.preRun == "function" && (f2.preRun = [f2.preRun]); f2.preRun.length; ) + ya(); + N2(ua); + 0 < J || (f2.setStatus ? (f2.setStatus("Running..."), setTimeout(function() { + setTimeout(function() { + f2.setStatus(""); + }, 1); + a2(); + }, 1)) : a2()); + } + } + f2.run = ob; + if (f2.preInit) + for (typeof f2.preInit == "function" && (f2.preInit = [f2.preInit]); 0 < f2.preInit.length; ) + f2.preInit.pop()(); + ob(); + return blosc_codec2.ready; + }; + }(); + var __isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null; + var __toBinary = __isNode ? (base64) => new Uint8Array(Buffer.from(base64, "base64")) : /* @__PURE__ */ (() => { + var table = new Uint8Array(128); + for (var i3 = 0; i3 < 64; i3++) + table[i3 < 26 ? i3 + 65 : i3 < 52 ? i3 + 71 : i3 < 62 ? i3 - 4 : i3 * 4 - 205] = i3; + return (base64) => { + var n2 = base64.length, bytes = new Uint8Array((n2 - (base64[n2 - 1] == "=") - (base64[n2 - 2] == "=")) * 3 / 4 | 0); + for (var i4 = 0, j = 0; i4 < n2; ) { + var c0 = table[base64.charCodeAt(i4++)], c1 = table[base64.charCodeAt(i4++)]; + var c2 = table[base64.charCodeAt(i4++)], c3 = table[base64.charCodeAt(i4++)]; + bytes[j++] = c0 << 2 | c1 >> 4; + bytes[j++] = c1 << 4 | c2 >> 2; + bytes[j++] = c2 << 6 | c3; + } + return bytes; + }; + })(); + var wasmBinary = __toBinary("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"); + var _a; + var BloscShuffle; + (function(BloscShuffle2) { + BloscShuffle2[BloscShuffle2["NOSHUFFLE"] = 0] = "NOSHUFFLE"; + BloscShuffle2[BloscShuffle2["SHUFFLE"] = 1] = "SHUFFLE"; + BloscShuffle2[BloscShuffle2["BITSHUFFLE"] = 2] = "BITSHUFFLE"; + BloscShuffle2[BloscShuffle2["AUTOSHUFFLE"] = -1] = "AUTOSHUFFLE"; + })(BloscShuffle || (BloscShuffle = {})); + var COMPRESSORS = /* @__PURE__ */ new Set(["blosclz", "lz4", "lz4hc", "snappy", "zlib", "zstd"]); + var emscriptenModule; + var init2 = () => blosc_codec({ noInitialRun: true, wasmBinary }); + var Blosc = (_a = class { + constructor(clevel = 5, cname = "lz4", shuffle = 1, blocksize = 0) { + if (clevel < 0 || clevel > 9) { + throw new Error(`Invalid compression level: '${clevel}'. It should be between 0 and 9`); + } + if (!COMPRESSORS.has(cname)) { + throw new Error(`Invalid compressor '${cname}'. Valid compressors include + 'blosclz', 'lz4', 'lz4hc','snappy', 'zlib', 'zstd'.`); + } + if (shuffle < -1 || shuffle > 2) { + throw new Error(`Invalid shuffle ${shuffle}. Must be one of 0 (NOSHUFFLE), + 1 (SHUFFLE), 2 (BITSHUFFLE), -1 (AUTOSHUFFLE).`); + } + this.blocksize = blocksize; + this.clevel = clevel; + this.cname = cname; + this.shuffle = shuffle; + } + static fromConfig({ blocksize, clevel, cname, shuffle }) { + return new _a(clevel, cname, shuffle, blocksize); + } + async encode(data) { + if (!emscriptenModule) { + emscriptenModule = init2(); + } + const module = await emscriptenModule; + const view = module.compress(data, this.cname, this.clevel, this.shuffle, this.blocksize); + const result = new Uint8Array(view); + module.free_result(); + return result; } - _getNeedsRedraw(opts) { - if (!this.internalState) { - return false; + async decode(data, out) { + if (!emscriptenModule) { + emscriptenModule = init2(); } - let redraw = false; - redraw = redraw || this.internalState.needsRedraw && this.id; - const attributeManager = this.getAttributeManager(); - const attributeManagerNeedsRedraw = attributeManager ? attributeManager.getNeedsRedraw(opts) : false; - redraw = redraw || attributeManagerNeedsRedraw; - if (redraw) { - for (const extension of this.props.extensions) { - extension.onNeedsRedraw.call(this, extension); - } + const module = await emscriptenModule; + const view = module.decompress(data); + const result = new Uint8Array(view); + module.free_result(); + if (out !== void 0) { + out.set(result); + return out; } - this.internalState.needsRedraw = this.internalState.needsRedraw && !opts.clearRedrawFlags; - return redraw; + return result; } - _onAsyncPropUpdated() { - this._diffProps(this.props, this.internalState.getOldProps()); - this.setNeedsUpdate(); + }, _a.codecId = "blosc", _a.COMPRESSORS = [...COMPRESSORS], _a.NOSHUFFLE = 0, _a.SHUFFLE = 1, _a.BITSHUFFLE = 2, _a.AUTOSHUFFLE = -1, _a); + var Blosc$1 = Blosc; + addCodec(Zlib$1.codecId, () => Zlib$1); + addCodec(GZip$1.codecId, () => GZip$1); + addCodec(Blosc$1.codecId, () => Blosc$1); + + // node_modules/@vivjs/loaders/dist/index.mjs + var __defProp$3 = Object.defineProperty; + var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; + var __publicField$3 = (obj, key, value) => { + __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; + }; + var LZWDecoder2 = class extends BaseDecoder { + constructor(fileDirectory) { + super(); + __publicField$3(this, "maxUncompressedSize"); + const width = fileDirectory.TileWidth || fileDirectory.ImageWidth; + const height = fileDirectory.TileLength || fileDirectory.ImageLength; + const nbytes = fileDirectory.BitsPerSample[0] / 8; + this.maxUncompressedSize = width * height * nbytes; + } + async decodeBlock(buffer) { + const bytes = new Uint8Array(buffer); + const decoded = await N(bytes, this.maxUncompressedSize); + return decoded.buffer; } }; - _defineProperty(Layer, "defaultProps", defaultProps2); - _defineProperty(Layer, "layerName", "Layer"); - - // node_modules/@deck.gl/core/dist/esm/viewports/orbit-viewport.js - var DEGREES_TO_RADIANS5 = Math.PI / 180; - function getViewMatrix2({ - height, - focalDistance, - orbitAxis, - rotationX, - rotationOrbit, - zoom + function intToRgba(int) { + if (!Number.isInteger(int)) { + throw Error("Not an integer."); + } + const buffer = new ArrayBuffer(4); + const view = new DataView(buffer); + view.setInt32(0, int, false); + const bytes = new Uint8Array(buffer); + return Array.from(bytes); + } + function isInterleaved(shape) { + const lastDimSize = shape[shape.length - 1]; + return lastDimSize === 3 || lastDimSize === 4; + } + function getImageSize(source) { + const interleaved = isInterleaved(source.shape); + const [height, width] = source.shape.slice(interleaved ? -3 : -2); + return { height, width }; + } + var SIGNAL_ABORTED = "__vivSignalAborted"; + var VIV_PROXY_KEY = "__viv"; + var OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets`; + function flattenAttributes({ + attr, + ...rest }) { - const up = orbitAxis === "Z" ? [0, 0, 1] : [0, 1, 0]; - const eye = orbitAxis === "Z" ? [0, -focalDistance, 0] : [0, 0, focalDistance]; - const viewMatrix = new Matrix4().lookAt({ - eye, - up - }); - viewMatrix.rotateX(rotationX * DEGREES_TO_RADIANS5); - if (orbitAxis === "Z") { - viewMatrix.rotateZ(rotationOrbit * DEGREES_TO_RADIANS5); - } else { - viewMatrix.rotateY(rotationOrbit * DEGREES_TO_RADIANS5); + return { ...attr, ...rest }; + } + function ensureArray(x2) { + return Array.isArray(x2) ? x2 : [x2]; + } + var DimensionOrderSchema = enumType([ + "XYZCT", + "XYZTC", + "XYCTZ", + "XYCZT", + "XYTCZ", + "XYTZC" + ]); + var PixelTypeSchema = enumType([ + "int8", + "int16", + "int32", + "uint8", + "uint16", + "uint32", + "float", + "bit", + "double", + "complex", + "double-complex" + ]); + var PhysicalUnitSchema = enumType([ + "Ym", + "Zm", + "Em", + "Pm", + "Tm", + "Gm", + "Mm", + "km", + "hm", + "dam", + "m", + "dm", + "cm", + "mm", + "\xB5m", + "nm", + "pm", + "fm", + "am", + "zm", + "ym", + "\xC5", + "thou", + "li", + "in", + "ft", + "yd", + "mi", + "ua", + "ly", + "pc", + "pt", + "pixel", + "reference frame" + ]); + var ChannelSchema = objectType({}).extend({ + attr: objectType({ + ID: stringType(), + SamplesPerPixel: coerce.number().optional(), + Name: stringType().optional(), + Color: coerce.number().transform(intToRgba).optional() + }) + }).transform(flattenAttributes); + var UuidSchema = objectType({}).extend({ + attr: objectType({ + FileName: stringType() + }) + }).transform(flattenAttributes); + var TiffDataSchema = objectType({ UUID: UuidSchema.optional() }).extend({ + attr: objectType({ + IFD: coerce.number(), + PlaneCount: coerce.number(), + FirstT: coerce.number().optional(), + FirstC: coerce.number().optional(), + FirstZ: coerce.number().optional() + }) + }).transform(flattenAttributes); + var PixelsSchema = objectType({ + Channel: preprocessType(ensureArray, ChannelSchema.array()), + TiffData: preprocessType(ensureArray, TiffDataSchema.array()).optional() + }).extend({ + attr: objectType({ + ID: stringType(), + DimensionOrder: DimensionOrderSchema, + Type: PixelTypeSchema, + SizeT: coerce.number(), + SizeC: coerce.number(), + SizeZ: coerce.number(), + SizeY: coerce.number(), + SizeX: coerce.number(), + PhysicalSizeX: coerce.number().optional(), + PhysicalSizeY: coerce.number().optional(), + PhysicalSizeZ: coerce.number().optional(), + SignificantBits: coerce.number().optional(), + PhysicalSizeXUnit: PhysicalUnitSchema.optional().default("\xB5m"), + PhysicalSizeYUnit: PhysicalUnitSchema.optional().default("\xB5m"), + PhysicalSizeZUnit: PhysicalUnitSchema.optional().default("\xB5m"), + BigEndian: stringType().transform((v2) => v2.toLowerCase() === "true").optional(), + Interleaved: stringType().transform((v2) => v2.toLowerCase() === "true").optional() + }) + }).transform(flattenAttributes).transform(({ Channel, ...rest }) => ({ Channels: Channel, ...rest })); + var ImageSchema = objectType({ + AquisitionDate: stringType().optional().default(""), + Description: unknownType().optional().default(""), + Pixels: PixelsSchema + }).extend({ + attr: objectType({ + ID: stringType(), + Name: stringType().optional() + }) + }).transform(flattenAttributes); + var OmeSchema = objectType({ + Image: preprocessType(ensureArray, ImageSchema.array()) + }); + addDecoder(5, () => LZWDecoder2); + + // node_modules/@vivjs/constants/dist/index.mjs + var MAX_COLOR_INTENSITY = 255; + var DEFAULT_COLOR_OFF = [0, 0, 0]; + var MAX_CHANNELS = 6; + var DEFAULT_FONT_FAMILY = "-apple-system, 'Helvetica Neue', Arial, sans-serif"; + var DTYPE_VALUES = { + Uint8: { + format: esm_default2.R8UI, + dataFormat: esm_default2.RED_INTEGER, + type: esm_default2.UNSIGNED_BYTE, + max: 2 ** 8 - 1, + sampler: "usampler2D" + }, + Uint16: { + format: esm_default2.R16UI, + dataFormat: esm_default2.RED_INTEGER, + type: esm_default2.UNSIGNED_SHORT, + max: 2 ** 16 - 1, + sampler: "usampler2D" + }, + Uint32: { + format: esm_default2.R32UI, + dataFormat: esm_default2.RED_INTEGER, + type: esm_default2.UNSIGNED_INT, + max: 2 ** 32 - 1, + sampler: "usampler2D" + }, + Float32: { + format: esm_default2.R32F, + dataFormat: esm_default2.RED, + type: esm_default2.FLOAT, + // Not sure what to do about this one - a good use case for channel stats, I suppose: + // https://en.wikipedia.org/wiki/Single-precision_floating-point_format. + max: 3.4 * 10 ** 38, + sampler: "sampler2D" + }, + Int8: { + format: esm_default2.R8I, + dataFormat: esm_default2.RED_INTEGER, + type: esm_default2.BYTE, + max: 2 ** (8 - 1) - 1, + sampler: "isampler2D" + }, + Int16: { + format: esm_default2.R16I, + dataFormat: esm_default2.RED_INTEGER, + type: esm_default2.SHORT, + max: 2 ** (16 - 1) - 1, + sampler: "isampler2D" + }, + Int32: { + format: esm_default2.R32I, + dataFormat: esm_default2.RED_INTEGER, + type: esm_default2.INT, + max: 2 ** (32 - 1) - 1, + sampler: "isampler2D" + }, + // Cast Float64 as 32 bit float point so it can be rendered. + Float64: { + format: esm_default2.R32F, + dataFormat: esm_default2.RED, + type: esm_default2.FLOAT, + // Not sure what to do about this one - a good use case for channel stats, I suppose: + // https://en.wikipedia.org/wiki/Single-precision_floating-point_format. + max: 3.4 * 10 ** 38, + sampler: "sampler2D", + cast: (data) => new Float32Array(data) } - const projectionScale = Math.pow(2, zoom) / height; - viewMatrix.scale(projectionScale); - return viewMatrix; + }; + + // node_modules/@vivjs/layers/node_modules/@vivjs/extensions/dist/index.mjs + var apply_transparent_color = `vec4 apply_transparent_color(vec3 color, vec3 transparentColor, bool useTransparentColor, float opacity){ + return vec4(color, (color == transparentColor && useTransparentColor) ? 0. : opacity); +} +`; + var alpha = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(1,1,1,0); + const float e1 = 1.0; + const vec4 v1 = vec4(1,1,1,1); + float a0 = smoothstep(e0,e1,x); + return mix(v0,v1,a0)*step(e0,x)*step(x,e1); +} +`; + var autumn = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(1,0,0,1); + const float e1 = 1.0; + const vec4 v1 = vec4(1,1,0,1); + float a0 = smoothstep(e0,e1,x); + return mix(v0,v1,a0)*step(e0,x)*step(x,e1); +} +`; + var bathymetry = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.1568627450980392,0.10196078431372549,0.17254901960784313,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.23137254901960785,0.19215686274509805,0.35294117647058826,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.25098039215686274,0.2980392156862745,0.5450980392156862,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.24705882352941178,0.43137254901960786,0.592156862745098,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.2823529411764706,0.5568627450980392,0.6196078431372549,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.3333333333333333,0.6823529411764706,0.6392156862745098,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.47058823529411764,0.807843137254902,0.6392156862745098,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.7333333333333333,0.9019607843137255,0.6745098039215687,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9921568627450981,0.996078431372549,0.8,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var blackbody = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0,1); + const float e1 = 0.2; + const vec4 v1 = vec4(0.9019607843137255,0,0,1); + const float e2 = 0.4; + const vec4 v2 = vec4(0.9019607843137255,0.8235294117647058,0,1); + const float e3 = 0.7; + const vec4 v3 = vec4(1,1,1,1); + const float e4 = 1.0; + const vec4 v4 = vec4(0.6274509803921569,0.7843137254901961,1,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3),mix(v3,v4,a3)*step(e3,x)*step(x,e4) + ))); +} +`; + var bluered = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,1,1); + const float e1 = 1.0; + const vec4 v1 = vec4(1,0,0,1); + float a0 = smoothstep(e0,e1,x); + return mix(v0,v1,a0)*step(e0,x)*step(x,e1); +} +`; + var bone = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0,1); + const float e1 = 0.376; + const vec4 v1 = vec4(0.32941176470588235,0.32941176470588235,0.4549019607843137,1); + const float e2 = 0.753; + const vec4 v2 = vec4(0.6627450980392157,0.7843137254901961,0.7843137254901961,1); + const float e3 = 1.0; + const vec4 v3 = vec4(1,1,1,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2),mix(v2,v3,a2)*step(e2,x)*step(x,e3) + )); +} +`; + var cdom = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.1843137254901961,0.058823529411764705,0.24313725490196078,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.3411764705882353,0.09019607843137255,0.33725490196078434,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.5098039215686274,0.10980392156862745,0.38823529411764707,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.6705882352941176,0.1607843137254902,0.3764705882352941,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.807843137254902,0.2627450980392157,0.33725490196078434,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.9019607843137255,0.41568627450980394,0.32941176470588235,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.9490196078431372,0.5843137254901961,0.403921568627451,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.9764705882352941,0.7568627450980392,0.5294117647058824,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.996078431372549,0.9294117647058824,0.6901960784313725,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var chlorophyll = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.07058823529411765,0.1411764705882353,0.0784313725490196,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.09803921568627451,0.24705882352941178,0.1607843137254902,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.09411764705882353,0.3568627450980392,0.23137254901960785,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.050980392156862744,0.4666666666666667,0.2823529411764706,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.07058823529411765,0.5803921568627451,0.3137254901960784,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.3137254901960784,0.6784313725490196,0.34901960784313724,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.5176470588235295,0.7686274509803922,0.47843137254901963,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.6862745098039216,0.8666666666666667,0.6352941176470588,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.8431372549019608,0.9764705882352941,0.8156862745098039,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var cool = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.49019607843137253,0,0.7019607843137254,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.4549019607843137,0,0.8549019607843137,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.3843137254901961,0.2901960784313726,0.9294117647058824,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.26666666666666666,0.5725490196078431,0.9058823529411765,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0,0.8,0.7725490196078432,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0,0.9686274509803922,0.5725490196078431,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0,1,0.34509803921568627,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.1568627450980392,1,0.03137254901960784,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.5764705882352941,1,0,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var copper = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0,1); + const float e1 = 0.804; + const vec4 v1 = vec4(1,0.6274509803921569,0.4,1); + const float e2 = 1.0; + const vec4 v2 = vec4(1,0.7803921568627451,0.4980392156862745,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1),mix(v1,v2,a1)*step(e1,x)*step(x,e2) + ); +} +`; + var cubehelix = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0,1); + const float e1 = 0.07; + const vec4 v1 = vec4(0.08627450980392157,0.0196078431372549,0.23137254901960785,1); + const float e2 = 0.13; + const vec4 v2 = vec4(0.23529411764705882,0.01568627450980392,0.4117647058823529,1); + const float e3 = 0.2; + const vec4 v3 = vec4(0.42745098039215684,0.00392156862745098,0.5294117647058824,1); + const float e4 = 0.27; + const vec4 v4 = vec4(0.6313725490196078,0,0.5764705882352941,1); + const float e5 = 0.33; + const vec4 v5 = vec4(0.8235294117647058,0.00784313725490196,0.5568627450980392,1); + const float e6 = 0.4; + const vec4 v6 = vec4(0.984313725490196,0.043137254901960784,0.4823529411764706,1); + const float e7 = 0.47; + const vec4 v7 = vec4(1,0.11372549019607843,0.3803921568627451,1); + const float e8 = 0.53; + const vec4 v8 = vec4(1,0.21176470588235294,0.27058823529411763,1); + const float e9 = 0.6; + const vec4 v9 = vec4(1,0.3333333333333333,0.1803921568627451,1); + const float e10 = 0.67; + const vec4 v10 = vec4(1,0.47058823529411764,0.13333333333333333,1); + const float e11 = 0.73; + const vec4 v11 = vec4(1,0.615686274509804,0.1450980392156863,1); + const float e12 = 0.8; + const vec4 v12 = vec4(0.9450980392156862,0.7490196078431373,0.2235294117647059,1); + const float e13 = 0.87; + const vec4 v13 = vec4(0.8784313725490196,0.8627450980392157,0.36470588235294116,1); + const float e14 = 0.93; + const vec4 v14 = vec4(0.8549019607843137,0.9450980392156862,0.5568627450980392,1); + const float e15 = 1.0; + const vec4 v15 = vec4(0.8901960784313725,0.9921568627450981,0.7764705882352941,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + float a8 = smoothstep(e8,e9,x); + float a9 = smoothstep(e9,e10,x); + float a10 = smoothstep(e10,e11,x); + float a11 = smoothstep(e11,e12,x); + float a12 = smoothstep(e12,e13,x); + float a13 = smoothstep(e13,e14,x); + float a14 = smoothstep(e14,e15,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7), + max(mix(v7,v8,a7)*step(e7,x)*step(x,e8), + max(mix(v8,v9,a8)*step(e8,x)*step(x,e9), + max(mix(v9,v10,a9)*step(e9,x)*step(x,e10), + max(mix(v10,v11,a10)*step(e10,x)*step(x,e11), + max(mix(v11,v12,a11)*step(e11,x)*step(x,e12), + max(mix(v12,v13,a12)*step(e12,x)*step(x,e13), + max(mix(v13,v14,a13)*step(e13,x)*step(x,e14),mix(v14,v15,a14)*step(e14,x)*step(x,e15) + )))))))))))))); +} +`; + var density = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.21176470588235294,0.054901960784313725,0.1411764705882353,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.34901960784313724,0.09019607843137255,0.3137254901960784,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.43137254901960786,0.17647058823529413,0.5176470588235295,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.47058823529411764,0.30196078431372547,0.6980392156862745,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.47058823529411764,0.44313725490196076,0.8352941176470589,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.45098039215686275,0.592156862745098,0.8941176470588236,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.5254901960784314,0.7254901960784313,0.8901960784313725,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.6941176470588235,0.8392156862745098,0.8901960784313725,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9019607843137255,0.9450980392156862,0.9450980392156862,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var earth = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0.5098039215686274,1); + const float e1 = 0.1; + const vec4 v1 = vec4(0,0.7058823529411765,0.7058823529411765,1); + const float e2 = 0.2; + const vec4 v2 = vec4(0.1568627450980392,0.8235294117647058,0.1568627450980392,1); + const float e3 = 0.4; + const vec4 v3 = vec4(0.9019607843137255,0.9019607843137255,0.19607843137254902,1); + const float e4 = 0.6; + const vec4 v4 = vec4(0.47058823529411764,0.27450980392156865,0.0784313725490196,1); + const float e5 = 1.0; + const vec4 v5 = vec4(1,1,1,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4),mix(v4,v5,a4)*step(e4,x)*step(x,e5) + )))); +} +`; + var electric = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0,1); + const float e1 = 0.15; + const vec4 v1 = vec4(0.11764705882352941,0,0.39215686274509803,1); + const float e2 = 0.4; + const vec4 v2 = vec4(0.47058823529411764,0,0.39215686274509803,1); + const float e3 = 0.6; + const vec4 v3 = vec4(0.6274509803921569,0.35294117647058826,0,1); + const float e4 = 0.8; + const vec4 v4 = vec4(0.9019607843137255,0.7843137254901961,0,1); + const float e5 = 1.0; + const vec4 v5 = vec4(1,0.9803921568627451,0.8627450980392157,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4),mix(v4,v5,a4)*step(e4,x)*step(x,e5) + )))); +} +`; + var freesurface_blue = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.11764705882352941,0.01568627450980392,0.43137254901960786,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.1843137254901961,0.054901960784313725,0.6901960784313725,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.1607843137254902,0.17647058823529413,0.9254901960784314,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.09803921568627451,0.38823529411764707,0.8313725490196079,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.26666666666666666,0.5137254901960784,0.7843137254901961,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.4470588235294118,0.611764705882353,0.7725490196078432,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.615686274509804,0.7098039215686275,0.796078431372549,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.7843137254901961,0.8156862745098039,0.8470588235294118,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9450980392156862,0.9294117647058824,0.9254901960784314,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var freesurface_red = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.23529411764705882,0.03529411764705882,0.07058823529411765,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.39215686274509803,0.06666666666666667,0.10588235294117647,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.5568627450980392,0.0784313725490196,0.11372549019607843,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.6941176470588235,0.16862745098039217,0.10588235294117647,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.7529411764705882,0.3411764705882353,0.24705882352941178,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.803921568627451,0.49019607843137253,0.4117647058823529,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.8470588235294118,0.6352941176470588,0.5803921568627451,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.8901960784313725,0.7803921568627451,0.7568627450980392,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9450980392156862,0.9294117647058824,0.9254901960784314,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var greens = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0.26666666666666666,0.10588235294117647,1); + const float e1 = 0.125; + const vec4 v1 = vec4(0,0.42745098039215684,0.17254901960784313,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.13725490196078433,0.5450980392156862,0.27058823529411763,1); + const float e3 = 0.375; + const vec4 v3 = vec4(0.2549019607843137,0.6705882352941176,0.36470588235294116,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.4549019607843137,0.7686274509803922,0.4627450980392157,1); + const float e5 = 0.625; + const vec4 v5 = vec4(0.6313725490196078,0.8509803921568627,0.6078431372549019,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.7803921568627451,0.9137254901960784,0.7529411764705882,1); + const float e7 = 0.875; + const vec4 v7 = vec4(0.8980392156862745,0.9607843137254902,0.8784313725490196,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9686274509803922,0.9882352941176471,0.9607843137254902,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var greys = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0,1); + const float e1 = 1.0; + const vec4 v1 = vec4(1,1,1,1); + float a0 = smoothstep(e0,e1,x); + return mix(v0,v1,a0)*step(e0,x)*step(x,e1); +} +`; + var hot = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0,1); + const float e1 = 0.3; + const vec4 v1 = vec4(0.9019607843137255,0,0,1); + const float e2 = 0.6; + const vec4 v2 = vec4(1,0.8235294117647058,0,1); + const float e3 = 1.0; + const vec4 v3 = vec4(1,1,1,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2),mix(v2,v3,a2)*step(e2,x)*step(x,e3) + )); +} +`; + var hsv = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(1,0,0,1); + const float e1 = 0.169; + const vec4 v1 = vec4(0.9921568627450981,1,0.00784313725490196,1); + const float e2 = 0.173; + const vec4 v2 = vec4(0.9686274509803922,1,0.00784313725490196,1); + const float e3 = 0.337; + const vec4 v3 = vec4(0,0.9882352941176471,0.01568627450980392,1); + const float e4 = 0.341; + const vec4 v4 = vec4(0,0.9882352941176471,0.0392156862745098,1); + const float e5 = 0.506; + const vec4 v5 = vec4(0.00392156862745098,0.9764705882352941,1,1); + const float e6 = 0.671; + const vec4 v6 = vec4(0.00784313725490196,0,0.9921568627450981,1); + const float e7 = 0.675; + const vec4 v7 = vec4(0.03137254901960784,0,0.9921568627450981,1); + const float e8 = 0.839; + const vec4 v8 = vec4(1,0,0.984313725490196,1); + const float e9 = 0.843; + const vec4 v9 = vec4(1,0,0.9607843137254902,1); + const float e10 = 1.0; + const vec4 v10 = vec4(1,0,0.023529411764705882,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + float a8 = smoothstep(e8,e9,x); + float a9 = smoothstep(e9,e10,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7), + max(mix(v7,v8,a7)*step(e7,x)*step(x,e8), + max(mix(v8,v9,a8)*step(e8,x)*step(x,e9),mix(v9,v10,a9)*step(e9,x)*step(x,e10) + ))))))))); +} +`; + var inferno = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0.01568627450980392,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.12156862745098039,0.047058823529411764,0.2823529411764706,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.3333333333333333,0.058823529411764705,0.42745098039215684,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.5333333333333333,0.13333333333333333,0.41568627450980394,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.7294117647058823,0.21176470588235294,0.3333333333333333,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.8901960784313725,0.34901960784313724,0.2,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.9764705882352941,0.5490196078431373,0.0392156862745098,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.9764705882352941,0.788235294117647,0.19607843137254902,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9882352941176471,1,0.6431372549019608,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var jet = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0.5137254901960784,1); + const float e1 = 0.125; + const vec4 v1 = vec4(0,0.23529411764705882,0.6666666666666666,1); + const float e2 = 0.375; + const vec4 v2 = vec4(0.0196078431372549,1,1,1); + const float e3 = 0.625; + const vec4 v3 = vec4(1,1,0,1); + const float e4 = 0.875; + const vec4 v4 = vec4(0.9803921568627451,0,0,1); + const float e5 = 1.0; + const vec4 v5 = vec4(0.5019607843137255,0,0,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4),mix(v4,v5,a4)*step(e4,x)*step(x,e5) + )))); +} +`; + var magma = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,0.01568627450980392,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.10980392156862745,0.06274509803921569,0.26666666666666666,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.30980392156862746,0.07058823529411765,0.4823529411764706,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.5058823529411764,0.1450980392156863,0.5058823529411764,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.7098039215686275,0.21176470588235294,0.47843137254901963,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.8980392156862745,0.3137254901960784,0.39215686274509803,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.984313725490196,0.5294117647058824,0.3803921568627451,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.996078431372549,0.7607843137254902,0.5294117647058824,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9882352941176471,0.9921568627450981,0.7490196078431373,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var oxygen = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.25098039215686274,0.0196078431372549,0.0196078431372549,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.41568627450980394,0.023529411764705882,0.058823529411764705,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.5647058823529412,0.10196078431372549,0.027450980392156862,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.6588235294117647,0.25098039215686274,0.011764705882352941,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.7372549019607844,0.39215686274509803,0.01568627450980392,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.807843137254902,0.5333333333333333,0.043137254901960784,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.8627450980392157,0.6823529411764706,0.09803921568627451,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.9058823529411765,0.8431372549019608,0.17254901960784313,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9725490196078431,0.996078431372549,0.4117647058823529,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var par = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.2,0.0784313725490196,0.09411764705882353,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.35294117647058826,0.12549019607843137,0.13725490196078433,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.5058823529411764,0.17254901960784313,0.13333333333333333,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.6235294117647059,0.26666666666666666,0.09803921568627451,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.7137254901960784,0.38823529411764707,0.07450980392156863,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.7803921568627451,0.5254901960784314,0.08627450980392157,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.8313725490196079,0.6705882352941176,0.13725490196078433,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.8666666666666667,0.8235294117647058,0.21176470588235294,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.8823529411764706,0.9921568627450981,0.29411764705882354,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var phase = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.5686274509803921,0.4117647058823529,0.07058823529411765,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.7215686274509804,0.2784313725490196,0.14901960784313725,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.7294117647058823,0.22745098039215686,0.45098039215686275,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.6274509803921569,0.2784313725490196,0.7254901960784313,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.43137254901960786,0.3803921568627451,0.8549019607843137,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.19607843137254902,0.4823529411764706,0.6431372549019608,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.12156862745098039,0.5137254901960784,0.43137254901960786,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.30196078431372547,0.5058823529411764,0.13333333333333333,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.5686274509803921,0.4117647058823529,0.07058823529411765,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var picnic = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,1,1); + const float e1 = 0.1; + const vec4 v1 = vec4(0.2,0.6,1,1); + const float e2 = 0.2; + const vec4 v2 = vec4(0.4,0.8,1,1); + const float e3 = 0.3; + const vec4 v3 = vec4(0.6,0.8,1,1); + const float e4 = 0.4; + const vec4 v4 = vec4(0.8,0.8,1,1); + const float e5 = 0.5; + const vec4 v5 = vec4(1,1,1,1); + const float e6 = 0.6; + const vec4 v6 = vec4(1,0.8,1,1); + const float e7 = 0.7; + const vec4 v7 = vec4(1,0.6,1,1); + const float e8 = 0.8; + const vec4 v8 = vec4(1,0.4,0.8,1); + const float e9 = 0.9; + const vec4 v9 = vec4(1,0.4,0.4,1); + const float e10 = 1.0; + const vec4 v10 = vec4(1,0,0,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + float a8 = smoothstep(e8,e9,x); + float a9 = smoothstep(e9,e10,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7), + max(mix(v7,v8,a7)*step(e7,x)*step(x,e8), + max(mix(v8,v9,a8)*step(e8,x)*step(x,e9),mix(v9,v10,a9)*step(e9,x)*step(x,e10) + ))))))))); +} +`; + var plasma = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.050980392156862744,0.03137254901960784,0.5294117647058824,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.29411764705882354,0.011764705882352941,0.6313725490196078,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.49019607843137253,0.011764705882352941,0.6588235294117647,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.6588235294117647,0.13333333333333333,0.5882352941176471,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.796078431372549,0.27450980392156865,0.4745098039215686,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.8980392156862745,0.4196078431372549,0.36470588235294116,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.9725490196078431,0.5803921568627451,0.2549019607843137,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.9921568627450981,0.7647058823529411,0.1568627450980392,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9411764705882353,0.9764705882352941,0.12941176470588237,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var portland = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.047058823529411764,0.2,0.5137254901960784,1); + const float e1 = 0.25; + const vec4 v1 = vec4(0.0392156862745098,0.5333333333333333,0.7294117647058823,1); + const float e2 = 0.5; + const vec4 v2 = vec4(0.9490196078431372,0.8274509803921568,0.2196078431372549,1); + const float e3 = 0.75; + const vec4 v3 = vec4(0.9490196078431372,0.5607843137254902,0.2196078431372549,1); + const float e4 = 1.0; + const vec4 v4 = vec4(0.8509803921568627,0.11764705882352941,0.11764705882352941,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3),mix(v3,v4,a3)*step(e3,x)*step(x,e4) + ))); +} +`; + var rainbow_soft = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.49019607843137253,0,0.7019607843137254,1); + const float e1 = 0.1; + const vec4 v1 = vec4(0.7803921568627451,0,0.7058823529411765,1); + const float e2 = 0.2; + const vec4 v2 = vec4(1,0,0.4745098039215686,1); + const float e3 = 0.3; + const vec4 v3 = vec4(1,0.4235294117647059,0,1); + const float e4 = 0.4; + const vec4 v4 = vec4(0.8705882352941177,0.7607843137254902,0,1); + const float e5 = 0.5; + const vec4 v5 = vec4(0.5882352941176471,1,0,1); + const float e6 = 0.6; + const vec4 v6 = vec4(0,1,0.21568627450980393,1); + const float e7 = 0.7; + const vec4 v7 = vec4(0,0.9647058823529412,0.5882352941176471,1); + const float e8 = 0.8; + const vec4 v8 = vec4(0.19607843137254902,0.6549019607843137,0.8705882352941177,1); + const float e9 = 0.9; + const vec4 v9 = vec4(0.403921568627451,0.2,0.9215686274509803,1); + const float e10 = 1.0; + const vec4 v10 = vec4(0.48627450980392156,0,0.7294117647058823,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + float a8 = smoothstep(e8,e9,x); + float a9 = smoothstep(e9,e10,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7), + max(mix(v7,v8,a7)*step(e7,x)*step(x,e8), + max(mix(v8,v9,a8)*step(e8,x)*step(x,e9),mix(v9,v10,a9)*step(e9,x)*step(x,e10) + ))))))))); +} +`; + var rainbow = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.5882352941176471,0,0.35294117647058826,1); + const float e1 = 0.125; + const vec4 v1 = vec4(0,0,0.7843137254901961,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0,0.09803921568627451,1,1); + const float e3 = 0.375; + const vec4 v3 = vec4(0,0.596078431372549,1,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.17254901960784313,1,0.5882352941176471,1); + const float e5 = 0.625; + const vec4 v5 = vec4(0.592156862745098,1,0,1); + const float e6 = 0.75; + const vec4 v6 = vec4(1,0.9176470588235294,0,1); + const float e7 = 0.875; + const vec4 v7 = vec4(1,0.43529411764705883,0,1); + const float e8 = 1.0; + const vec4 v8 = vec4(1,0,0,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var rdbu = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.0196078431372549,0.0392156862745098,0.6745098039215687,1); + const float e1 = 0.35; + const vec4 v1 = vec4(0.41568627450980394,0.5372549019607843,0.9686274509803922,1); + const float e2 = 0.5; + const vec4 v2 = vec4(0.7450980392156863,0.7450980392156863,0.7450980392156863,1); + const float e3 = 0.6; + const vec4 v3 = vec4(0.8627450980392157,0.6666666666666666,0.5176470588235295,1); + const float e4 = 0.7; + const vec4 v4 = vec4(0.9019607843137255,0.5686274509803921,0.35294117647058826,1); + const float e5 = 1.0; + const vec4 v5 = vec4(0.6980392156862745,0.0392156862745098,0.10980392156862745,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4),mix(v4,v5,a4)*step(e4,x)*step(x,e5) + )))); +} +`; + var salinity = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.16470588235294117,0.09411764705882353,0.4235294117647059,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.12941176470588237,0.19607843137254902,0.6352941176470588,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.058823529411764705,0.35294117647058826,0.5686274509803921,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.1568627450980392,0.4627450980392157,0.5372549019607843,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.23137254901960785,0.5725490196078431,0.5294117647058824,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.30980392156862746,0.6862745098039216,0.49411764705882355,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.47058823529411764,0.796078431372549,0.40784313725490196,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.7568627450980392,0.8666666666666667,0.39215686274509803,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9921568627450981,0.9372549019607843,0.6039215686274509,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var spring = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(1,0,1,1); + const float e1 = 1.0; + const vec4 v1 = vec4(1,1,0,1); + float a0 = smoothstep(e0,e1,x); + return mix(v0,v1,a0)*step(e0,x)*step(x,e1); +} +`; + var summer = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0.5019607843137255,0.4,1); + const float e1 = 1.0; + const vec4 v1 = vec4(1,1,0.4,1); + float a0 = smoothstep(e0,e1,x); + return mix(v0,v1,a0)*step(e0,x)*step(x,e1); +} +`; + var temperature = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.01568627450980392,0.13725490196078433,0.2,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.09019607843137255,0.2,0.47843137254901963,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.3333333333333333,0.23137254901960785,0.615686274509804,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.5058823529411764,0.30980392156862746,0.5607843137254902,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.6862745098039216,0.37254901960784315,0.5098039215686274,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.8705882352941177,0.4392156862745098,0.396078431372549,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.9764705882352941,0.5725490196078431,0.25882352941176473,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.9764705882352941,0.7686274509803922,0.2549019607843137,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9098039215686274,0.9803921568627451,0.3568627450980392,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var turbidity = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.13333333333333333,0.12156862745098039,0.10588235294117647,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.2549019607843137,0.19607843137254902,0.1607843137254902,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.3843137254901961,0.27058823529411763,0.20392156862745098,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.5137254901960784,0.34901960784313724,0.2235294117647059,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.6313725490196078,0.4392156862745098,0.23137254901960785,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.7254901960784313,0.5490196078431373,0.25882352941176473,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.792156862745098,0.6823529411764706,0.34509803921568627,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.8470588235294118,0.8196078431372549,0.49411764705882355,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9137254901960784,0.9647058823529412,0.6705882352941176,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var velocity_blue = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.06666666666666667,0.12549019607843137,0.25098039215686274,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.13725490196078433,0.20392156862745098,0.4549019607843137,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.11372549019607843,0.3176470588235294,0.611764705882353,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.12156862745098039,0.44313725490196076,0.6352941176470588,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.19607843137254902,0.5647058823529412,0.6627450980392157,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.3411764705882353,0.6784313725490196,0.6901960784313725,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.5843137254901961,0.7686274509803922,0.7411764705882353,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.796078431372549,0.8666666666666667,0.8274509803921568,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.996078431372549,0.984313725490196,0.9019607843137255,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var velocity_green = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.09019607843137255,0.13725490196078433,0.07450980392156863,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.09411764705882353,0.25098039215686274,0.14901960784313725,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.043137254901960784,0.37254901960784315,0.17647058823529413,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.15294117647058825,0.4823529411764706,0.13725490196078433,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.37254901960784315,0.5725490196078431,0.047058823529411764,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.596078431372549,0.6470588235294118,0.07058823529411765,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.788235294117647,0.7294117647058823,0.27058823529411763,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.9137254901960784,0.8470588235294118,0.5372549019607843,1); + const float e8 = 1.0; + const vec4 v8 = vec4(1,0.9921568627450981,0.803921568627451,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var viridis = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.26666666666666666,0.00392156862745098,0.32941176470588235,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.2784313725490196,0.17254901960784313,0.47843137254901963,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.23137254901960785,0.3176470588235294,0.5450980392156862,1); + const float e3 = 0.38; + const vec4 v3 = vec4(0.17254901960784313,0.44313725490196076,0.5568627450980392,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.12941176470588237,0.5647058823529412,0.5529411764705883,1); + const float e5 = 0.63; + const vec4 v5 = vec4(0.15294117647058825,0.6784313725490196,0.5058823529411764,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.3607843137254902,0.7843137254901961,0.38823529411764707,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.6666666666666666,0.8627450980392157,0.19607843137254902,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.9921568627450981,0.9058823529411765,0.1450980392156863,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var warm = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.49019607843137253,0,0.7019607843137254,1); + const float e1 = 0.13; + const vec4 v1 = vec4(0.6745098039215687,0,0.7333333333333333,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.8588235294117647,0,0.6666666666666666,1); + const float e3 = 0.38; + const vec4 v3 = vec4(1,0,0.5098039215686274,1); + const float e4 = 0.5; + const vec4 v4 = vec4(1,0.24705882352941178,0.2901960784313726,1); + const float e5 = 0.63; + const vec4 v5 = vec4(1,0.4823529411764706,0,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.9176470588235294,0.6901960784313725,0,1); + const float e7 = 0.88; + const vec4 v7 = vec4(0.7450980392156863,0.8941176470588236,0,1); + const float e8 = 1.0; + const vec4 v8 = vec4(0.5764705882352941,1,0,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var winter = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0,0,1,1); + const float e1 = 1.0; + const vec4 v1 = vec4(0,1,0.5019607843137255,1); + float a0 = smoothstep(e0,e1,x); + return mix(v0,v1,a0)*step(e0,x)*step(x,e1); +} +`; + var yignbu = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.03137254901960784,0.11372549019607843,0.34509803921568627,1); + const float e1 = 0.125; + const vec4 v1 = vec4(0.1450980392156863,0.20392156862745098,0.5803921568627451,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.13333333333333333,0.3686274509803922,0.6588235294117647,1); + const float e3 = 0.375; + const vec4 v3 = vec4(0.11372549019607843,0.5686274509803921,0.7529411764705882,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.2549019607843137,0.7137254901960784,0.7686274509803922,1); + const float e5 = 0.625; + const vec4 v5 = vec4(0.4980392156862745,0.803921568627451,0.7333333333333333,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.7803921568627451,0.9137254901960784,0.7058823529411765,1); + const float e7 = 0.875; + const vec4 v7 = vec4(0.9294117647058824,0.9725490196078431,0.8509803921568627,1); + const float e8 = 1.0; + const vec4 v8 = vec4(1,1,0.8509803921568627,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var yiorrd = `vec4 apply_cmap (float x) { + const float e0 = 0.0; + const vec4 v0 = vec4(0.5019607843137255,0,0.14901960784313725,1); + const float e1 = 0.125; + const vec4 v1 = vec4(0.7411764705882353,0,0.14901960784313725,1); + const float e2 = 0.25; + const vec4 v2 = vec4(0.8901960784313725,0.10196078431372549,0.10980392156862745,1); + const float e3 = 0.375; + const vec4 v3 = vec4(0.9882352941176471,0.3058823529411765,0.16470588235294117,1); + const float e4 = 0.5; + const vec4 v4 = vec4(0.9921568627450981,0.5529411764705883,0.23529411764705882,1); + const float e5 = 0.625; + const vec4 v5 = vec4(0.996078431372549,0.6980392156862745,0.2980392156862745,1); + const float e6 = 0.75; + const vec4 v6 = vec4(0.996078431372549,0.8509803921568627,0.4627450980392157,1); + const float e7 = 0.875; + const vec4 v7 = vec4(1,0.9294117647058824,0.6274509803921569,1); + const float e8 = 1.0; + const vec4 v8 = vec4(1,1,0.8,1); + float a0 = smoothstep(e0,e1,x); + float a1 = smoothstep(e1,e2,x); + float a2 = smoothstep(e2,e3,x); + float a3 = smoothstep(e3,e4,x); + float a4 = smoothstep(e4,e5,x); + float a5 = smoothstep(e5,e6,x); + float a6 = smoothstep(e6,e7,x); + float a7 = smoothstep(e7,e8,x); + return max(mix(v0,v1,a0)*step(e0,x)*step(x,e1), + max(mix(v1,v2,a1)*step(e1,x)*step(x,e2), + max(mix(v2,v3,a2)*step(e2,x)*step(x,e3), + max(mix(v3,v4,a3)*step(e3,x)*step(x,e4), + max(mix(v4,v5,a4)*step(e4,x)*step(x,e5), + max(mix(v5,v6,a5)*step(e5,x)*step(x,e6), + max(mix(v6,v7,a6)*step(e6,x)*step(x,e7),mix(v7,v8,a7)*step(e7,x)*step(x,e8) + ))))))); +} +`; + var cmaps = { + __proto__: null, + alpha, + autumn, + bathymetry, + blackbody, + bluered, + bone, + cdom, + chlorophyll, + cool, + copper, + cubehelix, + density, + earth, + electric, + freesurface_blue, + freesurface_red, + greens, + greys, + hot, + hsv, + inferno, + jet, + magma, + oxygen, + par, + phase, + picnic, + plasma, + portland, + rainbow, + rainbow_soft, + rdbu, + salinity, + spring, + summer, + temperature, + turbidity, + velocity_blue, + velocity_green, + viridis, + warm, + winter, + yignbu, + yiorrd + }; + function colormapModuleFactory(name, apply_cmap) { + return { + name: `additive-colormap-${name}`, + fs: `uniform float opacity; +uniform bool useTransparentColor; + +${apply_transparent_color} +${apply_cmap} + +vec4 colormap(float intensity) { + return vec4(apply_transparent_color(apply_cmap(min(1.,intensity)).xyz, apply_cmap(0.).xyz, useTransparentColor, opacity)); +}`, + inject: { + "fs:DECKGL_MUTATE_COLOR": ` float intensityCombo = 0.; + intensityCombo += max(0.,intensity0); + intensityCombo += max(0.,intensity1); + intensityCombo += max(0.,intensity2); + intensityCombo += max(0.,intensity3); + intensityCombo += max(0.,intensity4); + intensityCombo += max(0.,intensity5); + rgba = colormap(intensityCombo);` + } + }; } - var OrbitViewport = class extends Viewport { - constructor(props) { - const { - height, - projectionMatrix, - fovy = 50, - orbitAxis = "Z", - target = [0, 0, 0], - rotationX = 0, - rotationOrbit = 0, - zoom = 0 - } = props; - const focalDistance = projectionMatrix ? projectionMatrix[5] / 2 : fovyToAltitude(fovy); - super({ - ...props, - longitude: void 0, - viewMatrix: getViewMatrix2({ - height: height || 1, - focalDistance, - orbitAxis, - rotationX, - rotationOrbit, - zoom - }), - fovy, - focalDistance, - position: target, - zoom - }); - _defineProperty(this, "projectedCenter", void 0); - this.projectedCenter = this.project(this.center); + var defaultProps$4 = { + colormap: { type: "string", value: "viridis", compare: true }, + opacity: { type: "number", value: 1, compare: true }, + useTransparentColor: { type: "boolean", value: false, compare: true } + }; + var AdditiveColormapExtension = class extends LayerExtension { + getShaders() { + const name = this?.props?.colormap || defaultProps$4.colormap.value; + const apply_cmap = cmaps[name]; + if (!apply_cmap) { + throw Error(`No colormap named ${name} found in registry`); + } + return { modules: [colormapModuleFactory(name, apply_cmap)] }; } - unproject(xyz, { - topLeft = true - } = {}) { - const [x2, y2, z = this.projectedCenter[2]] = xyz; - const y22 = topLeft ? y2 : this.height - y2; - const [X, Y, Z] = pixelsToWorld([x2, y22, z], this.pixelUnprojectionMatrix); - return [X, Y, Z]; + updateState({ props, oldProps, changeFlags, ...rest }) { + super.updateState({ props, oldProps, changeFlags, ...rest }); + if (props.colormap !== oldProps.colormap) { + const { gl } = this.context; + if (this.state.model) { + this.state.model.delete(); + this.setState({ model: this._getModel(gl) }); + } + } } - panByPosition(coords, pixel) { - const p0 = this.project(coords); - const nextCenter = [this.width / 2 + p0[0] - pixel[0], this.height / 2 + p0[1] - pixel[1], this.projectedCenter[2]]; - return { - target: this.unproject(nextCenter) + draw() { + const { + useTransparentColor = defaultProps$4.useTransparentColor.value, + opacity = defaultProps$4.opacity.value + } = this.props; + const uniforms = { + opacity, + useTransparentColor }; + this.state.model?.setUniforms(uniforms); } }; + AdditiveColormapExtension.extensionName = "AdditiveColormapExtension"; + AdditiveColormapExtension.defaultProps = defaultProps$4; + var fs$1 = `uniform vec3 transparentColor; +uniform bool useTransparentColor; +uniform float opacity; + +uniform vec3 colors[6]; + +${apply_transparent_color} + +void mutate_color(inout vec3 rgb, float intensity0, float intensity1, float intensity2, float intensity3, float intensity4, float intensity5) { + rgb += max(0.0, min(1.0, intensity0)) * vec3(colors[0]); + rgb += max(0.0, min(1.0, intensity1)) * vec3(colors[1]); + rgb += max(0.0, min(1.0, intensity2)) * vec3(colors[2]); + rgb += max(0.0, min(1.0, intensity3)) * vec3(colors[3]); + rgb += max(0.0, min(1.0, intensity4)) * vec3(colors[4]); + rgb += max(0.0, min(1.0, intensity5)) * vec3(colors[5]); +} - // node_modules/@deck.gl/core/dist/esm/controllers/orbit-controller.js - var OrbitState = class extends ViewState { - constructor(options) { - const { - width, - height, - rotationX = 0, - rotationOrbit = 0, - target = [0, 0, 0], - zoom = 0, - minRotationX = -90, - maxRotationX = 90, - minZoom = -Infinity, - maxZoom = Infinity, - startPanPosition, - startRotatePos, - startRotationX, - startRotationOrbit, - startZoomPosition, - startZoom - } = options; - super({ - width, - height, - rotationX, - rotationOrbit, - target, - zoom, - minRotationX, - maxRotationX, - minZoom, - maxZoom - }, { - startPanPosition, - startRotatePos, - startRotationX, - startRotationOrbit, - startZoomPosition, - startZoom - }); - _defineProperty(this, "makeViewport", void 0); - this.makeViewport = options.makeViewport; - } - panStart({ - pos - }) { - return this._getUpdatedState({ - startPanPosition: this._unproject(pos) - }); +vec4 apply_opacity(vec3 rgb) { + return vec4(apply_transparent_color(rgb, transparentColor, useTransparentColor, opacity)); +} +`; + var DECKGL_MUTATE_COLOR = `vec3 rgb = rgba.rgb; +mutate_color(rgb, intensity0, intensity1, intensity2, intensity3, intensity4, intensity5); +rgba = apply_opacity(rgb); +`; + var colorPalette = { + name: "color-palette-module", + fs: fs$1, + inject: { + "fs:DECKGL_MUTATE_COLOR": DECKGL_MUTATE_COLOR } - pan({ - pos, - startPosition - }) { - const startPanPosition = this.getState().startPanPosition || startPosition; - if (!startPanPosition) { - return this; - } - const viewport = this.makeViewport(this.getViewportProps()); - const newProps = viewport.panByPosition(startPanPosition, pos); - return this._getUpdatedState(newProps); + }; + function padWithDefault(arr, defaultValue, padWidth) { + for (let i3 = 0; i3 < padWidth; i3 += 1) { + arr.push(defaultValue); + } + return arr; + } + var COLOR_PALETTE = [ + [0, 0, 255], + // blue + [0, 255, 0], + // green + [255, 0, 255], + // magenta + [255, 255, 0], + // yellow + [255, 128, 0], + // orange + [0, 255, 255], + // cyan + [255, 255, 255], + // white + [255, 0, 0] + // red + ]; + function getDefaultPalette(n2) { + if (n2 > COLOR_PALETTE.length) { + throw new Error("Too many colors"); + } + return COLOR_PALETTE.slice(0, n2); + } + function padColors({ colors, channelsVisible }) { + const newColors = colors.map( + (color, i3) => channelsVisible[i3] ? color.map((c2) => c2 / MAX_COLOR_INTENSITY) : DEFAULT_COLOR_OFF + ); + const padSize = MAX_CHANNELS - newColors.length; + const paddedColors = padWithDefault( + newColors, + /** @type {Color} */ + DEFAULT_COLOR_OFF, + padSize + ).reduce((acc, val) => acc.concat(val), []); + return paddedColors; + } + var defaultProps$3 = { + colors: { type: "array", value: null, compare: true }, + opacity: { type: "number", value: 1, compare: true }, + transparentColor: { type: "array", value: null, compare: true }, + useTransparentColor: { type: "boolean", value: false, compare: true } + }; + var ColorPaletteExtension = class extends LayerExtension { + getShaders() { + return { + ...super.getShaders(), + modules: [colorPalette] + }; } - panEnd() { - return this._getUpdatedState({ - startPanPosition: null + draw() { + const { + colors, + channelsVisible, + opacity = defaultProps$3.opacity.value, + transparentColor = defaultProps$3.transparentColor.value, + useTransparentColor = defaultProps$3.useTransparentColor.value + } = this.props; + const paddedColors = padColors({ + channelsVisible: channelsVisible || this.selections.map(() => true), + colors: colors || getDefaultPalette(this.props.selections.length) }); + const uniforms = { + colors: paddedColors, + opacity, + transparentColor: (transparentColor || [0, 0, 0]).map((i3) => i3 / 255), + useTransparentColor: Boolean(useTransparentColor) + }; + this.state.model?.setUniforms(uniforms); } - rotateStart({ - pos - }) { - return this._getUpdatedState({ - startRotatePos: pos, - startRotationX: this.getViewportProps().rotationX, - startRotationOrbit: this.getViewportProps().rotationOrbit - }); + }; + ColorPaletteExtension.extensionName = "ColorPaletteExtension"; + ColorPaletteExtension.defaultProps = defaultProps$3; + var fs4 = `// lens bounds for ellipse +uniform float majorLensAxis; +uniform float minorLensAxis; +uniform vec2 lensCenter; + +// lens uniforms +uniform bool lensEnabled; +uniform int lensSelection; +uniform vec3 lensBorderColor; +uniform float lensBorderRadius; + +// color palette +uniform vec3 colors[6]; + +bool frag_in_lens_bounds(vec2 vTexCoord) { + // Check membership in what is (not visually, but effectively) an ellipse. + // Since the fragment space is a unit square and the real coordinates could be longer than tall, + // to get a circle visually we have to treat the check as that of an ellipse to get the effect of a circle. + + // Check membership in ellipse. + return pow((lensCenter.x - vTexCoord.x) / majorLensAxis, 2.) + pow((lensCenter.y - vTexCoord.y) / minorLensAxis, 2.) < (1. - lensBorderRadius); +} + +bool frag_on_lens_bounds(vec2 vTexCoord) { + // Same as the above, except this checks the boundary. + + float ellipseDistance = pow((lensCenter.x - vTexCoord.x) / majorLensAxis, 2.) + pow((lensCenter.y - vTexCoord.y) / minorLensAxis, 2.); + + // Check membership on "bourndary" of ellipse. + return ellipseDistance <= 1. && ellipseDistance >= (1. - lensBorderRadius); +} +// Return a float for boolean arithmetic calculation. +float get_use_color_float(vec2 vTexCoord, int channelIndex) { + bool isFragInLensBounds = frag_in_lens_bounds(vTexCoord); + bool inLensAndUseLens = lensEnabled && isFragInLensBounds; + return float(int((inLensAndUseLens && channelIndex == lensSelection) || (!inLensAndUseLens))); + +} +void mutate_color(inout vec3 rgb, float intensity0, float intensity1, float intensity2, float intensity3, float intensity4, float intensity5, vec2 vTexCoord){ + float useColorValue = 0.; + + useColorValue = get_use_color_float(vTexCoord, 0); + rgb += max(0., min(1., intensity0)) * max(vec3(colors[0]), (1. - useColorValue) * vec3(1., 1., 1.)); + + useColorValue = get_use_color_float(vTexCoord, 1); + rgb += max(0., min(1., intensity1)) * max(vec3(colors[1]), (1. - useColorValue) * vec3(1., 1., 1.)); + + useColorValue = get_use_color_float(vTexCoord, 2); + rgb += max(0., min(1., intensity2)) * max(vec3(colors[2]), (1. - useColorValue) * vec3(1., 1., 1.)); + + useColorValue = get_use_color_float(vTexCoord, 3); + rgb += max(0., min(1., intensity3)) * max(vec3(colors[3]), (1. - useColorValue) * vec3(1., 1., 1.)); + + useColorValue = get_use_color_float(vTexCoord, 4); + rgb += max(0., min(1., intensity4)) * max(vec3(colors[4]), (1. - useColorValue) * vec3(1., 1., 1.)); + + useColorValue = get_use_color_float(vTexCoord, 5); + rgb += max(0., min(1., intensity5)) * max(vec3(colors[5]), (1. - useColorValue) * vec3(1., 1., 1.)); +} +`; + var lens = { + name: "lens-module", + fs: fs4, + inject: { + "fs:DECKGL_MUTATE_COLOR": ` + vec3 rgb = rgba.rgb; + mutate_color(rgb, intensity0, intensity1, intensity2, intensity3, intensity4, intensity5, vTexCoord); + rgba = vec4(rgb, 1.); + `, + "fs:#main-end": ` + bool isFragOnLensBounds = frag_on_lens_bounds(vTexCoord); + gl_FragColor = (lensEnabled && isFragOnLensBounds) ? vec4(lensBorderColor, 1.) : gl_FragColor; + ` } - rotate({ - pos, - deltaAngleX = 0, - deltaAngleY = 0 - }) { - const { - startRotatePos, - startRotationX, - startRotationOrbit - } = this.getState(); - const { - width, - height - } = this.getViewportProps(); - if (!startRotatePos || startRotationX === void 0 || startRotationOrbit === void 0) { - return this; + }; + var defaultProps$2 = { + lensEnabled: { type: "boolean", value: false, compare: true }, + lensSelection: { type: "number", value: 0, compare: true }, + lensRadius: { type: "number", value: 100, compare: true }, + lensBorderColor: { type: "array", value: [255, 255, 255], compare: true }, + lensBorderRadius: { type: "number", value: 0.02, compare: true }, + colors: { type: "array", value: null, compare: true } + }; + var LensExtension = class extends LayerExtension { + getShaders() { + return { + ...super.getShaders(), + modules: [lens] + }; + } + initializeState() { + const layer = this.getCurrentLayer(); + if (layer.isComposite) { + return; } - let newRotation; - if (pos) { - let deltaScaleX = (pos[0] - startRotatePos[0]) / width; - const deltaScaleY = (pos[1] - startRotatePos[1]) / height; - if (startRotationX < -90 || startRotationX > 90) { - deltaScaleX *= -1; + const onMouseMove = () => { + const { viewportId } = layer.props; + const { lensRadius = defaultProps$2.lensRadius.value } = this.props; + if (!viewportId) { + layer.setState({ unprojectLensBounds: [0, 0, 0, 0] }); + return; + } + const { mousePosition } = layer.context; + const layerView = layer.context.deck.viewManager.views.filter( + (view) => view.id === viewportId + )[0]; + const viewState = layer.context.deck.viewManager.viewState[viewportId]; + const viewport = layerView.makeViewport({ + ...viewState, + viewState + }); + if (mousePosition && viewport.containsPixel(mousePosition)) { + const offsetMousePosition = { + x: mousePosition.x - viewport.x, + y: mousePosition.y - viewport.y + }; + const mousePositionBounds = [ + // left + [offsetMousePosition.x - lensRadius, offsetMousePosition.y], + // bottom + [offsetMousePosition.x, offsetMousePosition.y + lensRadius], + // right + [offsetMousePosition.x + lensRadius, offsetMousePosition.y], + // top + [offsetMousePosition.x, offsetMousePosition.y - lensRadius] + ]; + const unprojectLensBounds = mousePositionBounds.map( + (bounds, i3) => viewport.unproject(bounds)[i3 % 2] + ); + layer.setState({ unprojectLensBounds }); + } else { + layer.setState({ unprojectLensBounds: [0, 0, 0, 0] }); } - newRotation = { - rotationX: startRotationX + deltaScaleY * 180, - rotationOrbit: startRotationOrbit + deltaScaleX * 180 - }; - } else { - newRotation = { - rotationX: startRotationX + deltaAngleY, - rotationOrbit: startRotationOrbit + deltaAngleX - }; - } - return this._getUpdatedState(newRotation); - } - rotateEnd() { - return this._getUpdatedState({ - startRotationX: null, - startRotationOrbit: null - }); - } - shortestPathFrom(viewState) { - const fromProps = viewState.getViewportProps(); - const props = { - ...this.getViewportProps() }; - const { - rotationOrbit - } = props; - if (Math.abs(rotationOrbit - fromProps.rotationOrbit) > 180) { - props.rotationOrbit = rotationOrbit < 0 ? rotationOrbit + 360 : rotationOrbit - 360; + if (this.context.deck) { + this.context.deck.eventManager.on({ + pointermove: onMouseMove, + pointerleave: onMouseMove, + wheel: onMouseMove + }); } - return props; + this.setState({ onMouseMove, unprojectLensBounds: [0, 0, 0, 0] }); } - zoomStart({ - pos - }) { - return this._getUpdatedState({ - startZoomPosition: this._unproject(pos), - startZoom: this.getViewportProps().zoom + draw() { + const { unprojectLensBounds = [0, 0, 0, 0] } = this.state; + const { + bounds, + lensEnabled = defaultProps$2.lensEnabled.value, + lensSelection = defaultProps$2.lensSelection.value, + lensBorderColor = defaultProps$2.lensBorderColor.value, + lensBorderRadius = defaultProps$2.lensBorderRadius.value, + colors, + channelsVisible + } = this.props; + const [leftMouseBound, bottomMouseBound, rightMouseBound, topMouseBound] = unprojectLensBounds; + const [left, bottom, right, top] = bounds; + const leftMouseBoundScaled = (leftMouseBound - left) / (right - left); + const bottomMouseBoundScaled = (bottomMouseBound - top) / (bottom - top); + const rightMouseBoundScaled = (rightMouseBound - left) / (right - left); + const topMouseBoundScaled = (topMouseBound - top) / (bottom - top); + const paddedColors = padColors({ + channelsVisible: channelsVisible || this.selections.map(() => true), + colors: colors || getDefaultPalette(this.props.selections.length) }); - } - zoom({ - pos, - startPos, - scale: scale3 - }) { - let { - startZoom, - startZoomPosition - } = this.getState(); - if (!startZoomPosition) { - startZoom = this.getViewportProps().zoom; - startZoomPosition = this._unproject(startPos) || this._unproject(pos); - } - if (!startZoomPosition) { - return this; + const uniforms = { + majorLensAxis: (rightMouseBoundScaled - leftMouseBoundScaled) / 2, + minorLensAxis: (bottomMouseBoundScaled - topMouseBoundScaled) / 2, + lensCenter: [ + (rightMouseBoundScaled + leftMouseBoundScaled) / 2, + (bottomMouseBoundScaled + topMouseBoundScaled) / 2 + ], + lensEnabled, + lensSelection, + lensBorderColor, + lensBorderRadius, + colors: paddedColors + }; + this.state.model?.setUniforms(uniforms); + } + finalizeState() { + if (this.context.deck) { + this.context.deck.eventManager.off({ + pointermove: this.state?.onMouseMove, + pointerleave: this.state?.onMouseMove, + wheel: this.state?.onMouseMove + }); } - const newZoom = this._calculateNewZoom({ - scale: scale3, - startZoom - }); - const zoomedViewport = this.makeViewport({ - ...this.getViewportProps(), - zoom: newZoom - }); - return this._getUpdatedState({ - zoom: newZoom, - ...zoomedViewport.panByPosition(startZoomPosition, pos) - }); - } - zoomEnd() { - return this._getUpdatedState({ - startZoomPosition: null, - startZoom: null - }); } - zoomIn(speed = 2) { - return this._getUpdatedState({ - zoom: this._calculateNewZoom({ - scale: speed - }) - }); - } - zoomOut(speed = 2) { - return this._getUpdatedState({ - zoom: this._calculateNewZoom({ - scale: 1 / speed - }) - }); + }; + LensExtension.extensionName = "LensExtension"; + LensExtension.defaultProps = defaultProps$2; + function colormapModuleFactory3D(name, apply_cmap) { + const fs6 = `${apply_cmap} + +vec4 colormap(float intensity, float opacity) { + return vec4(apply_cmap(min(1.,intensity)).xyz, opacity); +}`; + return { + name: `additive-colormap-3d-${name}`, + fs: fs6 + }; + } + var defaultProps$1 = { + colormap: { type: "string", value: "viridis", compare: true } + }; + var BaseExtension$1 = class BaseExtension extends LayerExtension { + constructor(...args) { + super(args); + this.opts = this.opts || {}; } - moveLeft(speed = 50) { - return this._panFromCenter([-speed, 0]); + getShaders() { + const name = this?.props?.colormap || defaultProps$1.colormap.value; + const apply_cmap = cmaps[name]; + return { + ...super.getShaders(), + modules: [colormapModuleFactory3D(name, apply_cmap)] + }; } - moveRight(speed = 50) { - return this._panFromCenter([speed, 0]); + updateState({ props, oldProps, changeFlags, ...rest }) { + super.updateState({ props, oldProps, changeFlags, ...rest }); + if (props.colormap !== oldProps.colormap) { + const { gl } = this.context; + if (this.state.model) { + this.state.model.delete(); + this.setState({ model: this._getModel(gl) }); + } + } } - moveUp(speed = 50) { - return this._panFromCenter([0, -speed]); + }; + BaseExtension$1.extensionName = "BaseExtension"; + BaseExtension$1.defaultProps = defaultProps$1; + var _BEFORE_RENDER$5 = ""; + var _RENDER$5 = ` float intensityArray[6] = float[6](intensityValue0, intensityValue1, intensityValue2, intensityValue3, intensityValue4, intensityValue5); + float total = 0.0; + + for(int i = 0; i < 6; i++) { + total += intensityArray[i]; + } + // Do not go past 1 in opacity/colormap value. + total = min(total, 1.0); + + vec4 val_color = colormap(total, total); + + // Opacity correction + val_color.a = 1.0 - pow(1.0 - val_color.a, 1.0); + color.rgb += (1.0 - color.a) * val_color.a * val_color.rgb; + color.a += (1.0 - color.a) * val_color.a; + if (color.a >= 0.95) { + break; + } + p += ray_dir * dt; +`; + var _AFTER_RENDER$5 = ""; + var AdditiveBlendExtension$1 = class AdditiveBlendExtension extends BaseExtension$1 { + constructor(args) { + super(args); + this.rendering = { _BEFORE_RENDER: _BEFORE_RENDER$5, _RENDER: _RENDER$5, _AFTER_RENDER: _AFTER_RENDER$5 }; } - moveDown(speed = 50) { - return this._panFromCenter([0, speed]); + }; + AdditiveBlendExtension$1.extensionName = "AdditiveBlendExtension"; + var _BEFORE_RENDER$4 = ` float maxVals[6] = float[6](-1.0, -1.0, -1.0, -1.0, -1.0, -1.0); +`; + var _RENDER$4 = ` float intensityArray[6] = float[6](intensityValue0, intensityValue1, intensityValue2, intensityValue3, intensityValue4, intensityValue5); + + for(int i = 0; i < 6; i++) { + if(intensityArray[i] > maxVals[i]) { + maxVals[i] = intensityArray[i]; } - rotateLeft(speed = 15) { - return this._getUpdatedState({ - rotationOrbit: this.getViewportProps().rotationOrbit - speed - }); + } +`; + var _AFTER_RENDER$4 = ` float total = 0.0; + for(int i = 0; i < 6; i++) { + total += maxVals[i]; + } + // Do not go past 1 in opacity/colormap value. + total = min(total, 1.0); + color = colormap(total, total); +`; + var MaximumIntensityProjectionExtension$1 = class MaximumIntensityProjectionExtension extends BaseExtension$1 { + constructor(args) { + super(args); + this.rendering = { _BEFORE_RENDER: _BEFORE_RENDER$4, _RENDER: _RENDER$4, _AFTER_RENDER: _AFTER_RENDER$4 }; } - rotateRight(speed = 15) { - return this._getUpdatedState({ - rotationOrbit: this.getViewportProps().rotationOrbit + speed - }); + }; + MaximumIntensityProjectionExtension$1.extensionName = "MaximumIntensityProjectionExtension"; + var _BEFORE_RENDER$3 = ` float minVals[6] = float[6](1. / 0., 1. / 0., 1. / 0., 1. / 0., 1. / 0., 1. / 0.); +`; + var _RENDER$3 = ` float intensityArray[6] = float[6](intensityValue0, intensityValue1, intensityValue2, intensityValue3, intensityValue4, intensityValue5); + + for(int i = 0; i < 6; i++) { + if(intensityArray[i] < minVals[i]) { + minVals[i] = intensityArray[i]; } - rotateUp(speed = 10) { - return this._getUpdatedState({ - rotationX: this.getViewportProps().rotationX - speed - }); + } +`; + var _AFTER_RENDER$3 = ` float total = 0.0; + for(int i = 0; i < 6; i++) { + total += minVals[i]; + } + // Do not go past 1 in opacity/colormap value. + total = min(total, 1.0); + color = colormap(total, total); +`; + var MinimumIntensityProjectionExtension$1 = class MinimumIntensityProjectionExtension extends BaseExtension$1 { + constructor(args) { + super(args); + this.rendering = { _BEFORE_RENDER: _BEFORE_RENDER$3, _RENDER: _RENDER$3, _AFTER_RENDER: _AFTER_RENDER$3 }; } - rotateDown(speed = 10) { - return this._getUpdatedState({ - rotationX: this.getViewportProps().rotationX + speed + }; + MinimumIntensityProjectionExtension$1.extensionName = "MinimumIntensityProjectionExtension"; + var defaultProps16 = { + colors: { type: "array", value: null, compare: true } + }; + var BaseExtension2 = class extends LayerExtension { + constructor(...args) { + super(args); + this.opts = this.opts || {}; + } + draw() { + const { colors, channelsVisible } = this.props; + const paddedColors = padColors({ + channelsVisible: channelsVisible || this.selections.map(() => true), + colors: colors || getDefaultPalette(this.props.selections.length) }); + const uniforms = { + colors: paddedColors + }; + this.state.model?.setUniforms(uniforms); } - _unproject(pos) { - const viewport = this.makeViewport(this.getViewportProps()); - return pos && viewport.unproject(pos); + }; + BaseExtension2.extensionName = "BaseExtension"; + BaseExtension2.defaultProps = defaultProps16; + var _BEFORE_RENDER$2 = ``; + var _RENDER$2 = ` vec3 rgbCombo = vec3(0.0); + vec3 hsvCombo = vec3(0.0); + float intensityArray[6] = float[6](intensityValue0, intensityValue1, intensityValue2, intensityValue3, intensityValue4, intensityValue5); + float total = 0.0; + for(int i = 0; i < 6; i++) { + float intensityValue = intensityArray[i]; + rgbCombo += max(0.0, min(1.0, intensityValue)) * colors[i]; + total += intensityValue; + } + // Do not go past 1 in opacity. + total = min(total, 1.0); + vec4 val_color = vec4(rgbCombo, total); + // Opacity correction + val_color.a = 1.0 - pow(1.0 - val_color.a, 1.0); + color.rgb += (1.0 - color.a) * val_color.a * val_color.rgb; + color.a += (1.0 - color.a) * val_color.a; + if (color.a >= 0.95) { + break; + } +`; + var _AFTER_RENDER$2 = ``; + var AdditiveBlendExtension2 = class extends BaseExtension2 { + constructor(args) { + super(args); + this.rendering = { _BEFORE_RENDER: _BEFORE_RENDER$2, _RENDER: _RENDER$2, _AFTER_RENDER: _AFTER_RENDER$2 }; } - _calculateNewZoom({ - scale: scale3, - startZoom - }) { - const { - maxZoom, - minZoom - } = this.getViewportProps(); - if (startZoom === void 0) { - startZoom = this.getViewportProps().zoom; - } - const zoom = startZoom + Math.log2(scale3); - return clamp(zoom, minZoom, maxZoom); + }; + AdditiveBlendExtension2.extensionName = "AdditiveBlendExtension"; + var _BEFORE_RENDER$1 = ` float maxVals[6] = float[6](-1.0, -1.0, -1.0, -1.0, -1.0, -1.0); +`; + var _RENDER$1 = ` float intensityArray[6] = float[6](intensityValue0, intensityValue1, intensityValue2, intensityValue3, intensityValue4, intensityValue5); + + for(int i = 0; i < 6; i++) { + if(intensityArray[i] > maxVals[i]) { + maxVals[i] = intensityArray[i]; } - _panFromCenter(offset) { - const { - width, - height, - target - } = this.getViewportProps(); - return this.pan({ - startPosition: target, - pos: [width / 2 + offset[0], height / 2 + offset[1]] - }); + } +`; + var _AFTER_RENDER$1 = ` vec3 rgbCombo = vec3(0.0); + for(int i = 0; i < 6; i++) { + rgbCombo += max(0.0, min(1.0, maxVals[i])) * vec3(colors[i]); + } + color = vec4(rgbCombo, 1.0); +`; + var MaximumIntensityProjectionExtension2 = class extends BaseExtension2 { + constructor(args) { + super(args); + this.rendering = { _BEFORE_RENDER: _BEFORE_RENDER$1, _RENDER: _RENDER$1, _AFTER_RENDER: _AFTER_RENDER$1 }; } - _getUpdatedState(newProps) { - return new this.constructor({ - makeViewport: this.makeViewport, - ...this.getViewportProps(), - ...this.getState(), - ...newProps - }); + }; + MaximumIntensityProjectionExtension2.extensionName = "MaximumIntensityProjectionExtension"; + var _BEFORE_RENDER = ` float minVals[6] = float[6](1. / 0., 1. / 0., 1. / 0., 1. / 0., 1. / 0., 1. / 0.); +`; + var _RENDER = ` float intensityArray[6] = float[6](intensityValue0, intensityValue1, intensityValue2, intensityValue3, intensityValue4, intensityValue5); + + for(int i = 0; i < 6; i++) { + if(intensityArray[i] < minVals[i]) { + minVals[i] = intensityArray[i]; } - applyConstraints(props) { - const { - maxZoom, - minZoom, - zoom, - maxRotationX, - minRotationX, - rotationOrbit - } = props; - props.zoom = Array.isArray(zoom) ? [clamp(zoom[0], minZoom, maxZoom), clamp(zoom[1], minZoom, maxZoom)] : clamp(zoom, minZoom, maxZoom); - props.rotationX = clamp(props.rotationX, minRotationX, maxRotationX); - if (rotationOrbit < -180 || rotationOrbit > 180) { - props.rotationOrbit = mod2(rotationOrbit + 180, 360) - 180; - } - return props; + } +`; + var _AFTER_RENDER = ` vec3 rgbCombo = vec3(0.0); + for(int i = 0; i < 6; i++) { + rgbCombo += max(0.0, min(1.0, minVals[i])) * vec3(colors[i]); + } + color = vec4(rgbCombo, 1.0); +`; + var MinimumIntensityProjectionExtension2 = class extends BaseExtension2 { + constructor(args) { + super(args); + this.rendering = { _BEFORE_RENDER, _RENDER, _AFTER_RENDER }; } }; - var OrbitController = class extends Controller { - constructor(...args) { - super(...args); - _defineProperty(this, "ControllerState", OrbitState); - _defineProperty(this, "transition", { - transitionDuration: 300, - transitionInterpolator: new LinearInterpolator({ - transitionProps: { - compare: ["target", "zoom", "rotationX", "rotationOrbit"], - required: ["target", "zoom"] - } - }) - }); - } + MinimumIntensityProjectionExtension2.extensionName = "MinimumIntensityProjectionExtension"; + var ColorPalette3DExtensions = { + BaseExtension: BaseExtension2, + AdditiveBlendExtension: AdditiveBlendExtension2, + MaximumIntensityProjectionExtension: MaximumIntensityProjectionExtension2, + MinimumIntensityProjectionExtension: MinimumIntensityProjectionExtension2 }; - // node_modules/@deck.gl/core/dist/esm/views/orbit-view.js - var OrbitView = class extends View { - constructor(props = {}) { - super(props); - this.props.orbitAxis = props.orbitAxis || "Z"; + // node_modules/@vivjs/layers/dist/index.mjs + var fs$2 = `float apply_contrast_limits(float intensity, vec2 contrastLimits) { + return max(0., (intensity - contrastLimits[0]) / max(0.0005, (contrastLimits[1] - contrastLimits[0]))); +} +`; + var channels = { + name: "channel-intensity", + defines: { + SAMPLER_TYPE: "usampler2D", + COLORMAP_FUNCTION: "" + }, + fs: fs$2 + }; + function range(len2) { + return [...Array(len2).keys()]; + } + function padWithDefault2(arr, defaultValue, padWidth) { + for (let i3 = 0; i3 < padWidth; i3 += 1) { + arr.push(defaultValue); } - get ViewportType() { - return OrbitViewport; + return arr; + } + function getDtypeValues(dtype) { + const values = DTYPE_VALUES[dtype]; + if (!values) { + const valid = Object.keys(DTYPE_VALUES); + throw Error(`Dtype not supported, got ${dtype}. Must be one of ${valid}.`); } - get ControllerType() { - return OrbitController; + return values; + } + function padContrastLimits({ + contrastLimits = [], + channelsVisible, + domain, + dtype + }) { + const maxSliderValue = domain && domain[1] || getDtypeValues(dtype).max; + const newContrastLimits = contrastLimits.map( + (slider, i3) => channelsVisible[i3] ? slider : ( + /** @type {[number, number]} */ + [maxSliderValue, maxSliderValue] + ) + ); + const padSize = MAX_CHANNELS - newContrastLimits.length; + if (padSize < 0) { + throw Error( + `${newContrastLimits.lengths} channels passed in, but only 6 are allowed.` + ); } - }; - _defineProperty(OrbitView, "displayName", "OrbitView"); + const paddedContrastLimits = padWithDefault2( + newContrastLimits, + [maxSliderValue, maxSliderValue], + padSize + ).reduce((acc, val) => acc.concat(val), []); + return paddedContrastLimits; + } + function getPhysicalSizeScalingMatrix(loader) { + const { x: x2, y: y2, z } = loader?.meta?.physicalSizes ?? {}; + if (x2?.size && y2?.size && z?.size) { + const min = Math.min(z.size, x2.size, y2.size); + const ratio = [x2.size / min, y2.size / min, z.size / min]; + return new Matrix4().scale(ratio); + } + return new Matrix4().identity(); + } + function makeBoundingBox(viewState) { + const viewport = new OrthographicView().makeViewport({ + // From the current `detail` viewState, we need its projection matrix (actually the inverse). + viewState, + height: viewState.height, + width: viewState.width + }); + return [ + viewport.unproject([0, 0]), + viewport.unproject([viewport.width, 0]), + viewport.unproject([viewport.width, viewport.height]), + viewport.unproject([0, viewport.height]) + ]; + } + var TARGETS = [1, 2, 3, 4, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1e3]; + var MIN_TARGET = TARGETS[0]; + var MAX_TARGET = TARGETS[TARGETS.length - 1]; + var SI_PREFIXES = [ + { symbol: "Y", exponent: 24 }, + { symbol: "Z", exponent: 21 }, + { symbol: "E", exponent: 18 }, + { symbol: "P", exponent: 15 }, + { symbol: "T", exponent: 12 }, + { symbol: "G", exponent: 9 }, + { symbol: "M", exponent: 6 }, + { symbol: "k", exponent: 3 }, + { symbol: "h", exponent: 2 }, + { symbol: "da", exponent: 1 }, + { symbol: "", exponent: 0 }, + { symbol: "d", exponent: -1 }, + { symbol: "c", exponent: -2 }, + { symbol: "m", exponent: -3 }, + { symbol: "\xB5", exponent: -6 }, + { symbol: "n", exponent: -9 }, + { symbol: "p", exponent: -12 }, + { symbol: "f", exponent: -15 }, + { symbol: "a", exponent: -18 }, + { symbol: "z", exponent: -21 }, + { symbol: "y", exponent: -24 } + ]; + function sizeToMeters(size, unit) { + if (!unit || unit === "m") { + return size; + } + if (unit.length > 1) { + let unitPrefix = unit.substring(0, unit.length - 1); + if (unitPrefix === "u") { + unitPrefix = "\xB5"; + } + const unitObj = SI_PREFIXES.find((p2) => p2.symbol === unitPrefix); + if (unitObj) { + return size * 10 ** unitObj.exponent; + } + } + throw new Error("Received unknown unit"); + } + function snapValue(value) { + let magnitude = 0; + if (value < MIN_TARGET || value > MAX_TARGET) { + magnitude = Math.floor(Math.log10(value)); + } + let snappedUnit = SI_PREFIXES.find( + (p2) => p2.exponent % 3 === 0 && p2.exponent <= magnitude + ); + let adjustedValue = value / 10 ** snappedUnit.exponent; + if (adjustedValue > 500 && adjustedValue <= 1e3) { + snappedUnit = SI_PREFIXES.find( + (p2) => p2.exponent % 3 === 0 && p2.exponent <= magnitude + 3 + ); + adjustedValue = value / 10 ** snappedUnit.exponent; + } + const targetNewUnits = TARGETS.find((t2) => t2 > adjustedValue); + const targetOrigUnits = targetNewUnits * 10 ** snappedUnit.exponent; + return [targetOrigUnits, targetNewUnits, snappedUnit.symbol]; + } + var fs$12 = `#define SHADER_NAME xr-layer-fragment-shader - // node_modules/@deck.gl/layers/dist/esm/line-layer/line-layer-vertex.glsl.js - var line_layer_vertex_glsl_default = "#define SHADER_NAME line-layer-vertex-shader\n\nattribute vec3 positions;\nattribute vec3 instanceSourcePositions;\nattribute vec3 instanceTargetPositions;\nattribute vec3 instanceSourcePositions64Low;\nattribute vec3 instanceTargetPositions64Low;\nattribute vec4 instanceColors;\nattribute vec3 instancePickingColors;\nattribute float instanceWidths;\n\nuniform float opacity;\nuniform float widthScale;\nuniform float widthMinPixels;\nuniform float widthMaxPixels;\nuniform float useShortestPath;\nuniform int widthUnits;\n\nvarying vec4 vColor;\nvarying vec2 uv;\nvec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction, float width) {\n vec2 dir_screenspace = normalize(line_clipspace * project_uViewportSize);\n dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);\n\n return dir_screenspace * offset_direction * width / 2.0;\n}\n\nvec3 splitLine(vec3 a, vec3 b, float x) {\n float t = (x - a.x) / (b.x - a.x);\n return vec3(x, mix(a.yz, b.yz, t));\n}\n\nvoid main(void) {\n geometry.worldPosition = instanceSourcePositions;\n geometry.worldPositionAlt = instanceTargetPositions;\n\n vec3 source_world = instanceSourcePositions;\n vec3 target_world = instanceTargetPositions;\n vec3 source_world_64low = instanceSourcePositions64Low;\n vec3 target_world_64low = instanceTargetPositions64Low;\n\n if (useShortestPath > 0.5 || useShortestPath < -0.5) {\n source_world.x = mod(source_world.x + 180., 360.0) - 180.;\n target_world.x = mod(target_world.x + 180., 360.0) - 180.;\n float deltaLng = target_world.x - source_world.x;\n\n if (deltaLng * useShortestPath > 180.) {\n source_world.x += 360. * useShortestPath;\n source_world = splitLine(source_world, target_world, 180. * useShortestPath);\n source_world_64low = vec3(0.0);\n } else if (deltaLng * useShortestPath < -180.) {\n target_world.x += 360. * useShortestPath;\n target_world = splitLine(source_world, target_world, 180. * useShortestPath);\n target_world_64low = vec3(0.0);\n } else if (useShortestPath < 0.) {\n gl_Position = vec4(0.);\n return;\n }\n }\n vec4 source_commonspace;\n vec4 target_commonspace;\n vec4 source = project_position_to_clipspace(source_world, source_world_64low, vec3(0.), source_commonspace);\n vec4 target = project_position_to_clipspace(target_world, target_world_64low, vec3(0.), target_commonspace);\n float segmentIndex = positions.x;\n vec4 p = mix(source, target, segmentIndex);\n geometry.position = mix(source_commonspace, target_commonspace, segmentIndex);\n uv = positions.xy;\n geometry.uv = uv;\n geometry.pickingColor = instancePickingColors;\n float widthPixels = clamp(\n project_size_to_pixel(instanceWidths * widthScale, widthUnits),\n widthMinPixels, widthMaxPixels\n );\n vec3 offset = vec3(\n getExtrusionOffset(target.xy - source.xy, positions.y, widthPixels),\n 0.0);\n DECKGL_FILTER_SIZE(offset, geometry);\n DECKGL_FILTER_GL_POSITION(p, geometry);\n gl_Position = p + vec4(project_pixel_size_to_clipspace(offset.xy), 0.0, 0.0);\n vColor = vec4(instanceColors.rgb, instanceColors.a * opacity);\n DECKGL_FILTER_COLOR(vColor, geometry);\n}\n"; +precision highp float; +precision highp int; +precision highp SAMPLER_TYPE; - // node_modules/@deck.gl/layers/dist/esm/line-layer/line-layer-fragment.glsl.js - var line_layer_fragment_glsl_default = "#define SHADER_NAME line-layer-fragment-shader\n\nprecision highp float;\n\nvarying vec4 vColor;\nvarying vec2 uv;\n\nvoid main(void) {\n geometry.uv = uv;\n\n gl_FragColor = vColor;\n\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; +// our texture +uniform SAMPLER_TYPE channel0; +uniform SAMPLER_TYPE channel1; +uniform SAMPLER_TYPE channel2; +uniform SAMPLER_TYPE channel3; +uniform SAMPLER_TYPE channel4; +uniform SAMPLER_TYPE channel5; - // node_modules/@deck.gl/layers/dist/esm/line-layer/line-layer.js - var DEFAULT_COLOR = [0, 0, 0, 255]; - var defaultProps3 = { - getSourcePosition: { - type: "accessor", - value: (x2) => x2.sourcePosition - }, - getTargetPosition: { - type: "accessor", - value: (x2) => x2.targetPosition - }, - getColor: { - type: "accessor", - value: DEFAULT_COLOR - }, - getWidth: { - type: "accessor", - value: 1 - }, - widthUnits: "pixels", - widthScale: { - type: "number", - value: 1, - min: 0 - }, - widthMinPixels: { - type: "number", - value: 0, - min: 0 - }, - widthMaxPixels: { +in vec2 vTexCoord; + +// range +uniform vec2 contrastLimits[6]; + +void main() { + + float intensity0 = float(texture(channel0, vTexCoord).r); + DECKGL_PROCESS_INTENSITY(intensity0, contrastLimits[0], 0); + float intensity1 = float(texture(channel1, vTexCoord).r); + DECKGL_PROCESS_INTENSITY(intensity1, contrastLimits[1], 1); + float intensity2 = float(texture(channel2, vTexCoord).r); + DECKGL_PROCESS_INTENSITY(intensity2, contrastLimits[2], 2); + float intensity3 = float(texture(channel3, vTexCoord).r); + DECKGL_PROCESS_INTENSITY(intensity3, contrastLimits[3], 3); + float intensity4 = float(texture(channel4, vTexCoord).r); + DECKGL_PROCESS_INTENSITY(intensity4, contrastLimits[4], 4); + float intensity5 = float(texture(channel5, vTexCoord).r); + DECKGL_PROCESS_INTENSITY(intensity5, contrastLimits[5], 5); + + DECKGL_MUTATE_COLOR(gl_FragColor, intensity0, intensity1, intensity2, intensity3, intensity4, intensity5, vTexCoord); + + + geometry.uv = vTexCoord; + DECKGL_FILTER_COLOR(gl_FragColor, geometry); +} +`; + var vs$1 = `#define SHADER_NAME xr-layer-vertex-shader + +attribute vec2 texCoords; +attribute vec3 positions; +attribute vec3 positions64Low; +attribute vec3 instancePickingColors; +varying vec2 vTexCoord; + +void main(void) { + geometry.worldPosition = positions; + geometry.uv = texCoords; + geometry.pickingColor = instancePickingColors; + gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.), geometry.position); + DECKGL_FILTER_GL_POSITION(gl_Position, geometry); + vTexCoord = texCoords; + vec4 color = vec4(0.); + DECKGL_FILTER_COLOR(color, geometry); +} +`; + var coreShaderModule = { fs: fs$12, vs: vs$1 }; + function validateWebGL2Filter(gl, interpolation) { + const canShowFloat = hasFeature(gl, FEATURES.TEXTURE_FLOAT); + const canShowLinear = hasFeature(gl, FEATURES.TEXTURE_FILTER_LINEAR_FLOAT); + if (!canShowFloat) { + throw new Error( + "WebGL1 context does not support floating point textures. Unable to display raster data." + ); + } + if (!canShowLinear && interpolation === esm_default2.LINEAR) { + console.warn( + "LINEAR filtering not supported in WebGL1 context. Falling back to NEAREST." + ); + return esm_default2.NEAREST; + } + return interpolation; + } + function getRenderingAttrs$1(dtype, gl, interpolation) { + if (!isWebGL2(gl)) { + return { + format: esm_default2.LUMINANCE, + dataFormat: esm_default2.LUMINANCE, + type: esm_default2.FLOAT, + sampler: "sampler2D", + shaderModule: coreShaderModule, + filter: validateWebGL2Filter(gl, interpolation), + cast: (data) => new Float32Array(data) + }; + } + const isLinear = interpolation === esm_default2.LINEAR; + const upgradedShaderModule = { ...coreShaderModule }; + const version300str = "#version 300 es\n"; + upgradedShaderModule.fs = version300str.concat(upgradedShaderModule.fs); + upgradedShaderModule.vs = version300str.concat(upgradedShaderModule.vs); + const values = getDtypeValues(isLinear ? "Float32" : dtype); + return { + shaderModule: upgradedShaderModule, + filter: interpolation, + cast: isLinear ? (data) => new Float32Array(data) : (data) => data, + ...values + }; + } + var defaultProps$8 = { + pickable: { type: "boolean", value: true, compare: true }, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + channelData: { type: "object", value: {}, compare: true }, + bounds: { type: "array", value: [0, 0, 1, 1], compare: true }, + contrastLimits: { type: "array", value: [], compare: true }, + channelsVisible: { type: "array", value: [], compare: true }, + dtype: { type: "string", value: "Uint16", compare: true }, + interpolation: { type: "number", - value: Number.MAX_SAFE_INTEGER, - min: 0 + value: esm_default2.NEAREST, + compare: true } }; - var LineLayer = class extends Layer { - getBounds() { - var _this$getAttributeMan; - return (_this$getAttributeMan = this.getAttributeManager()) === null || _this$getAttributeMan === void 0 ? void 0 : _this$getAttributeMan.getBounds(["instanceSourcePositions", "instanceTargetPositions"]); - } + var XRLayer = class extends Layer { + /** + * This function replaces `usampler` with `sampler` if the data is not an unsigned integer + * and adds a standard ramp function default for DECKGL_PROCESS_INTENSITY. + */ getShaders() { + const { dtype, interpolation } = this.props; + const { shaderModule, sampler } = getRenderingAttrs$1( + dtype, + this.context.gl, + interpolation + ); + const extensionDefinesDeckglProcessIntensity = this._isHookDefinedByExtensions("fs:DECKGL_PROCESS_INTENSITY"); + const newChannelsModule = { ...channels, inject: {} }; + if (!extensionDefinesDeckglProcessIntensity) { + newChannelsModule.inject["fs:DECKGL_PROCESS_INTENSITY"] = ` + intensity = apply_contrast_limits(intensity, contrastLimits); + `; + } return super.getShaders({ - vs: line_layer_vertex_glsl_default, - fs: line_layer_fragment_glsl_default, - modules: [project32_default, picking_default] + ...shaderModule, + defines: { + SAMPLER_TYPE: sampler + }, + modules: [project32_default, picking_default, newChannelsModule] }); } - get wrapLongitude() { - return false; + _isHookDefinedByExtensions(hookName) { + const { extensions } = this.props; + return extensions?.some((e2) => { + const shaders = e2.getShaders(); + const { inject = {}, modules = [] } = shaders; + const definesInjection = inject[hookName]; + const moduleDefinesInjection = modules.some((m) => m?.inject[hookName]); + return definesInjection || moduleDefinesInjection; + }); } + /** + * This function initializes the internal state. + */ initializeState() { + const { gl } = this.context; + gl.pixelStorei(esm_default2.UNPACK_ALIGNMENT, 1); + gl.pixelStorei(esm_default2.PACK_ALIGNMENT, 1); const attributeManager = this.getAttributeManager(); - attributeManager.addInstanced({ - instanceSourcePositions: { - size: 3, - type: 5130, - fp64: this.use64bitPositions(), - transition: true, - accessor: "getSourcePosition" - }, - instanceTargetPositions: { + attributeManager.add({ + positions: { size: 3, - type: 5130, + type: esm_default2.DOUBLE, fp64: this.use64bitPositions(), - transition: true, - accessor: "getTargetPosition" - }, - instanceColors: { - size: this.props.colorFormat.length, - type: 5121, - normalized: true, - transition: true, - accessor: "getColor", - defaultValue: [0, 0, 0, 255] - }, - instanceWidths: { - size: 1, - transition: true, - accessor: "getWidth", - defaultValue: 1 + update: this.calculatePositions, + noAlloc: true } }); + this.setState({ + numInstances: 1, + positions: new Float64Array(12) + }); + const programManager = ProgramManager.getDefaultProgramManager(gl); + const mutateStr = "fs:DECKGL_MUTATE_COLOR(inout vec4 rgba, float intensity0, float intensity1, float intensity2, float intensity3, float intensity4, float intensity5, vec2 vTexCoord)"; + const processStr = `fs:DECKGL_PROCESS_INTENSITY(inout float intensity, vec2 contrastLimits, int channelIndex)`; + if (!programManager._hookFunctions.includes(mutateStr)) { + programManager.addShaderHook(mutateStr); + } + if (!programManager._hookFunctions.includes(processStr)) { + programManager.addShaderHook(processStr); + } } - updateState(params) { - super.updateState(params); - if (params.changeFlags.extensionsChanged) { - var _this$state$model; - const { - gl - } = this.context; - (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); - this.state.model = this._getModel(gl); - this.getAttributeManager().invalidateAll(); + /** + * This function finalizes state by clearing all textures from the WebGL context + */ + finalizeState() { + super.finalizeState(); + if (this.state.textures) { + Object.values(this.state.textures).forEach((tex) => tex && tex.delete()); } } - draw({ - uniforms - }) { - const { - widthUnits, - widthScale, - widthMinPixels, - widthMaxPixels, - wrapLongitude - } = this.props; - this.state.model.setUniforms(uniforms).setUniforms({ - widthUnits: UNIT[widthUnits], - widthScale, - widthMinPixels, - widthMaxPixels, - useShortestPath: wrapLongitude ? 1 : 0 - }).draw(); - if (wrapLongitude) { - this.state.model.setUniforms({ - useShortestPath: -1 - }).draw(); + /** + * This function updates state by retriggering model creation (shader compilation and attribute binding) + * and loading any textures that need be loading. + */ + updateState({ props, oldProps, changeFlags, ...rest }) { + super.updateState({ props, oldProps, changeFlags, ...rest }); + if (changeFlags.extensionsChanged || props.interpolation !== oldProps.interpolation) { + const { gl } = this.context; + if (this.state.model) { + this.state.model.delete(); + } + this.setState({ model: this._getModel(gl) }); + this.getAttributeManager().invalidateAll(); + } + if (props.channelData !== oldProps.channelData && props.channelData?.data !== oldProps.channelData?.data || props.interpolation !== oldProps.interpolation) { + this.loadChannelTextures(props.channelData); + } + const attributeManager = this.getAttributeManager(); + if (props.bounds !== oldProps.bounds) { + attributeManager.invalidate("positions"); } } + /** + * This function creates the luma.gl model. + */ _getModel(gl) { - const positions = [0, -1, 0, 0, 1, 0, 1, -1, 0, 1, 1, 0]; + if (!gl) { + return null; + } return new Model(gl, { ...this.getShaders(), id: this.props.id, geometry: new Geometry({ - drawMode: 5, + drawMode: esm_default2.TRIANGLE_FAN, + vertexCount: 4, attributes: { - positions: new Float32Array(positions) + texCoords: new Float32Array([0, 1, 0, 0, 1, 0, 1, 1]) } }), - isInstanced: true + isInstanced: false }); } - }; - _defineProperty(LineLayer, "layerName", "LineLayer"); - _defineProperty(LineLayer, "defaultProps", defaultProps3); - - // node_modules/@deck.gl/layers/dist/esm/point-cloud-layer/point-cloud-layer-vertex.glsl.js - var point_cloud_layer_vertex_glsl_default = "#define SHADER_NAME point-cloud-layer-vertex-shader\n\nattribute vec3 positions;\nattribute vec3 instanceNormals;\nattribute vec4 instanceColors;\nattribute vec3 instancePositions;\nattribute vec3 instancePositions64Low;\nattribute vec3 instancePickingColors;\n\nuniform float opacity;\nuniform float radiusPixels;\nuniform int sizeUnits;\n\nvarying vec4 vColor;\nvarying vec2 unitPosition;\n\nvoid main(void) {\n geometry.worldPosition = instancePositions;\n geometry.normal = project_normal(instanceNormals);\n unitPosition = positions.xy;\n geometry.uv = unitPosition;\n geometry.pickingColor = instancePickingColors;\n vec3 offset = vec3(positions.xy * project_size_to_pixel(radiusPixels, sizeUnits), 0.0);\n DECKGL_FILTER_SIZE(offset, geometry);\n\n gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.), geometry.position);\n DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);\n vec3 lightColor = lighting_getLightColor(instanceColors.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal);\n vColor = vec4(lightColor, instanceColors.a * opacity);\n DECKGL_FILTER_COLOR(vColor, geometry);\n}\n"; - - // node_modules/@deck.gl/layers/dist/esm/point-cloud-layer/point-cloud-layer-fragment.glsl.js - var point_cloud_layer_fragment_glsl_default = "#define SHADER_NAME point-cloud-layer-fragment-shader\n\nprecision highp float;\n\nvarying vec4 vColor;\nvarying vec2 unitPosition;\n\nvoid main(void) {\n geometry.uv = unitPosition;\n\n float distToCenter = length(unitPosition);\n\n if (distToCenter > 1.0) {\n discard;\n }\n\n gl_FragColor = vColor;\n DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n"; - - // node_modules/@deck.gl/layers/dist/esm/point-cloud-layer/point-cloud-layer.js - var DEFAULT_COLOR2 = [0, 0, 0, 255]; - var DEFAULT_NORMAL = [0, 0, 1]; - var defaultProps4 = { - sizeUnits: "pixels", - pointSize: { - type: "number", - min: 0, - value: 10 - }, - getPosition: { - type: "accessor", - value: (x2) => x2.position - }, - getNormal: { - type: "accessor", - value: DEFAULT_NORMAL - }, - getColor: { - type: "accessor", - value: DEFAULT_COLOR2 - }, - material: true, - radiusPixels: { - deprecatedFor: "pointSize" - } - }; - function normalizeData(data) { - const { - header, - attributes - } = data; - if (!header || !attributes) { - return; - } - data.length = header.vertexCount; - if (attributes.POSITION) { - attributes.instancePositions = attributes.POSITION; - } - if (attributes.NORMAL) { - attributes.instanceNormals = attributes.NORMAL; + /** + * This function generates view positions for use as a vec3 in the shader + */ + calculatePositions(attributes) { + const { positions } = this.state; + const { bounds } = this.props; + positions[0] = bounds[0]; + positions[1] = bounds[1]; + positions[2] = 0; + positions[3] = bounds[0]; + positions[4] = bounds[3]; + positions[5] = 0; + positions[6] = bounds[2]; + positions[7] = bounds[3]; + positions[8] = 0; + positions[9] = bounds[2]; + positions[10] = bounds[1]; + positions[11] = 0; + attributes.value = positions; } - if (attributes.COLOR_0) { - attributes.instanceColors = attributes.COLOR_0; + /** + * This function runs the shaders and draws to the canvas + */ + draw({ uniforms }) { + const { textures, model } = this.state; + if (textures && model) { + const { contrastLimits, domain, dtype, channelsVisible } = this.props; + const numTextures = Object.values(textures).filter((t2) => t2).length; + const paddedContrastLimits = padContrastLimits({ + contrastLimits: contrastLimits.slice(0, numTextures), + channelsVisible: channelsVisible.slice(0, numTextures), + domain, + dtype + }); + model.setUniforms({ + ...uniforms, + contrastLimits: paddedContrastLimits, + ...textures + }).draw(); + } } - } - var PointCloudLayer = class extends Layer { - getShaders() { - return super.getShaders({ - vs: point_cloud_layer_vertex_glsl_default, - fs: point_cloud_layer_fragment_glsl_default, - modules: [project32_default, gouraudLighting, picking_default] - }); + /** + * This function loads all channel textures from incoming resolved promises/data from the loaders by calling `dataToTexture` + */ + loadChannelTextures(channelData) { + const textures = { + channel0: null, + channel1: null, + channel2: null, + channel3: null, + channel4: null, + channel5: null + }; + if (this.state.textures) { + Object.values(this.state.textures).forEach((tex) => tex && tex.delete()); + } + if (channelData && Object.keys(channelData).length > 0 && channelData.data) { + channelData.data.forEach((d2, i3) => { + textures[`channel${i3}`] = this.dataToTexture( + d2, + channelData.width, + channelData.height + ); + }, this); + this.setState({ textures }); + } } - initializeState() { - this.getAttributeManager().addInstanced({ - instancePositions: { - size: 3, - type: 5130, - fp64: this.use64bitPositions(), - transition: true, - accessor: "getPosition" - }, - instanceNormals: { - size: 3, - transition: true, - accessor: "getNormal", - defaultValue: DEFAULT_NORMAL + /** + * This function creates textures from the data + */ + dataToTexture(data, width, height) { + const { interpolation } = this.props; + const attrs = getRenderingAttrs$1( + this.props.dtype, + this.context.gl, + interpolation + ); + return new Texture2D(this.context.gl, { + width, + height, + data: attrs.cast?.(data) ?? data, + // we don't want or need mimaps + mipmaps: false, + parameters: { + // NEAREST for integer data + [esm_default2.TEXTURE_MIN_FILTER]: attrs.filter, + [esm_default2.TEXTURE_MAG_FILTER]: attrs.filter, + // CLAMP_TO_EDGE to remove tile artifacts + [esm_default2.TEXTURE_WRAP_S]: esm_default2.CLAMP_TO_EDGE, + [esm_default2.TEXTURE_WRAP_T]: esm_default2.CLAMP_TO_EDGE }, - instanceColors: { - size: this.props.colorFormat.length, - type: 5121, - normalized: true, - transition: true, - accessor: "getColor", - defaultValue: DEFAULT_COLOR2 - } + format: attrs.format, + dataFormat: attrs.dataFormat, + type: attrs.type }); } - updateState(params) { - const { - changeFlags, - props - } = params; - super.updateState(params); - if (changeFlags.extensionsChanged) { - var _this$state$model; - const { - gl - } = this.context; - (_this$state$model = this.state.model) === null || _this$state$model === void 0 ? void 0 : _this$state$model.delete(); - this.state.model = this._getModel(gl); - this.getAttributeManager().invalidateAll(); - } - if (changeFlags.dataChanged) { - normalizeData(props.data); - } + }; + XRLayer.layerName = "XRLayer"; + XRLayer.defaultProps = defaultProps$8; + var PHOTOMETRIC_INTERPRETATIONS = { + WhiteIsZero: 0, + BlackIsZero: 1, + RGB: 2, + Palette: 3, + TransparencyMask: 4, + CMYK: 5, + YCbCr: 6, + CIELab: 8, + ICCLab: 9 + }; + var defaultProps$7 = { + ...BitmapLayer.defaultProps, + pickable: { type: "boolean", value: true, compare: true }, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN + }; + var getPhotometricInterpretationShader = (photometricInterpretation, transparentColorInHook) => { + const useTransparentColor = transparentColorInHook ? "true" : "false"; + const transparentColorVector = `vec3(${(transparentColorInHook || [0, 0, 0]).map((i3) => String(i3 / 255)).join(",")})`; + switch (photometricInterpretation) { + case PHOTOMETRIC_INTERPRETATIONS.RGB: + return `color[3] = (${useTransparentColor} && (color.rgb == ${transparentColorVector})) ? 0.0 : color.a;`; + case PHOTOMETRIC_INTERPRETATIONS.WhiteIsZero: + return ` float value = 1.0 - (color.r / 256.0); + color = vec4(value, value, value, (${useTransparentColor} && vec3(value, value, value) == ${transparentColorVector}) ? 0.0 : color.a); + `; + case PHOTOMETRIC_INTERPRETATIONS.BlackIsZero: + return ` float value = (color.r / 256.0); + color = vec4(value, value, value, (${useTransparentColor} && vec3(value, value, value) == ${transparentColorVector}) ? 0.0 : color.a); + `; + case PHOTOMETRIC_INTERPRETATIONS.YCbCr: + return ` float y = color[0]; + float cb = color[1]; + float cr = color[2]; + color[0] = (y + (1.40200 * (cr - .5))); + color[1] = (y - (0.34414 * (cb - .5)) - (0.71414 * (cr - .5))); + color[2] = (y + (1.77200 * (cb - .5))); + color[3] = (${useTransparentColor} && distance(color.rgb, ${transparentColorVector}) < 0.01) ? 0.0 : color.a; + `; + default: + console.error( + "Unsupported photometric interpretation or none provided. No transformation will be done to image data" + ); + return ""; } - draw({ - uniforms - }) { - const { - pointSize, - sizeUnits - } = this.props; - this.state.model.setUniforms(uniforms).setUniforms({ - sizeUnits: UNIT[sizeUnits], - radiusPixels: pointSize - }).draw(); + }; + var getTransparentColor = (photometricInterpretation) => { + switch (photometricInterpretation) { + case PHOTOMETRIC_INTERPRETATIONS.RGB: + return [0, 0, 0, 0]; + case PHOTOMETRIC_INTERPRETATIONS.WhiteIsZero: + return [255, 255, 255, 0]; + case PHOTOMETRIC_INTERPRETATIONS.BlackIsZero: + return [0, 0, 0, 0]; + case PHOTOMETRIC_INTERPRETATIONS.YCbCr: + return [16, 128, 128, 0]; + default: + console.error( + "Unsupported photometric interpretation or none provided. No transformation will be done to image data" + ); + return [0, 0, 0, 0]; } + }; + var BitmapLayerWrapper = class extends BitmapLayer { _getModel(gl) { - const positions = []; - for (let i2 = 0; i2 < 3; i2++) { - const angle2 = i2 / 3 * Math.PI * 2; - positions.push(Math.cos(angle2) * 2, Math.sin(angle2) * 2, 0); + const { photometricInterpretation, transparentColorInHook } = this.props; + const photometricInterpretationShader = getPhotometricInterpretationShader( + photometricInterpretation, + transparentColorInHook + ); + if (!gl) { + return null; } return new Model(gl, { ...this.getShaders(), id: this.props.id, geometry: new Geometry({ - drawMode: 4, - attributes: { - positions: new Float32Array(positions) - } + drawMode: esm_default2.TRIANGLES, + vertexCount: 6 }), - isInstanced: true + isInstanced: false, + inject: { + "fs:DECKGL_FILTER_COLOR": photometricInterpretationShader + } }); } - }; - _defineProperty(PointCloudLayer, "layerName", "PointCloudLayer"); - _defineProperty(PointCloudLayer, "defaultProps", defaultProps4); - - // node_modules/@deck.gl/carto/dist/esm/style/palette.js - var cartoColors = __toESM(require_cartocolor2()); - - // node_modules/@deck.gl/carto/dist/esm/style/utils.js - var ALLOWED_ATTR_TYPES = Object.freeze(["function", "string"]); - function getAttrValue(attr, d2) { - var _properties; - assert11(typeof d2 === "object", 'Expected "data" to be an object'); - assert11(ALLOWED_ATTR_TYPES.includes(typeof attr), 'Expected "attr" to be a function or string'); - if (typeof attr === "function") { - return attr(d2); - } - return d2 === null || d2 === void 0 ? void 0 : (_properties = d2.properties) === null || _properties === void 0 ? void 0 : _properties[attr]; - } - function assert11(condition, message = "") { - if (!condition) { - throw new Error("CARTO style error: ".concat(message)); - } - } - - // node_modules/@deck.gl/carto/dist/esm/style/palette.js - var DEFAULT_PALETTE = "PurpOr"; - var NULL_COLOR = [204, 204, 204]; - var OTHERS_COLOR = [119, 119, 119]; - function getPalette(name, numCategories) { - const palette = cartoColors[name]; - let paletteIndex = numCategories; - assert11(palette, 'Palette "'.concat(name, '" not found. Expected a CARTOColors string')); - const palettesColorVariants = Object.keys(palette).filter((p2) => p2 !== "tags").map(Number); - const longestPaletteIndex = Math.max(...palettesColorVariants); - const smallestPaletteIndex = Math.min(...palettesColorVariants); - if (!Number.isInteger(numCategories) || numCategories > longestPaletteIndex) { - paletteIndex = longestPaletteIndex; - } else if (numCategories < smallestPaletteIndex) { - paletteIndex = smallestPaletteIndex; - } - let colors = palette[paletteIndex]; - if (palette.tags && palette.tags.includes("qualitative")) { - colors = colors.slice(0, -1); - } - return colors.map((c2) => hexToRgb(c2)); - } - function hexToRgb(hex) { - let result = /^#?([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})$/i.exec(hex); - if (result) { - return [parseInt(result[1] + result[1], 16), parseInt(result[2] + result[2], 16), parseInt(result[3] + result[3], 16), 255]; - } - result = /^#?([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})([a-f\d]{1})$/i.exec(hex); - if (result) { - return [parseInt(result[1] + result[1], 16), parseInt(result[2] + result[2], 16), parseInt(result[3] + result[3], 16), parseInt(result[4] + result[4], 16)]; + }; + var BitmapLayer2 = class extends CompositeLayer { + initializeState(args) { + const { gl } = this.context; + gl.pixelStorei(esm_default2.UNPACK_ALIGNMENT, 1); + gl.pixelStorei(esm_default2.PACK_ALIGNMENT, 1); + super.initializeState(args); + } + renderLayers() { + const { + photometricInterpretation, + transparentColor: transparentColorInHook + } = this.props; + const transparentColor = getTransparentColor(photometricInterpretation); + return new BitmapLayerWrapper(this.props, { + // transparentColor is a prop applied to the original image data by deck.gl's + // BitmapLayer and needs to be in the original colorspace. It is used to determine + // what color is "transparent" in the original color space (i.e what shows when opacity is 0). + transparentColor, + // This is our transparentColor props which needs to be applied in the hook that converts to the RGB space. + transparentColorInHook, + id: `${this.props.id}-wrapped` + }); } - result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex); - if (result) { - return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16), 255]; + }; + BitmapLayer2.layerName = "BitmapLayer"; + BitmapLayer2.PHOTOMETRIC_INTERPRETATIONS = PHOTOMETRIC_INTERPRETATIONS; + BitmapLayer2.defaultProps = { + ...defaultProps$7, + // We don't want this layer to bind the texture so the type should not be `image`. + image: { type: "object", value: {}, compare: true }, + transparentColor: { type: "array", value: [0, 0, 0], compare: true }, + photometricInterpretation: { type: "number", value: 2, compare: true } + }; + BitmapLayerWrapper.defaultProps = defaultProps$7; + BitmapLayerWrapper.layerName = "BitmapLayerWrapper"; + function renderSubLayers(props) { + const { + bbox: { left, top, right, bottom }, + index: { x: x2, y: y2, z } + } = props.tile; + const { data, id, loader, maxZoom } = props; + if ([left, bottom, right, top].some((v2) => v2 < 0) || !data) { + return null; } - result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex); - assert11(result, 'Hexadecimal color "'.concat(hex, '" was not parsed correctly')); - return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16), parseInt(result[4], 16)]; - } - - // node_modules/@deck.gl/carto/dist/esm/style/color-categories-style.js - function colorCategories({ - attr, - domain, - colors = DEFAULT_PALETTE, - nullColor = NULL_COLOR, - othersColor = OTHERS_COLOR - }) { - assert11(Array.isArray(domain), 'Expected "domain" to be an array of numbers or strings'); - const colorsByCategory = {}; - const palette = typeof colors === "string" ? getPalette(colors, domain.length) : colors; - for (const [i2, c2] of domain.entries()) { - colorsByCategory[c2] = palette[i2]; + const base = loader[0]; + const { height, width } = getImageSize(base); + const bounds = [ + left, + data.height < base.tileSize ? height : bottom, + data.width < base.tileSize ? width : right, + top + ]; + if (isInterleaved(base.shape)) { + const { photometricInterpretation = 2 } = base.meta; + return new BitmapLayer2(props, { + image: data, + photometricInterpretation, + // Shared props with XRLayer: + bounds, + id: `tile-sub-layer-${bounds}-${id}`, + tileId: { x: x2, y: y2, z }, + extensions: [] + }); } - return (d2) => { - const value = getAttrValue(attr, d2); - return typeof value === "number" && Number.isFinite(value) || typeof value === "string" ? colorsByCategory[value] || othersColor : nullColor; - }; - } - - // node_modules/@preact/signals-core/dist/signals-core.module.js - function i() { - throw new Error("Cycle detected"); + return new XRLayer(props, { + channelData: data, + // Uncomment to help debugging - shades the tile being hovered over. + // autoHighlight: true, + // highlightColor: [80, 80, 80, 50], + // Shared props with BitmapLayer: + bounds, + id: `tile-sub-layer-${bounds}-${id}`, + tileId: { x: x2, y: y2, z }, + // The auto setting is NEAREST at the highest resolution but LINEAR otherwise. + interpolation: z === maxZoom ? esm_default2.NEAREST : esm_default2.LINEAR + }); } - var t = Symbol.for("preact-signals"); - function r() { - if (!(v > 1)) { - var i2, t2 = false; - while (void 0 !== f) { - var r2 = f; - f = void 0; - e++; - while (void 0 !== r2) { - var n2 = r2.o; - r2.o = void 0; - r2.f &= -3; - if (!(8 & r2.f) && l(r2)) - try { - r2.c(); - } catch (r3) { - if (!t2) { - i2 = r3; - t2 = true; - } - } - r2 = n2; - } + var defaultProps$6 = { + pickable: { type: "boolean", value: true, compare: true }, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + contrastLimits: { type: "array", value: [], compare: true }, + channelsVisible: { type: "array", value: [], compare: true }, + renderSubLayers: { type: "function", value: renderSubLayers, compare: false }, + dtype: { type: "string", value: "Uint16", compare: true }, + domain: { type: "array", value: [], compare: true }, + viewportId: { type: "string", value: "", compare: true }, + interpolation: { type: "number", value: null, compare: true } + }; + var MultiscaleImageLayerBase = class extends TileLayer { + /** + * This function allows us to controls which viewport gets to update the Tileset2D. + * This is a uniquely TileLayer issue since it updates based on viewport updates thanks + * to its ability to handle zoom-pan loading. Essentially, with a picture-in-picture, + * this prevents it from detecting the update of some other viewport that is unwanted. + */ + _updateTileset() { + if (!this.props.viewportId) { + super._updateTileset(); } - e = 0; - v--; - if (t2) - throw i2; - } else - v--; - } - function n(i2) { - if (v > 0) - return i2(); - v++; - try { - return i2(); - } finally { - r(); - } - } - var o = void 0; - var f = void 0; - var v = 0; - var e = 0; - var u = 0; - function c(i2) { - if (void 0 !== o) { - var t2 = i2.n; - if (void 0 === t2 || t2.t !== o) { - t2 = { i: 0, S: i2, p: o.s, n: void 0, t: o, e: void 0, x: void 0, r: t2 }; - if (void 0 !== o.s) - o.s.n = t2; - o.s = t2; - i2.n = t2; - if (32 & o.f) - i2.S(t2); - return t2; - } else if (-1 === t2.i) { - t2.i = 0; - if (void 0 !== t2.n) { - t2.n.p = t2.p; - if (void 0 !== t2.p) - t2.p.n = t2.n; - t2.p = o.s; - t2.n = void 0; - o.s.n = t2; - o.s = t2; - } - return t2; + if (this.props.viewportId && this.context.viewport.id === this.props.viewportId || // I don't know why, but DeckGL doesn't recognize multiple views on the first pass + // so we force update on the first pass by checking if there is a viewport in the tileset. + !this.state.tileset._viewport) { + super._updateTileset(); } } - } - function d(i2) { - this.v = i2; - this.i = 0; - this.n = void 0; - this.t = void 0; - } - d.prototype.brand = t; - d.prototype.h = function() { - return true; }; - d.prototype.S = function(i2) { - if (this.t !== i2 && void 0 === i2.e) { - i2.x = this.t; - if (void 0 !== this.t) - this.t.e = i2; - this.t = i2; + MultiscaleImageLayerBase.layerName = "MultiscaleImageLayerBase"; + MultiscaleImageLayerBase.defaultProps = defaultProps$6; + var defaultProps$5 = { + pickable: { type: "boolean", value: true, compare: true }, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + contrastLimits: { type: "array", value: [], compare: true }, + channelsVisible: { type: "array", value: [], compare: true }, + selections: { type: "array", value: [], compare: true }, + domain: { type: "array", value: [], compare: true }, + viewportId: { type: "string", value: "", compare: true }, + loader: { + type: "object", + value: { + getRaster: async () => ({ data: [], height: 0, width: 0 }), + dtype: "Uint16", + shape: [] + }, + compare: true + }, + onClick: { type: "function", value: null, compare: true }, + onViewportLoad: { type: "function", value: null, compare: true }, + interpolation: { + type: "number", + value: esm_default2.NEAREST, + compare: true + }, + extensions: { + type: "array", + value: [new ColorPaletteExtension()], + compare: true } }; - d.prototype.U = function(i2) { - if (void 0 !== this.t) { - var t2 = i2.e, r2 = i2.x; - if (void 0 !== t2) { - t2.x = r2; - i2.e = void 0; + var ImageLayer = class extends CompositeLayer { + finalizeState() { + this.state.abortController.abort(); + } + updateState({ props, oldProps }) { + const loaderChanged = props.loader !== oldProps.loader; + const selectionsChanged = props.selections !== oldProps.selections; + if (loaderChanged || selectionsChanged) { + const { loader, selections = [], onViewportLoad } = this.props; + const abortController = new AbortController(); + this.setState({ abortController }); + const { signal } = abortController; + const getRaster = (selection) => loader.getRaster({ selection, signal }); + const dataPromises = selections.map(getRaster); + Promise.all(dataPromises).then((rasters) => { + const raster = { + data: rasters.map((d2) => d2.data), + width: rasters[0]?.width, + height: rasters[0]?.height + }; + if (isInterleaved(loader.shape)) { + raster.data = raster.data[0]; + if (raster.data.length === raster.width * raster.height * 3) { + raster.format = esm_default2.RGB; + raster.dataFormat = esm_default2.RGB; + } + } + if (onViewportLoad) { + onViewportLoad(raster); + } + this.setState({ ...raster }); + }).catch((e2) => { + if (e2 !== SIGNAL_ABORTED) { + throw e2; + } + }); } - if (void 0 !== r2) { - r2.e = t2; - i2.x = void 0; + } + // eslint-disable-next-line class-methods-use-this + getPickingInfo({ info, sourceLayer }) { + info.sourceLayer = sourceLayer; + info.tile = sourceLayer.props.tile; + return info; + } + renderLayers() { + const { loader, id } = this.props; + const { dtype } = loader; + const { width, height, data } = this.state; + if (!(width && height)) + return null; + const bounds = [0, height, width, 0]; + if (isInterleaved(loader.shape)) { + const { photometricInterpretation = 2 } = loader.meta; + return new BitmapLayer2(this.props, { + image: this.state, + photometricInterpretation, + // Shared props with XRLayer: + bounds, + id: `image-sub-layer-${bounds}-${id}`, + extensions: [] + }); } - if (i2 === this.t) - this.t = r2; + return new XRLayer(this.props, { + channelData: { data, height, width }, + // Shared props with BitmapLayer: + bounds, + id: `image-sub-layer-${bounds}-${id}`, + dtype + }); } }; - d.prototype.subscribe = function(i2) { - var t2 = this; - return O(function() { - var r2 = t2.value, n2 = 32 & this.f; - this.f &= -33; - try { - i2(r2); - } finally { - this.f |= n2; - } - }); + ImageLayer.layerName = "ImageLayer"; + ImageLayer.defaultProps = defaultProps$5; + var defaultProps$42 = { + pickable: { type: "boolean", value: true, compare: true }, + onHover: { type: "function", value: null, compare: false }, + contrastLimits: { type: "array", value: [], compare: true }, + channelsVisible: { type: "array", value: [], compare: true }, + domain: { type: "array", value: [], compare: true }, + viewportId: { type: "string", value: "", compare: true }, + maxRequests: { type: "number", value: 10, compare: true }, + onClick: { type: "function", value: null, compare: true }, + refinementStrategy: { type: "string", value: null, compare: true }, + excludeBackground: { type: "boolean", value: false, compare: true }, + extensions: { + type: "array", + value: [new ColorPaletteExtension()], + compare: true + } }; - d.prototype.valueOf = function() { - return this.value; + var MultiscaleImageLayer = class extends CompositeLayer { + renderLayers() { + const { + loader, + selections, + opacity, + viewportId, + onTileError, + onHover, + id, + onClick, + modelMatrix, + excludeBackground, + refinementStrategy + } = this.props; + const { tileSize, dtype } = loader[0]; + const getTileData = async ({ index: { x: x2, y: y2, z }, signal }) => { + if (!selections || selections.length === 0) { + return null; + } + const resolution = Math.round(-z); + const getTile = (selection) => { + const config2 = { x: x2, y: y2, selection, signal }; + return loader[resolution].getTile(config2); + }; + try { + const tiles = await Promise.all(selections.map(getTile)); + const tile = { + data: tiles.map((d2) => d2.data), + width: tiles[0].width, + height: tiles[0].height + }; + if (isInterleaved(loader[resolution].shape)) { + tile.data = tile.data[0]; + if (tile.data.length === tile.width * tile.height * 3) { + tile.format = esm_default2.RGB; + tile.dataFormat = esm_default2.RGB; + } + return tile; + } + return tile; + } catch (err3) { + if (err3 === SIGNAL_ABORTED) { + return null; + } + throw err3; + } + }; + const { height, width } = getImageSize(loader[0]); + const tiledLayer = new MultiscaleImageLayerBase(this.props, { + id: `Tiled-Image-${id}`, + getTileData, + dtype, + tileSize, + // If you scale a matrix up or down, that is like zooming in or out. zoomOffset controls + // how the zoom level you fetch tiles at is offset, allowing us to fetch higher resolution tiles + // while at a lower "absolute" zoom level. If you didn't use this prop, an image that is scaled + // up would always look "low resolution" no matter the level of the image pyramid you are looking at. + zoomOffset: Math.round( + Math.log2(modelMatrix ? modelMatrix.getScale()[0] : 1) + ), + extent: [0, 0, width, height], + // See the above note within for why the use of zoomOffset and the rounding necessary. + minZoom: Math.round(-(loader.length - 1)), + maxZoom: 0, + // We want a no-overlap caching strategy with an opacity < 1 to prevent + // multiple rendered sublayers (some of which have been cached) from overlapping + refinementStrategy: refinementStrategy || (opacity === 1 ? "best-available" : "no-overlap"), + // TileLayer checks `changeFlags.updateTriggersChanged.getTileData` to see if tile cache + // needs to be re-created. We want to trigger this behavior if the loader changes. + // https://github.com/uber/deck.gl/blob/3f67ea6dfd09a4d74122f93903cb6b819dd88d52/modules/geo-layers/src/tile-layer/tile-layer.js#L50 + updateTriggers: { + getTileData: [loader, selections] + }, + onTileError: onTileError || loader[0].onTileError + }); + const lowestResolution = loader[loader.length - 1]; + const implementsGetRaster = typeof lowestResolution.getRaster === "function"; + const layerModelMatrix = modelMatrix ? modelMatrix.clone() : new Matrix4(); + const baseLayer = implementsGetRaster && !excludeBackground && new ImageLayer(this.props, { + id: `Background-Image-${id}`, + loader: lowestResolution, + modelMatrix: layerModelMatrix.scale(2 ** (loader.length - 1)), + visible: !viewportId || this.context.viewport.id === viewportId, + onHover, + onClick, + // Background image is nicest when LINEAR in my opinion. + interpolation: esm_default2.LINEAR, + onViewportLoad: null + }); + const layers = [baseLayer, tiledLayer]; + return layers; + } }; - d.prototype.toString = function() { - return this.value + ""; + MultiscaleImageLayer.layerName = "MultiscaleImageLayer"; + MultiscaleImageLayer.defaultProps = defaultProps$42; + var defaultProps$32 = { + pickable: { type: "boolean", value: true, compare: true }, + loader: { + type: "object", + value: { + getRaster: async () => ({ data: [], height: 0, width: 0 }), + getRasterSize: () => ({ height: 0, width: 0 }), + dtype: " f2, + filled: false, + stroked: true, + getLineColor: boundingBoxColor, + getLineWidth: boundingBoxOutlineWidth * 2 ** zoom + }); + const viewportOutline = new PolygonLayer({ + id: `viewport-outline-${id}`, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + data: [ + [ + [0, 0], + [width * overviewScale, 0], + [width * overviewScale, height * overviewScale], + [0, height * overviewScale] + ] + ], + getPolygon: (f2) => f2, + filled: false, + stroked: true, + getLineColor: viewportOutlineColor, + getLineWidth: viewportOutlineWidth * 2 ** zoom + }); + const layers = [overview, boundingBoxOutline, viewportOutline]; + return layers; + } }; - d.prototype.peek = function() { - return this.v; + OverviewLayer.layerName = "OverviewLayer"; + OverviewLayer.defaultProps = defaultProps$32; + function getPosition2(boundingBox, position, length4) { + const viewWidth = boundingBox[2][0] - boundingBox[0][0]; + const viewHeight = boundingBox[2][1] - boundingBox[0][1]; + switch (position) { + case "bottom-right": { + const yCoord = boundingBox[2][1] - viewHeight * length4; + const xLeftCoord = boundingBox[2][0] - viewWidth * length4; + return [yCoord, xLeftCoord]; + } + case "top-right": { + const yCoord = boundingBox[0][1] + viewHeight * length4; + const xLeftCoord = boundingBox[2][0] - viewWidth * length4; + return [yCoord, xLeftCoord]; + } + case "top-left": { + const yCoord = boundingBox[0][1] + viewHeight * length4; + const xLeftCoord = boundingBox[0][0] + viewWidth * length4; + return [yCoord, xLeftCoord]; + } + case "bottom-left": { + const yCoord = boundingBox[2][1] - viewHeight * length4; + const xLeftCoord = boundingBox[0][0] + viewWidth * length4; + return [yCoord, xLeftCoord]; + } + default: { + throw new Error(`Position ${position} not found`); + } + } + } + var defaultProps$22 = { + pickable: { type: "boolean", value: true, compare: true }, + viewState: { + type: "object", + value: { zoom: 0, target: [0, 0, 0] }, + compare: true + }, + unit: { type: "string", value: "", compare: true }, + size: { type: "number", value: 1, compare: true }, + position: { type: "string", value: "bottom-right", compare: true }, + length: { type: "number", value: 0.085, compare: true }, + snap: { type: "boolean", value: false, compare: true } }; - Object.defineProperty(d.prototype, "value", { get: function() { - var i2 = c(this); - if (void 0 !== i2) - i2.i = this.i; - return this.v; - }, set: function(t2) { - if (o instanceof _) - !function() { - throw new Error("Computed cannot have side-effects"); - }(); - if (t2 !== this.v) { - if (e > 100) - i(); - this.v = t2; - this.i++; - u++; - v++; - try { - for (var n2 = this.t; void 0 !== n2; n2 = n2.x) - n2.t.N(); - } finally { - r(); - } + var ScaleBarLayer = class extends CompositeLayer { + renderLayers() { + const { id, unit, size, position, viewState, length: length4, snap } = this.props; + const boundingBox = makeBoundingBox(viewState); + const { zoom } = viewState; + const viewLength = boundingBox[2][0] - boundingBox[0][0]; + const barLength = viewLength * 0.05; + const barHeight = Math.max( + 2 ** (-zoom + 1.5), + (boundingBox[2][1] - boundingBox[0][1]) * 7e-3 + ); + let adjustedBarLength = barLength; + let displayNumber = (barLength * size).toPrecision(5); + let displayUnit = unit; + if (snap) { + const meterSize = sizeToMeters(size, unit); + const numUnits = barLength * meterSize; + const [snappedOrigUnits, snappedNewUnits, snappedUnitPrefix] = snapValue(numUnits); + adjustedBarLength = snappedOrigUnits / meterSize; + displayNumber = snappedNewUnits; + displayUnit = `${snappedUnitPrefix}m`; + } + const [yCoord, xLeftCoord] = getPosition2(boundingBox, position, length4); + const xRightCoord = xLeftCoord + barLength; + const isLeft = position.endsWith("-left"); + const lengthBar = new LineLayer({ + id: `scale-bar-length-${id}`, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + data: [ + [ + [isLeft ? xLeftCoord : xRightCoord - adjustedBarLength, yCoord], + [isLeft ? xLeftCoord + adjustedBarLength : xRightCoord, yCoord] + ] + ], + getSourcePosition: (d2) => d2[0], + getTargetPosition: (d2) => d2[1], + getWidth: 2, + getColor: [220, 220, 220] + }); + const tickBoundsLeft = new LineLayer({ + id: `scale-bar-height-left-${id}`, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + data: [ + [ + [ + isLeft ? xLeftCoord : xRightCoord - adjustedBarLength, + yCoord - barHeight + ], + [ + isLeft ? xLeftCoord : xRightCoord - adjustedBarLength, + yCoord + barHeight + ] + ] + ], + getSourcePosition: (d2) => d2[0], + getTargetPosition: (d2) => d2[1], + getWidth: 2, + getColor: [220, 220, 220] + }); + const tickBoundsRight = new LineLayer({ + id: `scale-bar-height-right-${id}`, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + data: [ + [ + [ + isLeft ? xLeftCoord + adjustedBarLength : xRightCoord, + yCoord - barHeight + ], + [ + isLeft ? xLeftCoord + adjustedBarLength : xRightCoord, + yCoord + barHeight + ] + ] + ], + getSourcePosition: (d2) => d2[0], + getTargetPosition: (d2) => d2[1], + getWidth: 2, + getColor: [220, 220, 220] + }); + const textLayer = new TextLayer({ + id: `units-label-layer-${id}`, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + data: [ + { + text: `${displayNumber}${displayUnit}`, + position: [ + isLeft ? xLeftCoord + barLength * 0.5 : xRightCoord - barLength * 0.5, + yCoord + barHeight * 4 + ] + } + ], + getColor: [220, 220, 220, 255], + getSize: 12, + fontFamily: DEFAULT_FONT_FAMILY, + sizeUnits: "meters", + sizeScale: 2 ** -zoom, + characterSet: [ + ...displayUnit.split(""), + ...range(10).map((i3) => String(i3)), + ".", + "e", + "+" + ] + }); + return [lengthBar, tickBoundsLeft, tickBoundsRight, textLayer]; } - } }); - function a(i2) { - return new d(i2); - } - function l(i2) { - for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) - if (t2.S.i !== t2.i || !t2.S.h() || t2.S.i !== t2.i) - return true; - return false; - } - function y(i2) { - for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) { - var r2 = t2.S.n; - if (void 0 !== r2) - t2.r = r2; - t2.S.n = t2; - t2.i = -1; - if (void 0 === t2.n) { - i2.s = t2; - break; - } + }; + ScaleBarLayer.layerName = "ScaleBarLayer"; + ScaleBarLayer.defaultProps = defaultProps$22; + var vs7 = `#version 300 es +#define SHADER_NAME xr-layer-vertex-shader + +// Unit-cube vertices +in vec3 positions; + +// Eye position - last column of the inverted view matrix +uniform vec3 eye_pos; +// Projection matrix +uniform mat4 proj; +// Model Matrix +uniform mat4 model; +// View Matrix +uniform mat4 view; +// A matrix for scaling in the model space before any transformations. +// This projects the unit cube up to match the "pixel size" multiplied by the physical size ratio, if provided. +uniform mat4 scale; +uniform mat4 resolution; + + +out vec3 vray_dir; +flat out vec3 transformed_eye; + +void main() { + + // Step 1: Standard MVP transformation (+ the scale matrix) to place the positions on your 2D screen ready for rasterization + fragment processing. + gl_Position = proj * view * model * scale * resolution * vec4(positions, 1.); + + // Step 2: Invert the eye back from world space to the normalized 0-1 cube world space because ray casting on the fragment shader runs in 0-1 space. + // Geometrically, the transformed_eye is a position relative to the 0-1 normalized vertices, which themselves are the inverse of the model + scale trasnformation. + // See below for an example which does not involve a scale transformation, for simplicity, but motivates geometrically the needed transformation on eye_pos. + /* + This first diagram is a skewed volume (i.e a "shear" model matrix applied) top down with the eye marked as #, all in world space + ^ + ___|__ + \\ | \\ + \\ | \\ + \\|____\\ + | + | + | + # + + This next diagram shows the volume after the inverse model matrix has placed it back in model coordinates, but the eye still in world space. + ^ + ___|___ + | | | + | | | + |__|__| + | + | + | + # + + Finally, we apply the inverse model matrix transformation to the eye as well to bring it too into world space. + Notice that the ray here matches the "voxels" through which the first ray also passes, as desired. + ^ + ____/__ + | / | + | / | + |/____| + / + / + / + # + */ + transformed_eye = (inverse(resolution) * inverse(scale) * inverse(model) * (vec4(eye_pos, 1.))).xyz; + + // Step 3: Rays are from eye to vertices so that they get interpolated over the fragments. + vray_dir = positions - transformed_eye; +} +`; + var fs5 = `#version 300 es +precision highp int; +precision highp float; +precision highp SAMPLER_TYPE; + +uniform highp SAMPLER_TYPE volume0; +uniform highp SAMPLER_TYPE volume1; +uniform highp SAMPLER_TYPE volume2; +uniform highp SAMPLER_TYPE volume3; +uniform highp SAMPLER_TYPE volume4; +uniform highp SAMPLER_TYPE volume5; + +uniform vec3 scaledDimensions; + +uniform mat4 scale; + +uniform vec3 normals[NUM_PLANES]; +uniform float distances[NUM_PLANES]; + +// color +uniform vec3 colors[6]; + +// slices +uniform vec2 xSlice; +uniform vec2 ySlice; +uniform vec2 zSlice; + +// range +uniform vec2 contrastLimits[6]; + +in vec3 vray_dir; +flat in vec3 transformed_eye; +out vec4 color; + +vec2 intersect_box(vec3 orig, vec3 dir) { + vec3 box_min = vec3(xSlice[0], ySlice[0], zSlice[0]); + vec3 box_max = vec3(xSlice[1], ySlice[1], zSlice[1]); + vec3 inv_dir = 1. / dir; + vec3 tmin_tmp = (box_min - orig) * inv_dir; + vec3 tmax_tmp = (box_max - orig) * inv_dir; + vec3 tmin = min(tmin_tmp, tmax_tmp); + vec3 tmax = max(tmin_tmp, tmax_tmp); + float t0 = max(tmin.x, max(tmin.y, tmin.z)); + float t1 = min(tmax.x, min(tmax.y, tmax.z)); + vec2 val = vec2(t0, t1); + return val; +} + +float linear_to_srgb(float x) { + if (x <= 0.0031308f) { + return 12.92f * x; + } + return 1.055f * pow(x, 1.f / 2.4f) - 0.055f; +} + +// Pseudo-random number gen from +// http://www.reedbeta.com/blog/quick-and-easy-gpu-random-numbers-in-d3d11/ +// with some tweaks for the range of values +float wang_hash(int seed) { + seed = (seed ^ 61) ^ (seed >> 16); + seed *= 9; + seed = seed ^ (seed >> 4); + seed *= 0x27d4eb2d; + seed = seed ^ (seed >> 15); + return float(seed % 2147483647) / float(2147483647); +} + + +void main(void) { + // Step 1: Normalize the view ray + vec3 ray_dir = normalize(vray_dir); + + // Step 2: Intersect the ray with the volume bounds to find the interval + // along the ray overlapped by the volume. + vec2 t_hit = intersect_box(transformed_eye, ray_dir); + if (t_hit.x > t_hit.y) { + discard; + } + // We don't want to sample voxels behind the eye if it's + // inside the volume, so keep the starting point at or in front + // of the eye + t_hit.x = max(t_hit.x, 0.); + + // Step 3: Compute the step size to march through the volume grid + vec3 dt_vec = 1. / (scale * vec4(abs(ray_dir), 1.)).xyz; + float dt = 1. * min(dt_vec.x, min(dt_vec.y, dt_vec.z)); + + float offset = wang_hash(int(gl_FragCoord.x + 640. * gl_FragCoord.y)); + + // Step 4: Starting from the entry point, march the ray through the volume + // and sample it + vec3 p = transformed_eye + (t_hit.x + offset * dt) * ray_dir; + + // TODO: Probably want to stop this process at some point to improve performance when marching down the edges. + _BEFORE_RENDER + for (float t = t_hit.x; t < t_hit.y; t += dt) { + // Check if this point is on the "positive" side or "negative" side of the plane - only show positive. + float canShow = 1.; + for (int i = 0; i < NUM_PLANES; i += 1) { + canShow *= max(0., sign(dot(normals[i], p) + distances[i])); + } + // Do not show coordinates outside 0-1 box. + // Something about the undefined behavior outside the box causes the additive blender to + // render some very odd artifacts. + float canShowXCoordinate = max(p.x - 0., 0.) * max(1. - p.x , 0.); + float canShowYCoordinate = max(p.y - 0., 0.) * max(1. - p.y , 0.); + float canShowZCoordinate = max(p.z - 0., 0.) * max(1. - p.z , 0.); + float canShowCoordinate = float(ceil(canShowXCoordinate * canShowYCoordinate * canShowZCoordinate)); + canShow = canShowCoordinate * canShow; + float intensityValue0 = float(texture(volume0, p).r); + DECKGL_PROCESS_INTENSITY(intensityValue0, contrastLimits[0], 0); + intensityValue0 = canShow * intensityValue0; + float intensityValue1 = float(texture(volume1, p).r); + DECKGL_PROCESS_INTENSITY(intensityValue1, contrastLimits[1], 1); + intensityValue1 = canShow * intensityValue1; + float intensityValue2 = float(texture(volume2, p).r); + DECKGL_PROCESS_INTENSITY(intensityValue2, contrastLimits[2], 2); + intensityValue2 = canShow * intensityValue2; + float intensityValue3 = float(texture(volume3, p).r); + DECKGL_PROCESS_INTENSITY(intensityValue3, contrastLimits[3], 3); + intensityValue3 = canShow * intensityValue3; + float intensityValue4 = float(texture(volume4, p).r); + DECKGL_PROCESS_INTENSITY(intensityValue4, contrastLimits[4], 4); + intensityValue4 = canShow * intensityValue4; + float intensityValue5 = float(texture(volume5, p).r); + DECKGL_PROCESS_INTENSITY(intensityValue5, contrastLimits[5], 5); + intensityValue5 = canShow * intensityValue5; + + _RENDER + + p += ray_dir * dt; + } + _AFTER_RENDER + color.r = linear_to_srgb(color.r); + color.g = linear_to_srgb(color.g); + color.b = linear_to_srgb(color.b); +} +`; + var channelsModule = { + name: "channel-intensity-module", + fs: ` float apply_contrast_limits(float intensity, vec2 contrastLimits) { + float contrastLimitsAppliedToIntensity = (intensity - contrastLimits[0]) / max(0.0005, (contrastLimits[1] - contrastLimits[0])); + return max(0., contrastLimitsAppliedToIntensity); } - } - function w(i2) { - var t2 = i2.s, r2 = void 0; - while (void 0 !== t2) { - var n2 = t2.p; - if (-1 === t2.i) { - t2.S.U(t2); - if (void 0 !== n2) - n2.n = t2.n; - if (void 0 !== t2.n) - t2.n.p = n2; - } else - r2 = t2; - t2.S.n = t2.r; - if (void 0 !== t2.r) - t2.r = void 0; - t2 = n2; + ` + }; + var CUBE_STRIP = [ + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ]; + var NUM_PLANES_DEFAULT = 1; + var defaultProps$12 = { + pickable: false, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + channelData: { type: "object", value: {}, compare: true }, + contrastLimits: { type: "array", value: [], compare: true }, + dtype: { type: "string", value: "Uint8", compare: true }, + xSlice: { type: "array", value: null, compare: true }, + ySlice: { type: "array", value: null, compare: true }, + zSlice: { type: "array", value: null, compare: true }, + clippingPlanes: { type: "array", value: [], compare: true }, + resolutionMatrix: { type: "object", value: new Matrix4(), compare: true }, + channelsVisible: { type: "array", value: [], compare: true }, + extensions: { + type: "array", + value: [new ColorPalette3DExtensions.AdditiveBlendExtension()], + compare: true } - i2.s = r2; + }; + function getRenderingAttrs() { + const values = getDtypeValues("Float32"); + return { + ...values, + sampler: values.sampler.replace("2D", "3D"), + cast: (data) => new Float32Array(data) + }; } - function _(i2) { - d.call(this, void 0); - this.x = i2; - this.s = void 0; - this.g = u - 1; - this.f = 4; + function getRenderingFromExtensions(extensions) { + let rendering = {}; + extensions.forEach((extension) => { + rendering = extension.rendering; + }); + if (!rendering._RENDER) { + throw new Error( + "XR3DLayer requires at least one extension to define opts.rendering as an object with _RENDER as a property at the minimum." + ); + } + return rendering; } - (_.prototype = new d()).h = function() { - this.f &= -3; - if (1 & this.f) - return false; - if (32 == (36 & this.f)) - return true; - this.f &= -5; - if (this.g === u) - return true; - this.g = u; - this.f |= 1; - if (this.i > 0 && !l(this)) { - this.f &= -2; - return true; + var XR3DLayer = class extends Layer { + initializeState() { + const { gl } = this.context; + gl.pixelStorei(esm_default2.UNPACK_ALIGNMENT, 1); + gl.pixelStorei(esm_default2.PACK_ALIGNMENT, 1); + const programManager = ProgramManager.getDefaultProgramManager(gl); + const processStr = `fs:DECKGL_PROCESS_INTENSITY(inout float intensity, vec2 contrastLimits, int channelIndex)`; + if (!programManager._hookFunctions.includes(processStr)) { + programManager.addShaderHook(processStr); + } + } + _isHookDefinedByExtensions(hookName) { + const { extensions } = this.props; + return extensions?.some((e2) => { + const shaders = e2.getShaders(); + if (shaders) { + const { inject = {}, modules = [] } = shaders; + const definesInjection = inject[hookName]; + const moduleDefinesInjection = modules.some( + (m) => m.inject && m?.inject[hookName] + ); + return definesInjection || moduleDefinesInjection; + } + return false; + }); } - var i2 = o; - try { - y(this); - o = this; - var t2 = this.x(); - if (16 & this.f || this.v !== t2 || 0 === this.i) { - this.v = t2; - this.f &= -17; - this.i++; + /** + * This function compiles the shaders and the projection module. + */ + getShaders() { + const { clippingPlanes, extensions } = this.props; + const { sampler } = getRenderingAttrs(); + const { _BEFORE_RENDER: _BEFORE_RENDER2, _RENDER: _RENDER2, _AFTER_RENDER: _AFTER_RENDER2 } = getRenderingFromExtensions(extensions); + const extensionDefinesDeckglProcessIntensity = this._isHookDefinedByExtensions("fs:DECKGL_PROCESS_INTENSITY"); + const newChannelsModule = { inject: {}, ...channelsModule }; + if (!extensionDefinesDeckglProcessIntensity) { + newChannelsModule.inject["fs:DECKGL_PROCESS_INTENSITY"] = ` + intensity = apply_contrast_limits(intensity, contrastLimits); + `; } - } catch (i3) { - this.v = i3; - this.f |= 16; - this.i++; + return super.getShaders({ + vs: vs7, + fs: fs5.replace("_BEFORE_RENDER", _BEFORE_RENDER2).replace("_RENDER", _RENDER2).replace("_AFTER_RENDER", _AFTER_RENDER2), + defines: { + SAMPLER_TYPE: sampler, + NUM_PLANES: String(clippingPlanes.length || NUM_PLANES_DEFAULT) + }, + modules: [newChannelsModule] + }); } - o = i2; - w(this); - this.f &= -2; - return true; - }; - _.prototype.S = function(i2) { - if (void 0 === this.t) { - this.f |= 36; - for (var t2 = this.s; void 0 !== t2; t2 = t2.n) - t2.S.S(t2); + /** + * This function finalizes state by clearing all textures from the WebGL context + */ + finalizeState() { + super.finalizeState(); + if (this.state.textures) { + Object.values(this.state.textures).forEach((tex) => tex && tex.delete()); + } } - d.prototype.S.call(this, i2); - }; - _.prototype.U = function(i2) { - if (void 0 !== this.t) { - d.prototype.U.call(this, i2); - if (void 0 === this.t) { - this.f &= -33; - for (var t2 = this.s; void 0 !== t2; t2 = t2.n) - t2.S.U(t2); + /** + * This function updates state by retriggering model creation (shader compilation and attribute binding) + * and loading any textures that need be loading. + */ + updateState({ props, oldProps, changeFlags }) { + if (changeFlags.extensionsChanged || props.colormap !== oldProps.colormap || props.renderingMode !== oldProps.renderingMode || props.clippingPlanes.length !== oldProps.clippingPlanes.length) { + const { gl } = this.context; + if (this.state.model) { + this.state.model.delete(); + } + this.setState({ model: this._getModel(gl) }); + } + if (props.channelData && props?.channelData?.data !== oldProps?.channelData?.data) { + this.loadTexture(props.channelData); } } - }; - _.prototype.N = function() { - if (!(2 & this.f)) { - this.f |= 6; - for (var i2 = this.t; void 0 !== i2; i2 = i2.x) - i2.t.N(); + /** + * This function creates the luma.gl model. + */ + _getModel(gl) { + if (!gl) { + return null; + } + return new Model(gl, { + ...this.getShaders(), + geometry: new Geometry({ + drawMode: gl.TRIANGLE_STRIP, + attributes: { + positions: new Float32Array(CUBE_STRIP) + } + }) + }); } - }; - _.prototype.peek = function() { - if (!this.h()) - i(); - if (16 & this.f) - throw this.v; - return this.v; - }; - Object.defineProperty(_.prototype, "value", { get: function() { - if (1 & this.f) - i(); - var t2 = c(this); - this.h(); - if (void 0 !== t2) - t2.i = this.i; - if (16 & this.f) - throw this.v; - return this.v; - } }); - function p(i2) { - return new _(i2); - } - function g(i2) { - var t2 = i2.u; - i2.u = void 0; - if ("function" == typeof t2) { - v++; - var n2 = o; - o = void 0; - try { - t2(); - } catch (t3) { - i2.f &= -2; - i2.f |= 8; - b(i2); - throw t3; - } finally { - o = n2; - r(); + /** + * This function runs the shaders and draws to the canvas + */ + draw({ uniforms }) { + const { textures, model, scaleMatrix } = this.state; + const { + contrastLimits, + xSlice, + ySlice, + zSlice, + modelMatrix, + channelsVisible, + domain, + dtype, + clippingPlanes, + resolutionMatrix + } = this.props; + const { viewMatrix: viewMatrix2, viewMatrixInverse, projectionMatrix } = this.context.viewport; + if (textures && model && scaleMatrix) { + const paddedContrastLimits = padContrastLimits({ + contrastLimits, + channelsVisible, + domain, + dtype + }); + const invertedScaleMatrix = scaleMatrix.clone().invert(); + const invertedResolutionMatrix = resolutionMatrix.clone().invert(); + const paddedClippingPlanes = padWithDefault2( + clippingPlanes.map( + (p2) => p2.clone().transform(invertedScaleMatrix).transform(invertedResolutionMatrix) + ), + new Plane([1, 0, 0]), + clippingPlanes.length || NUM_PLANES_DEFAULT + ); + const normals = paddedClippingPlanes.map((plane) => plane.normal).flat(); + const distances = paddedClippingPlanes.map((plane) => plane.distance); + model.setUniforms({ + ...uniforms, + ...textures, + contrastLimits: paddedContrastLimits, + xSlice: new Float32Array( + xSlice ? xSlice.map((i3) => i3 / scaleMatrix[0] / resolutionMatrix[0]) : [0, 1] + ), + ySlice: new Float32Array( + ySlice ? ySlice.map((i3) => i3 / scaleMatrix[5] / resolutionMatrix[5]) : [0, 1] + ), + zSlice: new Float32Array( + zSlice ? zSlice.map((i3) => i3 / scaleMatrix[10] / resolutionMatrix[10]) : [0, 1] + ), + eye_pos: new Float32Array([ + viewMatrixInverse[12], + viewMatrixInverse[13], + viewMatrixInverse[14] + ]), + view: viewMatrix2, + proj: projectionMatrix, + scale: scaleMatrix, + resolution: resolutionMatrix, + model: modelMatrix || new Matrix4(), + normals, + distances + }).draw(); } } - } - function b(i2) { - for (var t2 = i2.s; void 0 !== t2; t2 = t2.n) - t2.S.U(t2); - i2.x = void 0; - i2.s = void 0; - g(i2); - } - function x(i2) { - if (o !== this) - throw new Error("Out-of-order effect"); - w(this); - o = i2; - this.f &= -2; - if (8 & this.f) - b(this); - r(); - } - function E(i2) { - this.x = i2; - this.u = void 0; - this.s = void 0; - this.o = void 0; - this.f = 32; - } - E.prototype.c = function() { - var i2 = this.S(); - try { - if (8 & this.f) - return; - if (void 0 === this.x) - return; - var t2 = this.x(); - if ("function" == typeof t2) - this.u = t2; - } finally { - i2(); + /** + * This function loads all textures from incoming resolved promises/data from the loaders by calling `dataToTexture` + */ + loadTexture(channelData) { + const textures = { + volume0: null, + volume1: null, + volume2: null, + volume3: null, + volume4: null, + volume5: null + }; + if (this.state.textures) { + Object.values(this.state.textures).forEach((tex) => tex && tex.delete()); + } + if (channelData && Object.keys(channelData).length > 0 && channelData.data) { + const { height, width, depth } = channelData; + channelData.data.forEach((d2, i3) => { + textures[`volume${i3}`] = this.dataToTexture(d2, width, height, depth); + }, this); + this.setState({ + textures, + scaleMatrix: new Matrix4().scale( + this.props.physicalSizeScalingMatrix.transformPoint([ + width, + height, + depth + ]) + ) + }); + } + } + /** + * This function creates textures from the data + */ + dataToTexture(data, width, height, depth) { + const attrs = getRenderingAttrs(); + const texture = new Texture3D(this.context.gl, { + width, + height, + depth, + data: attrs.cast?.(data) ?? data, + // ? Seems to be a luma.gl bug. Looks like Texture2D is wrong or this is but these are flipped somewhere. + format: attrs.dataFormat, + dataFormat: attrs.format, + type: attrs.type, + mipmaps: false, + parameters: { + [esm_default2.TEXTURE_MIN_FILTER]: esm_default2.LINEAR, + [esm_default2.TEXTURE_MAG_FILTER]: esm_default2.LINEAR, + [esm_default2.TEXTURE_WRAP_S]: esm_default2.CLAMP_TO_EDGE, + [esm_default2.TEXTURE_WRAP_T]: esm_default2.CLAMP_TO_EDGE, + [esm_default2.TEXTURE_WRAP_R]: esm_default2.CLAMP_TO_EDGE + } + }); + return texture; } }; - E.prototype.S = function() { - if (1 & this.f) - i(); - this.f |= 1; - this.f &= -9; - g(this); - y(this); - v++; - var t2 = o; - o = this; - return x.bind(this, t2); + XR3DLayer.layerName = "XR3DLayer"; + XR3DLayer.defaultProps = defaultProps$12; + async function getVolume({ + source, + selection, + onUpdate = () => { + }, + downsampleDepth = 1, + signal + }) { + const { shape, labels, dtype } = source; + const { height, width } = getImageSize(source); + const depth = shape[labels.indexOf("z")]; + const depthDownsampled = Math.max(1, Math.floor(depth / downsampleDepth)); + const rasterSize = height * width; + const name = `${dtype}Array`; + const TypedArray = globalThis[name]; + const volumeData = new TypedArray(rasterSize * depthDownsampled); + await Promise.all( + new Array(depthDownsampled).fill(0).map(async (_2, z) => { + const depthSelection = { + ...selection, + z: z * downsampleDepth + }; + const { data: rasterData } = await source.getRaster({ + selection: depthSelection, + signal + }); + let r2 = 0; + onUpdate(); + while (r2 < rasterSize) { + const volIndex = z * rasterSize + (rasterSize - r2 - 1); + const rasterIndex = (width - r2 - 1) % width + width * Math.floor(r2 / width); + volumeData[volIndex] = rasterData[rasterIndex]; + r2 += 1; + } + onUpdate(); + }) + ); + return { + data: volumeData, + height, + width, + depth: depthDownsampled + }; + } + var getTextLayer = (text, viewport, id) => { + return new TextLayer({ + id: `text-${id}`, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + data: [ + { + text, + position: viewport.position + } + ], + getColor: [220, 220, 220, 255], + getSize: 25, + sizeUnits: "meters", + sizeScale: 2 ** -viewport.zoom, + fontFamily: "Helvetica" + }); }; - E.prototype.N = function() { - if (!(2 & this.f)) { - this.f |= 2; - this.o = f; - f = this; + var defaultProps17 = { + pickable: false, + coordinateSystem: COORDINATE_SYSTEM.CARTESIAN, + contrastLimits: { type: "array", value: [], compare: true }, + channelsVisible: { type: "array", value: [], compare: true }, + selections: { type: "array", value: [], compare: true }, + resolution: { type: "number", value: 0, compare: true }, + domain: { type: "array", value: [], compare: true }, + loader: { + type: "object", + value: [ + { + getRaster: async () => ({ data: [], height: 0, width: 0 }), + dtype: "Uint16", + shape: [1], + labels: ["z"] + } + ], + compare: true + }, + xSlice: { type: "array", value: null, compare: true }, + ySlice: { type: "array", value: null, compare: true }, + zSlice: { type: "array", value: null, compare: true }, + clippingPlanes: { type: "array", value: [], compare: true }, + onUpdate: { type: "function", value: () => { + }, compare: true }, + useProgressIndicator: { type: "boolean", value: true, compare: true }, + useWebGL1Warning: { type: "boolean", value: true, compare: true }, + extensions: { + type: "array", + value: [new ColorPalette3DExtensions.AdditiveBlendExtension()], + compare: true } }; - E.prototype.d = function() { - this.f |= 8; - if (!(1 & this.f)) - b(this); - }; - function O(i2) { - var t2 = new E(i2); - try { - t2.c(); - } catch (i3) { - t2.d(); - throw i3; + var VolumeLayer = class extends CompositeLayer { + clearState() { + this.setState({ + height: null, + width: null, + depth: null, + data: null, + physicalSizeScalingMatrix: null, + resolutionMatrix: null, + progress: 0, + abortController: null + }); } - return t2.d.bind(t2); - } + finalizeState() { + this.state.abortController.abort(); + } + updateState({ oldProps, props }) { + const loaderChanged = props.loader !== oldProps.loader; + const resolutionChanged = props.resolution !== oldProps.resolution; + const selectionsChanged = props.selections !== oldProps.selections; + if (resolutionChanged) { + this.clearState(); + } + if (loaderChanged || selectionsChanged || resolutionChanged) { + const { + loader, + selections = [], + resolution, + onViewportLoad + } = this.props; + const source = loader[resolution]; + let progress = 0; + const totalRequests = ( + // eslint-disable-next-line no-bitwise + (source.shape[source.labels.indexOf("z")] >> resolution) * selections.length + ); + const onUpdate = () => { + progress += 0.5 / totalRequests; + if (this.props.onUpdate) { + this.props.onUpdate({ progress }); + } + this.setState({ progress }); + }; + const abortController = new AbortController(); + this.setState({ abortController }); + const { signal } = abortController; + const volumePromises = selections.map( + (selection) => getVolume({ + selection, + source, + onUpdate, + downsampleDepth: 2 ** resolution, + signal + }) + ); + const physicalSizeScalingMatrix = getPhysicalSizeScalingMatrix( + loader[resolution] + ); + Promise.all(volumePromises).then((volumes) => { + if (onViewportLoad) { + onViewportLoad(volumes); + } + const volume = { + data: volumes.map((d2) => d2.data), + width: volumes[0]?.width, + height: volumes[0]?.height, + depth: volumes[0]?.depth + }; + this.setState({ + ...volume, + physicalSizeScalingMatrix, + resolutionMatrix: new Matrix4().scale(2 ** resolution) + }); + }); + } + } + renderLayers() { + const { loader, id, resolution, useProgressIndicator, useWebGL1Warning } = this.props; + const { dtype } = loader[resolution]; + const { + data, + width, + height, + depth, + progress, + physicalSizeScalingMatrix, + resolutionMatrix + } = this.state; + const { gl } = this.context; + if (!isWebGL2(gl) && useWebGL1Warning) { + const { viewport } = this.context; + return getTextLayer( + [ + "Volume rendering is only available on browsers that support WebGL2. If you", + "are using Safari, you can turn on WebGL2 by navigating in the top menubar", + "to check Develop > Experimental Features > WebGL 2.0 and then refreshing", + "the page." + ].join("\n"), + viewport, + id + ); + } + if (!(width && height) && useProgressIndicator) { + const { viewport } = this.context; + return getTextLayer( + `Loading Volume ${String((progress || 0) * 100).slice(0, 5)}%...`, + viewport, + id + ); + } + return new XR3DLayer(this.props, { + channelData: { data, width, height, depth }, + id: `XR3DLayer-${0}-${height}-${width}-${0}-${resolution}-${id}`, + physicalSizeScalingMatrix, + parameters: { + [esm_default2.CULL_FACE]: true, + [esm_default2.CULL_FACE_MODE]: esm_default2.FRONT, + [esm_default2.DEPTH_TEST]: false, + blendFunc: [esm_default2.SRC_ALPHA, esm_default2.ONE], + blend: true + }, + resolutionMatrix, + dtype + }); + } + }; + VolumeLayer.layerName = "VolumeLayer"; + VolumeLayer.defaultProps = defaultProps17; // src/hra-node-dist-vis.js var import_cartocolor = __toESM(require_cartocolor2(), 1); @@ -31377,6 +62026,7 @@ nodeTargetKey = a(); nodeTargetValue = a(); maxEdgeDistance = a(); + viewState = a(); toDispose = []; initialized = false; nodes = a([]); @@ -31454,9 +62104,9 @@ for (const node of this.nodes.value) { maxDimSize = Math.max(maxDimSize, ...node.position); } - const scale3 = ([x2, y2, z]) => [x2 / maxDimSize, 1 - y2 / maxDimSize, z / maxDimSize]; + const scale5 = ([x2, y2, z]) => [x2 / maxDimSize, 1 - y2 / maxDimSize, z / maxDimSize]; return (attr) => { - return (d2) => scale3(attr(d2)); + return (d2) => scale5(attr(d2)); }; }); nodesLayer = p(() => { @@ -31493,6 +62143,18 @@ return void 0; } }); + scaleBarLayer = p(() => { + return this.nodes.value.length > 0 ? new ScaleBarLayer({ + id: "scalebar", + unit: "\xB5m", + size: 1 / this.positionScaling.value(() => [1, 1, 1])()[0], + // Scale 1µm the same way positions are scaled + position: "top-right", + viewState: { ...this.viewState.value, width: this.$canvas.width - 136, height: this.$canvas.height - 32 }, + length: 0.1, + snap: true + }) : void 0; + }); constructor() { super(); const root = this.attachShadow({ mode: "open" }); @@ -31501,6 +62163,7 @@ this.$canvas.addEventListener("contextmenu", (e2) => e2.preventDefault()); } async connectedCallback() { + let isHovering = false; this.deck = new Deck({ canvas: this.$canvas, controller: true, @@ -31516,12 +62179,17 @@ dragMode: "rotate", target: [0.5, 0.5] }, - onClick: (e2) => e2.picked && console.log("Node Clicked", e2), + onClick: (e2) => e2.picked && console.log("Node Clicked", e2.object.x, e2.object.y), + onViewStateChange: ({ viewState }) => this.viewState.value = viewState, + onLoad: () => this.viewState.value = this.deck.viewState, + onHover: (e2) => isHovering = e2.picked, + getCursor: (e2) => isHovering ? "pointer" : e2.isDragging ? "grabbing" : "grab", layers: [] }); this.trackDisposal( O(() => { - this.deck.setProps({ layers: [this.nodesLayer.value, this.edgesLayer.value].filter((l2) => !!l2) }); + const layers = [this.nodesLayer.value, this.edgesLayer.value, this.scaleBarLayer.value].filter((l2) => !!l2); + this.deck.setProps({ layers }); }) ); this.trackDisposal( @@ -31593,6 +62261,12 @@ hammerjs/hammer.js: * Copyright (c) 2016 Jorik Tangelder; * Licensed under the MIT license *) +pako/dist/pako.esm.mjs: + (*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) *) + +lerc/LercDecode.js: + (* Copyright 2015-2021 Esri. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 @preserve *) + papaparse/papaparse.min.js: (* @license Papa Parse @@ -31600,4 +62274,7 @@ papaparse/papaparse.min.js: https://github.com/mholt/PapaParse License: MIT *) + +zarr/zarr.mjs: + (*! pako 2.0.3 https://github.com/nodeca/pako @license (MIT AND Zlib) *) */ diff --git a/package-lock.json b/package-lock.json index c958a9e..f1faed6 100644 --- a/package-lock.json +++ b/package-lock.json @@ -14,6 +14,7 @@ "@deck.gl/layers": "^8.9.34", "@material/web": "^1.3.0", "@preact/signals-core": "^1.5.1", + "@vivjs/layers": "^0.16.0", "papaparse": "^5.4.1" }, "bin": { @@ -57,9 +58,9 @@ } }, "node_modules/@deck.gl/carto": { - "version": "8.9.34", - "resolved": "https://registry.npmjs.org/@deck.gl/carto/-/carto-8.9.34.tgz", - "integrity": "sha512-LJe2Ipd8AKCL1GQiAHRmwa3ubVrlpHVaSAscwGUt5fnFM0J4gTIk5LysTwXBxg5owyCEd4yOgXK3m1PZ+CHu3w==", + "version": "8.9.35", + "resolved": "https://registry.npmjs.org/@deck.gl/carto/-/carto-8.9.35.tgz", + "integrity": "sha512-Ln9yFQqagQ5Zpfl5SUJl/09lw0S9zkpSVeay976aSPnQt9U7L4ES5lxOZZBQvxHmKATmar5B5V36vXaW2bAezQ==", "dependencies": { "@babel/runtime": "^7.0.0", "@loaders.gl/gis": "^3.4.13", @@ -88,9 +89,9 @@ } }, "node_modules/@deck.gl/core": { - "version": "8.9.34", - "resolved": "https://registry.npmjs.org/@deck.gl/core/-/core-8.9.34.tgz", - "integrity": "sha512-VDne26NevBBvD9Xq6pIBuBt2ffZhzW1COU3IogqhJLhejECiC3RQhWtDRWQqUZpQYKTU2SlyKZcu+Nj7kaLBWA==", + "version": "8.9.35", + "resolved": "https://registry.npmjs.org/@deck.gl/core/-/core-8.9.35.tgz", + "integrity": "sha512-xOASWScUCB5fpfuSjPaJrwas8pCJpbKXNIfwQElhvnfP3Yk8GGkAcRbPgiPNCfpkbEno7eDpAWJt6+6UJsSp9g==", "dependencies": { "@babel/runtime": "^7.0.0", "@loaders.gl/core": "^3.4.13", @@ -128,22 +129,20 @@ } }, "node_modules/@deck.gl/geo-layers": { - "version": "8.9.34", - "resolved": "https://registry.npmjs.org/@deck.gl/geo-layers/-/geo-layers-8.9.34.tgz", - "integrity": "sha512-oXOdNByo8QHNrqjREeIX0btVzsj3aFzJcplatBpdLg6vr/iV8ZdsbRv8WO4CJJI3N6oVKIug2gHWogdIjpxHTg==", + "version": "8.8.27", + "resolved": "https://registry.npmjs.org/@deck.gl/geo-layers/-/geo-layers-8.8.27.tgz", + "integrity": "sha512-7tYe+fJAoo0W9t3rvek/+QeK90DBpUVnO7+9+dYND+Ge9Cok0c5gf9CB4WZ/Qlemmk1eOavdha9FsGejhpnx2A==", "peer": true, "dependencies": { - "@babel/runtime": "^7.0.0", - "@loaders.gl/3d-tiles": "^3.4.13", - "@loaders.gl/gis": "^3.4.13", - "@loaders.gl/loader-utils": "^3.4.13", - "@loaders.gl/mvt": "^3.4.13", - "@loaders.gl/schema": "^3.4.13", - "@loaders.gl/terrain": "^3.4.13", - "@loaders.gl/tiles": "^3.4.13", - "@loaders.gl/wms": "^3.4.13", - "@luma.gl/constants": "^8.5.21", - "@luma.gl/experimental": "^8.5.21", + "@loaders.gl/3d-tiles": "^3.2.10", + "@loaders.gl/gis": "^3.2.10", + "@loaders.gl/loader-utils": "^3.2.10", + "@loaders.gl/mvt": "^3.2.10", + "@loaders.gl/schema": "^3.2.10", + "@loaders.gl/terrain": "^3.2.10", + "@loaders.gl/tiles": "^3.2.10", + "@luma.gl/constants": "^8.5.16", + "@luma.gl/experimental": "^8.5.16", "@math.gl/core": "^3.6.2", "@math.gl/culling": "^3.6.2", "@math.gl/web-mercator": "^3.6.2", @@ -156,14 +155,14 @@ "@deck.gl/extensions": "^8.0.0", "@deck.gl/layers": "^8.0.0", "@deck.gl/mesh-layers": "^8.0.0", - "@loaders.gl/core": "^3.4.13", + "@loaders.gl/core": "^3.0.0", "@luma.gl/core": "^8.0.0" } }, "node_modules/@deck.gl/layers": { - "version": "8.9.34", - "resolved": "https://registry.npmjs.org/@deck.gl/layers/-/layers-8.9.34.tgz", - "integrity": "sha512-kc9Wzk8Zf2XwdG/V0Md6dh6mlJjStkWHKCKQLJOwj9GDwP4KihzYY2xC98CMCgi2/H/lH03xYm3e5EHvwIENww==", + "version": "8.9.35", + "resolved": "https://registry.npmjs.org/@deck.gl/layers/-/layers-8.9.35.tgz", + "integrity": "sha512-4amaGO+tGvaCNi2KZ90twmajGh5xUAaQzBIyh42dnM10GRj/62sOIYD9uT032oV/KpjKY+TfOstx5ooXBGKDjg==", "dependencies": { "@babel/runtime": "^7.0.0", "@loaders.gl/images": "^3.4.13", @@ -874,22 +873,6 @@ "@babel/runtime": "^7.0.0" } }, - "node_modules/@loaders.gl/wms": { - "version": "3.4.14", - "resolved": "https://registry.npmjs.org/@loaders.gl/wms/-/wms-3.4.14.tgz", - "integrity": "sha512-D1pObPSUj885zGPyHIb7GtcwpHQNk0T8nK/4EHb0SHLe0y1b4qwqSOswdS9geXT9Q61hyhl/L0zqyTgwjiMStg==", - "peer": true, - "dependencies": { - "@babel/runtime": "^7.3.1", - "@loaders.gl/images": "3.4.14", - "@loaders.gl/loader-utils": "3.4.14", - "@loaders.gl/schema": "3.4.14", - "@loaders.gl/xml": "3.4.14", - "@turf/rewind": "^5.1.5", - "deep-strict-equal": "^0.2.0", - "lerc": "^4.0.1" - } - }, "node_modules/@loaders.gl/worker-utils": { "version": "3.4.14", "resolved": "https://registry.npmjs.org/@loaders.gl/worker-utils/-/worker-utils-3.4.14.tgz", @@ -898,18 +881,6 @@ "@babel/runtime": "^7.3.1" } }, - "node_modules/@loaders.gl/xml": { - "version": "3.4.14", - "resolved": "https://registry.npmjs.org/@loaders.gl/xml/-/xml-3.4.14.tgz", - "integrity": "sha512-SNMGOHz4p8Cw+M6kxXhFEjXdNddJPOZY1rzNmRq7NYdGQlQYYeJdqV5HWzHx9BkoQYyrDXkrweGN0mY9QxCfeA==", - "peer": true, - "dependencies": { - "@babel/runtime": "^7.3.1", - "@loaders.gl/loader-utils": "3.4.14", - "@loaders.gl/schema": "3.4.14", - "fast-xml-parser": "^4.2.5" - } - }, "node_modules/@luma.gl/constants": { "version": "8.5.21", "resolved": "https://registry.npmjs.org/@luma.gl/constants/-/constants-8.5.21.tgz", @@ -1097,6 +1068,11 @@ "gl-matrix": "^3.4.0" } }, + "node_modules/@petamoriken/float16": { + "version": "3.8.5", + "resolved": "https://registry.npmjs.org/@petamoriken/float16/-/float16-3.8.5.tgz", + "integrity": "sha512-XCO48r7/l1BMzA0DuB9/osQ6cXWk3PUl90RqFUjR2DB/LIpY98aEpzjYTkiRh2a5nTgEA8kDFDy88O0Kiib/wA==" + }, "node_modules/@pkgjs/parseargs": { "version": "0.11.0", "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", @@ -1141,62 +1117,6 @@ "@babel/runtime": "^7.0.0" } }, - "node_modules/@turf/boolean-clockwise": { - "version": "5.1.5", - "resolved": "https://registry.npmjs.org/@turf/boolean-clockwise/-/boolean-clockwise-5.1.5.tgz", - "integrity": "sha512-FqbmEEOJ4rU4/2t7FKx0HUWmjFEVqR+NJrFP7ymGSjja2SQ7Q91nnBihGuT+yuHHl6ElMjQ3ttsB/eTmyCycxA==", - "peer": true, - "dependencies": { - "@turf/helpers": "^5.1.5", - "@turf/invariant": "^5.1.5" - } - }, - "node_modules/@turf/clone": { - "version": "5.1.5", - "resolved": "https://registry.npmjs.org/@turf/clone/-/clone-5.1.5.tgz", - "integrity": "sha512-//pITsQ8xUdcQ9pVb4JqXiSqG4dos5Q9N4sYFoWghX21tfOV2dhc5TGqYOhnHrQS7RiKQL1vQ48kIK34gQ5oRg==", - "peer": true, - "dependencies": { - "@turf/helpers": "^5.1.5" - } - }, - "node_modules/@turf/helpers": { - "version": "5.1.5", - "resolved": "https://registry.npmjs.org/@turf/helpers/-/helpers-5.1.5.tgz", - "integrity": "sha512-/lF+JR+qNDHZ8bF9d+Cp58nxtZWJ3sqFe6n3u3Vpj+/0cqkjk4nXKYBSY0azm+GIYB5mWKxUXvuP/m0ZnKj1bw==", - "peer": true - }, - "node_modules/@turf/invariant": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/@turf/invariant/-/invariant-5.2.0.tgz", - "integrity": "sha512-28RCBGvCYsajVkw2EydpzLdcYyhSA77LovuOvgCJplJWaNVyJYH6BOR3HR9w50MEkPqb/Vc/jdo6I6ermlRtQA==", - "peer": true, - "dependencies": { - "@turf/helpers": "^5.1.5" - } - }, - "node_modules/@turf/meta": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/@turf/meta/-/meta-5.2.0.tgz", - "integrity": "sha512-ZjQ3Ii62X9FjnK4hhdsbT+64AYRpaI8XMBMcyftEOGSmPMUVnkbvuv3C9geuElAXfQU7Zk1oWGOcrGOD9zr78Q==", - "peer": true, - "dependencies": { - "@turf/helpers": "^5.1.5" - } - }, - "node_modules/@turf/rewind": { - "version": "5.1.5", - "resolved": "https://registry.npmjs.org/@turf/rewind/-/rewind-5.1.5.tgz", - "integrity": "sha512-Gdem7JXNu+G4hMllQHXRFRihJl3+pNl7qY+l4qhQFxq+hiU1cQoVFnyoleIqWKIrdK/i2YubaSwc3SCM7N5mMw==", - "peer": true, - "dependencies": { - "@turf/boolean-clockwise": "^5.1.5", - "@turf/clone": "^5.1.5", - "@turf/helpers": "^5.1.5", - "@turf/invariant": "^5.1.5", - "@turf/meta": "^5.1.5" - } - }, "node_modules/@types/geojson": { "version": "7946.0.14", "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.14.tgz", @@ -1217,6 +1137,69 @@ "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz", "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==" }, + "node_modules/@vivjs/constants": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/@vivjs/constants/-/constants-0.16.0.tgz", + "integrity": "sha512-PqGSlLzwE51CPXt9qOm8AF3rJKdsUv45Sw/ab7NNcXt9IBMrbS3lsh15hN+U7tP4a1uHWwqP0qRl/C3U9Dq76g==", + "dependencies": { + "@luma.gl/constants": "~8.5.21" + } + }, + "node_modules/@vivjs/layers": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/@vivjs/layers/-/layers-0.16.0.tgz", + "integrity": "sha512-aD3D4qdvfMPKXUHZa+NiL1XOOZcOeCINsoSR+SbK584U8ZUmDj2lWOnyU4VUGL39qdParwEUURsw7xUuTs/Yug==", + "dependencies": { + "@math.gl/core": "^3.5.7", + "@math.gl/culling": "^3.5.7", + "@vivjs/constants": "0.16.0", + "@vivjs/extensions": "0.16.0", + "@vivjs/loaders": "0.16.0", + "@vivjs/types": "0.16.0" + }, + "peerDependencies": { + "@deck.gl/core": "~8.8.27", + "@deck.gl/geo-layers": "~8.8.27", + "@deck.gl/layers": "~8.8.27", + "@luma.gl/constants": "~8.5.21", + "@luma.gl/core": "~8.5.21", + "@luma.gl/engine": "~8.5.21", + "@luma.gl/webgl": "~8.5.21" + } + }, + "node_modules/@vivjs/layers/node_modules/@vivjs/extensions": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/@vivjs/extensions/-/extensions-0.16.0.tgz", + "integrity": "sha512-otZXgaBCigKLkRgMkv8N3DR1AzRqDffXNk3J6N9i0njL1zYxwx/EcWbZTGx2sIOtAXNTaUKNISoXgS9fltNMaA==", + "dependencies": { + "@vivjs/constants": "0.16.0" + }, + "peerDependencies": { + "@deck.gl/core": "~8.8.27" + } + }, + "node_modules/@vivjs/loaders": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/@vivjs/loaders/-/loaders-0.16.0.tgz", + "integrity": "sha512-FU6XrMOJ94b4Ep2P0eRuJOFGEVkDT1tIRMiYjCq9LitGRKUiS8tHF8xzYkUrbzHXa1WwH/9PyIw5eeyMndc9Vw==", + "dependencies": { + "@vivjs/types": "0.16.0", + "geotiff": "^2.0.5", + "lzw-tiff-decoder": "^0.1.1", + "quickselect": "^2.0.0", + "zarr": "^0.6.2", + "zod": "^3.22.4" + } + }, + "node_modules/@vivjs/types": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/@vivjs/types/-/types-0.16.0.tgz", + "integrity": "sha512-n898DVFlHmDbvBsCG1SdSoPv9sgUDfCYedFp9A1msoHn/SVJhA5e6oTvVbgKGAxuTXKa3baXz7fIGvduVytZ3Q==", + "dependencies": { + "@vivjs/constants": "0.16.0", + "math.gl": "^3.5.7" + } + }, "node_modules/ansi-regex": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", @@ -1319,15 +1302,6 @@ "concat-map": "0.0.1" } }, - "node_modules/buf-compare": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/buf-compare/-/buf-compare-1.0.1.tgz", - "integrity": "sha512-Bvx4xH00qweepGc43xFvMs5BKASXTbHaHm6+kDYIK9p/4iFwjATQkmPKHQSgJZzKbAymhztRbXUf1Nqhzl73/Q==", - "peer": true, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/call-bind": { "version": "1.0.7", "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz", @@ -1390,19 +1364,6 @@ "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", "dev": true }, - "node_modules/core-assert": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/core-assert/-/core-assert-0.2.1.tgz", - "integrity": "sha512-IG97qShIP+nrJCXMCgkNZgH7jZQ4n8RpPyPeXX++T6avR/KhLhgLiHKoEn5Rc1KjfycSfA9DMa6m+4C4eguHhw==", - "peer": true, - "dependencies": { - "buf-compare": "^1.0.0", - "is-error": "^2.2.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/cross-spawn": { "version": "6.0.5", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz", @@ -1509,18 +1470,6 @@ "node": ">=12" } }, - "node_modules/deep-strict-equal": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/deep-strict-equal/-/deep-strict-equal-0.2.0.tgz", - "integrity": "sha512-3daSWyvZ/zwJvuMGlzG1O+Ow0YSadGfb3jsh9xoCutv2tWyB9dA4YvR9L9/fSdDZa2dByYQe+TqapSGUrjnkoA==", - "peer": true, - "dependencies": { - "core-assert": "^0.2.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/define-data-property": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", @@ -1751,27 +1700,10 @@ "node": ">=0.8.0" } }, - "node_modules/fast-xml-parser": { - "version": "4.3.5", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-4.3.5.tgz", - "integrity": "sha512-sWvP1Pl8H03B8oFJpFR3HE31HUfwtX7Rlf9BNsvdpujD4n7WMhfmu8h9wOV2u+c1k0ZilTADhPqypzx2J690ZQ==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - }, - { - "type": "paypal", - "url": "https://paypal.me/naturalintelligence" - } - ], - "peer": true, - "dependencies": { - "strnum": "^1.0.5" - }, - "bin": { - "fxparser": "src/cli/cli.js" - } + "node_modules/eventemitter3": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz", + "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==" }, "node_modules/find-cache-dir": { "version": "3.3.2", @@ -1929,6 +1861,24 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/geotiff": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/geotiff/-/geotiff-2.1.3.tgz", + "integrity": "sha512-PT6uoF5a1+kbC3tHmZSUsLHBp2QJlHasxxxxPW47QIY1VBKpFB+FcDvX+MxER6UzgLQZ0xDzJ9s48B9JbOCTqA==", + "dependencies": { + "@petamoriken/float16": "^3.4.7", + "lerc": "^3.0.0", + "pako": "^2.0.4", + "parse-headers": "^2.0.2", + "quick-lru": "^6.1.1", + "web-worker": "^1.2.0", + "xml-utils": "^1.0.2", + "zstddec": "^0.1.0" + }, + "engines": { + "node": ">=10.19" + } + }, "node_modules/get-intrinsic": { "version": "1.2.4", "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz", @@ -2312,12 +2262,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/is-error": { - "version": "2.2.2", - "resolved": "https://registry.npmjs.org/is-error/-/is-error-2.2.2.tgz", - "integrity": "sha512-IOQqts/aHWbiisY5DuPJQ0gcbvaLFCa7fBa9xoLfxBZvQ+ZI/Zh9xoI7Gk+G64N0FdK4AbibytHht2tWgpJWLg==", - "peer": true - }, "node_modules/is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", @@ -2485,10 +2429,9 @@ "peer": true }, "node_modules/lerc": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/lerc/-/lerc-4.0.4.tgz", - "integrity": "sha512-nHZH+ffiGPkgKUQtiZrljGUGV2GddvPcVTV5E345ZFncbKz+/rBIjDPrSxkiqW0EAtg1Jw7qAgRdaCwV+95Fow==", - "peer": true + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/lerc/-/lerc-3.0.0.tgz", + "integrity": "sha512-Rm4J/WaHhRa93nCN2mwWDZFoRVF18G1f47C+kvQWyHGEZxFpTUi73p7lMVSAndyxGt6lJ2/CFbOcf9ra5p8aww==" }, "node_modules/lit": { "version": "3.1.2", @@ -2563,6 +2506,11 @@ "node": "14 || >=16.14" } }, + "node_modules/lzw-tiff-decoder": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/lzw-tiff-decoder/-/lzw-tiff-decoder-0.1.1.tgz", + "integrity": "sha512-RUiNDPLzKEhX3JM9BgnFneerJd/uLgV4TeaNnkNJ0eO/GdlPeX01PKDCUsob8jhWILxOl3dGlDbD98KGex39ig==" + }, "node_modules/make-dir": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", @@ -2762,6 +2710,14 @@ "node": ">=4" } }, + "node_modules/numcodecs": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/numcodecs/-/numcodecs-0.2.2.tgz", + "integrity": "sha512-Y5K8mv80yb4MgVpcElBkUeMZqeE4TrovxRit/dTZvoRl6YkB6WEjY+fiUjGCblITnt3T3fmrDg8yRWu0gOLjhQ==", + "engines": { + "node": ">=12" + } + }, "node_modules/object-inspect": { "version": "1.13.1", "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.1.tgz", @@ -2834,6 +2790,32 @@ "node": ">=8" } }, + "node_modules/p-queue": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/p-queue/-/p-queue-7.4.1.tgz", + "integrity": "sha512-vRpMXmIkYF2/1hLBKisKeVYJZ8S2tZ0zEAmIJgdVKP2nq0nh4qCdf8bgw+ZgKrkh71AOCaqzwbJJk1WtdcF3VA==", + "dependencies": { + "eventemitter3": "^5.0.1", + "p-timeout": "^5.0.2" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-timeout": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-5.1.0.tgz", + "integrity": "sha512-auFDyzzzGZZZdHz3BtET9VEz0SE/uMEAx7uWfGPucfzEwwe/xH0iVeZibQmANYE/hp9T2+UUZT5m+BKyrDp3Ew==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/p-try": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", @@ -2843,11 +2825,21 @@ "node": ">=6" } }, + "node_modules/pako": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz", + "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==" + }, "node_modules/papaparse": { "version": "5.4.1", "resolved": "https://registry.npmjs.org/papaparse/-/papaparse-5.4.1.tgz", "integrity": "sha512-HipMsgJkZu8br23pW15uvo6sib6wne/4woLZPlFf3rpDyMe9ywEXUsuD7+6K9PRkJlVT51j/sCOYDKGGS3ZJrw==" }, + "node_modules/parse-headers": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/parse-headers/-/parse-headers-2.0.5.tgz", + "integrity": "sha512-ft3iAoLOB/MlwbNXgzy43SWGP6sQki2jQvAyBg/zDFAgr9bfNWZIUj42Kw2eJIl8kEi4PbgE6U1Zau/HwI75HA==" + }, "node_modules/parse-json": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz", @@ -2992,6 +2984,22 @@ "node": ">=14" } }, + "node_modules/quick-lru": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-6.1.2.tgz", + "integrity": "sha512-AAFUA5O1d83pIHEhJwWCq/RQcRukCkn/NSm2QsTEMle5f2hP0ChI2+3Xb051PZCkLryI/Ir1MVKviT2FIloaTQ==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/quickselect": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/quickselect/-/quickselect-2.0.0.tgz", + "integrity": "sha512-RKJ22hX8mHe3Y6wH/N3wCM6BWtjaxIyyUIkpHOvfFnxdI4yD4tBXEBKSbriGujF6jnSVkJrffuo6vxACiSSxIw==" + }, "node_modules/read-pkg": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz", @@ -3402,12 +3410,6 @@ "node": ">=4" } }, - "node_modules/strnum": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-1.0.5.tgz", - "integrity": "sha512-J8bbNyKKXl5qYcR36TIO8W3mVGVHrmmxsd5PAItGkmyzwJvybiw2IVq5nqd0i4LSNSkB/sx9VHllbfFdr9k1JA==", - "peer": true - }, "node_modules/supports-preserve-symlinks-flag": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", @@ -3542,6 +3544,11 @@ "spdx-expression-parse": "^3.0.0" } }, + "node_modules/web-worker": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/web-worker/-/web-worker-1.3.0.tgz", + "integrity": "sha512-BSR9wyRsy/KOValMgd5kMyr3JzpdeoR9KVId8u5GVlTTAtNChlsE4yTxeY7zMdNSyOmoKBv8NH2qeRY9Tg+IaA==" + }, "node_modules/which": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", @@ -3612,6 +3619,36 @@ "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", "dev": true + }, + "node_modules/xml-utils": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/xml-utils/-/xml-utils-1.7.0.tgz", + "integrity": "sha512-bWB489+RQQclC7A9OW8e5BzbT8Tu//jtAOvkYwewFr+Q9T9KDGvfzC1lp0pYPEQPEoPQLDkmxkepSC/2gIAZGw==" + }, + "node_modules/zarr": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/zarr/-/zarr-0.6.2.tgz", + "integrity": "sha512-3gtxrnpziRlDtrz0hz/M+hreCC5YexppeCVHK62Pmb2FSn947h14GHMDj9rQFkY2mPhRKDHhtB+AUGa8wqJW6Q==", + "dependencies": { + "numcodecs": "^0.2.2", + "p-queue": "^7.1.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/zod": { + "version": "3.22.4", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.22.4.tgz", + "integrity": "sha512-iC+8Io04lddc+mVqQ9AZ7OQ2MrUKGN+oIQyq1vemgt46jwCwLfhq7/pwnBnNXXXZb8VTVLKwp9EDkx+ryxIWmg==", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zstddec": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/zstddec/-/zstddec-0.1.0.tgz", + "integrity": "sha512-w2NTI8+3l3eeltKAdK8QpiLo/flRAr2p8AGeakfMZOXBxOg9HIu4LVDxBi81sYgVhFhdJjv1OrB5ssI8uFPoLg==" } } } diff --git a/package.json b/package.json index 1252c14..151378d 100644 --- a/package.json +++ b/package.json @@ -22,6 +22,7 @@ "@deck.gl/layers": "^8.9.34", "@material/web": "^1.3.0", "@preact/signals-core": "^1.5.1", + "@vivjs/layers": "^0.16.0", "papaparse": "^5.4.1" }, "devDependencies": { diff --git a/src/hra-node-dist-vis.js b/src/hra-node-dist-vis.js index ab80af7..9318f05 100644 --- a/src/hra-node-dist-vis.js +++ b/src/hra-node-dist-vis.js @@ -2,6 +2,7 @@ import { colorCategories } from '@deck.gl/carto'; import { COORDINATE_SYSTEM, Deck, OrbitView } from '@deck.gl/core'; import { LineLayer, PointCloudLayer } from '@deck.gl/layers'; import { batch, computed, effect, signal } from '@preact/signals-core'; +import { ScaleBarLayer } from '@vivjs/layers'; import cartocolor from 'cartocolor'; import Papa from 'papaparse'; import DistanceEdgesWorker from './distance-edges.worker.js'; @@ -71,6 +72,7 @@ class HraNodeDistanceVisualization extends HTMLElement { nodeTargetKey = signal(); nodeTargetValue = signal(); maxEdgeDistance = signal(); + viewState = signal(); toDispose = []; initialized = false; @@ -196,6 +198,20 @@ class HraNodeDistanceVisualization extends HTMLElement { } }); + scaleBarLayer = computed(() => { + return this.nodes.value.length > 0 + ? new ScaleBarLayer({ + id: 'scalebar', + unit: 'µm', + size: 1 / this.positionScaling.value(() => [1, 1, 1])()[0], // Scale 1µm the same way positions are scaled + position: 'top-right', + viewState: { ...this.viewState.value, width: this.$canvas.width - 136, height: this.$canvas.height - 32 }, + length: 0.1, + snap: true, + }) + : undefined; + }); + constructor() { super(); const root = this.attachShadow({ mode: 'open' }); @@ -205,6 +221,7 @@ class HraNodeDistanceVisualization extends HTMLElement { } async connectedCallback() { + let isHovering = false; this.deck = new Deck({ canvas: this.$canvas, controller: true, @@ -220,13 +237,18 @@ class HraNodeDistanceVisualization extends HTMLElement { dragMode: 'rotate', target: [0.5, 0.5], }, - onClick: (e) => e.picked && console.log('Node Clicked', e), + onClick: (e) => e.picked && console.log('Node Clicked', e.object.x, e.object.y), + onViewStateChange: ({ viewState }) => (this.viewState.value = viewState), + onLoad: () => (this.viewState.value = this.deck.viewState), + onHover: (e) => (isHovering = e.picked), + getCursor: (e) => (isHovering ? 'pointer' : e.isDragging ? 'grabbing' : 'grab'), layers: [], }); this.trackDisposal( effect(() => { - this.deck.setProps({ layers: [this.nodesLayer.value, this.edgesLayer.value].filter((l) => !!l) }); + const layers = [this.nodesLayer.value, this.edgesLayer.value, this.scaleBarLayer.value].filter((l) => !!l); + this.deck.setProps({ layers }); }) );