kopia lustrzana https://github.com/altilunium/vmap
1400 wiersze
43 KiB
JavaScript
1400 wiersze
43 KiB
JavaScript
var pmtiles = (() => {
|
|
var __defProp = Object.defineProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, {get: all[name], enumerable: true});
|
|
};
|
|
var __async = (__this, __arguments, generator) => {
|
|
return new Promise((resolve, reject) => {
|
|
var fulfilled = (value) => {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var rejected = (value) => {
|
|
try {
|
|
step(generator.throw(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
};
|
|
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
|
|
step((generator = generator.apply(__this, __arguments)).next());
|
|
});
|
|
};
|
|
|
|
// index.ts
|
|
var js_exports = {};
|
|
__export(js_exports, {
|
|
Compression: () => Compression,
|
|
EtagMismatch: () => EtagMismatch,
|
|
FetchSource: () => FetchSource,
|
|
FileAPISource: () => FileAPISource,
|
|
PMTiles: () => PMTiles,
|
|
Protocol: () => Protocol,
|
|
ResolvedValueCache: () => ResolvedValueCache,
|
|
SharedPromiseCache: () => SharedPromiseCache,
|
|
TileType: () => TileType,
|
|
bytesToHeader: () => bytesToHeader,
|
|
findTile: () => findTile,
|
|
leafletRasterLayer: () => leafletRasterLayer,
|
|
readVarint: () => readVarint,
|
|
tileIdToZxy: () => tileIdToZxy,
|
|
zxyToTileId: () => zxyToTileId
|
|
});
|
|
|
|
// node_modules/fflate/esm/browser.js
|
|
var u8 = Uint8Array;
|
|
var u16 = Uint16Array;
|
|
var u32 = Uint32Array;
|
|
var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
|
|
var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
|
|
var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
|
|
var freb = function(eb, start) {
|
|
var b = new u16(31);
|
|
for (var i = 0; i < 31; ++i) {
|
|
b[i] = start += 1 << eb[i - 1];
|
|
}
|
|
var r = new u32(b[30]);
|
|
for (var i = 1; i < 30; ++i) {
|
|
for (var j = b[i]; j < b[i + 1]; ++j) {
|
|
r[j] = j - b[i] << 5 | i;
|
|
}
|
|
}
|
|
return [b, r];
|
|
};
|
|
var _a = freb(fleb, 2);
|
|
var fl = _a[0];
|
|
var revfl = _a[1];
|
|
fl[28] = 258, revfl[258] = 28;
|
|
var _b = freb(fdeb, 0);
|
|
var fd = _b[0];
|
|
var revfd = _b[1];
|
|
var rev = new u16(32768);
|
|
for (var i = 0; i < 32768; ++i) {
|
|
x = (i & 43690) >>> 1 | (i & 21845) << 1;
|
|
x = (x & 52428) >>> 2 | (x & 13107) << 2;
|
|
x = (x & 61680) >>> 4 | (x & 3855) << 4;
|
|
rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
|
|
}
|
|
var x;
|
|
var hMap = function(cd, mb, r) {
|
|
var s = cd.length;
|
|
var i = 0;
|
|
var l = new u16(mb);
|
|
for (; i < s; ++i) {
|
|
if (cd[i])
|
|
++l[cd[i] - 1];
|
|
}
|
|
var le = new u16(mb);
|
|
for (i = 0; i < mb; ++i) {
|
|
le[i] = le[i - 1] + l[i - 1] << 1;
|
|
}
|
|
var co;
|
|
if (r) {
|
|
co = new u16(1 << mb);
|
|
var rvb = 15 - mb;
|
|
for (i = 0; i < s; ++i) {
|
|
if (cd[i]) {
|
|
var sv = i << 4 | cd[i];
|
|
var r_1 = mb - cd[i];
|
|
var v = le[cd[i] - 1]++ << r_1;
|
|
for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
|
|
co[rev[v] >>> rvb] = sv;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
co = new u16(s);
|
|
for (i = 0; i < s; ++i) {
|
|
if (cd[i]) {
|
|
co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
|
|
}
|
|
}
|
|
}
|
|
return co;
|
|
};
|
|
var flt = new u8(288);
|
|
for (var i = 0; i < 144; ++i)
|
|
flt[i] = 8;
|
|
for (var i = 144; i < 256; ++i)
|
|
flt[i] = 9;
|
|
for (var i = 256; i < 280; ++i)
|
|
flt[i] = 7;
|
|
for (var i = 280; i < 288; ++i)
|
|
flt[i] = 8;
|
|
var fdt = new u8(32);
|
|
for (var i = 0; i < 32; ++i)
|
|
fdt[i] = 5;
|
|
var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
|
|
var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
|
|
var max = function(a) {
|
|
var m = a[0];
|
|
for (var i = 1; i < a.length; ++i) {
|
|
if (a[i] > m)
|
|
m = a[i];
|
|
}
|
|
return m;
|
|
};
|
|
var bits = function(d, p, m) {
|
|
var o = p / 8 | 0;
|
|
return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
|
|
};
|
|
var bits16 = function(d, p) {
|
|
var o = p / 8 | 0;
|
|
return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
|
|
};
|
|
var shft = function(p) {
|
|
return (p + 7) / 8 | 0;
|
|
};
|
|
var slc = function(v, s, e) {
|
|
if (s == null || s < 0)
|
|
s = 0;
|
|
if (e == null || e > v.length)
|
|
e = v.length;
|
|
var n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
|
|
n.set(v.subarray(s, e));
|
|
return n;
|
|
};
|
|
var ec = [
|
|
"unexpected EOF",
|
|
"invalid block type",
|
|
"invalid length/literal",
|
|
"invalid distance",
|
|
"stream finished",
|
|
"no stream handler",
|
|
,
|
|
"no callback",
|
|
"invalid UTF-8 data",
|
|
"extra field too long",
|
|
"date not in range 1980-2099",
|
|
"filename too long",
|
|
"stream finishing",
|
|
"invalid zip data"
|
|
];
|
|
var err = function(ind, msg, nt) {
|
|
var e = new Error(msg || ec[ind]);
|
|
e.code = ind;
|
|
if (Error.captureStackTrace)
|
|
Error.captureStackTrace(e, err);
|
|
if (!nt)
|
|
throw e;
|
|
return e;
|
|
};
|
|
var inflt = function(dat, buf, st) {
|
|
var sl = dat.length;
|
|
if (!sl || st && st.f && !st.l)
|
|
return buf || new u8(0);
|
|
var noBuf = !buf || st;
|
|
var noSt = !st || st.i;
|
|
if (!st)
|
|
st = {};
|
|
if (!buf)
|
|
buf = new u8(sl * 3);
|
|
var cbuf = function(l2) {
|
|
var bl = buf.length;
|
|
if (l2 > bl) {
|
|
var nbuf = new u8(Math.max(bl * 2, l2));
|
|
nbuf.set(buf);
|
|
buf = nbuf;
|
|
}
|
|
};
|
|
var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
|
|
var tbts = sl * 8;
|
|
do {
|
|
if (!lm) {
|
|
final = bits(dat, pos, 1);
|
|
var type = bits(dat, pos + 1, 3);
|
|
pos += 3;
|
|
if (!type) {
|
|
var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
|
|
if (t > sl) {
|
|
if (noSt)
|
|
err(0);
|
|
break;
|
|
}
|
|
if (noBuf)
|
|
cbuf(bt + l);
|
|
buf.set(dat.subarray(s, t), bt);
|
|
st.b = bt += l, st.p = pos = t * 8, st.f = final;
|
|
continue;
|
|
} else if (type == 1)
|
|
lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
|
|
else if (type == 2) {
|
|
var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
|
|
var tl = hLit + bits(dat, pos + 5, 31) + 1;
|
|
pos += 14;
|
|
var ldt = new u8(tl);
|
|
var clt = new u8(19);
|
|
for (var i = 0; i < hcLen; ++i) {
|
|
clt[clim[i]] = bits(dat, pos + i * 3, 7);
|
|
}
|
|
pos += hcLen * 3;
|
|
var clb = max(clt), clbmsk = (1 << clb) - 1;
|
|
var clm = hMap(clt, clb, 1);
|
|
for (var i = 0; i < tl; ) {
|
|
var r = clm[bits(dat, pos, clbmsk)];
|
|
pos += r & 15;
|
|
var s = r >>> 4;
|
|
if (s < 16) {
|
|
ldt[i++] = s;
|
|
} else {
|
|
var c = 0, n = 0;
|
|
if (s == 16)
|
|
n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
|
|
else if (s == 17)
|
|
n = 3 + bits(dat, pos, 7), pos += 3;
|
|
else if (s == 18)
|
|
n = 11 + bits(dat, pos, 127), pos += 7;
|
|
while (n--)
|
|
ldt[i++] = c;
|
|
}
|
|
}
|
|
var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
|
|
lbt = max(lt);
|
|
dbt = max(dt);
|
|
lm = hMap(lt, lbt, 1);
|
|
dm = hMap(dt, dbt, 1);
|
|
} else
|
|
err(1);
|
|
if (pos > tbts) {
|
|
if (noSt)
|
|
err(0);
|
|
break;
|
|
}
|
|
}
|
|
if (noBuf)
|
|
cbuf(bt + 131072);
|
|
var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
|
|
var lpos = pos;
|
|
for (; ; lpos = pos) {
|
|
var c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
|
|
pos += c & 15;
|
|
if (pos > tbts) {
|
|
if (noSt)
|
|
err(0);
|
|
break;
|
|
}
|
|
if (!c)
|
|
err(2);
|
|
if (sym < 256)
|
|
buf[bt++] = sym;
|
|
else if (sym == 256) {
|
|
lpos = pos, lm = null;
|
|
break;
|
|
} else {
|
|
var add = sym - 254;
|
|
if (sym > 264) {
|
|
var i = sym - 257, b = fleb[i];
|
|
add = bits(dat, pos, (1 << b) - 1) + fl[i];
|
|
pos += b;
|
|
}
|
|
var d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
|
|
if (!d)
|
|
err(3);
|
|
pos += d & 15;
|
|
var dt = fd[dsym];
|
|
if (dsym > 3) {
|
|
var b = fdeb[dsym];
|
|
dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
|
|
}
|
|
if (pos > tbts) {
|
|
if (noSt)
|
|
err(0);
|
|
break;
|
|
}
|
|
if (noBuf)
|
|
cbuf(bt + 131072);
|
|
var end = bt + add;
|
|
for (; bt < end; bt += 4) {
|
|
buf[bt] = buf[bt - dt];
|
|
buf[bt + 1] = buf[bt + 1 - dt];
|
|
buf[bt + 2] = buf[bt + 2 - dt];
|
|
buf[bt + 3] = buf[bt + 3 - dt];
|
|
}
|
|
bt = end;
|
|
}
|
|
}
|
|
st.l = lm, st.p = lpos, st.b = bt, st.f = final;
|
|
if (lm)
|
|
final = 1, st.m = lbt, st.d = dm, st.n = dbt;
|
|
} while (!final);
|
|
return bt == buf.length ? buf : slc(buf, 0, bt);
|
|
};
|
|
var et = /* @__PURE__ */ new u8(0);
|
|
var gzs = function(d) {
|
|
if (d[0] != 31 || d[1] != 139 || d[2] != 8)
|
|
err(6, "invalid gzip data");
|
|
var flg = d[3];
|
|
var st = 10;
|
|
if (flg & 4)
|
|
st += d[10] | (d[11] << 8) + 2;
|
|
for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
|
|
;
|
|
return st + (flg & 2);
|
|
};
|
|
var gzl = function(d) {
|
|
var l = d.length;
|
|
return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
|
|
};
|
|
var zlv = function(d) {
|
|
if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31)
|
|
err(6, "invalid zlib data");
|
|
if (d[1] & 32)
|
|
err(6, "invalid zlib data: preset dictionaries not supported");
|
|
};
|
|
function inflateSync(data, out) {
|
|
return inflt(data, out);
|
|
}
|
|
function gunzipSync(data, out) {
|
|
return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
|
|
}
|
|
function unzlibSync(data, out) {
|
|
return inflt((zlv(data), data.subarray(2, -4)), out);
|
|
}
|
|
function decompressSync(data, out) {
|
|
return data[0] == 31 && data[1] == 139 && data[2] == 8 ? gunzipSync(data, out) : (data[0] & 15) != 8 || data[0] >> 4 > 7 || (data[0] << 8 | data[1]) % 31 ? inflateSync(data, out) : unzlibSync(data, out);
|
|
}
|
|
var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
|
|
var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
|
|
var tds = 0;
|
|
try {
|
|
td.decode(et, {stream: true});
|
|
tds = 1;
|
|
} catch (e) {
|
|
}
|
|
var mt = typeof queueMicrotask == "function" ? queueMicrotask : typeof setTimeout == "function" ? setTimeout : function(fn) {
|
|
fn();
|
|
};
|
|
|
|
// v2.ts
|
|
var shift = (n, shift2) => {
|
|
return n * Math.pow(2, shift2);
|
|
};
|
|
var unshift = (n, shift2) => {
|
|
return Math.floor(n / Math.pow(2, shift2));
|
|
};
|
|
var getUint24 = (view, pos) => {
|
|
return shift(view.getUint16(pos + 1, true), 8) + view.getUint8(pos);
|
|
};
|
|
var getUint48 = (view, pos) => {
|
|
return shift(view.getUint32(pos + 2, true), 16) + view.getUint16(pos, true);
|
|
};
|
|
var compare = (tz, tx, ty, view, i) => {
|
|
if (tz != view.getUint8(i))
|
|
return tz - view.getUint8(i);
|
|
const x = getUint24(view, i + 1);
|
|
if (tx != x)
|
|
return tx - x;
|
|
const y = getUint24(view, i + 4);
|
|
if (ty != y)
|
|
return ty - y;
|
|
return 0;
|
|
};
|
|
var queryLeafdir = (view, z, x, y) => {
|
|
const offset_len = queryView(view, z | 128, x, y);
|
|
if (offset_len) {
|
|
return {
|
|
z,
|
|
x,
|
|
y,
|
|
offset: offset_len[0],
|
|
length: offset_len[1],
|
|
is_dir: true
|
|
};
|
|
}
|
|
return null;
|
|
};
|
|
var queryTile = (view, z, x, y) => {
|
|
const offset_len = queryView(view, z, x, y);
|
|
if (offset_len) {
|
|
return {
|
|
z,
|
|
x,
|
|
y,
|
|
offset: offset_len[0],
|
|
length: offset_len[1],
|
|
is_dir: false
|
|
};
|
|
}
|
|
return null;
|
|
};
|
|
var queryView = (view, z, x, y) => {
|
|
let m = 0;
|
|
let n = view.byteLength / 17 - 1;
|
|
while (m <= n) {
|
|
const k = n + m >> 1;
|
|
const cmp = compare(z, x, y, view, k * 17);
|
|
if (cmp > 0) {
|
|
m = k + 1;
|
|
} else if (cmp < 0) {
|
|
n = k - 1;
|
|
} else {
|
|
return [getUint48(view, k * 17 + 7), view.getUint32(k * 17 + 13, true)];
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
var entrySort = (a, b) => {
|
|
if (a.is_dir && !b.is_dir) {
|
|
return 1;
|
|
}
|
|
if (!a.is_dir && b.is_dir) {
|
|
return -1;
|
|
}
|
|
if (a.z !== b.z) {
|
|
return a.z - b.z;
|
|
}
|
|
if (a.x !== b.x) {
|
|
return a.x - b.x;
|
|
}
|
|
return a.y - b.y;
|
|
};
|
|
var parseEntry = (dataview, i) => {
|
|
const z_raw = dataview.getUint8(i * 17);
|
|
const z = z_raw & 127;
|
|
return {
|
|
z,
|
|
x: getUint24(dataview, i * 17 + 1),
|
|
y: getUint24(dataview, i * 17 + 4),
|
|
offset: getUint48(dataview, i * 17 + 7),
|
|
length: dataview.getUint32(i * 17 + 13, true),
|
|
is_dir: z_raw >> 7 === 1
|
|
};
|
|
};
|
|
var sortDir = (a) => {
|
|
const entries = [];
|
|
const view = new DataView(a);
|
|
for (let i = 0; i < view.byteLength / 17; i++) {
|
|
entries.push(parseEntry(view, i));
|
|
}
|
|
return createDirectory(entries);
|
|
};
|
|
var createDirectory = (entries) => {
|
|
entries.sort(entrySort);
|
|
const buffer = new ArrayBuffer(17 * entries.length);
|
|
const arr = new Uint8Array(buffer);
|
|
for (let i = 0; i < entries.length; i++) {
|
|
const entry = entries[i];
|
|
let z = entry.z;
|
|
if (entry.is_dir)
|
|
z = z | 128;
|
|
arr[i * 17] = z;
|
|
arr[i * 17 + 1] = entry.x & 255;
|
|
arr[i * 17 + 2] = entry.x >> 8 & 255;
|
|
arr[i * 17 + 3] = entry.x >> 16 & 255;
|
|
arr[i * 17 + 4] = entry.y & 255;
|
|
arr[i * 17 + 5] = entry.y >> 8 & 255;
|
|
arr[i * 17 + 6] = entry.y >> 16 & 255;
|
|
arr[i * 17 + 7] = entry.offset & 255;
|
|
arr[i * 17 + 8] = unshift(entry.offset, 8) & 255;
|
|
arr[i * 17 + 9] = unshift(entry.offset, 16) & 255;
|
|
arr[i * 17 + 10] = unshift(entry.offset, 24) & 255;
|
|
arr[i * 17 + 11] = unshift(entry.offset, 32) & 255;
|
|
arr[i * 17 + 12] = unshift(entry.offset, 48) & 255;
|
|
arr[i * 17 + 13] = entry.length & 255;
|
|
arr[i * 17 + 14] = entry.length >> 8 & 255;
|
|
arr[i * 17 + 15] = entry.length >> 16 & 255;
|
|
arr[i * 17 + 16] = entry.length >> 24 & 255;
|
|
}
|
|
return buffer;
|
|
};
|
|
var deriveLeaf = (view, tile) => {
|
|
if (view.byteLength < 17)
|
|
return null;
|
|
const numEntries = view.byteLength / 17;
|
|
const entry = parseEntry(view, numEntries - 1);
|
|
if (entry.is_dir) {
|
|
const leaf_level = entry.z;
|
|
const level_diff = tile.z - leaf_level;
|
|
const leaf_x = Math.trunc(tile.x / (1 << level_diff));
|
|
const leaf_y = Math.trunc(tile.y / (1 << level_diff));
|
|
return {z: leaf_level, x: leaf_x, y: leaf_y};
|
|
}
|
|
return null;
|
|
};
|
|
function getHeader(source) {
|
|
return __async(this, null, function* () {
|
|
const resp = yield source.getBytes(0, 512e3);
|
|
const dataview = new DataView(resp.data);
|
|
const json_size = dataview.getUint32(4, true);
|
|
const root_entries = dataview.getUint16(8, true);
|
|
const dec = new TextDecoder("utf-8");
|
|
const json_metadata = JSON.parse(dec.decode(new DataView(resp.data, 10, json_size)));
|
|
let tile_compression = Compression.Unknown;
|
|
if (json_metadata.compression === "gzip") {
|
|
tile_compression = Compression.Gzip;
|
|
}
|
|
let minzoom = 0;
|
|
if ("minzoom" in json_metadata) {
|
|
minzoom = +json_metadata.minzoom;
|
|
}
|
|
let maxzoom = 0;
|
|
if ("maxzoom" in json_metadata) {
|
|
maxzoom = +json_metadata.maxzoom;
|
|
}
|
|
let center_lon = 0;
|
|
let center_lat = 0;
|
|
let center_zoom = 0;
|
|
let min_lon = -180;
|
|
let min_lat = -85;
|
|
let max_lon = 180;
|
|
let max_lat = 85;
|
|
if (json_metadata.bounds) {
|
|
const split = json_metadata.bounds.split(",");
|
|
min_lon = +split[0];
|
|
min_lat = +split[1];
|
|
max_lon = +split[2];
|
|
max_lat = +split[3];
|
|
}
|
|
if (json_metadata.center) {
|
|
const split = json_metadata.center.split(",");
|
|
center_lon = +split[0];
|
|
center_lat = +split[1];
|
|
center_zoom = +split[2];
|
|
}
|
|
const header = {
|
|
specVersion: dataview.getUint16(2, true),
|
|
rootDirectoryOffset: 10 + json_size,
|
|
rootDirectoryLength: root_entries * 17,
|
|
jsonMetadataOffset: 10,
|
|
jsonMetadataLength: json_size,
|
|
leafDirectoryOffset: 0,
|
|
leafDirectoryLength: void 0,
|
|
tileDataOffset: 0,
|
|
tileDataLength: void 0,
|
|
numAddressedTiles: 0,
|
|
numTileEntries: 0,
|
|
numTileContents: 0,
|
|
clustered: false,
|
|
internalCompression: Compression.None,
|
|
tileCompression: tile_compression,
|
|
tileType: TileType.Mvt,
|
|
minZoom: minzoom,
|
|
maxZoom: maxzoom,
|
|
minLon: min_lon,
|
|
minLat: min_lat,
|
|
maxLon: max_lon,
|
|
maxLat: max_lat,
|
|
centerZoom: center_zoom,
|
|
centerLon: center_lon,
|
|
centerLat: center_lat,
|
|
etag: resp.etag
|
|
};
|
|
return header;
|
|
});
|
|
}
|
|
function getZxy(header, source, cache, z, x, y, signal) {
|
|
return __async(this, null, function* () {
|
|
let root_dir = yield cache.getArrayBuffer(source, header.rootDirectoryOffset, header.rootDirectoryLength, header);
|
|
if (header.specVersion === 1) {
|
|
root_dir = sortDir(root_dir);
|
|
}
|
|
const entry = queryTile(new DataView(root_dir), z, x, y);
|
|
if (entry) {
|
|
const resp = yield source.getBytes(entry.offset, entry.length, signal);
|
|
let tile_data = resp.data;
|
|
const view = new DataView(tile_data);
|
|
if (view.getUint8(0) == 31 && view.getUint8(1) == 139) {
|
|
tile_data = decompressSync(new Uint8Array(tile_data));
|
|
}
|
|
return {
|
|
data: tile_data
|
|
};
|
|
}
|
|
const leafcoords = deriveLeaf(new DataView(root_dir), {z, x, y});
|
|
if (leafcoords) {
|
|
const leafdir_entry = queryLeafdir(new DataView(root_dir), leafcoords.z, leafcoords.x, leafcoords.y);
|
|
if (leafdir_entry) {
|
|
let leaf_dir = yield cache.getArrayBuffer(source, leafdir_entry.offset, leafdir_entry.length, header);
|
|
if (header.specVersion === 1) {
|
|
leaf_dir = sortDir(leaf_dir);
|
|
}
|
|
const tile_entry = queryTile(new DataView(leaf_dir), z, x, y);
|
|
if (tile_entry) {
|
|
const resp = yield source.getBytes(tile_entry.offset, tile_entry.length, signal);
|
|
let tile_data = resp.data;
|
|
const view = new DataView(tile_data);
|
|
if (view.getUint8(0) == 31 && view.getUint8(1) == 139) {
|
|
tile_data = decompressSync(new Uint8Array(tile_data));
|
|
}
|
|
return {
|
|
data: tile_data
|
|
};
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
});
|
|
}
|
|
var v2_default = {
|
|
getHeader,
|
|
getZxy
|
|
};
|
|
|
|
// adapters.ts
|
|
var leafletRasterLayer = (source, options) => {
|
|
const cls = L.GridLayer.extend({
|
|
createTile: function(coord, done) {
|
|
const el = document.createElement("img");
|
|
const controller = new AbortController();
|
|
const signal = controller.signal;
|
|
el.cancel = () => {
|
|
controller.abort();
|
|
};
|
|
source.getZxy(coord.z, coord.x, coord.y, signal).then((arr) => {
|
|
if (arr) {
|
|
const blob = new Blob([arr.data]);
|
|
const imageUrl = window.URL.createObjectURL(blob);
|
|
el.src = imageUrl;
|
|
el.cancel = null;
|
|
done(null, el);
|
|
}
|
|
}).catch((e) => {
|
|
if (e.name !== "AbortError") {
|
|
throw e;
|
|
}
|
|
});
|
|
return el;
|
|
},
|
|
_removeTile: function(key) {
|
|
const tile = this._tiles[key];
|
|
if (!tile) {
|
|
return;
|
|
}
|
|
if (tile.el.cancel)
|
|
tile.el.cancel();
|
|
tile.el.width = 0;
|
|
tile.el.height = 0;
|
|
tile.el.deleted = true;
|
|
L.DomUtil.remove(tile.el);
|
|
delete this._tiles[key];
|
|
this.fire("tileunload", {
|
|
tile: tile.el,
|
|
coords: this._keyToTileCoords(key)
|
|
});
|
|
}
|
|
});
|
|
return new cls(options);
|
|
};
|
|
var Protocol = class {
|
|
constructor() {
|
|
this.tile = (params, callback) => {
|
|
if (params.type == "json") {
|
|
const pmtiles_url = params.url.substr(10);
|
|
let instance = this.tiles.get(pmtiles_url);
|
|
if (!instance) {
|
|
instance = new PMTiles(pmtiles_url);
|
|
this.tiles.set(pmtiles_url, instance);
|
|
}
|
|
instance.getHeader().then((h) => {
|
|
const tilejson = {
|
|
tiles: [params.url + "/{z}/{x}/{y}"],
|
|
minzoom: h.minZoom,
|
|
maxzoom: h.maxZoom
|
|
};
|
|
callback(null, tilejson, null, null);
|
|
});
|
|
return {
|
|
cancel: () => {
|
|
}
|
|
};
|
|
} else {
|
|
const re = new RegExp(/pmtiles:\/\/(.+)\/(\d+)\/(\d+)\/(\d+)/);
|
|
const result = params.url.match(re);
|
|
if (!result) {
|
|
throw new Error("Invalid PMTiles protocol URL");
|
|
return {
|
|
cancel: () => {
|
|
}
|
|
};
|
|
}
|
|
const pmtiles_url = result[1];
|
|
let instance = this.tiles.get(pmtiles_url);
|
|
if (!instance) {
|
|
instance = new PMTiles(pmtiles_url);
|
|
this.tiles.set(pmtiles_url, instance);
|
|
}
|
|
const z = result[2];
|
|
const x = result[3];
|
|
const y = result[4];
|
|
const controller = new AbortController();
|
|
const signal = controller.signal;
|
|
let cancel = () => {
|
|
controller.abort();
|
|
};
|
|
instance.getHeader().then((header) => {
|
|
instance.getZxy(+z, +x, +y, signal).then((resp) => {
|
|
if (resp) {
|
|
callback(null, new Uint8Array(resp.data), resp.cacheControl, resp.expires);
|
|
} else {
|
|
if (header.tileType == TileType.Mvt) {
|
|
callback(null, new Uint8Array(), null, null);
|
|
} else {
|
|
callback(null, null, null, null);
|
|
}
|
|
}
|
|
}).catch((e) => {
|
|
if (e.name !== "AbortError") {
|
|
throw e;
|
|
}
|
|
});
|
|
});
|
|
return {
|
|
cancel
|
|
};
|
|
}
|
|
};
|
|
this.tiles = new Map();
|
|
}
|
|
add(p) {
|
|
this.tiles.set(p.source.getKey(), p);
|
|
}
|
|
get(url) {
|
|
return this.tiles.get(url);
|
|
}
|
|
};
|
|
|
|
// index.ts
|
|
function toNum(low, high) {
|
|
return (high >>> 0) * 4294967296 + (low >>> 0);
|
|
}
|
|
function readVarintRemainder(l, p) {
|
|
const buf = p.buf;
|
|
let h, b;
|
|
b = buf[p.pos++];
|
|
h = (b & 112) >> 4;
|
|
if (b < 128)
|
|
return toNum(l, h);
|
|
b = buf[p.pos++];
|
|
h |= (b & 127) << 3;
|
|
if (b < 128)
|
|
return toNum(l, h);
|
|
b = buf[p.pos++];
|
|
h |= (b & 127) << 10;
|
|
if (b < 128)
|
|
return toNum(l, h);
|
|
b = buf[p.pos++];
|
|
h |= (b & 127) << 17;
|
|
if (b < 128)
|
|
return toNum(l, h);
|
|
b = buf[p.pos++];
|
|
h |= (b & 127) << 24;
|
|
if (b < 128)
|
|
return toNum(l, h);
|
|
b = buf[p.pos++];
|
|
h |= (b & 1) << 31;
|
|
if (b < 128)
|
|
return toNum(l, h);
|
|
throw new Error("Expected varint not more than 10 bytes");
|
|
}
|
|
function readVarint(p) {
|
|
const buf = p.buf;
|
|
let val, b;
|
|
b = buf[p.pos++];
|
|
val = b & 127;
|
|
if (b < 128)
|
|
return val;
|
|
b = buf[p.pos++];
|
|
val |= (b & 127) << 7;
|
|
if (b < 128)
|
|
return val;
|
|
b = buf[p.pos++];
|
|
val |= (b & 127) << 14;
|
|
if (b < 128)
|
|
return val;
|
|
b = buf[p.pos++];
|
|
val |= (b & 127) << 21;
|
|
if (b < 128)
|
|
return val;
|
|
b = buf[p.pos];
|
|
val |= (b & 15) << 28;
|
|
return readVarintRemainder(val, p);
|
|
}
|
|
function rotate(n, xy, rx, ry) {
|
|
if (ry == 0) {
|
|
if (rx == 1) {
|
|
xy[0] = n - 1 - xy[0];
|
|
xy[1] = n - 1 - xy[1];
|
|
}
|
|
const t = xy[0];
|
|
xy[0] = xy[1];
|
|
xy[1] = t;
|
|
}
|
|
}
|
|
function idOnLevel(z, pos) {
|
|
const n = 1 << z;
|
|
let rx = pos;
|
|
let ry = pos;
|
|
let t = pos;
|
|
const xy = [0, 0];
|
|
let s = 1;
|
|
while (s < n) {
|
|
rx = 1 & t / 2 >> 0;
|
|
ry = 1 & (t ^ rx);
|
|
rotate(s, xy, rx, ry);
|
|
xy[0] += s * rx;
|
|
xy[1] += s * ry;
|
|
t = t / 4 >> 0;
|
|
s *= 2;
|
|
}
|
|
return [z, xy[0], xy[1]];
|
|
}
|
|
function zxyToTileId(z, x, y) {
|
|
let acc = 0;
|
|
let tz = 0;
|
|
while (tz < z) {
|
|
acc += (1 << tz) * (1 << tz);
|
|
tz++;
|
|
}
|
|
const n = 1 << z;
|
|
let rx = 0;
|
|
let ry = 0;
|
|
let d = 0;
|
|
const xy = [x, y];
|
|
let s = n / 2 >> 0;
|
|
while (s > 0) {
|
|
rx = (xy[0] & s) > 0 ? 1 : 0;
|
|
ry = (xy[1] & s) > 0 ? 1 : 0;
|
|
d += s * s * (3 * rx ^ ry);
|
|
rotate(s, xy, rx, ry);
|
|
s = s / 2 >> 0;
|
|
}
|
|
return acc + d;
|
|
}
|
|
function tileIdToZxy(i) {
|
|
let acc = 0;
|
|
let z = 0;
|
|
for (; ; ) {
|
|
const num_tiles = (1 << z) * (1 << z);
|
|
if (acc + num_tiles > i) {
|
|
return idOnLevel(z, i - acc);
|
|
}
|
|
acc += num_tiles;
|
|
z++;
|
|
}
|
|
}
|
|
var Compression;
|
|
(function(Compression2) {
|
|
Compression2[Compression2["Unknown"] = 0] = "Unknown";
|
|
Compression2[Compression2["None"] = 1] = "None";
|
|
Compression2[Compression2["Gzip"] = 2] = "Gzip";
|
|
Compression2[Compression2["Brotli"] = 3] = "Brotli";
|
|
Compression2[Compression2["Zstd"] = 4] = "Zstd";
|
|
})(Compression || (Compression = {}));
|
|
function fflateDecompress(buf, compression) {
|
|
return __async(this, null, function* () {
|
|
if (compression === 1 || compression === 0) {
|
|
return buf;
|
|
} else if (compression === 2) {
|
|
return decompressSync(new Uint8Array(buf));
|
|
} else {
|
|
throw Error("Compression method not supported");
|
|
}
|
|
});
|
|
}
|
|
var TileType;
|
|
(function(TileType2) {
|
|
TileType2[TileType2["Unknown"] = 0] = "Unknown";
|
|
TileType2[TileType2["Mvt"] = 1] = "Mvt";
|
|
TileType2[TileType2["Png"] = 2] = "Png";
|
|
TileType2[TileType2["Jpeg"] = 3] = "Jpeg";
|
|
TileType2[TileType2["Webp"] = 4] = "Webp";
|
|
})(TileType || (TileType = {}));
|
|
var HEADER_SIZE_BYTES = 127;
|
|
function findTile(entries, tileId) {
|
|
let m = 0;
|
|
let n = entries.length - 1;
|
|
while (m <= n) {
|
|
const k = n + m >> 1;
|
|
const cmp = tileId - entries[k].tileId;
|
|
if (cmp > 0) {
|
|
m = k + 1;
|
|
} else if (cmp < 0) {
|
|
n = k - 1;
|
|
} else {
|
|
return entries[k];
|
|
}
|
|
}
|
|
if (n >= 0) {
|
|
if (entries[n].runLength === 0) {
|
|
return entries[n];
|
|
}
|
|
if (tileId - entries[n].tileId < entries[n].runLength) {
|
|
return entries[n];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
var FileAPISource = class {
|
|
constructor(file) {
|
|
this.file = file;
|
|
}
|
|
getKey() {
|
|
return this.file.name;
|
|
}
|
|
getBytes(offset, length) {
|
|
return __async(this, null, function* () {
|
|
const blob = this.file.slice(offset, offset + length);
|
|
const a = yield blob.arrayBuffer();
|
|
return {data: a};
|
|
});
|
|
}
|
|
};
|
|
var FetchSource = class {
|
|
constructor(url) {
|
|
this.url = url;
|
|
}
|
|
getKey() {
|
|
return this.url;
|
|
}
|
|
getBytes(offset, length, signal) {
|
|
return __async(this, null, function* () {
|
|
let controller;
|
|
if (!signal) {
|
|
controller = new AbortController();
|
|
signal = controller.signal;
|
|
}
|
|
const resp = yield fetch(this.url, {
|
|
signal,
|
|
headers: {Range: "bytes=" + offset + "-" + (offset + length - 1)}
|
|
});
|
|
if (resp.status >= 300) {
|
|
throw Error("404");
|
|
controller.abort();
|
|
}
|
|
const contentLength = resp.headers.get("Content-Length");
|
|
if (!contentLength || +contentLength !== length) {
|
|
console.error("Content-Length mismatch indicates byte serving not supported; aborting.");
|
|
if (controller)
|
|
controller.abort();
|
|
}
|
|
const a = yield resp.arrayBuffer();
|
|
return {
|
|
data: a,
|
|
etag: resp.headers.get("ETag") || void 0,
|
|
cacheControl: resp.headers.get("Cache-Control") || void 0,
|
|
expires: resp.headers.get("Expires") || void 0
|
|
};
|
|
});
|
|
}
|
|
};
|
|
function bytesToHeader(bytes, etag) {
|
|
const v = new DataView(bytes);
|
|
const spec_version = v.getUint8(7);
|
|
if (spec_version > 3) {
|
|
throw Error(`Archive is spec version ${spec_version} but this library supports up to spec version 3`);
|
|
}
|
|
return {
|
|
specVersion: spec_version,
|
|
rootDirectoryOffset: Number(v.getBigUint64(8, true)),
|
|
rootDirectoryLength: Number(v.getBigUint64(16, true)),
|
|
jsonMetadataOffset: Number(v.getBigUint64(24, true)),
|
|
jsonMetadataLength: Number(v.getBigUint64(32, true)),
|
|
leafDirectoryOffset: Number(v.getBigUint64(40, true)),
|
|
leafDirectoryLength: Number(v.getBigUint64(48, true)),
|
|
tileDataOffset: Number(v.getBigUint64(56, true)),
|
|
tileDataLength: Number(v.getBigUint64(64, true)),
|
|
numAddressedTiles: Number(v.getBigUint64(72, true)),
|
|
numTileEntries: Number(v.getBigUint64(80, true)),
|
|
numTileContents: Number(v.getBigUint64(88, true)),
|
|
clustered: v.getUint8(96) === 1,
|
|
internalCompression: v.getUint8(97),
|
|
tileCompression: v.getUint8(98),
|
|
tileType: v.getUint8(99),
|
|
minZoom: v.getUint8(100),
|
|
maxZoom: v.getUint8(101),
|
|
minLon: v.getInt32(102, true) / 1e7,
|
|
minLat: v.getInt32(106, true) / 1e7,
|
|
maxLon: v.getInt32(110, true) / 1e7,
|
|
maxLat: v.getInt32(114, true) / 1e7,
|
|
centerZoom: v.getUint8(118),
|
|
centerLon: v.getInt32(119, true) / 1e7,
|
|
centerLat: v.getInt32(123, true) / 1e7,
|
|
etag
|
|
};
|
|
}
|
|
function deserializeIndex(buffer) {
|
|
const p = {buf: new Uint8Array(buffer), pos: 0};
|
|
const numEntries = readVarint(p);
|
|
const entries = [];
|
|
let lastId = 0;
|
|
for (let i = 0; i < numEntries; i++) {
|
|
const v = readVarint(p);
|
|
entries.push({tileId: lastId + v, offset: 0, length: 0, runLength: 1});
|
|
lastId += v;
|
|
}
|
|
for (let i = 0; i < numEntries; i++) {
|
|
entries[i].runLength = readVarint(p);
|
|
}
|
|
for (let i = 0; i < numEntries; i++) {
|
|
entries[i].length = readVarint(p);
|
|
}
|
|
for (let i = 0; i < numEntries; i++) {
|
|
const v = readVarint(p);
|
|
if (v === 0 && i > 0) {
|
|
entries[i].offset = entries[i - 1].offset + entries[i - 1].length;
|
|
} else {
|
|
entries[i].offset = v - 1;
|
|
}
|
|
}
|
|
return entries;
|
|
}
|
|
function detectVersion(a) {
|
|
const v = new DataView(a);
|
|
if (v.getUint16(2, true) === 2) {
|
|
console.warn("PMTiles spec version 2 has been deprecated; please see github.com/protomaps/PMTiles for tools to upgrade");
|
|
return 2;
|
|
} else if (v.getUint16(2, true) === 1) {
|
|
console.warn("PMTiles spec version 1 has been deprecated; please see github.com/protomaps/PMTiles for tools to upgrade");
|
|
return 1;
|
|
}
|
|
return 3;
|
|
}
|
|
var EtagMismatch = class extends Error {
|
|
};
|
|
function getHeaderAndRoot(source, decompress, prefetch, current_etag) {
|
|
return __async(this, null, function* () {
|
|
const resp = yield source.getBytes(0, 16384);
|
|
const v = new DataView(resp.data);
|
|
if (v.getUint16(0, true) !== 19792) {
|
|
throw new Error("Wrong magic number for PMTiles archive");
|
|
}
|
|
if (detectVersion(resp.data) < 3) {
|
|
return [yield v2_default.getHeader(source)];
|
|
}
|
|
const headerData = resp.data.slice(0, HEADER_SIZE_BYTES);
|
|
let resp_etag = resp.etag;
|
|
if (current_etag && resp.etag != current_etag) {
|
|
console.warn("ETag conflict detected; your HTTP server might not support content-based ETag headers. ETags disabled for " + source.getKey());
|
|
resp_etag = void 0;
|
|
}
|
|
const header = bytesToHeader(headerData, resp_etag);
|
|
if (prefetch) {
|
|
const rootDirData = resp.data.slice(header.rootDirectoryOffset, header.rootDirectoryOffset + header.rootDirectoryLength);
|
|
const dirKey = source.getKey() + "|" + (header.etag || "") + "|" + header.rootDirectoryOffset + "|" + header.rootDirectoryLength;
|
|
const rootDir = deserializeIndex(yield decompress(rootDirData, header.internalCompression));
|
|
return [header, [dirKey, rootDir.length, rootDir]];
|
|
}
|
|
return [header, void 0];
|
|
});
|
|
}
|
|
function getDirectory(source, decompress, offset, length, header) {
|
|
return __async(this, null, function* () {
|
|
const resp = yield source.getBytes(offset, length);
|
|
if (header.etag && header.etag !== resp.etag) {
|
|
throw new EtagMismatch(resp.etag);
|
|
}
|
|
const data = yield decompress(resp.data, header.internalCompression);
|
|
const directory = deserializeIndex(data);
|
|
if (directory.length === 0) {
|
|
throw new Error("Empty directory is invalid");
|
|
}
|
|
return directory;
|
|
});
|
|
}
|
|
var ResolvedValueCache = class {
|
|
constructor(maxCacheEntries = 100, prefetch = true, decompress = fflateDecompress) {
|
|
this.cache = new Map();
|
|
this.maxCacheEntries = maxCacheEntries;
|
|
this.counter = 1;
|
|
this.prefetch = prefetch;
|
|
this.decompress = decompress;
|
|
}
|
|
getHeader(source, current_etag) {
|
|
return __async(this, null, function* () {
|
|
const cacheKey = source.getKey();
|
|
if (this.cache.has(cacheKey)) {
|
|
this.cache.get(cacheKey).lastUsed = this.counter++;
|
|
const data = this.cache.get(cacheKey).data;
|
|
return data;
|
|
}
|
|
const res = yield getHeaderAndRoot(source, this.decompress, this.prefetch, current_etag);
|
|
if (res[1]) {
|
|
this.cache.set(res[1][0], {
|
|
lastUsed: this.counter++,
|
|
data: res[1][2]
|
|
});
|
|
}
|
|
this.cache.set(cacheKey, {
|
|
lastUsed: this.counter++,
|
|
data: res[0]
|
|
});
|
|
this.prune();
|
|
return res[0];
|
|
});
|
|
}
|
|
getDirectory(source, offset, length, header) {
|
|
return __async(this, null, function* () {
|
|
const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length;
|
|
if (this.cache.has(cacheKey)) {
|
|
this.cache.get(cacheKey).lastUsed = this.counter++;
|
|
const data = this.cache.get(cacheKey).data;
|
|
return data;
|
|
}
|
|
const directory = yield getDirectory(source, this.decompress, offset, length, header);
|
|
this.cache.set(cacheKey, {
|
|
lastUsed: this.counter++,
|
|
data: directory
|
|
});
|
|
this.prune();
|
|
return directory;
|
|
});
|
|
}
|
|
getArrayBuffer(source, offset, length, header) {
|
|
return __async(this, null, function* () {
|
|
const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length;
|
|
if (this.cache.has(cacheKey)) {
|
|
this.cache.get(cacheKey).lastUsed = this.counter++;
|
|
const data = yield this.cache.get(cacheKey).data;
|
|
return data;
|
|
}
|
|
const resp = yield source.getBytes(offset, length);
|
|
if (header.etag && header.etag !== resp.etag) {
|
|
throw new EtagMismatch(header.etag);
|
|
}
|
|
this.cache.set(cacheKey, {
|
|
lastUsed: this.counter++,
|
|
data: resp.data
|
|
});
|
|
this.prune();
|
|
return resp.data;
|
|
});
|
|
}
|
|
prune() {
|
|
if (this.cache.size > this.maxCacheEntries) {
|
|
let minUsed = Infinity;
|
|
let minKey = void 0;
|
|
this.cache.forEach((cache_value, key) => {
|
|
if (cache_value.lastUsed < minUsed) {
|
|
minUsed = cache_value.lastUsed;
|
|
minKey = key;
|
|
}
|
|
});
|
|
if (minKey) {
|
|
this.cache.delete(minKey);
|
|
}
|
|
}
|
|
}
|
|
invalidate(source, current_etag) {
|
|
return __async(this, null, function* () {
|
|
this.cache.delete(source.getKey());
|
|
yield this.getHeader(source, current_etag);
|
|
});
|
|
}
|
|
};
|
|
var SharedPromiseCache = class {
|
|
constructor(maxCacheEntries = 100, prefetch = true, decompress = fflateDecompress) {
|
|
this.cache = new Map();
|
|
this.maxCacheEntries = maxCacheEntries;
|
|
this.counter = 1;
|
|
this.prefetch = prefetch;
|
|
this.decompress = decompress;
|
|
}
|
|
getHeader(source, current_etag) {
|
|
return __async(this, null, function* () {
|
|
const cacheKey = source.getKey();
|
|
if (this.cache.has(cacheKey)) {
|
|
this.cache.get(cacheKey).lastUsed = this.counter++;
|
|
const data = yield this.cache.get(cacheKey).data;
|
|
return data;
|
|
}
|
|
const p = new Promise((resolve, reject) => {
|
|
getHeaderAndRoot(source, this.decompress, this.prefetch, current_etag).then((res) => {
|
|
if (res[1]) {
|
|
this.cache.set(res[1][0], {
|
|
lastUsed: this.counter++,
|
|
data: Promise.resolve(res[1][2])
|
|
});
|
|
}
|
|
resolve(res[0]);
|
|
this.prune();
|
|
}).catch((e) => {
|
|
reject(e);
|
|
});
|
|
});
|
|
this.cache.set(cacheKey, {lastUsed: this.counter++, data: p});
|
|
return p;
|
|
});
|
|
}
|
|
getDirectory(source, offset, length, header) {
|
|
return __async(this, null, function* () {
|
|
const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length;
|
|
if (this.cache.has(cacheKey)) {
|
|
this.cache.get(cacheKey).lastUsed = this.counter++;
|
|
const data = yield this.cache.get(cacheKey).data;
|
|
return data;
|
|
}
|
|
const p = new Promise((resolve, reject) => {
|
|
getDirectory(source, this.decompress, offset, length, header).then((directory) => {
|
|
resolve(directory);
|
|
this.prune();
|
|
}).catch((e) => {
|
|
reject(e);
|
|
});
|
|
});
|
|
this.cache.set(cacheKey, {lastUsed: this.counter++, data: p});
|
|
return p;
|
|
});
|
|
}
|
|
getArrayBuffer(source, offset, length, header) {
|
|
return __async(this, null, function* () {
|
|
const cacheKey = source.getKey() + "|" + (header.etag || "") + "|" + offset + "|" + length;
|
|
if (this.cache.has(cacheKey)) {
|
|
this.cache.get(cacheKey).lastUsed = this.counter++;
|
|
const data = yield this.cache.get(cacheKey).data;
|
|
return data;
|
|
}
|
|
const p = new Promise((resolve, reject) => {
|
|
source.getBytes(offset, length).then((resp) => {
|
|
if (header.etag && header.etag !== resp.etag) {
|
|
throw new EtagMismatch(resp.etag);
|
|
}
|
|
resolve(resp.data);
|
|
if (this.cache.has(cacheKey)) {
|
|
}
|
|
this.prune();
|
|
}).catch((e) => {
|
|
reject(e);
|
|
});
|
|
});
|
|
this.cache.set(cacheKey, {lastUsed: this.counter++, data: p});
|
|
return p;
|
|
});
|
|
}
|
|
prune() {
|
|
if (this.cache.size >= this.maxCacheEntries) {
|
|
let minUsed = Infinity;
|
|
let minKey = void 0;
|
|
this.cache.forEach((cache_value, key) => {
|
|
if (cache_value.lastUsed < minUsed) {
|
|
minUsed = cache_value.lastUsed;
|
|
minKey = key;
|
|
}
|
|
});
|
|
if (minKey) {
|
|
this.cache.delete(minKey);
|
|
}
|
|
}
|
|
}
|
|
invalidate(source, current_etag) {
|
|
return __async(this, null, function* () {
|
|
this.cache.delete(source.getKey());
|
|
yield this.getHeader(source, current_etag);
|
|
});
|
|
}
|
|
};
|
|
var PMTiles = class {
|
|
constructor(source, cache, decompress) {
|
|
if (typeof source === "string") {
|
|
this.source = new FetchSource(source);
|
|
} else {
|
|
this.source = source;
|
|
}
|
|
if (decompress) {
|
|
this.decompress = decompress;
|
|
} else {
|
|
this.decompress = fflateDecompress;
|
|
}
|
|
if (cache) {
|
|
this.cache = cache;
|
|
} else {
|
|
this.cache = new SharedPromiseCache();
|
|
}
|
|
}
|
|
root_entries() {
|
|
return __async(this, null, function* () {
|
|
const header = yield this.cache.getHeader(this.source);
|
|
if (header.specVersion < 3) {
|
|
return [];
|
|
}
|
|
return yield this.cache.getDirectory(this.source, header.rootDirectoryOffset, header.rootDirectoryLength, header);
|
|
});
|
|
}
|
|
getHeader() {
|
|
return __async(this, null, function* () {
|
|
return yield this.cache.getHeader(this.source);
|
|
});
|
|
}
|
|
getZxyAttempt(z, x, y, signal) {
|
|
return __async(this, null, function* () {
|
|
const tile_id = zxyToTileId(z, x, y);
|
|
const header = yield this.cache.getHeader(this.source);
|
|
if (header.specVersion < 3) {
|
|
return v2_default.getZxy(header, this.source, this.cache, z, x, y, signal);
|
|
}
|
|
if (z < header.minZoom || z > header.maxZoom) {
|
|
return void 0;
|
|
}
|
|
let d_o = header.rootDirectoryOffset;
|
|
let d_l = header.rootDirectoryLength;
|
|
for (let depth = 0; depth <= 3; depth++) {
|
|
const directory = yield this.cache.getDirectory(this.source, d_o, d_l, header);
|
|
const entry = findTile(directory, tile_id);
|
|
if (entry) {
|
|
if (entry.runLength > 0) {
|
|
const resp = yield this.source.getBytes(header.tileDataOffset + entry.offset, entry.length, signal);
|
|
if (header.etag && header.etag !== resp.etag) {
|
|
throw new EtagMismatch(resp.etag);
|
|
}
|
|
return {
|
|
data: yield this.decompress(resp.data, header.tileCompression),
|
|
cacheControl: resp.cacheControl,
|
|
expires: resp.expires
|
|
};
|
|
} else {
|
|
d_o = header.leafDirectoryOffset + entry.offset;
|
|
d_l = entry.length;
|
|
}
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
throw Error("Maximum directory depth exceeded");
|
|
});
|
|
}
|
|
getZxy(z, x, y, signal) {
|
|
return __async(this, null, function* () {
|
|
try {
|
|
return yield this.getZxyAttempt(z, x, y, signal);
|
|
} catch (e) {
|
|
if (e instanceof EtagMismatch) {
|
|
this.cache.invalidate(this.source, e.message);
|
|
return yield this.getZxyAttempt(z, x, y, signal);
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
getMetadataAttempt() {
|
|
return __async(this, null, function* () {
|
|
const header = yield this.cache.getHeader(this.source);
|
|
const resp = yield this.source.getBytes(header.jsonMetadataOffset, header.jsonMetadataLength);
|
|
if (header.etag && header.etag !== resp.etag) {
|
|
throw new EtagMismatch(resp.etag);
|
|
}
|
|
const decompressed = yield this.decompress(resp.data, header.internalCompression);
|
|
const dec = new TextDecoder("utf-8");
|
|
return JSON.parse(dec.decode(decompressed));
|
|
});
|
|
}
|
|
getMetadata() {
|
|
return __async(this, null, function* () {
|
|
try {
|
|
return yield this.getMetadataAttempt();
|
|
} catch (e) {
|
|
if (e instanceof EtagMismatch) {
|
|
this.cache.invalidate(this.source, e.message);
|
|
return yield this.getMetadataAttempt();
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
return js_exports;
|
|
})(); |