@loaders.gl/mvt
Version:
Loader for Mapbox Vector Tiles
1,531 lines (1,520 loc) • 175 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if (typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if (typeof define === 'function' && define.amd) define([], factory);
else if (typeof exports === 'object') exports['loaders'] = factory();
else root['loaders'] = factory();})(globalThis, function () {
"use strict";
var __exports__ = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
// external-global-plugin:@loaders.gl/core
var require_core = __commonJS({
"external-global-plugin:@loaders.gl/core"(exports, module) {
module.exports = globalThis.loaders;
}
});
// ../../node_modules/ieee754/index.js
var require_ieee754 = __commonJS({
"../../node_modules/ieee754/index.js"(exports) {
exports.read = function(buffer, offset, isLE, mLen, nBytes) {
var e, m;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var nBits = -7;
var i = isLE ? nBytes - 1 : 0;
var d = isLE ? -1 : 1;
var s = buffer[offset + i];
i += d;
e = s & (1 << -nBits) - 1;
s >>= -nBits;
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
}
m = e & (1 << -nBits) - 1;
e >>= -nBits;
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
}
if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : (s ? -1 : 1) * Infinity;
} else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};
exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c;
var eLen = nBytes * 8 - mLen - 1;
var eMax = (1 << eLen) - 1;
var eBias = eMax >> 1;
var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
var i = isLE ? 0 : nBytes - 1;
var d = isLE ? 1 : -1;
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) {
value += rt / c;
} else {
value += rt * Math.pow(2, 1 - eBias);
}
if (value * c >= 2) {
e++;
c /= 2;
}
if (e + eBias >= eMax) {
m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
}
e = e << mLen | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
}
buffer[offset + i - d] |= s * 128;
};
}
});
// ../../node_modules/pbf/index.js
var require_pbf = __commonJS({
"../../node_modules/pbf/index.js"(exports, module) {
"use strict";
module.exports = Pbf2;
var ieee754 = require_ieee754();
function Pbf2(buf) {
this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
this.pos = 0;
this.type = 0;
this.length = this.buf.length;
}
Pbf2.Varint = 0;
Pbf2.Fixed64 = 1;
Pbf2.Bytes = 2;
Pbf2.Fixed32 = 5;
var SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
var TEXT_DECODER_MIN_LENGTH = 12;
var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8");
Pbf2.prototype = {
destroy: function() {
this.buf = null;
},
// === READING =================================================================
readFields: function(readField, result, end) {
end = end || this.length;
while (this.pos < end) {
var val = this.readVarint(), tag = val >> 3, startPos = this.pos;
this.type = val & 7;
readField(tag, result, this);
if (this.pos === startPos)
this.skip(val);
}
return result;
},
readMessage: function(readField, result) {
return this.readFields(readField, result, this.readVarint() + this.pos);
},
readFixed32: function() {
var val = readUInt32(this.buf, this.pos);
this.pos += 4;
return val;
},
readSFixed32: function() {
var val = readInt32(this.buf, this.pos);
this.pos += 4;
return val;
},
// 64-bit int handling is based on github.com/dpw/node-buffer-more-ints (MIT-licensed)
readFixed64: function() {
var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
this.pos += 8;
return val;
},
readSFixed64: function() {
var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
this.pos += 8;
return val;
},
readFloat: function() {
var val = ieee754.read(this.buf, this.pos, true, 23, 4);
this.pos += 4;
return val;
},
readDouble: function() {
var val = ieee754.read(this.buf, this.pos, true, 52, 8);
this.pos += 8;
return val;
},
readVarint: function(isSigned) {
var buf = this.buf, val, b;
b = buf[this.pos++];
val = b & 127;
if (b < 128)
return val;
b = buf[this.pos++];
val |= (b & 127) << 7;
if (b < 128)
return val;
b = buf[this.pos++];
val |= (b & 127) << 14;
if (b < 128)
return val;
b = buf[this.pos++];
val |= (b & 127) << 21;
if (b < 128)
return val;
b = buf[this.pos];
val |= (b & 15) << 28;
return readVarintRemainder(val, isSigned, this);
},
readVarint64: function() {
return this.readVarint(true);
},
readSVarint: function() {
var num = this.readVarint();
return num % 2 === 1 ? (num + 1) / -2 : num / 2;
},
readBoolean: function() {
return Boolean(this.readVarint());
},
readString: function() {
var end = this.readVarint() + this.pos;
var pos = this.pos;
this.pos = end;
if (end - pos >= TEXT_DECODER_MIN_LENGTH && utf8TextDecoder) {
return readUtf8TextDecoder(this.buf, pos, end);
}
return readUtf8(this.buf, pos, end);
},
readBytes: function() {
var end = this.readVarint() + this.pos, buffer = this.buf.subarray(this.pos, end);
this.pos = end;
return buffer;
},
// verbose for performance reasons; doesn't affect gzipped size
readPackedVarint: function(arr, isSigned) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readVarint(isSigned));
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readVarint(isSigned));
return arr;
},
readPackedSVarint: function(arr) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readSVarint());
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readSVarint());
return arr;
},
readPackedBoolean: function(arr) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readBoolean());
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readBoolean());
return arr;
},
readPackedFloat: function(arr) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readFloat());
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readFloat());
return arr;
},
readPackedDouble: function(arr) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readDouble());
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readDouble());
return arr;
},
readPackedFixed32: function(arr) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readFixed32());
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readFixed32());
return arr;
},
readPackedSFixed32: function(arr) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readSFixed32());
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readSFixed32());
return arr;
},
readPackedFixed64: function(arr) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readFixed64());
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readFixed64());
return arr;
},
readPackedSFixed64: function(arr) {
if (this.type !== Pbf2.Bytes)
return arr.push(this.readSFixed64());
var end = readPackedEnd(this);
arr = arr || [];
while (this.pos < end)
arr.push(this.readSFixed64());
return arr;
},
skip: function(val) {
var type = val & 7;
if (type === Pbf2.Varint)
while (this.buf[this.pos++] > 127) {
}
else if (type === Pbf2.Bytes)
this.pos = this.readVarint() + this.pos;
else if (type === Pbf2.Fixed32)
this.pos += 4;
else if (type === Pbf2.Fixed64)
this.pos += 8;
else
throw new Error("Unimplemented type: " + type);
},
// === WRITING =================================================================
writeTag: function(tag, type) {
this.writeVarint(tag << 3 | type);
},
realloc: function(min) {
var length = this.length || 16;
while (length < this.pos + min)
length *= 2;
if (length !== this.length) {
var buf = new Uint8Array(length);
buf.set(this.buf);
this.buf = buf;
this.length = length;
}
},
finish: function() {
this.length = this.pos;
this.pos = 0;
return this.buf.subarray(0, this.length);
},
writeFixed32: function(val) {
this.realloc(4);
writeInt32(this.buf, val, this.pos);
this.pos += 4;
},
writeSFixed32: function(val) {
this.realloc(4);
writeInt32(this.buf, val, this.pos);
this.pos += 4;
},
writeFixed64: function(val) {
this.realloc(8);
writeInt32(this.buf, val & -1, this.pos);
writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
this.pos += 8;
},
writeSFixed64: function(val) {
this.realloc(8);
writeInt32(this.buf, val & -1, this.pos);
writeInt32(this.buf, Math.floor(val * SHIFT_RIGHT_32), this.pos + 4);
this.pos += 8;
},
writeVarint: function(val) {
val = +val || 0;
if (val > 268435455 || val < 0) {
writeBigVarint(val, this);
return;
}
this.realloc(4);
this.buf[this.pos++] = val & 127 | (val > 127 ? 128 : 0);
if (val <= 127)
return;
this.buf[this.pos++] = (val >>>= 7) & 127 | (val > 127 ? 128 : 0);
if (val <= 127)
return;
this.buf[this.pos++] = (val >>>= 7) & 127 | (val > 127 ? 128 : 0);
if (val <= 127)
return;
this.buf[this.pos++] = val >>> 7 & 127;
},
writeSVarint: function(val) {
this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
},
writeBoolean: function(val) {
this.writeVarint(Boolean(val));
},
writeString: function(str) {
str = String(str);
this.realloc(str.length * 4);
this.pos++;
var startPos = this.pos;
this.pos = writeUtf8(this.buf, str, this.pos);
var len = this.pos - startPos;
if (len >= 128)
makeRoomForExtraLength(startPos, len, this);
this.pos = startPos - 1;
this.writeVarint(len);
this.pos += len;
},
writeFloat: function(val) {
this.realloc(4);
ieee754.write(this.buf, val, this.pos, true, 23, 4);
this.pos += 4;
},
writeDouble: function(val) {
this.realloc(8);
ieee754.write(this.buf, val, this.pos, true, 52, 8);
this.pos += 8;
},
writeBytes: function(buffer) {
var len = buffer.length;
this.writeVarint(len);
this.realloc(len);
for (var i = 0; i < len; i++)
this.buf[this.pos++] = buffer[i];
},
writeRawMessage: function(fn, obj) {
this.pos++;
var startPos = this.pos;
fn(obj, this);
var len = this.pos - startPos;
if (len >= 128)
makeRoomForExtraLength(startPos, len, this);
this.pos = startPos - 1;
this.writeVarint(len);
this.pos += len;
},
writeMessage: function(tag, fn, obj) {
this.writeTag(tag, Pbf2.Bytes);
this.writeRawMessage(fn, obj);
},
writePackedVarint: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedVarint, arr);
},
writePackedSVarint: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedSVarint, arr);
},
writePackedBoolean: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedBoolean, arr);
},
writePackedFloat: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedFloat, arr);
},
writePackedDouble: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedDouble, arr);
},
writePackedFixed32: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedFixed32, arr);
},
writePackedSFixed32: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedSFixed32, arr);
},
writePackedFixed64: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedFixed64, arr);
},
writePackedSFixed64: function(tag, arr) {
if (arr.length)
this.writeMessage(tag, writePackedSFixed64, arr);
},
writeBytesField: function(tag, buffer) {
this.writeTag(tag, Pbf2.Bytes);
this.writeBytes(buffer);
},
writeFixed32Field: function(tag, val) {
this.writeTag(tag, Pbf2.Fixed32);
this.writeFixed32(val);
},
writeSFixed32Field: function(tag, val) {
this.writeTag(tag, Pbf2.Fixed32);
this.writeSFixed32(val);
},
writeFixed64Field: function(tag, val) {
this.writeTag(tag, Pbf2.Fixed64);
this.writeFixed64(val);
},
writeSFixed64Field: function(tag, val) {
this.writeTag(tag, Pbf2.Fixed64);
this.writeSFixed64(val);
},
writeVarintField: function(tag, val) {
this.writeTag(tag, Pbf2.Varint);
this.writeVarint(val);
},
writeSVarintField: function(tag, val) {
this.writeTag(tag, Pbf2.Varint);
this.writeSVarint(val);
},
writeStringField: function(tag, str) {
this.writeTag(tag, Pbf2.Bytes);
this.writeString(str);
},
writeFloatField: function(tag, val) {
this.writeTag(tag, Pbf2.Fixed32);
this.writeFloat(val);
},
writeDoubleField: function(tag, val) {
this.writeTag(tag, Pbf2.Fixed64);
this.writeDouble(val);
},
writeBooleanField: function(tag, val) {
this.writeVarintField(tag, Boolean(val));
}
};
function readVarintRemainder(l, s, p) {
var buf = p.buf, h, b;
b = buf[p.pos++];
h = (b & 112) >> 4;
if (b < 128)
return toNum(l, h, s);
b = buf[p.pos++];
h |= (b & 127) << 3;
if (b < 128)
return toNum(l, h, s);
b = buf[p.pos++];
h |= (b & 127) << 10;
if (b < 128)
return toNum(l, h, s);
b = buf[p.pos++];
h |= (b & 127) << 17;
if (b < 128)
return toNum(l, h, s);
b = buf[p.pos++];
h |= (b & 127) << 24;
if (b < 128)
return toNum(l, h, s);
b = buf[p.pos++];
h |= (b & 1) << 31;
if (b < 128)
return toNum(l, h, s);
throw new Error("Expected varint not more than 10 bytes");
}
function readPackedEnd(pbf) {
return pbf.type === Pbf2.Bytes ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
}
function toNum(low, high, isSigned) {
if (isSigned) {
return high * 4294967296 + (low >>> 0);
}
return (high >>> 0) * 4294967296 + (low >>> 0);
}
function writeBigVarint(val, pbf) {
var low, high;
if (val >= 0) {
low = val % 4294967296 | 0;
high = val / 4294967296 | 0;
} else {
low = ~(-val % 4294967296);
high = ~(-val / 4294967296);
if (low ^ 4294967295) {
low = low + 1 | 0;
} else {
low = 0;
high = high + 1 | 0;
}
}
if (val >= 18446744073709552e3 || val < -18446744073709552e3) {
throw new Error("Given varint doesn't fit into 10 bytes");
}
pbf.realloc(10);
writeBigVarintLow(low, high, pbf);
writeBigVarintHigh(high, pbf);
}
function writeBigVarintLow(low, high, pbf) {
pbf.buf[pbf.pos++] = low & 127 | 128;
low >>>= 7;
pbf.buf[pbf.pos++] = low & 127 | 128;
low >>>= 7;
pbf.buf[pbf.pos++] = low & 127 | 128;
low >>>= 7;
pbf.buf[pbf.pos++] = low & 127 | 128;
low >>>= 7;
pbf.buf[pbf.pos] = low & 127;
}
function writeBigVarintHigh(high, pbf) {
var lsb = (high & 7) << 4;
pbf.buf[pbf.pos++] |= lsb | ((high >>>= 3) ? 128 : 0);
if (!high)
return;
pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
if (!high)
return;
pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
if (!high)
return;
pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
if (!high)
return;
pbf.buf[pbf.pos++] = high & 127 | ((high >>>= 7) ? 128 : 0);
if (!high)
return;
pbf.buf[pbf.pos++] = high & 127;
}
function makeRoomForExtraLength(startPos, len, pbf) {
var extraLen = len <= 16383 ? 1 : len <= 2097151 ? 2 : len <= 268435455 ? 3 : Math.floor(Math.log(len) / (Math.LN2 * 7));
pbf.realloc(extraLen);
for (var i = pbf.pos - 1; i >= startPos; i--)
pbf.buf[i + extraLen] = pbf.buf[i];
}
function writePackedVarint(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeVarint(arr[i]);
}
function writePackedSVarint(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeSVarint(arr[i]);
}
function writePackedFloat(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeFloat(arr[i]);
}
function writePackedDouble(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeDouble(arr[i]);
}
function writePackedBoolean(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeBoolean(arr[i]);
}
function writePackedFixed32(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeFixed32(arr[i]);
}
function writePackedSFixed32(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeSFixed32(arr[i]);
}
function writePackedFixed64(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeFixed64(arr[i]);
}
function writePackedSFixed64(arr, pbf) {
for (var i = 0; i < arr.length; i++)
pbf.writeSFixed64(arr[i]);
}
function readUInt32(buf, pos) {
return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + buf[pos + 3] * 16777216;
}
function writeInt32(buf, val, pos) {
buf[pos] = val;
buf[pos + 1] = val >>> 8;
buf[pos + 2] = val >>> 16;
buf[pos + 3] = val >>> 24;
}
function readInt32(buf, pos) {
return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16) + (buf[pos + 3] << 24);
}
function readUtf8(buf, pos, end) {
var str = "";
var i = pos;
while (i < end) {
var b0 = buf[i];
var c = null;
var bytesPerSequence = b0 > 239 ? 4 : b0 > 223 ? 3 : b0 > 191 ? 2 : 1;
if (i + bytesPerSequence > end)
break;
var b1, b2, b3;
if (bytesPerSequence === 1) {
if (b0 < 128) {
c = b0;
}
} else if (bytesPerSequence === 2) {
b1 = buf[i + 1];
if ((b1 & 192) === 128) {
c = (b0 & 31) << 6 | b1 & 63;
if (c <= 127) {
c = null;
}
}
} else if (bytesPerSequence === 3) {
b1 = buf[i + 1];
b2 = buf[i + 2];
if ((b1 & 192) === 128 && (b2 & 192) === 128) {
c = (b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63;
if (c <= 2047 || c >= 55296 && c <= 57343) {
c = null;
}
}
} else if (bytesPerSequence === 4) {
b1 = buf[i + 1];
b2 = buf[i + 2];
b3 = buf[i + 3];
if ((b1 & 192) === 128 && (b2 & 192) === 128 && (b3 & 192) === 128) {
c = (b0 & 15) << 18 | (b1 & 63) << 12 | (b2 & 63) << 6 | b3 & 63;
if (c <= 65535 || c >= 1114112) {
c = null;
}
}
}
if (c === null) {
c = 65533;
bytesPerSequence = 1;
} else if (c > 65535) {
c -= 65536;
str += String.fromCharCode(c >>> 10 & 1023 | 55296);
c = 56320 | c & 1023;
}
str += String.fromCharCode(c);
i += bytesPerSequence;
}
return str;
}
function readUtf8TextDecoder(buf, pos, end) {
return utf8TextDecoder.decode(buf.subarray(pos, end));
}
function writeUtf8(buf, str, pos) {
for (var i = 0, c, lead; i < str.length; i++) {
c = str.charCodeAt(i);
if (c > 55295 && c < 57344) {
if (lead) {
if (c < 56320) {
buf[pos++] = 239;
buf[pos++] = 191;
buf[pos++] = 189;
lead = c;
continue;
} else {
c = lead - 55296 << 10 | c - 56320 | 65536;
lead = null;
}
} else {
if (c > 56319 || i + 1 === str.length) {
buf[pos++] = 239;
buf[pos++] = 191;
buf[pos++] = 189;
} else {
lead = c;
}
continue;
}
} else if (lead) {
buf[pos++] = 239;
buf[pos++] = 191;
buf[pos++] = 189;
lead = null;
}
if (c < 128) {
buf[pos++] = c;
} else {
if (c < 2048) {
buf[pos++] = c >> 6 | 192;
} else {
if (c < 65536) {
buf[pos++] = c >> 12 | 224;
} else {
buf[pos++] = c >> 18 | 240;
buf[pos++] = c >> 12 & 63 | 128;
}
buf[pos++] = c >> 6 & 63 | 128;
}
buf[pos++] = c & 63 | 128;
}
}
return pos;
}
}
});
// bundle.ts
var bundle_exports = {};
__export(bundle_exports, {
MVTLoader: () => MVTLoader,
MVTSource: () => MVTSource,
MVTWorkerLoader: () => MVTWorkerLoader,
MVTWriter: () => MVTWriter,
TableTileSource: () => TableTileSource,
TileJSONLoader: () => TileJSONLoader
});
__reExport(bundle_exports, __toESM(require_core(), 1));
// src/lib/get-schemas-from-tilejson.ts
function getSchemaFromTileJSONLayer(layer) {
const fields = [];
if (layer.fields) {
for (const field of layer.fields) {
fields.push({
name: field.name,
type: getDataTypeFromTileJSONField(field),
metadata: getMetadataFromTileJSONField(field)
});
}
}
return {
metadata: getMetadataFromTileJSONLayer(layer),
fields
};
}
function getMetadataFromTileJSONLayer(layer) {
const metadata = {};
for (const [key, value] of Object.entries(layer)) {
if (key !== "fields" && value) {
metadata[key] = JSON.stringify(value);
}
}
return metadata;
}
function getDataTypeFromTileJSONField(field) {
switch (field.type.toLowerCase()) {
case "float32":
return "float32";
case "number":
case "float64":
return "float64";
case "string":
case "utf8":
return "utf8";
case "boolean":
return "bool";
default:
return "null";
}
}
function getMetadataFromTileJSONField(field) {
const metadata = {};
for (const [key, value] of Object.entries(field)) {
if (key !== "name" && value) {
metadata[key] = JSON.stringify(value);
}
}
return metadata;
}
// src/lib/parse-tilejson.ts
var isObject = (x) => x !== null && typeof x === "object";
function parseTileJSON(jsonMetadata, options) {
if (!jsonMetadata || !isObject(jsonMetadata)) {
return null;
}
let tileJSON = {
name: jsonMetadata.name || "",
description: jsonMetadata.description || ""
};
if (typeof jsonMetadata.generator === "string") {
tileJSON.generator = jsonMetadata.generator;
}
if (typeof jsonMetadata.generator_options === "string") {
tileJSON.generatorOptions = jsonMetadata.generator_options;
}
tileJSON.boundingBox = parseBounds(jsonMetadata.bounds) || parseBounds(jsonMetadata.antimeridian_adjusted_bounds);
tileJSON.center = parseCenter(jsonMetadata.center);
tileJSON.maxZoom = safeParseFloat(jsonMetadata.maxzoom);
tileJSON.minZoom = safeParseFloat(jsonMetadata.minzoom);
if (typeof jsonMetadata?.json === "string") {
try {
tileJSON.metaJson = JSON.parse(jsonMetadata.json);
} catch (error) {
console.warn("Failed to parse tilejson.json field", error);
}
}
const tilestats = jsonMetadata.tilestats || tileJSON.metaJson?.tilestats;
const tileStatsLayers = parseTilestatsLayers(tilestats, options);
const tileJSONlayers = parseTileJSONLayers(jsonMetadata.vector_layers);
const layers = mergeLayers(tileJSONlayers, tileStatsLayers);
tileJSON = {
...tileJSON,
layers
};
if (tileJSON.maxZoom === null && layers.length > 0) {
tileJSON.maxZoom = layers[0].maxZoom || null;
}
if (tileJSON.minZoom === null && layers.length > 0) {
tileJSON.minZoom = layers[0].minZoom || null;
}
return tileJSON;
}
function parseTileJSONLayers(layers) {
if (!Array.isArray(layers)) {
return [];
}
return layers.map((layer) => parseTileJSONLayer(layer));
}
function parseTileJSONLayer(layer) {
const fields = Object.entries(layer.fields || []).map(([key, datatype]) => ({
name: key,
...attributeTypeToFieldType(String(datatype))
}));
const layer2 = { ...layer };
delete layer2.fields;
return {
name: layer.id || "",
...layer2,
fields
};
}
function parseTilestatsLayers(tilestats, options) {
if (isObject(tilestats) && Array.isArray(tilestats.layers)) {
return tilestats.layers.map((layer) => parseTilestatsForLayer(layer, options));
}
return [];
}
function parseTilestatsForLayer(layer, options) {
const fields = [];
const indexedAttributes = {};
const attributes = layer.attributes || [];
for (const attribute of attributes) {
const name = attribute.attribute;
if (typeof name === "string") {
if (name.split("|").length > 1) {
const fname = name.split("|")[0];
indexedAttributes[fname] = indexedAttributes[fname] || [];
indexedAttributes[fname].push(attribute);
console.warn("ignoring tilestats indexed field", fname);
} else if (!fields[name]) {
fields.push(attributeToField(attribute, options));
} else {
}
}
}
return {
name: layer.layer || "",
dominantGeometry: layer.geometry,
fields
};
}
function mergeLayers(layers, tilestatsLayers) {
return layers.map((layer) => {
const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
const fields = tilestatsLayer?.fields || layer.fields || [];
const mergedLayer = {
...layer,
...tilestatsLayer,
fields
};
mergedLayer.schema = getSchemaFromTileJSONLayer(mergedLayer);
return mergedLayer;
});
}
function parseBounds(bounds) {
const result = fromArrayOrString(bounds);
if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
return [
[result[0], result[1]],
[result[2], result[3]]
];
}
return void 0;
}
function parseCenter(center) {
const result = fromArrayOrString(center);
if (Array.isArray(result) && result.length === 3 && isLng(result[0]) && isLat(result[1]) && isZoom(result[2])) {
return result;
}
return null;
}
function safeParseFloat(input) {
const result = typeof input === "string" ? parseFloat(input) : typeof input === "number" ? input : null;
return result === null || isNaN(result) ? null : result;
}
function isLat(num) {
return Number.isFinite(num) && num <= 90 && num >= -90;
}
function isLng(num) {
return Number.isFinite(num) && num <= 180 && num >= -180;
}
function isZoom(num) {
return Number.isFinite(num) && num >= 0 && num <= 22;
}
function fromArrayOrString(data) {
if (typeof data === "string") {
return data.split(",").map(parseFloat);
} else if (Array.isArray(data)) {
return data;
}
return null;
}
var attrTypeMap = {
number: {
type: "float32"
},
numeric: {
type: "float32"
},
string: {
type: "utf8"
},
vachar: {
type: "utf8"
},
float: {
type: "float32"
},
int: {
type: "int32"
},
int4: {
type: "int32"
},
boolean: {
type: "boolean"
},
bool: {
type: "boolean"
}
};
function attributeToField(attribute = {}, options) {
const fieldTypes = attributeTypeToFieldType(attribute.type);
const field = {
name: attribute.attribute,
// what happens if attribute type is string...
// filterProps: getFilterProps(fieldTypes.type, attribute),
...fieldTypes
};
if (typeof attribute.min === "number") {
field.min = attribute.min;
}
if (typeof attribute.max === "number") {
field.max = attribute.max;
}
if (typeof attribute.count === "number") {
field.uniqueValueCount = attribute.count;
}
if (attribute.values) {
field.values = attribute.values;
}
if (field.values && typeof options.maxValues === "number") {
field.values = field.values?.slice(0, options.maxValues);
}
return field;
}
function attributeTypeToFieldType(aType) {
const type = aType.toLowerCase();
if (!type || !attrTypeMap[type]) {
}
return attrTypeMap[type] || { type: "string" };
}
// src/tilejson-loader.ts
var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
var TileJSONLoader = {
dataType: null,
batchType: null,
name: "TileJSON",
id: "tilejson",
module: "pmtiles",
version: VERSION,
worker: true,
extensions: ["json"],
mimeTypes: ["application/json"],
text: true,
options: {
tilejson: {
maxValues: void 0
}
},
parse: async (arrayBuffer, options) => {
const jsonString = new TextDecoder().decode(arrayBuffer);
const json = JSON.parse(jsonString);
const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
return parseTileJSON(json, tilejsonOptions);
},
parseTextSync: (text, options) => {
const json = JSON.parse(text);
const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
return parseTileJSON(json, tilejsonOptions);
}
};
// ../schema-utils/src/lib/schema/data-type.ts
function getDataTypeFromValue(value, defaultNumberType = "float32") {
if (value instanceof Date) {
return "date-millisecond";
}
if (value instanceof Number) {
return defaultNumberType;
}
if (typeof value === "string") {
return "utf8";
}
if (value === null || value === "undefined") {
return "null";
}
return "null";
}
function getDataTypeFromArray(array) {
let type = getDataTypeFromTypedArray(array);
if (type !== "null") {
return { type, nullable: false };
}
if (array.length > 0) {
type = getDataTypeFromValue(array[0]);
return { type, nullable: true };
}
return { type: "null", nullable: true };
}
function getDataTypeFromTypedArray(array) {
switch (array.constructor) {
case Int8Array:
return "int8";
case Uint8Array:
case Uint8ClampedArray:
return "uint8";
case Int16Array:
return "int16";
case Uint16Array:
return "uint16";
case Int32Array:
return "int32";
case Uint32Array:
return "uint32";
case Float32Array:
return "float32";
case Float64Array:
return "float64";
default:
return "null";
}
}
// ../schema-utils/src/lib/schema/deduce-table-schema.ts
function deduceTableSchema(table) {
switch (table.shape) {
case "array-row-table":
case "object-row-table":
return deduceSchemaFromRows(table.data);
case "geojson-table":
return deduceSchemaFromGeoJSON(table.features);
case "columnar-table":
return deduceSchemaFromColumns(table.data);
case "arrow-table":
default:
throw new Error("Deduce schema");
}
}
function deduceSchemaFromColumns(columnarTable) {
const fields = [];
for (const [columnName, column] of Object.entries(columnarTable)) {
const field = deduceFieldFromColumn(column, columnName);
fields.push(field);
}
return { fields, metadata: {} };
}
function deduceSchemaFromRows(rowTable) {
if (!rowTable.length) {
throw new Error("deduce from empty table");
}
const fields = [];
const row0 = rowTable[0];
for (const [columnName, value] of Object.entries(row0)) {
fields.push(deduceFieldFromValue(value, columnName));
}
return { fields, metadata: {} };
}
function deduceSchemaFromGeoJSON(features2) {
if (!features2.length) {
throw new Error("deduce from empty table");
}
const fields = [];
const row0 = features2[0].properties || {};
for (const [columnName, value] of Object.entries(row0)) {
fields.push(deduceFieldFromValue(value, columnName));
}
return { fields, metadata: {} };
}
function deduceFieldFromColumn(column, name) {
if (ArrayBuffer.isView(column)) {
const type = getDataTypeFromArray(column);
return {
name,
type: type.type || "null",
nullable: type.nullable
// metadata: {}
};
}
if (Array.isArray(column) && column.length > 0) {
const value = column[0];
const type = getDataTypeFromValue(value);
return {
name,
type,
nullable: true
// metadata: {},
};
}
throw new Error("empty table");
}
function deduceFieldFromValue(value, name) {
const type = getDataTypeFromValue(value);
return {
name,
type,
nullable: true
// metadata: {}
};
}
// ../../node_modules/@math.gl/polygon/dist/polygon-utils.js
var DimIndex = {
x: 0,
y: 1,
z: 2
};
function getPolygonSignedArea(points, options = {}) {
const { start = 0, end = points.length, plane = "xy" } = options;
const dim = options.size || 2;
let area2 = 0;
const i0 = DimIndex[plane[0]];
const i1 = DimIndex[plane[1]];
for (let i = start, j = end - dim; i < end; i += dim) {
area2 += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
j = i;
}
return area2 / 2;
}
// ../../node_modules/@math.gl/polygon/dist/earcut.js
function earcut(positions, holeIndices, dim = 2, areas, plane = "xy") {
const hasHoles = holeIndices && holeIndices.length;
const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0], plane);
const triangles = [];
if (!outerNode || outerNode.next === outerNode.prev)
return triangles;
let invSize;
let maxX;
let maxY;
let minX;
let minY;
let x;
let y;
if (hasHoles)
outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
if (positions.length > 80 * dim) {
minX = maxX = positions[0];
minY = maxY = positions[1];
for (let i = dim; i < outerLen; i += dim) {
x = positions[i];
y = positions[i + 1];
if (x < minX)
minX = x;
if (y < minY)
minY = y;
if (x > maxX)
maxX = x;
if (y > maxY)
maxY = y;
}
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, area2, plane) {
let i;
let last;
if (area2 === void 0) {
area2 = getPolygonSignedArea(data, { start, end, size: dim, plane });
}
let i0 = DimIndex[plane[0]];
let i1 = DimIndex[plane[1]];
if (clockwise === area2 < 0) {
for (i = start; i < end; i += dim)
last = insertNode(i, data[i + i0], data[i + i1], last);
} else {
for (i = end - dim; i >= start; i -= dim)
last = insertNode(i, data[i + i0], data[i + i1], last);
}
if (last && equals(last, last.next)) {
removeNode(last);
last = last.next;
}
return last;
}
function filterPoints(start, end) {
if (!start)
return start;
if (!end)
end = start;
let p = start;
let again;
do {
again = false;
if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
removeNode(p);
p = end = p.prev;
if (p === p.next)
break;
again = true;
} else {
p = p.next;
}
} while (again || p !== end);
return end;
}
function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
if (!ear)
return;
if (!pass && invSize)
indexCurve(ear, minX, minY, invSize);
let stop = ear;
let prev;
let 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) {
const a = ear.prev;
const b = ear;
const c = ear.next;
if (area(a, b, c) >= 0)
return false;
const ax = a.x;
const bx = b.x;
const cx = c.x;
const ay = a.y;
const by = b.y;
const cy = c.y;
const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx;
const y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy;
const x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx;
const y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
let p = c.next;
while (p !== a) {
if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
return false;
p = p.next;
}
return true;
}
function isEarHashed(ear, minX, minY, invSize) {
const a = ear.prev;
const b = ear;
const c = ear.next;
if (area(a, b, c) >= 0)
return false;
const ax = a.x;
const bx = b.x;
const cx = c.x;
const ay = a.y;
const by = b.y;
const cy = c.y;
const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx;
const y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy;
const x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx;
const y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
const minZ = zOrder(x0, y0, minX, minY, invSize);
const maxZ = zOrder(x1, y1, minX, minY, invSize);
let p = ear.prevZ;
let n = ear.nextZ;
while (p && p.z >= minZ && n && n.z <= maxZ) {
if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
return false;
p = p.prevZ;
if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
return false;
n = n.nextZ;
}
while (p && p.z >= minZ) {
if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
return false;
p = p.prevZ;
}
while (n && n.z <= maxZ) {
if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
return false;
n = n.nextZ;
}
return true;
}
function cureLocalIntersections(start, triangles, dim) {
let p = start;
do {
const a = p.prev;
const b = p.next.next;
if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
triangles.push(a.i / dim | 0);
triangles.push(p.i / dim | 0);
triangles.push(b.i / dim | 0);
removeNode(p);
removeNode(p.next);
p = start = b;
}
p = p.next;
} while (p !== start);
return filterPoints(p);
}
function splitEarcut(start, triangles, dim, minX, minY, invSize) {
let a = start;
do {
let b = a.next.next;
while (b !== a.prev) {
if (a.i !== b.i && isValidDiagonal(a, b)) {
let c = splitPolygon(a, b);
a = filterPoints(a, a.next);
c = filterPoints(c, c.next);
earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
return;
}
b = b.next;
}
a = a.next;
} while (a !== start);
}
function eliminateHoles(data, holeIndices, outerNode, dim, areas, plane) {
const queue = [];
let i;
let len;
let start;
let end;
let list;
for (i = 0, len = holeIndices.length; i < len; i++) {
start = holeIndices[i] * dim;
end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
list = linkedList(data, start, end, dim, false, areas && areas[i + 1], plane);
if (list === list.next)
list.steiner = true;
queue.push(getLeftmost(list));
}
queue.sort(compareX);
for (i = 0; i < queue.length; i++) {
outerNode = eliminateHole(queue[i], outerNode);
}
return outerNode;
}
function compareX(a, b) {
return a.x - b.x;
}
function eliminateHole(hole, outerNode) {
const bridge = findHoleBridge(hole, outerNode);
if (!bridge) {
return outerNode;
}
const bridgeReverse = splitPolygon(bridge, hole);
filterPoints(bridgeReverse, bridgeReverse.next);
return filterPoints(bridge, bridge.next);
}
function findHoleBridge(hole, outerNode) {
let p = outerNode;
const hx = hole.x;
const hy = hole.y;
let qx = -Infinity;
let m;
do {
if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
if (x <= hx && x > qx) {
qx = x;
m = p.x < p.next.x ? p : p.next;
if (x === hx)
return m;
}
}
p = p.next;
} while (p !== outerNode);
if (!m)
return null;
const stop = m;
const mx = m.x;
const my = m.y;
let tanMin = Infinity;
let tan;
p = m;
do {
if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
tan = Math.abs(hy - p.y) / (hx - p.x);
if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
m = p;
tanMin = tan;
}
}
p = p.next;
} while (p !== stop);
return m;
}
function sectorContainsSector(m, p) {
return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
}
function indexCurve(start, minX, minY, invSize) {
let p = start;
do {
if (p.z === 0)
p.z = zOrder(p.x, p.y, minX, minY, invSize);
p.pre