ts-maps 0.3.1 → 0.3.3

package/dist/core-map/symbols/index.js

@@ -40,24 +40,39 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 // src/core-map/symbols/CollisionIndex.ts
 class CollisionIndex {
   _cellSize;
-  _cols;
-  _rows;
   _cells;
+  _ownerCells;
   constructor(opts) {
     this._cellSize = opts?.cellSize ?? 64;
-    const width = opts?.width ?? 1;
-    const height = opts?.height ?? 1;
-    this._cols = Math.max(1, Math.ceil(width / this._cellSize));
-    this._rows = Math.max(1, Math.ceil(height / this._cellSize));
-    this._cells = [];
-    for (let i = 0;i < this._cols * this._rows; i++)
-      this._cells.push([]);
+    this._cells = new Map;
+    this._ownerCells = new Map;
+  }
+  hits(box) {
+    const range = this._cellRange(box);
+    for (let cy = range.y0;cy <= range.y1; cy++) {
+      for (let cx = range.x0;cx <= range.x1; cx++) {
+        const bucket = this._cells.get(cellKey(cx, cy));
+        if (!bucket)
+          continue;
+        for (const other of bucket) {
+          if (!overlaps(box, other))
+            continue;
+          if (other.priority === undefined || box.priority === undefined)
+            return true;
+          if (other.priority >= box.priority)
+            return true;
+        }
+      }
+    }
+    return false;
   }
   tryInsert(box) {
     const range = this._cellRange(box);
     for (let cy = range.y0;cy <= range.y1; cy++) {
       for (let cx = range.x0;cx <= range.x1; cx++) {
-        const bucket = this._cells[cy * this._cols + cx];
+        const bucket = this._cells.get(cellKey(cx, cy));
+        if (!bucket)
+          continue;
         for (const other of bucket) {
           if (!overlaps(box, other))
             continue;
@@ -74,38 +89,68 @@ class CollisionIndex {
   insert(box) {
     this._insertBucketed(box, this._cellRange(box));
   }
+  removeOwner(owner) {
+    const cells = this._ownerCells.get(owner);
+    if (!cells)
+      return;
+    for (const key of cells) {
+      const bucket = this._cells.get(key);
+      if (!bucket)
+        continue;
+      const kept = bucket.filter((box) => box.owner !== owner);
+      if (kept.length)
+        this._cells.set(key, kept);
+      else
+        this._cells.delete(key);
+    }
+    this._ownerCells.delete(owner);
+  }
   clear() {
-    for (let i = 0;i < this._cells.length; i++)
-      this._cells[i] = [];
+    this._cells.clear();
+    this._ownerCells.clear();
+  }
+  get size() {
+    const seen = new Set;
+    for (const bucket of this._cells.values()) {
+      for (const box of bucket)
+        seen.add(box);
+    }
+    return seen.size;
   }
   _cellRange(box) {
     const cs = this._cellSize;
-    let x0 = Math.floor(box.minX / cs);
-    let y0 = Math.floor(box.minY / cs);
-    let x1 = Math.floor(box.maxX / cs);
-    let y1 = Math.floor(box.maxY / cs);
-    if (x0 < 0)
-      x0 = 0;
-    if (y0 < 0)
-      y0 = 0;
-    if (x1 > this._cols - 1)
-      x1 = this._cols - 1;
-    if (y1 > this._rows - 1)
-      y1 = this._rows - 1;
-    if (x1 < x0)
-      x1 = x0;
-    if (y1 < y0)
-      y1 = y0;
-    return { x0, y0, x1, y1 };
+    return {
+      x0: Math.floor(box.minX / cs),
+      y0: Math.floor(box.minY / cs),
+      x1: Math.floor(box.maxX / cs),
+      y1: Math.floor(box.maxY / cs)
+    };
   }
   _insertBucketed(box, range) {
+    let ownerCells;
+    if (box.owner !== undefined) {
+      ownerCells = this._ownerCells.get(box.owner);
+      if (!ownerCells) {
+        ownerCells = new Set;
+        this._ownerCells.set(box.owner, ownerCells);
+      }
+    }
     for (let cy = range.y0;cy <= range.y1; cy++) {
       for (let cx = range.x0;cx <= range.x1; cx++) {
-        this._cells[cy * this._cols + cx].push(box);
+        const key = cellKey(cx, cy);
+        const bucket = this._cells.get(key);
+        if (bucket)
+          bucket.push(box);
+        else
+          this._cells.set(key, [box]);
+        ownerCells?.add(key);
       }
     }
   }
 }
+function cellKey(x, y) {
+  return `${x}:${y}`;
+}
 function overlaps(a, b) {
   if (a.maxX < b.minX)
     return false;
@@ -119,6 +164,10 @@ function overlaps(a, b) {
 }
 
 // src/core-map/symbols/GlyphAtlas.ts
+var exports_GlyphAtlas = {};
+__export(exports_GlyphAtlas, {
+  GlyphAtlas: () => GlyphAtlas
+});
 function styleKey(k) {
   if (!k)
     return "r";
@@ -141,7 +190,7 @@ class GlyphAtlas {
   constructor(opts) {
     this._fontFamily = opts?.fontFamily ?? "system-ui, -apple-system, Segoe UI, Roboto";
     this._fontSize = opts?.fontSize ?? 24;
-    this._padding = opts?.padding ?? 4;
+    this._padding = opts?.padding ?? 8;
     const bucketSize = opts?.bucketSize ?? 512;
     this.canvas = document.createElement("canvas");
     this.canvas.width = bucketSize;
@@ -175,19 +224,105 @@ class GlyphAtlas {
     }
     return { width, height };
   }
-  drawText(ctx, text, x, y, options) {
-    const style = { italic: !!options.italic, bold: !!options.bold };
-    const scale = options.size / this._fontSize;
-    if (options.haloColor && options.haloWidth && options.haloWidth > 0) {
+  advances(text, size, style) {
+    const ctx = this._ctx;
+    const out = [];
+    if (ctx) {
       ctx.save();
-      ctx.globalCompositeOperation = "destination-over";
-      ctx.fillStyle = options.haloColor;
-      this._drawRun(ctx, text, x, y, scale, style, options.haloWidth);
+      ctx.font = this.fontString(size, style);
+      for (const ch of text)
+        out.push({ char: ch, advance: ctx.measureText(ch).width });
       ctx.restore();
+      return out;
+    }
+    const scale = size / this._fontSize;
+    for (const ch of text) {
+      const cp = ch.codePointAt(0) ?? 0;
+      const g = this.getOrAddGlyph(cp, style);
+      out.push({ char: ch, advance: g.advance * scale });
+    }
+    return out;
+  }
+  measureText(text, size, style) {
+    const ctx = this._ctx;
+    if (!ctx) {
+      const atlas = this.measure(text, style);
+      const scale = size / this._fontSize;
+      const height = atlas.height * scale;
+      return { width: atlas.width * scale, height, ascent: height * 0.8, descent: height * 0.2 };
     }
     ctx.save();
+    ctx.font = this.fontString(size, style);
+    const m = ctx.measureText(text);
+    ctx.restore();
+    const ascent = m.fontBoundingBoxAscent || m.actualBoundingBoxAscent || size * 0.8;
+    const descent = m.fontBoundingBoxDescent || m.actualBoundingBoxDescent || size * 0.2;
+    return { width: m.width, height: ascent + descent, ascent, descent };
+  }
+  fontString(size, style) {
+    const parts = [];
+    if (style?.italic)
+      parts.push("italic");
+    if (style?.bold)
+      parts.push("700");
+    parts.push(`${size}px`, style?.family || this._fontFamily);
+    return parts.join(" ");
+  }
+  resolveFont(textFont) {
+    const names = Array.isArray(textFont) ? textFont : textFont ? [textFont] : [];
+    if (!names.length)
+      return { family: this._fontFamily, bold: false, italic: false };
+    let bold = false;
+    let italic = false;
+    const families = [];
+    for (const raw of names) {
+      if (typeof raw !== "string" || !raw)
+        continue;
+      let name = raw;
+      for (const [token, apply] of [
+        ["Semibold", () => {
+          bold = true;
+        }],
+        ["Bold", () => {
+          bold = true;
+        }],
+        ["Italic", () => {
+          italic = true;
+        }],
+        ["Oblique", () => {
+          italic = true;
+        }],
+        ["Regular", () => {}],
+        ["Medium", () => {}],
+        ["Light", () => {}]
+      ]) {
+        if (name.includes(token)) {
+          apply();
+          name = name.replace(token, "");
+        }
+      }
+      const cleaned = name.replace(/\s+/g, " ").trim();
+      if (cleaned)
+        families.push(cleaned.includes(" ") ? `"${cleaned}"` : cleaned);
+    }
+    families.push(this._fontFamily);
+    return { family: families.join(", "), bold, italic };
+  }
+  drawText(ctx, text, x, y, options) {
+    const style = { italic: !!options.italic, bold: !!options.bold, family: options.family };
+    ctx.save();
+    ctx.font = this.fontString(options.size, style);
+    ctx.textAlign = "left";
+    ctx.textBaseline = "alphabetic";
+    if (options.haloColor && options.haloWidth && options.haloWidth > 0) {
+      ctx.strokeStyle = options.haloColor;
+      ctx.lineWidth = options.haloWidth * 2;
+      ctx.lineJoin = "round";
+      ctx.miterLimit = 2;
+      ctx.strokeText(text, x, y);
+    }
     ctx.fillStyle = options.color;
-    this._drawRun(ctx, text, x, y, scale, style, 0);
+    ctx.fillText(text, x, y);
     ctx.restore();
   }
   _buildSDF(imageData) {
@@ -195,23 +330,23 @@ class GlyphAtlas {
     const h = imageData.height;
     const radius = this._padding;
     const INF = 1 << 20;
-    const inside = new Int32Array(w * h);
-    const outside = new Int32Array(w * h);
+    const depthInside = new Int32Array(w * h);
+    const distanceToInk = new Int32Array(w * h);
     for (let i = 0;i < w * h; i++) {
       const a = imageData.data[i * 4 + 3];
       if (a >= 128) {
-        outside[i] = INF;
-        inside[i] = 0;
+        depthInside[i] = INF;
+        distanceToInk[i] = 0;
       } else {
-        outside[i] = 0;
-        inside[i] = INF;
+        depthInside[i] = 0;
+        distanceToInk[i] = INF;
       }
     }
-    chamfer34(outside, w, h);
-    chamfer34(inside, w, h);
+    chamfer34(depthInside, w, h);
+    chamfer34(distanceToInk, w, h);
     const out = createImageData(w, h);
     for (let i = 0;i < w * h; i++) {
-      const d = (outside[i] - inside[i]) / 3;
+      const d = (distanceToInk[i] - depthInside[i]) / 3;
       let v = 128 - d / radius * 128;
       if (v < 0)
         v = 0;
@@ -224,21 +359,6 @@ class GlyphAtlas {
     }
     return out;
   }
-  _drawRun(ctx, text, x, y, scale, style, haloInflate) {
-    let pen = x;
-    for (const ch of text) {
-      const cp = ch.codePointAt(0) ?? 0;
-      const g = this.getOrAddGlyph(cp, style);
-      if (g.width > 0 && g.height > 0) {
-        const dx = pen + g.bearingX * scale - haloInflate;
-        const dy = y - g.bearingY * scale - haloInflate;
-        const dw = g.width * scale + haloInflate * 2;
-        const dh = g.height * scale + haloInflate * 2;
-        ctx.drawImage(this.canvas, g.x, g.y, g.width, g.height, dx, dy, dw, dh);
-      }
-      pen += g.advance * scale;
-    }
-  }
   _rasterize(key) {
     const ctx = this._ctx;
     if (!ctx) {
@@ -397,6 +517,81 @@ function chamfer34(buf, w, h) {
   }
 }
 
+// src/core-map/symbols/sdf.ts
+function renderSdfPixels(field, width, height, options) {
+  const out = new Uint8ClampedArray(width * height * 4);
+  const fill = parseColor(options.color);
+  const haloWidth = options.haloWidth ?? 0;
+  const halo = options.haloColor && haloWidth > 0 ? parseColor(options.haloColor) : null;
+  const haloEdge = halo ? Math.max(0.02, 0.5 - haloWidth / 16) : 0;
+  const band = 0.06;
+  for (let i = 0;i < width * height; i++) {
+    const distance = field[i * 4 + 3] / 255;
+    const inside = smoothstep(0.5 - band, 0.5 + band, distance);
+    const outline = halo ? smoothstep(haloEdge - band, haloEdge + band, distance) : 0;
+    const alpha = inside + outline * (1 - inside);
+    if (alpha <= 0)
+      continue;
+    const weight = outline * (1 - inside);
+    out[i * 4] = halo ? (fill[0] * inside + halo[0] * weight) / alpha : fill[0];
+    out[i * 4 + 1] = halo ? (fill[1] * inside + halo[1] * weight) / alpha : fill[1];
+    out[i * 4 + 2] = halo ? (fill[2] * inside + halo[2] * weight) / alpha : fill[2];
+    out[i * 4 + 3] = Math.round(alpha * 255);
+  }
+  return out;
+}
+function smoothstep(edge0, edge1, x) {
+  if (edge1 <= edge0)
+    return x < edge0 ? 0 : 1;
+  const t = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));
+  return t * t * (3 - 2 * t);
+}
+function parseColor(color) {
+  const text = color.trim();
+  const hex = /^#([0-9a-f]{3,8})$/i.exec(text);
+  if (hex) {
+    let body = hex[1];
+    if (body.length === 3 || body.length === 4)
+      body = body.slice(0, 3).split("").map((c) => c + c).join("");
+    if (body.length < 6)
+      return [0, 0, 0];
+    const n = Number.parseInt(body.slice(0, 6), 16);
+    return [n >> 16 & 255, n >> 8 & 255, n & 255];
+  }
+  const rgb = /^rgba?\(([^)]+)\)$/i.exec(text);
+  if (rgb) {
+    const parts = rgb[1].split(/[,/\s]+/).filter(Boolean);
+    if (parts.length >= 3) {
+      const channel = (value) => {
+        const n = Number.parseFloat(value);
+        if (Number.isNaN(n))
+          return 0;
+        return Math.max(0, Math.min(255, Math.round(value.includes("%") ? n / 100 * 255 : n)));
+      };
+      return [channel(parts[0]), channel(parts[1]), channel(parts[2])];
+    }
+  }
+  return probeColor(text);
+}
+function probeColor(color) {
+  if (typeof document === "undefined")
+    return [0, 0, 0];
+  const probe = document.createElement("canvas");
+  probe.width = 1;
+  probe.height = 1;
+  const ctx = probe.getContext("2d");
+  if (!ctx)
+    return [0, 0, 0];
+  ctx.fillStyle = color;
+  ctx.fillRect(0, 0, 1, 1);
+  try {
+    const data = ctx.getImageData(0, 0, 1, 1).data;
+    return [data[0], data[1], data[2]];
+  } catch {
+    return [0, 0, 0];
+  }
+}
+
 // src/core-map/symbols/IconAtlas.ts
 class IconAtlas {
   canvas;
@@ -405,6 +600,7 @@ class IconAtlas {
   _cursorX;
   _cursorY;
   _rowH;
+  _sdfCache;
   constructor() {
     this.canvas = document.createElement("canvas");
     this.canvas.width = 512;
@@ -414,6 +610,7 @@ class IconAtlas {
     this._cursorX = 0;
     this._cursorY = 0;
     this._rowH = 0;
+    this._sdfCache = new Map;
   }
   addSprite(entry, source) {
     const w = entry.width;
@@ -448,7 +645,8 @@ class IconAtlas {
       y: dy,
       width: w,
       height: h,
-      pixelRatio: entry.pixelRatio ?? 1
+      pixelRatio: entry.pixelRatio ?? 1,
+      sdf: entry.sdf
     };
     this._sprites.set(entry.id, packed);
     this._cursorX += w;
@@ -466,15 +664,54 @@ class IconAtlas {
     const scale = target / s.width;
     const w = s.width * scale;
     const h = s.height * scale;
+    const source = s.sdf ? this._renderSdf(s, opts) : this.canvas;
+    const sx = source === this.canvas ? s.x : 0;
+    const sy = source === this.canvas ? s.y : 0;
+    const previousAlpha = ctx.globalAlpha;
+    const opacity = opts?.opacity;
+    if (opacity !== undefined && opacity < 1)
+      ctx.globalAlpha = previousAlpha * Math.max(0, opacity);
     if (opts?.rotation) {
       ctx.save();
       ctx.translate(dx, dy);
       ctx.rotate(opts.rotation);
-      ctx.drawImage(this.canvas, s.x, s.y, s.width, s.height, -w / 2, -h / 2, w, h);
+      ctx.drawImage(source, sx, sy, s.width, s.height, -w / 2, -h / 2, w, h);
       ctx.restore();
     } else {
-      ctx.drawImage(this.canvas, s.x, s.y, s.width, s.height, dx - w / 2, dy - h / 2, w, h);
+      ctx.drawImage(source, sx, sy, s.width, s.height, dx - w / 2, dy - h / 2, w, h);
     }
+    ctx.globalAlpha = previousAlpha;
+  }
+  _renderSdf(entry, opts) {
+    const color = opts?.color ?? "#000000";
+    const haloColor = opts?.haloColor;
+    const haloWidth = opts?.haloWidth ?? 0;
+    const key = `${entry.id}|${color}|${haloColor ?? ""}|${haloWidth}`;
+    const cached = this._sdfCache.get(key);
+    if (cached)
+      return cached;
+    const w = entry.width;
+    const h = entry.height;
+    const out = document.createElement("canvas");
+    out.width = w;
+    out.height = h;
+    const octx = out.getContext("2d");
+    const src = this._ctx;
+    if (!octx || !src)
+      return out;
+    let field;
+    try {
+      field = src.getImageData(entry.x, entry.y, w, h);
+    } catch {
+      return out;
+    }
+    const pixels = octx.createImageData(w, h);
+    pixels.data.set(renderSdfPixels(field.data, w, h, { color, haloColor, haloWidth }));
+    octx.putImageData(pixels, 0, 0);
+    if (this._sdfCache.size > 128)
+      this._sdfCache.clear();
+    this._sdfCache.set(key, out);
+    return out;
   }
   _grow(newSide) {
     const old = this.canvas;
@@ -494,8 +731,775 @@ function isImageData(v) {
   const anyV = v;
   return typeof anyV.width === "number" && typeof anyV.height === "number" && (anyV.data instanceof Uint8ClampedArray || anyV.data instanceof Uint8Array);
 }
+var init_IconAtlas = () => {};
+
+// src/core-map/proto/Pbf.ts
+class Pbf {
+  buf;
+  pos;
+  type;
+  length;
+  _view;
+  constructor(buf) {
+    if (buf instanceof Uint8Array) {
+      this.buf = buf;
+    } else if (buf instanceof ArrayBuffer) {
+      this.buf = new Uint8Array(buf);
+    } else {
+      this.buf = new Uint8Array(0);
+    }
+    this.pos = 0;
+    this.type = 0;
+    this.length = this.buf.length;
+    this._view = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.byteLength);
+  }
+  readFields(readField, result, end) {
+    const endPos = end === undefined ? this.length : end;
+    while (this.pos < endPos) {
+      const val = this.readVarint();
+      const tag = val >> 3;
+      const startPos = this.pos;
+      this.type = val & 7;
+      readField(tag, result, this);
+      if (this.pos === startPos)
+        this.skip(val);
+    }
+    return result;
+  }
+  readMessage(readField, result) {
+    return this.readFields(readField, result, this.readVarint() + this.pos);
+  }
+  readFixed32() {
+    const val = this._view.getUint32(this.pos, true);
+    this.pos += 4;
+    return val;
+  }
+  readSFixed32() {
+    const val = this._view.getInt32(this.pos, true);
+    this.pos += 4;
+    return val;
+  }
+  readFixed64() {
+    const lo = this._view.getUint32(this.pos, true);
+    const hi = this._view.getUint32(this.pos + 4, true);
+    this.pos += 8;
+    return hi * SHIFT_LEFT_32 + lo;
+  }
+  readSFixed64() {
+    const lo = this._view.getUint32(this.pos, true);
+    const hi = this._view.getInt32(this.pos + 4, true);
+    this.pos += 8;
+    return hi * SHIFT_LEFT_32 + lo;
+  }
+  readFloat() {
+    const val = this._view.getFloat32(this.pos, true);
+    this.pos += 4;
+    return val;
+  }
+  readDouble() {
+    const val = this._view.getFloat64(this.pos, true);
+    this.pos += 8;
+    return val;
+  }
+  readVarint(isSigned) {
+    const buf = this.buf;
+    let val;
+    let 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 >>> 0;
+    b = buf[this.pos];
+    return readVarintRemainder(val >>> 0, isSigned === true, this);
+  }
+  readVarint64() {
+    return this.readVarint(true);
+  }
+  readSVarint() {
+    const n = this.readVarint();
+    return n % 2 === 1 ? (n + 1) / -2 : n / 2;
+  }
+  readBoolean() {
+    return Boolean(this.readVarint());
+  }
+  readString() {
+    const end = this.readVarint() + this.pos;
+    const start = this.pos;
+    this.pos = end;
+    if (utf8Decoder !== null) {
+      return utf8Decoder.decode(this.buf.subarray(start, end));
+    }
+    return manualUtf8Decode(this.buf, start, end);
+  }
+  readBytes() {
+    const end = this.readVarint() + this.pos;
+    const bytes = this.buf.subarray(this.pos, end);
+    this.pos = end;
+    return new Uint8Array(bytes);
+  }
+  readPackedVarint(arr, isSigned) {
+    return readPacked(this, arr, (p) => p.readVarint(isSigned));
+  }
+  readPackedSVarint(arr) {
+    return readPacked(this, arr, (p) => p.readSVarint());
+  }
+  readPackedBoolean(arr) {
+    return readPacked(this, arr, (p) => p.readBoolean());
+  }
+  readPackedFloat(arr) {
+    return readPacked(this, arr, (p) => p.readFloat());
+  }
+  readPackedDouble(arr) {
+    return readPacked(this, arr, (p) => p.readDouble());
+  }
+  readPackedFixed32(arr) {
+    return readPacked(this, arr, (p) => p.readFixed32());
+  }
+  readPackedSFixed32(arr) {
+    return readPacked(this, arr, (p) => p.readSFixed32());
+  }
+  readPackedFixed64(arr) {
+    return readPacked(this, arr, (p) => p.readFixed64());
+  }
+  readPackedSFixed64(arr) {
+    return readPacked(this, arr, (p) => p.readSFixed64());
+  }
+  skip(val) {
+    const type = val & 7;
+    if (type === PBF_VARINT) {
+      while (this.buf[this.pos++] >= 128) {}
+    } else if (type === PBF_BYTES) {
+      this.pos = this.readVarint() + this.pos;
+    } else if (type === PBF_FIXED32) {
+      this.pos += 4;
+    } else if (type === PBF_FIXED64) {
+      this.pos += 8;
+    } else {
+      throw new Error(`Unimplemented wire type: ${type}`);
+    }
+  }
+  writeTag(tag, type) {
+    this.writeVarint(tag << 3 | type);
+  }
+  realloc(min) {
+    let length = Math.max(this.length, 16);
+    while (length < this.pos + min)
+      length *= 2;
+    if (length !== this.buf.length) {
+      const next = new Uint8Array(length);
+      next.set(this.buf);
+      this.buf = next;
+      this._view = new DataView(next.buffer);
+      this.length = length;
+    }
+  }
+  finish() {
+    this.length = this.pos;
+    this.pos = 0;
+    return this.buf.subarray(0, this.length);
+  }
+  destroy() {
+    this.buf = new Uint8Array(0);
+    this._view = new DataView(this.buf.buffer);
+    this.pos = 0;
+    this.length = 0;
+    this.type = 0;
+  }
+  writeVarint(val) {
+    if (val > 268435455 || val < 0) {
+      writeBigVarint(val, this);
+      return;
+    }
+    this.realloc(4);
+    const v = val | 0;
+    this.buf[this.pos++] = v & 127 | (v > 127 ? 128 : 0);
+    if (v <= 127)
+      return;
+    this.buf[this.pos++] = v >>> 7 & 127 | (v > 16383 ? 128 : 0);
+    if (v <= 16383)
+      return;
+    this.buf[this.pos++] = v >>> 14 & 127 | (v > 2097151 ? 128 : 0);
+    if (v <= 2097151)
+      return;
+    this.buf[this.pos++] = v >>> 21 & 127 | (v > 268435455 ? 128 : 0);
+    if (v <= 268435455)
+      return;
+  }
+  writeSVarint(val) {
+    this.writeVarint(val < 0 ? -val * 2 - 1 : val * 2);
+  }
+  writeBoolean(val) {
+    this.writeVarint(val ? 1 : 0);
+  }
+  writeString(str) {
+    const bytes = utf8Encoder !== null ? utf8Encoder.encode(str) : manualUtf8Encode(str);
+    this.writeVarint(bytes.length);
+    this.realloc(bytes.length);
+    this.buf.set(bytes, this.pos);
+    this.pos += bytes.length;
+  }
+  writeFloat(val) {
+    this.realloc(4);
+    this._view.setFloat32(this.pos, val, true);
+    this.pos += 4;
+  }
+  writeDouble(val) {
+    this.realloc(8);
+    this._view.setFloat64(this.pos, val, true);
+    this.pos += 8;
+  }
+  writeBytes(bytes) {
+    this.writeVarint(bytes.length);
+    this.realloc(bytes.length);
+    this.buf.set(bytes, this.pos);
+    this.pos += bytes.length;
+  }
+  writeRawFixed32(val) {
+    this.realloc(4);
+    this._view.setUint32(this.pos, val >>> 0, true);
+    this.pos += 4;
+  }
+  writeRawSFixed32(val) {
+    this.realloc(4);
+    this._view.setInt32(this.pos, val | 0, true);
+    this.pos += 4;
+  }
+  writeRawFixed64(val) {
+    this.realloc(8);
+    const lo = val >>> 0;
+    const hi = Math.floor(val * SHIFT_RIGHT_32) >>> 0;
+    this._view.setUint32(this.pos, lo, true);
+    this._view.setUint32(this.pos + 4, hi, true);
+    this.pos += 8;
+  }
+  writeRawSFixed64(val) {
+    this.realloc(8);
+    const lo = val >>> 0;
+    const hi = Math.floor(val * SHIFT_RIGHT_32) | 0;
+    this._view.setUint32(this.pos, lo, true);
+    this._view.setInt32(this.pos + 4, hi, true);
+    this.pos += 8;
+  }
+  writeMessage(tag, fn, value) {
+    this.writeTag(tag, PBF_BYTES);
+    const headPos = this.pos;
+    this.pos++;
+    const startMessage = this.pos;
+    fn(value, this);
+    const len = this.pos - startMessage;
+    if (len >= 128) {
+      const varintLen = varintLength(len);
+      this.realloc(varintLen - 1);
+      this.buf.copyWithin(startMessage + varintLen - 1, startMessage, startMessage + len);
+      this.pos = headPos;
+      this.writeVarint(len);
+      this.pos = startMessage + varintLen - 1 + len;
+    } else {
+      this.buf[headPos] = len;
+    }
+  }
+  writePackedVarint(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedVarintFn, arr);
+  }
+  writePackedSVarint(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedSVarintFn, arr);
+  }
+  writePackedBoolean(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedBooleanFn, arr);
+  }
+  writePackedFloat(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedFloatFn, arr);
+  }
+  writePackedDouble(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedDoubleFn, arr);
+  }
+  writePackedFixed32(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedFixed32Fn, arr);
+  }
+  writePackedSFixed32(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedSFixed32Fn, arr);
+  }
+  writePackedFixed64(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedFixed64Fn, arr);
+  }
+  writePackedSFixed64(tag, arr) {
+    if (arr.length > 0)
+      this.writeMessage(tag, writePackedSFixed64Fn, arr);
+  }
+  writeBytesField(tag, buffer) {
+    this.writeTag(tag, PBF_BYTES);
+    this.writeBytes(buffer);
+  }
+  writeFixed32(tag, val) {
+    this.writeTag(tag, PBF_FIXED32);
+    this.writeRawFixed32(val);
+  }
+  writeSFixed32(tag, val) {
+    this.writeTag(tag, PBF_FIXED32);
+    this.writeRawSFixed32(val);
+  }
+  writeFixed64(tag, val) {
+    this.writeTag(tag, PBF_FIXED64);
+    this.writeRawFixed64(val);
+  }
+  writeSFixed64(tag, val) {
+    this.writeTag(tag, PBF_FIXED64);
+    this.writeRawSFixed64(val);
+  }
+  writeVarintField(tag, val) {
+    this.writeTag(tag, PBF_VARINT);
+    this.writeVarint(val);
+  }
+  writeSVarintField(tag, val) {
+    this.writeTag(tag, PBF_VARINT);
+    this.writeSVarint(val);
+  }
+  writeStringField(tag, str) {
+    this.writeTag(tag, PBF_BYTES);
+    this.writeString(str);
+  }
+  writeFloatField(tag, val) {
+    this.writeTag(tag, PBF_FIXED32);
+    this.writeFloat(val);
+  }
+  writeDoubleField(tag, val) {
+    this.writeTag(tag, PBF_FIXED64);
+    this.writeDouble(val);
+  }
+  writeBooleanField(tag, val) {
+    this.writeVarintField(tag, val ? 1 : 0);
+  }
+}
+function readVarintRemainder(low, isSigned, pbf) {
+  const buf = pbf.buf;
+  let b;
+  let high = 0;
+  b = buf[pbf.pos++];
+  low |= (b & 15) << 28;
+  high = (b & 112) >> 4;
+  if (b < 128)
+    return toNum(low, high, isSigned);
+  b = buf[pbf.pos++];
+  high |= (b & 127) << 3;
+  if (b < 128)
+    return toNum(low, high, isSigned);
+  b = buf[pbf.pos++];
+  high |= (b & 127) << 10;
+  if (b < 128)
+    return toNum(low, high, isSigned);
+  b = buf[pbf.pos++];
+  high |= (b & 127) << 17;
+  if (b < 128)
+    return toNum(low, high, isSigned);
+  b = buf[pbf.pos++];
+  high |= (b & 127) << 24;
+  if (b < 128)
+    return toNum(low, high, isSigned);
+  b = buf[pbf.pos++];
+  high |= (b & 1) << 31;
+  if (b < 128)
+    return toNum(low, high, isSigned);
+  throw new Error("Expected varint not more than 10 bytes");
+}
+function toNum(low, high, isSigned) {
+  if (isSigned && (high & 2147483648) !== 0) {
+    const negLow = ~low + 1 >>> 0;
+    let negHigh = ~high >>> 0;
+    if (negLow === 0)
+      negHigh = negHigh + 1 >>> 0;
+    const mag = negHigh * SHIFT_LEFT_32 + negLow;
+    if (mag > MAX_SAFE)
+      throw new Error("Varint exceeds safe integer range");
+    return -mag;
+  }
+  const val = (high >>> 0) * SHIFT_LEFT_32 + (low >>> 0);
+  if (val > MAX_SAFE)
+    throw new Error("Varint exceeds safe integer range");
+  return val;
+}
+function readPackedEnd(pbf) {
+  return pbf.readVarint() + pbf.pos;
+}
+function readPacked(pbf, arr, readOne) {
+  if (pbf.type !== PBF_BYTES) {
+    if (arr === undefined)
+      return [readOne(pbf)];
+    arr.push(readOne(pbf));
+    return arr;
+  }
+  const out = arr === undefined ? [] : arr;
+  const end = readPackedEnd(pbf);
+  while (pbf.pos < end)
+    out.push(readOne(pbf));
+  return out;
+}
+function varintLength(val) {
+  let n = 1;
+  while (val >= 128) {
+    val = Math.floor(val / 128);
+    n++;
+  }
+  return n;
+}
+function writeBigVarint(val, pbf) {
+  let low;
+  let high;
+  if (val < 0) {
+    const mag = -val;
+    low = ~(mag >>> 0) + 1 >>> 0;
+    high = ~Math.floor(mag / SHIFT_LEFT_32) >>> 0;
+    if (low === 0)
+      high = high + 1 >>> 0;
+  } else {
+    low = val >>> 0;
+    high = Math.floor(val / SHIFT_LEFT_32) >>> 0;
+  }
+  pbf.realloc(10);
+  for (let i = 0;i < 10; i++) {
+    const bit = i * 7;
+    const chunk = readBits7(low, high, bit);
+    const more = bit + 7 < 64 ? readBitsAbove(low, high, bit + 7) : false;
+    pbf.buf[pbf.pos++] = more ? chunk | 128 : chunk;
+    if (!more)
+      break;
+  }
+}
+function readBits7(low, high, bit) {
+  if (bit >= 32)
+    return high >>> bit - 32 & 127;
+  if (bit + 7 <= 32)
+    return low >>> bit & 127;
+  return (low >>> bit | high << 32 - bit) & 127;
+}
+function readBitsAbove(low, high, startBit) {
+  if (startBit >= 64)
+    return false;
+  if (startBit >= 32)
+    return high >>> startBit - 32 !== 0;
+  return low >>> startBit !== 0 || high !== 0;
+}
+function writePackedVarintFn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeVarint(arr[i]);
+}
+function writePackedSVarintFn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeSVarint(arr[i]);
+}
+function writePackedBooleanFn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeBoolean(arr[i]);
+}
+function writePackedFloatFn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeFloat(arr[i]);
+}
+function writePackedDoubleFn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeDouble(arr[i]);
+}
+function writePackedFixed32Fn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeRawFixed32(arr[i]);
+}
+function writePackedSFixed32Fn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeRawSFixed32(arr[i]);
+}
+function writePackedFixed64Fn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeRawFixed64(arr[i]);
+}
+function writePackedSFixed64Fn(arr, pbf) {
+  for (let i = 0;i < arr.length; i++)
+    pbf.writeRawSFixed64(arr[i]);
+}
+function manualUtf8Decode(buf, start, end) {
+  let out = "";
+  let i = start;
+  while (i < end) {
+    const b0 = buf[i++];
+    if (b0 < 128) {
+      out += String.fromCharCode(b0);
+    } else if (b0 < 224) {
+      const b1 = buf[i++] & 63;
+      out += String.fromCharCode((b0 & 31) << 6 | b1);
+    } else if (b0 < 240) {
+      const b1 = buf[i++] & 63;
+      const b2 = buf[i++] & 63;
+      out += String.fromCharCode((b0 & 15) << 12 | b1 << 6 | b2);
+    } else {
+      const b1 = buf[i++] & 63;
+      const b2 = buf[i++] & 63;
+      const b3 = buf[i++] & 63;
+      let cp = (b0 & 7) << 18 | b1 << 12 | b2 << 6 | b3;
+      cp -= 65536;
+      out += String.fromCharCode(55296 | cp >> 10);
+      out += String.fromCharCode(56320 | cp & 1023);
+    }
+  }
+  return out;
+}
+function manualUtf8Encode(str) {
+  const out = [];
+  for (let i = 0;i < str.length; i++) {
+    let cp = str.charCodeAt(i);
+    if (cp >= 55296 && cp <= 56319 && i + 1 < str.length) {
+      const low = str.charCodeAt(i + 1);
+      if (low >= 56320 && low <= 57343) {
+        cp = 65536 + ((cp & 1023) << 10 | low & 1023);
+        i++;
+      }
+    }
+    if (cp < 128) {
+      out.push(cp);
+    } else if (cp < 2048) {
+      out.push(192 | cp >> 6, 128 | cp & 63);
+    } else if (cp < 65536) {
+      out.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+    } else {
+      out.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
+    }
+  }
+  return new Uint8Array(out);
+}
+var PBF_VARINT = 0, PBF_FIXED64 = 1, PBF_BYTES = 2, PBF_FIXED32 = 5, SHIFT_LEFT_32, SHIFT_RIGHT_32, MAX_SAFE, utf8Decoder, utf8Encoder;
+var init_Pbf = __esm(() => {
+  SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
+  SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
+  MAX_SAFE = Number.MAX_SAFE_INTEGER;
+  utf8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8") : null;
+  utf8Encoder = typeof TextEncoder !== "undefined" ? new TextEncoder : null;
+});
+
+// src/core-map/symbols/loadGlyphs.ts
+var exports_loadGlyphs = {};
+__export(exports_loadGlyphs, {
+  GLYPH_BORDER: () => GLYPH_BORDER,
+  GlyphSource: () => GlyphSource,
+  decodeGlyphPbf: () => decodeGlyphPbf,
+  glyphUrl: () => glyphUrl,
+  rangeStartFor: () => rangeStartFor
+});
+function glyphUrl(template, fontstack, rangeStart) {
+  const range = `${rangeStart}-${rangeStart + 255}`;
+  return template.replace("{fontstack}", encodeURIComponent(fontstack)).replace("{range}", range);
+}
+function rangeStartFor(codePoint) {
+  return Math.floor(codePoint / 256) * 256;
+}
+function decodeGlyphPbf(bytes) {
+  const glyphs = new Map;
+  const pbf = new Pbf(bytes);
+  while (pbf.pos < pbf.length) {
+    const tag = pbf.readVarint() >> 3;
+    if (tag !== 1) {
+      pbf.skip(tag << 3);
+      continue;
+    }
+    const stackEnd = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < stackEnd) {
+      const value = pbf.readVarint();
+      const stackTag = value >> 3;
+      pbf.type = value & 7;
+      if (stackTag !== 3) {
+        pbf.skip(value);
+        continue;
+      }
+      const glyphEnd = pbf.readVarint() + pbf.pos;
+      const glyph = { id: 0, width: 0, height: 0, left: 0, top: 0, advance: 0 };
+      while (pbf.pos < glyphEnd) {
+        const gv = pbf.readVarint();
+        const gTag = gv >> 3;
+        pbf.type = gv & 7;
+        switch (gTag) {
+          case 1:
+            glyph.id = pbf.readVarint();
+            break;
+          case 2:
+            glyph.bitmap = pbf.readBytes();
+            break;
+          case 3:
+            glyph.width = pbf.readVarint();
+            break;
+          case 4:
+            glyph.height = pbf.readVarint();
+            break;
+          case 5:
+            glyph.left = pbf.readSVarint();
+            break;
+          case 6:
+            glyph.top = pbf.readSVarint();
+            break;
+          case 7:
+            glyph.advance = pbf.readVarint();
+            break;
+          default:
+            pbf.skip(gv);
+        }
+      }
+      pbf.pos = glyphEnd;
+      glyphs.set(glyph.id, glyph);
+    }
+    pbf.pos = stackEnd;
+  }
+  return glyphs;
+}
+
+class GlyphSource {
+  _template;
+  _fetch;
+  _ranges;
+  _pending;
+  constructor(template, options = {}) {
+    this._template = template;
+    this._fetch = options.fetch ?? globalThis.fetch;
+    this._ranges = new Map;
+    this._pending = new Map;
+  }
+  get(fontstack, codePoint) {
+    const key = `${fontstack}/${rangeStartFor(codePoint)}`;
+    return this._ranges.get(key)?.get(codePoint);
+  }
+  has(fontstack, codePoint) {
+    return this._ranges.has(`${fontstack}/${rangeStartFor(codePoint)}`);
+  }
+  async load(fontstack, codePoint, signal) {
+    const start = rangeStartFor(codePoint);
+    const key = `${fontstack}/${start}`;
+    const cached = this._ranges.get(key);
+    if (cached)
+      return cached;
+    const inFlight = this._pending.get(key);
+    if (inFlight)
+      return inFlight;
+    const request = (async () => {
+      const url = glyphUrl(this._template, fontstack, start);
+      const response = await this._fetch(url, { signal });
+      if (!response.ok)
+        throw new Error(`HTTP ${response.status} fetching glyphs ${url}`);
+      const range = decodeGlyphPbf(new Uint8Array(await response.arrayBuffer()));
+      this._ranges.set(key, range);
+      this._pending.delete(key);
+      return range;
+    })();
+    this._pending.set(key, request);
+    request.catch(() => this._pending.delete(key));
+    return request;
+  }
+  async loadForText(fontstack, text, signal) {
+    const starts = new Set;
+    for (const ch of text)
+      starts.add(rangeStartFor(ch.codePointAt(0) ?? 0));
+    await Promise.all([...starts].map((start) => this.load(fontstack, start, signal)));
+  }
+  get size() {
+    return this._ranges.size;
+  }
+}
+var GLYPH_BORDER = 3;
+var init_loadGlyphs = __esm(() => {
+  init_Pbf();
+});
+
+// src/core-map/symbols/loadSprite.ts
+var exports_loadSprite = {};
+__export(exports_loadSprite, {
+  addSpriteToAtlas: () => addSpriteToAtlas,
+  loadSprite: () => loadSprite,
+  spriteUrl: () => spriteUrl
+});
+function spriteUrl(base, extension, pixelRatio) {
+  const suffix = pixelRatio > 1 ? "@2x" : "";
+  const queryAt = base.indexOf("?");
+  if (queryAt === -1)
+    return `${base}${suffix}.${extension}`;
+  return `${base.slice(0, queryAt)}${suffix}.${extension}${base.slice(queryAt)}`;
+}
+function defaultLoadImage(url) {
+  return new Promise((resolve, reject) => {
+    const image = new Image;
+    image.crossOrigin = "anonymous";
+    image.onload = () => resolve(image);
+    image.onerror = () => reject(new Error(`failed to load sprite image ${url}`));
+    image.src = url;
+  });
+}
+async function loadSprite(base, options = {}) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const loadImage = options.loadImage ?? defaultLoadImage;
+  const wanted = (options.pixelRatio ?? 1) > 1 ? 2 : 1;
+  const attempt = async (ratio) => {
+    const response = await doFetch(spriteUrl(base, "json", ratio), { signal: options.signal });
+    if (!response.ok)
+      throw new Error(`HTTP ${response.status} fetching sprite index for ${base}`);
+    const index = await response.json();
+    const image = await loadImage(spriteUrl(base, "png", ratio));
+    return { index, image, pixelRatio: ratio };
+  };
+  if (wanted === 2) {
+    try {
+      return await attempt(2);
+    } catch {}
+  }
+  return attempt(1);
+}
+function addSpriteToAtlas(atlas, sprite, prefix) {
+  let added = 0;
+  for (const [name, entry] of Object.entries(sprite.index)) {
+    const id = prefix ? `${prefix}:${name}` : name;
+    if (!entry || typeof entry.width !== "number" || typeof entry.height !== "number")
+      continue;
+    if (entry.width <= 0 || entry.height <= 0)
+      continue;
+    const packed = {
+      id,
+      x: entry.x,
+      y: entry.y,
+      width: entry.width,
+      height: entry.height,
+      pixelRatio: entry.pixelRatio ?? sprite.pixelRatio,
+      sdf: entry.sdf === true
+    };
+    atlas.addSprite(packed, sprite.image);
+    added += 1;
+  }
+  return added;
+}
+
+// src/core-map/symbols/index.ts
+init_IconAtlas();
+init_loadGlyphs();
 export {
-  IconAtlas,
+  CollisionIndex,
+  GLYPH_BORDER,
   GlyphAtlas,
-  CollisionIndex
+  GlyphSource,
+  IconAtlas,
+  addSpriteToAtlas,
+  decodeGlyphPbf,
+  glyphUrl,
+  loadSprite,
+  rangeStartFor,
+  spriteUrl
 };