stipple-maplibre 0.1.0

package/dist/index.global.js

@@ -0,0 +1,1787 @@
+"use strict";
+var MaplibrePatternFills = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    PATTERN_METADATA_KEY: () => PATTERN_METADATA_KEY,
+    buildStyleFragment: () => buildStyleFragment,
+    createFontPatternDefinition: () => createFontPatternDefinition,
+    createFontPatternTile: () => createFontPatternTile,
+    createMiniContext: () => createMiniContext,
+    createSvgPatternDefinition: () => createSvgPatternDefinition,
+    createSvgScatterLayout: () => createSvgScatterLayout,
+    createSvgScatterTile: () => createSvgScatterTile,
+    hashStringToSeed: () => hashStringToSeed,
+    importGeoJsonPolygons: () => importGeoJsonPolygons,
+    installFontPatternFill: () => installFontPatternFill,
+    installPatternFills: () => installPatternFills,
+    installSvgIconScatter: () => installSvgIconScatter,
+    installSvgPatternFill: () => installSvgPatternFill,
+    makeTile: () => makeTile,
+    mulberry32: () => mulberry32,
+    observePatternFills: () => observePatternFills,
+    parsePatternDefinition: () => parsePatternDefinition,
+    parsePatternMetadata: () => parsePatternMetadata,
+    patternDefinitionId: () => patternDefinitionId,
+    scalePatternForZoom: () => scalePatternForZoom,
+    scatterIconPoints: () => scatterIconPoints,
+    scatterPointsInPolygon: () => scatterPointsInPolygon,
+    screenPatternPhase: () => screenPatternPhase,
+    serializePatternDefinition: () => serializePatternDefinition,
+    syncPatternTexture: () => syncPatternTexture
+  });
+
+  // src/engine/miniContext.ts
+  function parseColor(v) {
+    const hex8 = v.match(/^#([0-9a-f]{8})$/i);
+    if (hex8) {
+      const n = parseInt(hex8[1], 16);
+      return { r: n >>> 24 & 255, g: n >>> 16 & 255, b: n >>> 8 & 255, a: (n & 255) / 255 };
+    }
+    const hex6 = v.match(/^#([0-9a-f]{6})$/i);
+    if (hex6) {
+      const n = parseInt(hex6[1], 16);
+      return { r: n >> 16 & 255, g: n >> 8 & 255, b: n & 255, a: 1 };
+    }
+    const hex4 = v.match(/^#([0-9a-f]{4})$/i);
+    if (hex4) {
+      const [r, g, b, a] = hex4[1].split("").map((c) => parseInt(c + c, 16));
+      return { r, g, b, a: a / 255 };
+    }
+    const hex3 = v.match(/^#([0-9a-f]{3})$/i);
+    if (hex3) {
+      const [r, g, b] = hex3[1].split("").map((c) => parseInt(c + c, 16));
+      return { r, g, b, a: 1 };
+    }
+    const rgbaComma = v.match(
+      /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+%?)\s*)?\)$/i
+    );
+    const rgbaSpace = v.match(
+      /^rgba?\(\s*([\d.]+)\s+([\d.]+)\s+([\d.]+)\s*(?:\/\s*([\d.]+%?)\s*)?\)$/i
+    );
+    const rgba = rgbaComma ?? rgbaSpace;
+    if (rgba) {
+      const alphaToken = rgba[4];
+      const a = alphaToken === void 0 ? 1 : alphaToken.endsWith("%") ? parseFloat(alphaToken) / 100 : +alphaToken;
+      return { r: +rgba[1], g: +rgba[2], b: +rgba[3], a };
+    }
+    throw new TypeError(
+      `Unsupported color "${v}" in the Node mini rasterizer. Supported: #rgb, #rgba, #rrggbb, #rrggbbaa, and rgb()/rgba() (comma or space/slash syntax). Named colors and hsl() require a real browser canvas.`
+    );
+  }
+  var clamp01 = (v) => Math.max(0, Math.min(1, v));
+  function createMiniContext(size) {
+    const buf = new Uint8ClampedArray(size * size * 4);
+    let strokeColor = { r: 0, g: 0, b: 0, a: 1 };
+    let fillColor = { r: 0, g: 0, b: 0, a: 1 };
+    let lineWidth = 1;
+    let subpaths = [];
+    let pendingArc = null;
+    function setPixel(x, y, c) {
+      if (x < 0 || y < 0 || x >= size || y >= size || c.a <= 0) return;
+      const i = (y * size + x) * 4;
+      if (c.a >= 1) {
+        buf[i] = c.r;
+        buf[i + 1] = c.g;
+        buf[i + 2] = c.b;
+        buf[i + 3] = 255;
+        return;
+      }
+      const dstA = buf[i + 3] / 255;
+      const outA = c.a + dstA * (1 - c.a);
+      if (outA <= 0) return;
+      buf[i] = (c.r * c.a + buf[i] * dstA * (1 - c.a)) / outA;
+      buf[i + 1] = (c.g * c.a + buf[i + 1] * dstA * (1 - c.a)) / outA;
+      buf[i + 2] = (c.b * c.a + buf[i + 2] * dstA * (1 - c.a)) / outA;
+      buf[i + 3] = outA * 255;
+    }
+    function strokeSegment(x0, y0, x1, y1) {
+      const half = lineWidth / 2;
+      const minX = Math.max(0, Math.floor(Math.min(x0, x1) - half - 1));
+      const maxX = Math.min(size - 1, Math.ceil(Math.max(x0, x1) + half + 1));
+      const minY = Math.max(0, Math.floor(Math.min(y0, y1) - half - 1));
+      const maxY = Math.min(size - 1, Math.ceil(Math.max(y0, y1) + half + 1));
+      const dx = x1 - x0;
+      const dy = y1 - y0;
+      const lenSq = dx * dx + dy * dy;
+      for (let py = minY; py <= maxY; py++) {
+        for (let px = minX; px <= maxX; px++) {
+          const cx = px + 0.5;
+          const cy = py + 0.5;
+          let t = lenSq === 0 ? 0 : ((cx - x0) * dx + (cy - y0) * dy) / lenSq;
+          t = clamp01(t);
+          const projX = x0 + t * dx;
+          const projY = y0 + t * dy;
+          const dist = Math.hypot(cx - projX, cy - projY);
+          const coverage = clamp01(half + 0.5 - dist);
+          if (coverage > 0) setPixel(px, py, { ...strokeColor, a: strokeColor.a * coverage });
+        }
+      }
+    }
+    function fillCircle(cx, cy, r) {
+      const minX = Math.max(0, Math.floor(cx - r - 1));
+      const maxX = Math.min(size - 1, Math.ceil(cx + r + 1));
+      const minY = Math.max(0, Math.floor(cy - r - 1));
+      const maxY = Math.min(size - 1, Math.ceil(cy + r + 1));
+      for (let py = minY; py <= maxY; py++) {
+        for (let px = minX; px <= maxX; px++) {
+          const dist = Math.hypot(px + 0.5 - cx, py + 0.5 - cy);
+          const coverage = clamp01(r + 0.5 - dist);
+          if (coverage > 0) setPixel(px, py, { ...fillColor, a: fillColor.a * coverage });
+        }
+      }
+    }
+    const ctx = {
+      get strokeStyle() {
+        return `rgba(${strokeColor.r},${strokeColor.g},${strokeColor.b},${strokeColor.a})`;
+      },
+      set strokeStyle(v) {
+        strokeColor = parseColor(v);
+      },
+      get fillStyle() {
+        return `rgba(${fillColor.r},${fillColor.g},${fillColor.b},${fillColor.a})`;
+      },
+      set fillStyle(v) {
+        fillColor = parseColor(v);
+      },
+      get lineWidth() {
+        return lineWidth;
+      },
+      set lineWidth(v) {
+        lineWidth = v;
+      },
+      lineCap: "round",
+      clearRect() {
+        buf.fill(0);
+      },
+      beginPath() {
+        subpaths = [];
+        pendingArc = null;
+      },
+      moveTo(x, y) {
+        subpaths.push([{ x, y }]);
+      },
+      lineTo(x, y) {
+        const current = subpaths[subpaths.length - 1];
+        if (current) current.push({ x, y });
+      },
+      stroke() {
+        for (const sp of subpaths) {
+          for (let i = 1; i < sp.length; i++) strokeSegment(sp[i - 1].x, sp[i - 1].y, sp[i].x, sp[i].y);
+        }
+      },
+      arc(x, y, radius) {
+        pendingArc = { x, y, r: radius };
+      },
+      fill() {
+        if (pendingArc) fillCircle(pendingArc.x, pendingArc.y, pendingArc.r);
+      }
+    };
+    return {
+      ctx,
+      toTileImage: () => ({ width: size, height: size, data: new Uint8Array(buf.buffer) })
+    };
+  }
+
+  // src/engine/seededRandom.ts
+  function mulberry32(seed) {
+    let a = seed >>> 0;
+    return function next() {
+      a |= 0;
+      a = a + 1831565813 | 0;
+      let t = Math.imul(a ^ a >>> 15, 1 | a);
+      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  function hashStringToSeed(str) {
+    let h = 1779033703 ^ str.length;
+    for (let i = 0; i < str.length; i++) {
+      h = Math.imul(h ^ str.charCodeAt(i), 3432918353);
+      h = h << 13 | h >>> 19;
+    }
+    return (h ^ h >>> 16) >>> 0;
+  }
+
+  // src/engine/makeTile.ts
+  var DEFAULT_STIPPLE_COUNT = 7;
+  function toroidalDistance(a, b, period) {
+    const dx = Math.min(Math.abs(a.x - b.x), period - Math.abs(a.x - b.x));
+    const dy = Math.min(Math.abs(a.y - b.y), period - Math.abs(a.y - b.y));
+    return Math.hypot(dx, dy);
+  }
+  function defaultContextFactory(size) {
+    if (typeof document !== "undefined") {
+      const canvas = document.createElement("canvas");
+      canvas.width = canvas.height = size;
+      const canvasCtx = canvas.getContext("2d");
+      if (!canvasCtx) throw new Error("2D canvas context unavailable");
+      return {
+        ctx: canvasCtx,
+        toTileImage: () => {
+          const img = canvasCtx.getImageData(0, 0, size, size);
+          return { width: size, height: size, data: new Uint8Array(img.data.buffer) };
+        }
+      };
+    }
+    return createMiniContext(size);
+  }
+  function makeTile(pattern, size, color, weight, angle, options = {}) {
+    const pixelRatio = options.pixelRatio ?? 1;
+    if (!Number.isFinite(pixelRatio) || pixelRatio <= 0) {
+      throw new RangeError("pixelRatio must be a finite number greater than 0");
+    }
+    if (!Number.isFinite(size) || size <= 0) {
+      throw new RangeError("size must be a finite number greater than 0");
+    }
+    if (!Number.isFinite(weight) || weight <= 0) {
+      throw new RangeError("weight must be a finite number greater than 0");
+    }
+    if (!Number.isFinite(angle)) {
+      throw new TypeError("angle must be a finite number");
+    }
+    if (options.stippleCount !== void 0 && (!Number.isInteger(options.stippleCount) || options.stippleCount <= 0)) {
+      throw new RangeError("stippleCount must be a positive integer");
+    }
+    if (typeof color !== "string" || color.trim().length === 0) {
+      throw new TypeError("color must be a non-empty string");
+    }
+    const physicalSize = Math.max(1, Math.round(size * pixelRatio));
+    const renderScale = physicalSize / size;
+    const { ctx, toTileImage } = (options.contextFactory ?? defaultContextFactory)(physicalSize);
+    ctx.clearRect(0, 0, physicalSize, physicalSize);
+    ctx.strokeStyle = color;
+    ctx.fillStyle = color;
+    ctx.lineWidth = weight * renderScale;
+    ctx.lineCap = "round";
+    const drawHachures = (deg) => {
+      ctx.beginPath();
+      const step = Math.max(physicalSize / 2, 4 * renderScale);
+      if (deg === 0) {
+        for (let y = 0; y <= physicalSize; y += step) {
+          ctx.moveTo(0, y + 0.5 * renderScale);
+          ctx.lineTo(physicalSize, y + 0.5 * renderScale);
+        }
+      } else if (deg === 90) {
+        for (let x = 0; x <= physicalSize; x += step) {
+          ctx.moveTo(x + 0.5 * renderScale, 0);
+          ctx.lineTo(x + 0.5 * renderScale, physicalSize);
+        }
+      } else if (deg === 45) {
+        for (let o = -physicalSize; o <= physicalSize * 2; o += step) {
+          ctx.moveTo(o, 0);
+          ctx.lineTo(o + physicalSize, physicalSize);
+        }
+      } else {
+        for (let o = -physicalSize; o <= physicalSize * 2; o += step) {
+          ctx.moveTo(o + physicalSize, 0);
+          ctx.lineTo(o, physicalSize);
+        }
+      }
+      ctx.stroke();
+    };
+    switch (pattern) {
+      case "hachures":
+        drawHachures(angle);
+        break;
+      case "cross":
+        drawHachures(angle);
+        drawHachures((angle + 90 + 45) % 180 - 45);
+        break;
+      case "grid": {
+        ctx.beginPath();
+        ctx.moveTo(0.5 * renderScale, 0);
+        ctx.lineTo(0.5 * renderScale, physicalSize);
+        ctx.moveTo(0, 0.5 * renderScale);
+        ctx.lineTo(physicalSize, 0.5 * renderScale);
+        ctx.stroke();
+        break;
+      }
+      case "stipple": {
+        const r = weight * renderScale * 0.6;
+        const count = options.stippleCount ?? DEFAULT_STIPPLE_COUNT;
+        const seedKey = `fixed:${count}`;
+        const rand = mulberry32(hashStringToSeed(`stipple:${seedKey}`));
+        const candidateCount = 20;
+        const positions = [];
+        for (let i = 0; i < count; i++) {
+          let best = { x: rand() * physicalSize, y: rand() * physicalSize };
+          let bestDistance = -1;
+          for (let c = 0; c < candidateCount; c++) {
+            const candidate = { x: rand() * physicalSize, y: rand() * physicalSize };
+            const nearest = positions.length === 0 ? Infinity : Math.min(...positions.map((p) => toroidalDistance(candidate, p, physicalSize)));
+            if (nearest > bestDistance) {
+              best = candidate;
+              bestDistance = nearest;
+            }
+          }
+          positions.push(best);
+        }
+        for (const { x, y } of positions) {
+          const minShiftX = Math.ceil((-r - x) / physicalSize);
+          const maxShiftX = Math.floor((physicalSize + r - x) / physicalSize);
+          const minShiftY = Math.ceil((-r - y) / physicalSize);
+          const maxShiftY = Math.floor((physicalSize + r - y) / physicalSize);
+          for (let shiftY = minShiftY; shiftY <= maxShiftY; shiftY++) {
+            for (let shiftX = minShiftX; shiftX <= maxShiftX; shiftX++) {
+              ctx.beginPath();
+              ctx.arc(x + shiftX * physicalSize, y + shiftY * physicalSize, r, 0, Math.PI * 2);
+              ctx.fill();
+            }
+          }
+        }
+        break;
+      }
+      case "dots": {
+        const r = Math.max(weight * renderScale * 0.5, renderScale);
+        ctx.beginPath();
+        ctx.arc(physicalSize / 2, physicalSize / 2, r, 0, Math.PI * 2);
+        ctx.fill();
+        break;
+      }
+      case "solid":
+        break;
+    }
+    return toTileImage();
+  }
+
+  // src/engine/scatterPoints.ts
+  function isInsideRings(x, y, rings) {
+    let inside = false;
+    for (const ring2 of rings) {
+      for (let i = 0, j = ring2.length - 1; i < ring2.length; j = i++) {
+        const [xi, yi] = ring2[i];
+        const [xj, yj] = ring2[j];
+        const crosses = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
+        if (crosses) inside = !inside;
+      }
+    }
+    return inside;
+  }
+  function squaredDistanceToSegment(x, y, start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    if (dx === 0 && dy === 0) return (x - start[0]) ** 2 + (y - start[1]) ** 2;
+    const projection = Math.max(
+      0,
+      Math.min(1, ((x - start[0]) * dx + (y - start[1]) * dy) / (dx * dx + dy * dy))
+    );
+    const nearestX = start[0] + projection * dx;
+    const nearestY = start[1] + projection * dy;
+    return (x - nearestX) ** 2 + (y - nearestY) ** 2;
+  }
+  function discFitsInside(x, y, radius, rings) {
+    if (!isInsideRings(x, y, rings)) return false;
+    const squaredRadius = radius * radius;
+    for (const ring2 of rings) {
+      for (let index = 0; index < ring2.length; index++) {
+        const start = ring2[index];
+        const end = ring2[(index + 1) % ring2.length];
+        if (squaredDistanceToSegment(x, y, start, end) < squaredRadius) return false;
+      }
+    }
+    return true;
+  }
+  function scatterPointsInPolygon(rings, options) {
+    const {
+      radius,
+      density = 1,
+      seed = 1,
+      rotationJitterDeg = 0,
+      scaleJitter = 0,
+      positionJitter = 0.15,
+      stagger = true,
+      distribution = stagger ? "offset" : "regular",
+      minSpacing = 0,
+      clipBounds
+    } = options;
+    if (!Number.isFinite(radius) || radius < 0) {
+      throw new RangeError("radius must be a finite number greater than or equal to 0");
+    }
+    if (!Number.isFinite(density) || density <= 0) {
+      throw new RangeError("density must be a finite number greater than 0");
+    }
+    if (!Number.isFinite(rotationJitterDeg) || rotationJitterDeg < 0) {
+      throw new RangeError("rotationJitterDeg must be a finite number greater than or equal to 0");
+    }
+    if (!Number.isFinite(scaleJitter) || scaleJitter < 0 || scaleJitter >= 1) {
+      throw new RangeError("scaleJitter must be a finite number greater than or equal to 0 and less than 1");
+    }
+    if (!Number.isFinite(positionJitter) || positionJitter < 0) {
+      throw new RangeError("positionJitter must be a finite number greater than or equal to 0");
+    }
+    if (!["regular", "offset", "natural"].includes(distribution)) {
+      throw new TypeError("distribution must be regular, offset, or natural");
+    }
+    if (!Number.isFinite(minSpacing) || minSpacing < 0) {
+      throw new RangeError("minSpacing must be a finite number greater than or equal to 0");
+    }
+    const exterior = rings[0] ?? [];
+    if (exterior.length === 0) return [];
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const [x, y] of exterior) {
+      if (x < minX) minX = x;
+      if (x > maxX) maxX = x;
+      if (y < minY) minY = y;
+      if (y > maxY) maxY = y;
+    }
+    const seedNum = typeof seed === "string" ? hashStringToSeed(seed) : seed;
+    const rand = mulberry32(seedNum);
+    const cell = 100 / Math.sqrt(density);
+    const points = [];
+    const width = maxX - minX;
+    const height = maxY - minY;
+    const clipMinX = Math.max(minX, clipBounds?.minX ?? minX);
+    const clipMinY = Math.max(minY, clipBounds?.minY ?? minY);
+    const clipMaxX = Math.min(maxX, clipBounds?.maxX ?? maxX);
+    const clipMaxY = Math.min(maxY, clipBounds?.maxY ?? maxY);
+    if (clipMaxX <= clipMinX || clipMaxY <= clipMinY) return [];
+    if (distribution === "natural") {
+      const clippedWidth = clipMaxX - clipMinX;
+      const clippedHeight = clipMaxY - clipMinY;
+      const targetCount = Math.max(1, Math.round(density * clippedWidth * clippedHeight / 1e4));
+      const minimumDistance = Math.max(
+        cell * 0.76,
+        radius * 2 * (1 + scaleJitter) + minSpacing
+      );
+      const conservativeRadius = radius * (1 + scaleJitter);
+      const minimumDistanceSquared = minimumDistance ** 2;
+      const gridCell = Math.max(minimumDistance / Math.SQRT2, 1);
+      const grid = /* @__PURE__ */ new Map();
+      const active = [];
+      const gridCoordinate = (value, origin) => Math.floor((value - origin) / gridCell);
+      const gridKey = (column, row) => `${column}:${row}`;
+      const isFarEnough = (x, y) => {
+        if (minimumDistanceSquared === 0) return true;
+        const column = gridCoordinate(x, clipMinX);
+        const row = gridCoordinate(y, clipMinY);
+        for (let offsetY = -2; offsetY <= 2; offsetY++) {
+          for (let offsetX = -2; offsetX <= 2; offsetX++) {
+            const pointIndex = grid.get(gridKey(column + offsetX, row + offsetY));
+            if (pointIndex === void 0) continue;
+            const point = points[pointIndex];
+            if ((x - point.x) ** 2 + (y - point.y) ** 2 < minimumDistanceSquared) return false;
+          }
+        }
+        return true;
+      };
+      const addPoint = (x, y) => {
+        const pointIndex = points.length;
+        points.push({
+          x,
+          y,
+          rotation: (rand() * 2 - 1) * rotationJitterDeg,
+          scale: 1 + (rand() * 2 - 1) * scaleJitter
+        });
+        active.push(pointIndex);
+        grid.set(gridKey(
+          gridCoordinate(x, clipMinX),
+          gridCoordinate(y, clipMinY)
+        ), pointIndex);
+      };
+      for (let attempt = 0; attempt < 128 && points.length === 0; attempt++) {
+        const x = clipMinX + rand() * clippedWidth;
+        const y = clipMinY + rand() * clippedHeight;
+        if (discFitsInside(x, y, conservativeRadius, rings)) addPoint(x, y);
+      }
+      while (active.length > 0 && points.length < targetCount) {
+        const activeSlot = Math.floor(rand() * active.length);
+        const origin = points[active[activeSlot]];
+        let accepted = false;
+        for (let attempt = 0; attempt < 30; attempt++) {
+          const angle = rand() * Math.PI * 2;
+          const distance = minimumDistance * (1 + rand());
+          const x = origin.x + Math.cos(angle) * distance;
+          const y = origin.y + Math.sin(angle) * distance;
+          if (x < clipMinX || x > clipMaxX || y < clipMinY || y > clipMaxY || !discFitsInside(x, y, conservativeRadius, rings) || !isFarEnough(x, y)) continue;
+          addPoint(x, y);
+          accepted = true;
+          break;
+        }
+        if (!accepted) active.splice(activeSlot, 1);
+      }
+      return points;
+    }
+    const columns = Math.max(1, Math.floor(width / cell));
+    const rows = Math.max(1, Math.floor(height / cell));
+    const startX = minX + (width - (columns - 1) * cell) / 2;
+    const startY = minY + (height - (rows - 1) * cell) / 2;
+    const jitterMargin = cell * positionJitter / 2;
+    const firstRow = Math.max(0, Math.ceil((clipMinY - jitterMargin - startY) / cell));
+    const lastRow = Math.min(rows - 1, Math.floor((clipMaxY + jitterMargin - startY) / cell));
+    for (let row = firstRow; row <= lastRow; row++) {
+      const rowOffset = distribution === "offset" && columns > 1 ? row % 2 === 0 ? -cell / 4 : cell / 4 : 0;
+      const firstColumn = Math.max(
+        0,
+        Math.ceil((clipMinX - jitterMargin - startX - rowOffset) / cell)
+      );
+      const lastColumn = Math.min(
+        columns - 1,
+        Math.floor((clipMaxX + jitterMargin - startX - rowOffset) / cell)
+      );
+      for (let column = firstColumn; column <= lastColumn; column++) {
+        const jitter = distribution === "offset" ? positionJitter : 0;
+        const jx = startX + column * cell + rowOffset + (rand() - 0.5) * cell * jitter;
+        const jy = startY + row * cell + (rand() - 0.5) * cell * jitter;
+        if (jx < clipMinX || jx > clipMaxX || jy < clipMinY || jy > clipMaxY) continue;
+        const rotation = (rand() * 2 - 1) * rotationJitterDeg;
+        const scale = 1 + (rand() * 2 - 1) * scaleJitter;
+        if (discFitsInside(jx, jy, radius * scale, rings)) points.push({ x: jx, y: jy, rotation, scale });
+      }
+    }
+    return points;
+  }
+
+  // src/engine/svgScatterLayout.ts
+  function positiveFinite(name, value) {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new RangeError(`${name} must be a finite number greater than 0`);
+    }
+  }
+  function nonNegativeFinite(name, value) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new RangeError(`${name} must be a finite number greater than or equal to 0`);
+    }
+  }
+  function modulo(value, divisor) {
+    return (value % divisor + divisor) % divisor;
+  }
+  function toroidalDistance2(first, second, tileSize) {
+    const dx = Math.min(Math.abs(first.x - second.x), tileSize - Math.abs(first.x - second.x));
+    const dy = Math.min(Math.abs(first.y - second.y), tileSize - Math.abs(first.y - second.y));
+    return Math.hypot(dx, dy);
+  }
+  function createNaturalPositions(count, tileSize, minimumDistance, rand) {
+    const positions = [];
+    const candidateCount = 24;
+    while (positions.length < count) {
+      let best;
+      let bestDistance = -1;
+      for (let candidateIndex = 0; candidateIndex < candidateCount; candidateIndex++) {
+        const candidate = { x: rand() * tileSize, y: rand() * tileSize };
+        const nearest = positions.length === 0 ? Infinity : Math.min(...positions.map((position2) => toroidalDistance2(candidate, position2, tileSize)));
+        if (nearest > bestDistance) {
+          best = candidate;
+          bestDistance = nearest;
+        }
+      }
+      if (!best || positions.length > 0 && bestDistance < minimumDistance) break;
+      positions.push(best);
+    }
+    return positions;
+  }
+  function createSvgScatterLayout(options) {
+    const {
+      tileSize,
+      stampSize,
+      density,
+      seed,
+      rotationJitterDeg,
+      scaleJitter,
+      positionJitter,
+      stagger
+    } = options;
+    const distribution = options.distribution ?? (stagger ? "offset" : "regular");
+    const minSpacing = options.minSpacing ?? 0;
+    positiveFinite("tileSize", tileSize);
+    positiveFinite("stampSize", stampSize);
+    positiveFinite("density", density);
+    nonNegativeFinite("rotationJitterDeg", rotationJitterDeg);
+    nonNegativeFinite("scaleJitter", scaleJitter);
+    nonNegativeFinite("positionJitter", positionJitter);
+    nonNegativeFinite("minSpacing", minSpacing);
+    if (!["regular", "offset", "natural"].includes(distribution)) {
+      throw new TypeError("distribution must be regular, offset, or natural");
+    }
+    if (scaleJitter >= 1) {
+      throw new RangeError("scaleJitter must be less than 1 so every stamp has a positive scale");
+    }
+    const seedNum = typeof seed === "string" ? hashStringToSeed(seed) : seed;
+    if (!Number.isFinite(seedNum)) throw new RangeError("seed must be a finite number or a string");
+    const rand = mulberry32(seedNum);
+    const targetCount = Math.max(1, Math.round(density * (tileSize * tileSize) / 1e4));
+    let positions;
+    if (distribution === "natural") {
+      const minimumDistance = stampSize * Math.SQRT2 * (1 + scaleJitter) + minSpacing;
+      positions = createNaturalPositions(targetCount, tileSize, minimumDistance, rand);
+    } else {
+      const targetCell = 100 / Math.sqrt(density);
+      const cols = Math.max(1, Math.round(tileSize / targetCell));
+      let rows = Math.max(1, Math.round(tileSize / targetCell));
+      const isOffset = distribution === "offset";
+      if (isOffset && rows % 2 !== 0) {
+        const lower = Math.max(2, rows - 1);
+        const upper = rows + 1;
+        rows = Math.abs(cols * lower - targetCount) <= Math.abs(cols * upper - targetCount) ? lower : upper;
+      }
+      const cellWidth = tileSize / cols;
+      const cellHeight = tileSize / rows;
+      const jitterAmount = distribution === "regular" ? 0 : positionJitter;
+      positions = [];
+      for (let row = 0; row < rows; row++) {
+        const rowOffset = isOffset && row % 2 === 1 ? cellWidth / 2 : 0;
+        for (let col = 0; col < cols; col++) {
+          const jitterX = (rand() - 0.5) * cellWidth * jitterAmount;
+          const jitterY = (rand() - 0.5) * cellHeight * jitterAmount;
+          positions.push({
+            x: modulo(col * cellWidth + cellWidth / 2 + rowOffset + jitterX, tileSize),
+            y: modulo(row * cellHeight + cellHeight / 2 + jitterY, tileSize)
+          });
+        }
+      }
+    }
+    const placements = [];
+    positions.forEach(({ x, y }, stampIndex) => {
+      const rotationRad = (rand() * 2 - 1) * rotationJitterDeg * (Math.PI / 180);
+      const scale = 1 + (rand() * 2 - 1) * scaleJitter;
+      const extent = stampSize * scale * Math.SQRT2 / 2;
+      const minShiftX = Math.ceil((-extent - x) / tileSize);
+      const maxShiftX = Math.floor((tileSize + extent - x) / tileSize);
+      const minShiftY = Math.ceil((-extent - y) / tileSize);
+      const maxShiftY = Math.floor((tileSize + extent - y) / tileSize);
+      for (let shiftY = minShiftY; shiftY <= maxShiftY; shiftY++) {
+        for (let shiftX = minShiftX; shiftX <= maxShiftX; shiftX++) {
+          placements.push({
+            stampIndex,
+            x: x + shiftX * tileSize,
+            y: y + shiftY * tileSize,
+            rotationRad,
+            scale
+          });
+        }
+      }
+    });
+    return placements;
+  }
+
+  // src/engine/patternScale.ts
+  function finite(value, name) {
+    if (!Number.isFinite(value)) throw new TypeError(`${name} must be finite`);
+    return value;
+  }
+  function positive(value, name) {
+    finite(value, name);
+    if (value <= 0) throw new RangeError(`${name} must be greater than 0`);
+    return value;
+  }
+  function clamp(value, minimum, maximum) {
+    return Math.max(minimum, Math.min(maximum, value));
+  }
+  function scalePatternForZoom(options) {
+    const zoom = finite(options.zoom, "zoom");
+    const referenceZoom = finite(options.referenceZoom, "referenceZoom");
+    const visualSize = positive(options.visualSize, "visualSize");
+    const spacing = positive(options.spacing, "spacing");
+    const opticalScale = positive(options.opticalScale ?? 1, "opticalScale");
+    const minReadableSize = positive(
+      options.minReadableSize ?? 10,
+      "minReadableSize"
+    );
+    const maxVisualSize = positive(
+      options.maxVisualSize ?? 72,
+      "maxVisualSize"
+    );
+    const maxSpacingAtReadableFloorRatio = options.maxSpacingAtReadableFloorRatio === void 0 ? void 0 : positive(
+      options.maxSpacingAtReadableFloorRatio,
+      "maxSpacingAtReadableFloorRatio"
+    );
+    if (maxVisualSize < minReadableSize) {
+      throw new RangeError("maxVisualSize must be greater than or equal to minReadableSize");
+    }
+    const rawScale = options.mode === "map" ? 2 ** (zoom - referenceZoom) : 1;
+    const rawVisualSize = visualSize * rawScale;
+    const minimumVisualSize = Math.min(visualSize, minReadableSize);
+    const minimumScale = minimumVisualSize / visualSize;
+    const maximumScale = maxVisualSize / visualSize;
+    const scale = clamp(rawScale, minimumScale, maximumScale);
+    const renderedVisualSize = visualSize * scale;
+    let renderedSpacing = spacing * scale;
+    if (maxSpacingAtReadableFloorRatio !== void 0 && rawScale <= minimumScale) {
+      renderedSpacing = Math.min(
+        renderedSpacing,
+        renderedVisualSize * maxSpacingAtReadableFloorRatio
+      );
+    }
+    return {
+      scale,
+      rawVisualSize,
+      visualSize: renderedVisualSize,
+      stampSize: renderedVisualSize / opticalScale,
+      spacing: renderedSpacing,
+      density: 1e4 / (renderedSpacing * renderedSpacing),
+      opacity: 1,
+      floored: rawScale < minimumScale,
+      capped: rawScale > maximumScale
+    };
+  }
+
+  // src/engine/screenPatternPhase.ts
+  function screenPatternPhase(zoom, steps = 8) {
+    if (!Number.isFinite(zoom)) {
+      throw new TypeError("zoom must be a finite number");
+    }
+    if (!Number.isInteger(steps) || steps < 1) {
+      throw new RangeError("steps must be a positive integer");
+    }
+    const fraction = zoom - Math.floor(zoom);
+    const index = Math.min(steps, Math.round(fraction * steps));
+    return {
+      index,
+      pixelRatioScale: 2 ** (index / steps)
+    };
+  }
+
+  // src/engine/geojsonImport.ts
+  function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function position(value, path) {
+    if (!Array.isArray(value) || value.length < 2 || value.some((coordinate) => typeof coordinate !== "number" || !Number.isFinite(coordinate))) {
+      throw new TypeError(`${path} must contain finite coordinate positions`);
+    }
+    const [longitude, latitude] = value;
+    if (longitude < -180 || longitude > 180 || latitude < -90 || latitude > 90) {
+      throw new RangeError(`${path} must use WGS84 longitude and latitude`);
+    }
+    return value.slice();
+  }
+  function samePosition(a, b) {
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+  }
+  function ring(value, path) {
+    if (!Array.isArray(value) || value.length < 3) {
+      throw new TypeError(`${path} must contain at least three positions`);
+    }
+    const positions = value.map((item, index) => position(item, `${path}[${index}]`));
+    if (!samePosition(positions[0], positions[positions.length - 1])) {
+      positions.push(positions[0].slice());
+    }
+    const unique = new Set(
+      positions.slice(0, -1).map((item) => `${item[0]},${item[1]}`)
+    );
+    if (unique.size < 3) {
+      throw new TypeError(`${path} must contain at least three distinct positions`);
+    }
+    return positions;
+  }
+  function polygonCoordinates(value, path) {
+    if (!Array.isArray(value) || value.length === 0) {
+      throw new TypeError(`${path} must contain at least one linear ring`);
+    }
+    return value.map((item, index) => ring(item, `${path}[${index}]`));
+  }
+  function properties(value) {
+    return record(value) ? { ...value } : {};
+  }
+  function featureId(value) {
+    return typeof value === "string" || typeof value === "number" ? value : void 0;
+  }
+  function importGeoJsonPolygons(input, maximumFeatures = 48) {
+    if (!Number.isInteger(maximumFeatures) || maximumFeatures < 1) {
+      throw new RangeError("maximumFeatures must be a positive integer");
+    }
+    const result = [];
+    let ignoredFeatures = 0;
+    function appendPolygon(coordinates, sourceProperties, id, path) {
+      result.push({
+        type: "Feature",
+        ...featureId(id) === void 0 ? {} : { id: featureId(id) },
+        properties: properties(sourceProperties),
+        geometry: {
+          type: "Polygon",
+          coordinates: polygonCoordinates(coordinates, path)
+        }
+      });
+      if (result.length > maximumFeatures) {
+        throw new RangeError(
+          `GeoJSON contains more than ${maximumFeatures} polygon parts`
+        );
+      }
+    }
+    function visitGeometry(geometry, sourceProperties, id, path) {
+      if (!record(geometry) || typeof geometry.type !== "string") return false;
+      if (geometry.type === "Polygon") {
+        appendPolygon(geometry.coordinates, sourceProperties, id, `${path}.coordinates`);
+        return true;
+      }
+      if (geometry.type === "MultiPolygon") {
+        if (!Array.isArray(geometry.coordinates) || geometry.coordinates.length === 0) {
+          throw new TypeError(`${path}.coordinates must contain polygons`);
+        }
+        geometry.coordinates.forEach((coordinates, index) => {
+          appendPolygon(
+            coordinates,
+            sourceProperties,
+            id,
+            `${path}.coordinates[${index}]`
+          );
+        });
+        return true;
+      }
+      if (geometry.type === "GeometryCollection") {
+        if (!Array.isArray(geometry.geometries)) {
+          throw new TypeError(`${path}.geometries must be an array`);
+        }
+        let found = false;
+        geometry.geometries.forEach((item, index) => {
+          found = visitGeometry(
+            item,
+            sourceProperties,
+            id,
+            `${path}.geometries[${index}]`
+          ) || found;
+        });
+        return found;
+      }
+      return false;
+    }
+    function visit(value, path) {
+      if (!record(value) || typeof value.type !== "string") {
+        throw new TypeError(`${path} must be a GeoJSON object`);
+      }
+      if (value.type === "FeatureCollection") {
+        if (!Array.isArray(value.features)) {
+          throw new TypeError(`${path}.features must be an array`);
+        }
+        value.features.forEach((item, index) => {
+          if (!record(item) || item.type !== "Feature") {
+            throw new TypeError(`${path}.features[${index}] must be a Feature`);
+          }
+          const found = visitGeometry(
+            item.geometry,
+            item.properties,
+            item.id,
+            `${path}.features[${index}].geometry`
+          );
+          if (!found) ignoredFeatures++;
+        });
+        return;
+      }
+      if (value.type === "Feature") {
+        const found = visitGeometry(
+          value.geometry,
+          value.properties,
+          value.id,
+          `${path}.geometry`
+        );
+        if (!found) ignoredFeatures++;
+        return;
+      }
+      if (!visitGeometry(value, {}, void 0, path)) ignoredFeatures++;
+    }
+    visit(input, "GeoJSON");
+    if (result.length === 0) {
+      throw new TypeError("GeoJSON does not contain Polygon or MultiPolygon geometry");
+    }
+    return { features: result, ignoredFeatures };
+  }
+
+  // src/maplibre/patternDefinition.ts
+  var PATTERN_METADATA_KEY = "maplibre-pattern-fills:v1";
+  var geometricTypes = /* @__PURE__ */ new Set([
+    "stipple",
+    "hachures",
+    "cross",
+    "grid",
+    "dots"
+  ]);
+  function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function finiteNumber(record2, key) {
+    const value = record2[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new TypeError(`${key} must be a finite number`);
+    }
+    return value;
+  }
+  function positiveNumber(record2, key) {
+    const value = finiteNumber(record2, key);
+    if (value <= 0) throw new RangeError(`${key} must be greater than 0`);
+    return value;
+  }
+  function nonNegativeNumber(record2, key) {
+    const value = finiteNumber(record2, key);
+    if (value < 0) throw new RangeError(`${key} must be greater than or equal to 0`);
+    return value;
+  }
+  function nonEmptyString(record2, key) {
+    const value = record2[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+      throw new TypeError(`${key} must be a non-empty string`);
+    }
+    return value;
+  }
+  function parsePatternDefinition(value) {
+    if (!isRecord(value)) throw new TypeError("pattern definition must be an object");
+    if (value.kind === "geometric") {
+      if (typeof value.pattern !== "string" || !geometricTypes.has(value.pattern)) {
+        throw new TypeError("pattern must be a supported non-solid geometric pattern");
+      }
+      const definition = {
+        kind: "geometric",
+        pattern: value.pattern,
+        size: positiveNumber(value, "size"),
+        color: nonEmptyString(value, "color"),
+        weight: positiveNumber(value, "weight"),
+        angle: finiteNumber(value, "angle")
+      };
+      if (value.pixelRatio !== void 0) {
+        definition.pixelRatio = positiveNumber(value, "pixelRatio");
+      }
+      if (value.stippleCount !== void 0) {
+        const stippleCount = positiveNumber(value, "stippleCount");
+        if (!Number.isInteger(stippleCount)) {
+          throw new RangeError("stippleCount must be a positive integer");
+        }
+        definition.stippleCount = stippleCount;
+      }
+      return definition;
+    }
+    if (value.kind === "svg") {
+      const scaleJitter = nonNegativeNumber(value, "scaleJitter");
+      if (scaleJitter >= 1) throw new RangeError("scaleJitter must be less than 1");
+      const seed = value.seed;
+      if ((typeof seed !== "string" || seed.length === 0) && (typeof seed !== "number" || !Number.isFinite(seed))) {
+        throw new TypeError("seed must be a finite number or a non-empty string");
+      }
+      if (typeof value.stagger !== "boolean") throw new TypeError("stagger must be a boolean");
+      const distribution = value.distribution ?? (value.stagger ? "offset" : "regular");
+      if (distribution !== "regular" && distribution !== "offset" && distribution !== "natural") {
+        throw new TypeError("distribution must be regular, offset, or natural");
+      }
+      return {
+        kind: "svg",
+        svg: nonEmptyString(value, "svg"),
+        tileSize: positiveNumber(value, "tileSize"),
+        stampSize: positiveNumber(value, "stampSize"),
+        density: positiveNumber(value, "density"),
+        seed,
+        rotationJitterDeg: nonNegativeNumber(value, "rotationJitterDeg"),
+        scaleJitter,
+        positionJitter: nonNegativeNumber(value, "positionJitter"),
+        stagger: distribution === "offset",
+        distribution,
+        minSpacing: value.minSpacing === void 0 ? 0 : nonNegativeNumber(value, "minSpacing")
+      };
+    }
+    if (value.kind === "font") {
+      const fontStyle = value.fontStyle;
+      if (fontStyle !== "normal" && fontStyle !== "italic") {
+        throw new TypeError("fontStyle must be normal or italic");
+      }
+      if (typeof value.stagger !== "boolean") throw new TypeError("stagger must be a boolean");
+      return {
+        kind: "font",
+        text: nonEmptyString(value, "text"),
+        fontFamily: nonEmptyString(value, "fontFamily"),
+        fontSize: positiveNumber(value, "fontSize"),
+        fontWeight: nonEmptyString(value, "fontWeight"),
+        fontStyle,
+        letterSpacing: finiteNumber(value, "letterSpacing"),
+        horizontalSpacing: nonNegativeNumber(value, "horizontalSpacing"),
+        verticalSpacing: nonNegativeNumber(value, "verticalSpacing"),
+        rotationDeg: finiteNumber(value, "rotationDeg"),
+        stagger: value.stagger,
+        color: nonEmptyString(value, "color")
+      };
+    }
+    throw new TypeError('pattern definition kind must be "geometric", "svg", or "font"');
+  }
+  function parsePatternMetadata(value) {
+    if (!isRecord(value)) throw new TypeError("pattern metadata must be an object");
+    const metadata = {
+      imageId: nonEmptyString(value, "imageId"),
+      definition: parsePatternDefinition(value.definition)
+    };
+    if (value.variants !== void 0) {
+      if (!Array.isArray(value.variants) || value.variants.length === 0) {
+        throw new TypeError("variants must be a non-empty array");
+      }
+      metadata.variants = value.variants.map((variant, index) => {
+        if (!isRecord(variant)) {
+          throw new TypeError(`variants[${index}] must be an object`);
+        }
+        return {
+          zoom: finiteNumber(variant, "zoom"),
+          imageId: nonEmptyString(variant, "imageId"),
+          definition: parsePatternDefinition(variant.definition)
+        };
+      });
+      for (let index = 1; index < metadata.variants.length; index++) {
+        if (metadata.variants[index].zoom <= metadata.variants[index - 1].zoom) {
+          throw new RangeError("variant zoom levels must be strictly increasing");
+        }
+      }
+    }
+    return metadata;
+  }
+  function serializePatternDefinition(definition) {
+    return JSON.stringify(parsePatternDefinition(definition));
+  }
+  function patternDefinitionId(definition, prefix = "mpf") {
+    const serialized = serializePatternDefinition(definition);
+    let hash = 2166136261;
+    for (let index = 0; index < serialized.length; index++) {
+      hash ^= serialized.charCodeAt(index);
+      hash = Math.imul(hash, 16777619);
+    }
+    return `${prefix}_${(hash >>> 0).toString(16).padStart(8, "0")}`;
+  }
+  function createSvgPatternDefinition(options) {
+    const distribution = options.distribution ?? (options.stagger === false ? "regular" : "offset");
+    return parsePatternDefinition({
+      kind: "svg",
+      svg: options.svg,
+      tileSize: options.tileSize ?? 288,
+      stampSize: options.stampSize ?? 28,
+      density: options.density ?? 1.4,
+      seed: options.seed ?? 1,
+      rotationJitterDeg: options.rotationJitterDeg ?? 0,
+      scaleJitter: options.scaleJitter ?? 0,
+      positionJitter: options.positionJitter ?? 0.15,
+      stagger: distribution === "offset",
+      distribution,
+      minSpacing: options.minSpacing ?? 0
+    });
+  }
+  function createFontPatternDefinition(options) {
+    return parsePatternDefinition({
+      kind: "font",
+      text: options.text,
+      fontFamily: options.fontFamily ?? "sans-serif",
+      fontSize: options.fontSize ?? 18,
+      fontWeight: options.fontWeight ?? "500",
+      fontStyle: options.fontStyle ?? "normal",
+      letterSpacing: options.letterSpacing ?? 0,
+      horizontalSpacing: options.horizontalSpacing ?? 26,
+      verticalSpacing: options.verticalSpacing ?? 22,
+      rotationDeg: options.rotationDeg ?? 0,
+      stagger: options.stagger ?? true,
+      color: options.color ?? "#000000"
+    });
+  }
+
+  // src/maplibre/syncPatternTexture.ts
+  var installedPatterns = /* @__PURE__ */ new WeakMap();
+  function resolvePixelRatio(value) {
+    const displayRatio = typeof globalThis.devicePixelRatio === "number" ? globalThis.devicePixelRatio : 1;
+    const ratio = value ?? Math.min(Math.max(displayRatio, 1), 2);
+    if (!Number.isFinite(ratio) || ratio <= 0) {
+      throw new RangeError("pixelRatio must be a finite number greater than 0");
+    }
+    return ratio;
+  }
+  function syncPatternTexture(map, options) {
+    const { imageId, pattern, size, color, weight, angle, stippleCount } = options;
+    if (pattern === "solid") return;
+    const pixelRatio = resolvePixelRatio(options.pixelRatio);
+    let byImage = installedPatterns.get(map);
+    if (!byImage) {
+      byImage = /* @__PURE__ */ new Map();
+      installedPatterns.set(map, byImage);
+    }
+    const signature = JSON.stringify({ pattern, size, color, weight, angle, pixelRatio, stippleCount });
+    const previous = byImage.get(imageId);
+    if (map.hasImage(imageId) && previous?.signature === signature) return;
+    const tile = makeTile(pattern, size, color, weight, angle, { pixelRatio, stippleCount });
+    if (map.hasImage(imageId) && previous?.width === tile.width && previous.height === tile.height && previous.pixelRatio === pixelRatio) {
+      map.updateImage(imageId, tile);
+    } else {
+      if (map.hasImage(imageId)) map.removeImage(imageId);
+      map.addImage(imageId, tile, { pixelRatio });
+    }
+    byImage.set(imageId, {
+      signature,
+      width: tile.width,
+      height: tile.height,
+      pixelRatio
+    });
+    map.triggerRepaint();
+  }
+
+  // src/maplibre/buildStyleFragment.ts
+  function buildStyleFragment(options) {
+    const { source, sourceLayer, sourceUrl, bg, pattern, line } = options;
+    const layers = [];
+    if (bg?.enabled) {
+      layers.push({
+        id: `${source}__bg`,
+        type: "fill",
+        source,
+        "source-layer": sourceLayer,
+        paint: { "fill-color": bg.color, "fill-opacity": bg.opacity }
+      });
+    }
+    if (pattern.pattern === "solid") {
+      layers.push({
+        id: `${source}__pat`,
+        type: "fill",
+        source,
+        "source-layer": sourceLayer,
+        paint: { "fill-color": pattern.color, "fill-opacity": pattern.opacity }
+      });
+    } else {
+      const definition = {
+        kind: "geometric",
+        pattern: pattern.pattern,
+        size: pattern.tile,
+        color: pattern.color,
+        weight: pattern.weight,
+        angle: pattern.angle,
+        ...pattern.pixelRatio === void 0 ? {} : { pixelRatio: pattern.pixelRatio },
+        ...pattern.stippleCount === void 0 ? {} : { stippleCount: pattern.stippleCount }
+      };
+      const imageId = patternDefinitionId(definition);
+      layers.push({
+        id: `${source}__pat`,
+        type: "fill",
+        source,
+        "source-layer": sourceLayer,
+        paint: { "fill-pattern": imageId, "fill-opacity": pattern.opacity },
+        metadata: {
+          [PATTERN_METADATA_KEY]: { imageId, definition }
+        }
+      });
+    }
+    if (line?.enabled) {
+      layers.push({
+        id: `${source}__line`,
+        type: "line",
+        source,
+        "source-layer": sourceLayer,
+        paint: {
+          "line-color": line.color,
+          "line-width": line.width,
+          ...line.dash.length ? { "line-dasharray": line.dash } : {}
+        }
+      });
+    }
+    return {
+      sources: { [source]: { type: "vector", url: sourceUrl ?? `<url>/${source}` } },
+      layers
+    };
+  }
+
+  // src/maplibre/loadSvgImage.ts
+  async function loadSvgImage(svg) {
+    const blob = new Blob([svg], { type: "image/svg+xml" });
+    const url = URL.createObjectURL(blob);
+    try {
+      const img = new Image();
+      img.src = url;
+      await img.decode();
+      return img;
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }
+
+  // src/maplibre/svgPattern.ts
+  function resolvePixelRatio2(value, useDisplayRatio) {
+    const displayRatio = useDisplayRatio && typeof globalThis.devicePixelRatio === "number" ? globalThis.devicePixelRatio : 1;
+    const ratio = value ?? Math.min(Math.max(displayRatio, 1), 2);
+    if (!Number.isFinite(ratio) || ratio <= 0) {
+      throw new RangeError("pixelRatio must be a finite number greater than 0");
+    }
+    return ratio;
+  }
+  async function createSvgScatterTile(options) {
+    const definition = createSvgPatternDefinition(options);
+    const pixelRatio = resolvePixelRatio2(options.pixelRatio, false);
+    const {
+      svg,
+      tileSize,
+      stampSize,
+      density,
+      seed,
+      rotationJitterDeg,
+      scaleJitter,
+      positionJitter,
+      stagger,
+      distribution,
+      minSpacing
+    } = definition;
+    const image = await loadSvgImage(svg);
+    const canvas = document.createElement("canvas");
+    const physicalTileSize = Math.max(1, Math.round(tileSize * pixelRatio));
+    const renderScale = physicalTileSize / tileSize;
+    canvas.width = canvas.height = physicalTileSize;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("2D canvas context unavailable");
+    ctx.clearRect(0, 0, physicalTileSize, physicalTileSize);
+    ctx.scale(renderScale, renderScale);
+    const placements = createSvgScatterLayout({
+      tileSize,
+      stampSize,
+      density,
+      seed,
+      rotationJitterDeg,
+      scaleJitter,
+      positionJitter,
+      stagger,
+      distribution,
+      minSpacing
+    });
+    for (const placement of placements) {
+      ctx.save();
+      ctx.translate(placement.x, placement.y);
+      ctx.rotate(placement.rotationRad);
+      ctx.scale(placement.scale, placement.scale);
+      ctx.drawImage(image, -stampSize / 2, -stampSize / 2, stampSize, stampSize);
+      ctx.restore();
+    }
+    const imageData = ctx.getImageData(0, 0, physicalTileSize, physicalTileSize);
+    return {
+      width: physicalTileSize,
+      height: physicalTileSize,
+      data: new Uint8Array(imageData.data.buffer)
+    };
+  }
+  var installedSvgPatterns = /* @__PURE__ */ new WeakMap();
+  var svgPatternGenerations = /* @__PURE__ */ new WeakMap();
+  async function installSvgPatternFill(map, options) {
+    const definition = createSvgPatternDefinition(options);
+    const pixelRatio = resolvePixelRatio2(options.pixelRatio, true);
+    const signature = `${serializePatternDefinition(definition)}@${pixelRatio}`;
+    let installedById = installedSvgPatterns.get(map);
+    if (!installedById) {
+      installedById = /* @__PURE__ */ new Map();
+      installedSvgPatterns.set(map, installedById);
+    }
+    if (map.hasImage(options.imageId) && installedById.get(options.imageId)?.signature === signature) {
+      return;
+    }
+    let generationsById = svgPatternGenerations.get(map);
+    if (!generationsById) {
+      generationsById = /* @__PURE__ */ new Map();
+      svgPatternGenerations.set(map, generationsById);
+    }
+    const generation = (generationsById.get(options.imageId) ?? 0) + 1;
+    generationsById.set(options.imageId, generation);
+    const tile = await createSvgScatterTile({ ...options, pixelRatio });
+    if (generationsById.get(options.imageId) !== generation) return;
+    const previous = installedById.get(options.imageId);
+    if (map.hasImage(options.imageId) && previous?.width === tile.width && previous.height === tile.height && previous.pixelRatio === pixelRatio) {
+      map.updateImage(options.imageId, tile);
+    } else {
+      if (map.hasImage(options.imageId)) map.removeImage(options.imageId);
+      map.addImage(options.imageId, tile, { pixelRatio });
+    }
+    installedById.set(options.imageId, {
+      signature,
+      width: tile.width,
+      height: tile.height,
+      pixelRatio
+    });
+    map.triggerRepaint();
+  }
+
+  // src/maplibre/fontPattern.ts
+  function resolvePixelRatio3(value, useDisplayRatio) {
+    const displayRatio = useDisplayRatio && typeof globalThis.devicePixelRatio === "number" ? globalThis.devicePixelRatio : 1;
+    const ratio = value ?? Math.min(Math.max(displayRatio, 1), 2);
+    if (!Number.isFinite(ratio) || ratio <= 0) {
+      throw new RangeError("pixelRatio must be a finite number greater than 0");
+    }
+    return ratio;
+  }
+  function textWidth(ctx, characters, letterSpacing) {
+    const glyphs = characters.reduce((total, character) => total + ctx.measureText(character).width, 0);
+    return Math.max(1, glyphs + Math.max(0, characters.length - 1) * letterSpacing);
+  }
+  function fillSpacedText(ctx, characters, width, letterSpacing) {
+    let x = -width / 2;
+    for (const character of characters) {
+      const characterWidth = ctx.measureText(character).width;
+      ctx.fillText(character, x, 0);
+      x += characterWidth + letterSpacing;
+    }
+  }
+  async function createFontPatternTile(options) {
+    const definition = createFontPatternDefinition(options);
+    const pixelRatio = resolvePixelRatio3(options.pixelRatio, false);
+    const {
+      text,
+      fontFamily,
+      fontSize,
+      fontWeight,
+      fontStyle,
+      letterSpacing,
+      horizontalSpacing,
+      verticalSpacing,
+      rotationDeg,
+      stagger,
+      color
+    } = definition;
+    if (typeof document === "undefined") {
+      throw new Error("Font pattern rasterization requires a browser canvas");
+    }
+    const font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily}`;
+    if (document.fonts?.load) {
+      await document.fonts.load(font, text.slice(0, 32)).catch(() => void 0);
+    }
+    const measureCanvas = document.createElement("canvas");
+    const measureContext = measureCanvas.getContext("2d");
+    if (!measureContext) throw new Error("2D canvas context unavailable");
+    measureContext.font = font;
+    const characters = Array.from(text);
+    const measuredWidth = textWidth(measureContext, characters, letterSpacing);
+    const metrics = measureContext.measureText(text);
+    const measuredHeight = Math.max(
+      fontSize,
+      (metrics.actualBoundingBoxAscent || fontSize * 0.8) + (metrics.actualBoundingBoxDescent || fontSize * 0.2)
+    );
+    const radians = rotationDeg * Math.PI / 180;
+    const rotatedWidth = Math.abs(measuredWidth * Math.cos(radians)) + Math.abs(measuredHeight * Math.sin(radians));
+    const rotatedHeight = Math.abs(measuredWidth * Math.sin(radians)) + Math.abs(measuredHeight * Math.cos(radians));
+    const cellWidth = Math.max(1, Math.ceil(rotatedWidth + horizontalSpacing));
+    const rowHeight = Math.max(1, Math.ceil(rotatedHeight + verticalSpacing));
+    const logicalWidth = cellWidth * (stagger ? 2 : 1);
+    const logicalHeight = rowHeight * (stagger ? 2 : 1);
+    const physicalWidth = Math.max(1, Math.round(logicalWidth * pixelRatio));
+    const physicalHeight = Math.max(1, Math.round(logicalHeight * pixelRatio));
+    const canvas = document.createElement("canvas");
+    canvas.width = physicalWidth;
+    canvas.height = physicalHeight;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("2D canvas context unavailable");
+    ctx.clearRect(0, 0, physicalWidth, physicalHeight);
+    ctx.scale(physicalWidth / logicalWidth, physicalHeight / logicalHeight);
+    ctx.font = font;
+    ctx.textAlign = "left";
+    ctx.textBaseline = "middle";
+    ctx.fillStyle = color;
+    const rowCount = stagger ? 2 : 1;
+    const columnCount = stagger ? 2 : 1;
+    for (let row = -2; row <= rowCount + 1; row++) {
+      const offset = stagger && Math.abs(row % 2) === 1 ? cellWidth / 2 : 0;
+      for (let column = -2; column <= columnCount + 1; column++) {
+        const x = column * cellWidth + cellWidth / 2 + offset;
+        const y = row * rowHeight + rowHeight / 2;
+        ctx.save();
+        ctx.translate(x, y);
+        ctx.rotate(radians);
+        fillSpacedText(ctx, characters, measuredWidth, letterSpacing);
+        ctx.restore();
+      }
+    }
+    const imageData = ctx.getImageData(0, 0, physicalWidth, physicalHeight);
+    return {
+      width: physicalWidth,
+      height: physicalHeight,
+      data: new Uint8Array(imageData.data.buffer)
+    };
+  }
+  var installedFontPatterns = /* @__PURE__ */ new WeakMap();
+  var fontPatternGenerations = /* @__PURE__ */ new WeakMap();
+  async function installFontPatternFill(map, options) {
+    if (typeof options.imageId !== "string" || options.imageId.trim().length === 0) {
+      throw new TypeError("imageId must be a non-empty string");
+    }
+    const definition = createFontPatternDefinition(options);
+    const pixelRatio = resolvePixelRatio3(options.pixelRatio, true);
+    const signature = `${serializePatternDefinition(definition)}@${pixelRatio}`;
+    let installedById = installedFontPatterns.get(map);
+    if (!installedById) {
+      installedById = /* @__PURE__ */ new Map();
+      installedFontPatterns.set(map, installedById);
+    }
+    if (map.hasImage(options.imageId) && installedById.get(options.imageId)?.signature === signature) {
+      return;
+    }
+    let generationsById = fontPatternGenerations.get(map);
+    if (!generationsById) {
+      generationsById = /* @__PURE__ */ new Map();
+      fontPatternGenerations.set(map, generationsById);
+    }
+    const generation = (generationsById.get(options.imageId) ?? 0) + 1;
+    generationsById.set(options.imageId, generation);
+    const tile = await createFontPatternTile({ ...options, pixelRatio });
+    if (generationsById.get(options.imageId) !== generation) return;
+    const previous = installedById.get(options.imageId);
+    if (map.hasImage(options.imageId) && previous?.width === tile.width && previous.height === tile.height && previous.pixelRatio === pixelRatio) {
+      map.updateImage(options.imageId, tile);
+    } else {
+      if (map.hasImage(options.imageId)) map.removeImage(options.imageId);
+      map.addImage(options.imageId, tile, { pixelRatio });
+    }
+    installedById.set(options.imageId, {
+      signature,
+      width: tile.width,
+      height: tile.height,
+      pixelRatio
+    });
+    map.triggerRepaint();
+  }
+
+  // src/maplibre/installPatternFills.ts
+  async function installPatternFills(map, style) {
+    const installed = /* @__PURE__ */ new Map();
+    const pending = [];
+    for (const layer of style.layers) {
+      const metadata = layer.metadata;
+      if (!metadata) continue;
+      const rawDefinition = metadata[PATTERN_METADATA_KEY];
+      if (!rawDefinition) continue;
+      const registration = parsePatternMetadata(rawDefinition);
+      const definitions = [
+        { imageId: registration.imageId, definition: registration.definition },
+        ...registration.variants ?? []
+      ];
+      for (const item of definitions) {
+        const signature = serializePatternDefinition(item.definition);
+        const previous = installed.get(item.imageId);
+        if (previous && previous !== signature) {
+          throw new Error(`Conflicting pattern definitions use image id "${item.imageId}"`);
+        }
+        if (previous) continue;
+        installed.set(item.imageId, signature);
+        const p = item.definition;
+        if (p.kind === "geometric") {
+          syncPatternTexture(map, {
+            imageId: item.imageId,
+            pattern: p.pattern,
+            size: p.size,
+            color: p.color,
+            weight: p.weight,
+            angle: p.angle,
+            pixelRatio: p.pixelRatio,
+            stippleCount: p.stippleCount
+          });
+        } else if (p.kind === "svg") {
+          pending.push(installSvgPatternFill(map, { imageId: item.imageId, ...p }));
+        } else {
+          pending.push(installFontPatternFill(map, { imageId: item.imageId, ...p }));
+        }
+      }
+    }
+    await Promise.all(pending);
+  }
+
+  // src/maplibre/observePatternFills.ts
+  function observePatternFills(map, options = {}) {
+    const getStyle = options.getStyle ?? (() => map.getStyle());
+    const onError = options.onError ?? ((error) => {
+      console.error("stipple-maplibre: failed to restore pattern images", error);
+    });
+    let disposed = false;
+    const refresh = async () => {
+      if (disposed) return;
+      await installPatternFills(map, getStyle());
+    };
+    const onStyleLoad = () => {
+      void refresh().catch(onError);
+    };
+    map.on("style.load", onStyleLoad);
+    return {
+      refresh,
+      dispose() {
+        if (disposed) return;
+        disposed = true;
+        map.off("style.load", onStyleLoad);
+      }
+    };
+  }
+
+  // src/maplibre/scatterIconPoints.ts
+  function toPolygons(polygon) {
+    return polygon.type === "Polygon" ? [polygon.coordinates] : polygon.coordinates;
+  }
+  function componentSeed(seed, index) {
+    const base = seed ?? 1;
+    return typeof base === "string" ? `${base}:${index}` : base + Math.imul(index, 2654435761);
+  }
+  function scatterIconPoints(options) {
+    const {
+      map,
+      polygon,
+      iconRadiusPx,
+      density,
+      seed,
+      rotationJitterDeg,
+      scaleJitter,
+      positionJitter,
+      stagger,
+      distribution,
+      minSpacing,
+      viewportPaddingPx
+    } = options;
+    let clipBounds;
+    if (viewportPaddingPx !== void 0) {
+      if (!Number.isFinite(viewportPaddingPx) || viewportPaddingPx < 0) {
+        throw new RangeError("viewportPaddingPx must be a finite number greater than or equal to 0");
+      }
+      const canvas = map.getCanvas?.();
+      if (canvas) {
+        const pixelRatio = globalThis.devicePixelRatio || 1;
+        const width = canvas.clientWidth || canvas.width / pixelRatio;
+        const height = canvas.clientHeight || canvas.height / pixelRatio;
+        clipBounds = {
+          minX: -viewportPaddingPx,
+          minY: -viewportPaddingPx,
+          maxX: width + viewportPaddingPx,
+          maxY: height + viewportPaddingPx
+        };
+      }
+    }
+    const points = toPolygons(polygon).flatMap((polygonRings, polygonIndex) => {
+      const pixelRings = polygonRings.map(
+        (ring2) => ring2.map(([lng, lat]) => {
+          const p = map.project([lng, lat]);
+          return [p.x, p.y];
+        })
+      );
+      return scatterPointsInPolygon(pixelRings, {
+        radius: iconRadiusPx,
+        density,
+        seed: componentSeed(seed, polygonIndex),
+        rotationJitterDeg,
+        scaleJitter,
+        positionJitter,
+        stagger,
+        distribution,
+        minSpacing,
+        clipBounds
+      });
+    });
+    const features = points.map(({ x, y, rotation, scale }, index) => {
+      const lngLat = map.unproject([x, y]);
+      return {
+        type: "Feature",
+        id: index,
+        geometry: { type: "Point", coordinates: [lngLat.lng, lngLat.lat] },
+        properties: { rotation, scale }
+      };
+    });
+    return { type: "FeatureCollection", features };
+  }
+
+  // src/maplibre/svgIcon.ts
+  var installedSvgIcons = /* @__PURE__ */ new WeakMap();
+  async function addSvgIcon(map, options) {
+    const { id, svg, size = 32, pixelRatio = 2 } = options;
+    const px = Math.round(size * pixelRatio);
+    const signature = `${size}@${pixelRatio}:${svg}`;
+    let installedById = installedSvgIcons.get(map);
+    if (!installedById) {
+      installedById = /* @__PURE__ */ new Map();
+      installedSvgIcons.set(map, installedById);
+    }
+    const previous = installedById.get(id);
+    if (map.hasImage(id) && previous?.signature === signature) {
+      return { id, width: previous.width, height: previous.height };
+    }
+    const image = await loadSvgImage(svg);
+    const canvas = document.createElement("canvas");
+    canvas.width = canvas.height = px;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("2D canvas context unavailable");
+    ctx.clearRect(0, 0, px, px);
+    ctx.drawImage(image, 0, 0, px, px);
+    const imageData = ctx.getImageData(0, 0, px, px);
+    const tile = { width: px, height: px, data: new Uint8Array(imageData.data.buffer) };
+    if (map.hasImage(id) && previous?.width === px && previous.height === px && previous.pixelRatio === pixelRatio) {
+      map.updateImage(id, tile);
+    } else {
+      if (map.hasImage(id)) map.removeImage(id);
+      map.addImage(id, tile, { pixelRatio });
+    }
+    installedById.set(id, {
+      signature,
+      width: px,
+      height: px,
+      pixelRatio
+    });
+    return { id, width: px, height: px };
+  }
+
+  // src/maplibre/svgIconScatter.ts
+  var installedScatterFeatures = /* @__PURE__ */ new WeakMap();
+  var installedScatterLayerStates = /* @__PURE__ */ new WeakMap();
+  function featureDiff(previous, next) {
+    const [previousLng, previousLat] = previous.geometry.coordinates;
+    const [nextLng, nextLat] = next.geometry.coordinates;
+    const geometryChanged = previousLng !== nextLng || previousLat !== nextLat;
+    const propertiesChanged = previous.properties.rotation !== next.properties.rotation || previous.properties.scale !== next.properties.scale;
+    if (!geometryChanged && !propertiesChanged) return void 0;
+    return {
+      id: next.id,
+      ...geometryChanged ? { newGeometry: next.geometry } : {},
+      ...propertiesChanged ? {
+        addOrUpdateProperties: [
+          { key: "rotation", value: next.properties.rotation },
+          { key: "scale", value: next.properties.scale }
+        ]
+      } : {}
+    };
+  }
+  function scatterSourceDiff(previous, next) {
+    const sharedCount = Math.min(previous.length, next.length);
+    const update = [];
+    for (let index = 0; index < sharedCount; index++) {
+      const diff = featureDiff(previous[index], next[index]);
+      if (diff) update.push(diff);
+    }
+    return {
+      ...previous.length > next.length ? { remove: previous.slice(next.length).map(({ id }) => id) } : {},
+      ...next.length > previous.length ? { add: next.slice(previous.length) } : {},
+      ...update.length ? { update } : {}
+    };
+  }
+  async function updateScatterSource(map, sourceId, points) {
+    let featuresBySource = installedScatterFeatures.get(map);
+    if (!featuresBySource) {
+      featuresBySource = /* @__PURE__ */ new Map();
+      installedScatterFeatures.set(map, featuresBySource);
+    }
+    const previous = featuresBySource.get(sourceId);
+    featuresBySource.set(sourceId, points.features);
+    const existingSource = map.getSource(sourceId);
+    if (!existingSource) {
+      map.addSource(sourceId, {
+        type: "geojson",
+        data: points,
+        // Point geometry does not need high-zoom vector-tile subdivision.
+        // Overscaling above z14 preserves positions while reducing rebuild work.
+        maxzoom: 14
+      });
+      return;
+    }
+    if (previous && typeof existingSource.updateData === "function") {
+      const diff = scatterSourceDiff(previous, points.features);
+      if (!diff.add && !diff.remove && !diff.update) return;
+      try {
+        await existingSource.updateData(diff);
+        return;
+      } catch {
+      }
+    }
+    existingSource.setData(points);
+  }
+  async function installSvgIconScatter(map, options) {
+    const {
+      sourceId,
+      layerId,
+      iconId,
+      polygon,
+      svg,
+      size = 32,
+      density,
+      seed,
+      rotationJitterDeg,
+      scaleJitter,
+      positionJitter,
+      stagger,
+      distribution,
+      minSpacing,
+      opacity = 1,
+      scaleMode = "screen",
+      edgeClearance = true,
+      viewportPaddingPx
+    } = options;
+    if (scaleMode !== "screen" && scaleMode !== "map") {
+      throw new TypeError("scaleMode must be screen or map");
+    }
+    await addSvgIcon(map, { id: iconId, svg, size });
+    const approximateSpacing = density && density > 0 ? 100 / Math.sqrt(density) : 100;
+    const screenPadding = viewportPaddingPx ?? Math.max(
+      192,
+      size * (1 + (scaleJitter ?? 0)) * 2,
+      approximateSpacing * 2
+    );
+    const points = scatterIconPoints({
+      map,
+      polygon,
+      iconRadiusPx: edgeClearance ? size / Math.SQRT2 : 0,
+      density,
+      seed,
+      rotationJitterDeg,
+      scaleJitter,
+      positionJitter,
+      stagger,
+      distribution,
+      minSpacing,
+      viewportPaddingPx: scaleMode === "screen" ? screenPadding : void 0
+    });
+    await updateScatterSource(map, sourceId, points);
+    const iconSize = scaleMode === "map" ? [
+      "interpolate",
+      ["exponential", 2],
+      ["zoom"],
+      map.getZoom() - 8,
+      ["*", ["get", "scale"], 1 / 256],
+      map.getZoom(),
+      ["get", "scale"],
+      map.getZoom() + 8,
+      ["*", ["get", "scale"], 256]
+    ] : ["get", "scale"];
+    let layerStates = installedScatterLayerStates.get(map);
+    if (!layerStates) {
+      layerStates = /* @__PURE__ */ new Map();
+      installedScatterLayerStates.set(map, layerStates);
+    }
+    const layerModeSignature = scaleMode === "screen" ? "screen" : `map:${map.getZoom()}`;
+    if (!map.getLayer(layerId)) {
+      map.addLayer({
+        id: layerId,
+        type: "symbol",
+        source: sourceId,
+        layout: {
+          "icon-image": iconId,
+          "icon-rotate": ["get", "rotation"],
+          "icon-size": iconSize,
+          "icon-allow-overlap": true,
+          "icon-ignore-placement": true,
+          "symbol-z-order": "source"
+        },
+        paint: {
+          "icon-opacity": opacity
+        }
+      });
+      layerStates.set(layerId, {
+        mode: layerModeSignature,
+        iconId,
+        opacity
+      });
+    } else {
+      const previousLayer = layerStates.get(layerId);
+      if (previousLayer?.mode !== layerModeSignature) {
+        map.setLayoutProperty(layerId, "icon-size", iconSize);
+      }
+      if (previousLayer?.iconId !== iconId) {
+        map.setLayoutProperty(layerId, "icon-image", iconId);
+      }
+      if (previousLayer?.opacity !== opacity) {
+        map.setPaintProperty(layerId, "icon-opacity", opacity);
+      }
+      layerStates.set(layerId, {
+        mode: layerModeSignature,
+        iconId,
+        opacity
+      });
+    }
+  }
+  return __toCommonJS(src_exports);
+})();