@chrtco/sdk 0.10.53 → 0.10.55

package/dist/atlas/browser.js

@@ -18817,9 +18817,9 @@ function arcSegmentSvg(token, sweepDeg) {
   const box = segmentBox(sweepDeg);
   const end = sweepDeg + JOINT_OVERLAP_DEG;
   const core = token === "CHBRN" ? OBSCURED_CORE_WIDTH : CORE_WIDTH;
-  const R = SECTOR_ARC_RADIUS;
-  const outline = annularSectorPath(end, R - OUTLINE_WIDTH / 2, R + OUTLINE_WIDTH / 2, box);
-  const inner = annularSectorPath(end, R - core / 2, R + core / 2, box);
+  const R2 = SECTOR_ARC_RADIUS;
+  const outline = annularSectorPath(end, R2 - OUTLINE_WIDTH / 2, R2 + OUTLINE_WIDTH / 2, box);
+  const inner = annularSectorPath(end, R2 - core / 2, R2 + core / 2, box);
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${box.w}" height="${box.h}" viewBox="0 0 ${box.w} ${box.h}"><path d="${outline}" fill="CHBLK"/><path d="${inner}" fill="${token}"/></svg>`;
 }
 function legSvg() {
@@ -18971,17 +18971,17 @@ async function decode(spec) {
 var scratch = null;
 function scratchContext() {
   if (!scratch) {
-    const canvas = document.createElement("canvas");
-    scratch = canvas.getContext("2d", { willReadFrequently: true });
+    const canvas2 = document.createElement("canvas");
+    scratch = canvas2.getContext("2d", { willReadFrequently: true });
     if (!scratch) throw new Error("symbol-images: no 2d canvas context");
   }
   return scratch;
 }
 function rasterise(src, spec) {
   const ctx = scratchContext();
-  const canvas = ctx.canvas;
-  canvas.width = spec.width;
-  canvas.height = spec.height;
+  const canvas2 = ctx.canvas;
+  canvas2.width = spec.width;
+  canvas2.height = spec.height;
   ctx.drawImage(src.img, 0, -src.y, src.width, src.height);
   return ctx.getImageData(0, 0, spec.width, spec.height);
 }
@@ -19331,13 +19331,13 @@ function decodeSvgToImage(themedSvg, size) {
 }
 async function imageToBitmap(img, size) {
   try {
-    const canvas = document.createElement("canvas");
-    canvas.width = size.w;
-    canvas.height = size.h;
-    const ctx = canvas.getContext("2d");
+    const canvas2 = document.createElement("canvas");
+    canvas2.width = size.w;
+    canvas2.height = size.h;
+    const ctx = canvas2.getContext("2d");
     if (!ctx) return null;
     ctx.drawImage(img, 0, 0, size.w, size.h);
-    return await createImageBitmap(canvas);
+    return await createImageBitmap(canvas2);
   } catch {
     return null;
   }
@@ -20329,6 +20329,263 @@ function getThemedS101Svg(symbolName, table = "DAY") {
   });
 }
 
+// src/atlas/look-painter.ts
+function painter(w, h) {
+  const acc = new Float32Array(w * h * 4);
+  const over = (x, y, c, cov) => {
+    if (x < 0 || y < 0 || x >= w || y >= h || cov <= 0) return;
+    const k = (y * w + x) * 4;
+    const a = c[3] / 255 * Math.min(1, cov);
+    acc[k] = c[0] * a + acc[k] * (1 - a);
+    acc[k + 1] = c[1] * a + acc[k + 1] * (1 - a);
+    acc[k + 2] = c[2] * a + acc[k + 2] * (1 - a);
+    acc[k + 3] = a + acc[k + 3] * (1 - a);
+  };
+  const dot = (cx, cy, r, c) => {
+    for (let y = Math.floor(cy - r - 1); y <= Math.ceil(cy + r + 1); y++) {
+      for (let x = Math.floor(cx - r - 1); x <= Math.ceil(cx + r + 1); x++) over(x, y, c, r + 0.5 - Math.hypot(x + 0.5 - cx, y + 0.5 - cy));
+    }
+  };
+  const stroke = (pts, r, c) => {
+    const cov = new Float32Array(w * h);
+    for (let i = 1; i < pts.length; i++) {
+      const [x0, y0] = pts[i - 1];
+      const [x1, y1] = pts[i];
+      const n = Math.max(1, Math.ceil(Math.hypot(x1 - x0, y1 - y0) * 2));
+      for (let t = 0; t <= n; t++) {
+        const cx = x0 + (x1 - x0) * t / n;
+        const cy = y0 + (y1 - y0) * t / n;
+        for (let y = Math.floor(cy - r - 1); y <= Math.ceil(cy + r + 1); y++) {
+          for (let x = Math.floor(cx - r - 1); x <= Math.ceil(cx + r + 1); x++) {
+            if (x < 0 || y < 0 || x >= w || y >= h) continue;
+            const v = Math.max(0, Math.min(1, r + 0.5 - Math.hypot(x + 0.5 - cx, y + 0.5 - cy)));
+            if (v > cov[y * w + x]) cov[y * w + x] = v;
+          }
+        }
+      }
+    }
+    for (let k = 0; k < cov.length; k++) if (cov[k] > 0) over(k % w, Math.floor(k / w), c, cov[k]);
+  };
+  const fill = (pts, c) => {
+    const y0 = Math.max(0, Math.floor(Math.min(...pts.map((p) => p[1]))));
+    const y1 = Math.min(h - 1, Math.ceil(Math.max(...pts.map((p) => p[1]))));
+    const x0 = Math.max(0, Math.floor(Math.min(...pts.map((p) => p[0]))));
+    const x1 = Math.min(w - 1, Math.ceil(Math.max(...pts.map((p) => p[0]))));
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) {
+        let inside = 0;
+        for (let sy = 0; sy < 4; sy++) for (let sx = 0; sx < 4; sx++) {
+          const px = x + (sx + 0.5) / 4;
+          const py = y + (sy + 0.5) / 4;
+          let odd = false;
+          for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
+            const [xi, yi] = pts[i];
+            const [xj, yj] = pts[j];
+            if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi) odd = !odd;
+          }
+          if (odd) inside++;
+        }
+        over(x, y, c, inside / 16);
+      }
+    }
+  };
+  const data = () => {
+    const out = new Uint8Array(w * h * 4);
+    for (let k = 0; k < w * h; k++) {
+      const a = acc[k * 4 + 3];
+      if (a <= 0) continue;
+      out[k * 4] = Math.round(acc[k * 4] / a);
+      out[k * 4 + 1] = Math.round(acc[k * 4 + 1] / a);
+      out[k * 4 + 2] = Math.round(acc[k * 4 + 2] / a);
+      out[k * 4 + 3] = Math.round(a * 255);
+    }
+    return out;
+  };
+  return { dot, stroke, fill, data };
+}
+function turn([x, y], cx, cy, deg) {
+  const r = deg * Math.PI / 180;
+  const dx = x - cx;
+  const dy = y - cy;
+  return [cx + dx * Math.cos(r) - dy * Math.sin(r), cy + dx * Math.sin(r) + dy * Math.cos(r)];
+}
+
+// src/atlas/uschart1-marks.ts
+var CLASSIC_MARK_TONES = {
+  color: { magenta: "#953699", green: "#068b00", ink: "#000000", open: "#ffffff" },
+  // A laser printer's greys: red lighter than green, so a banded mark still
+  // shows its bands. The label (R, G) says which is which, as it always does.
+  mono: { magenta: "#8c8c8c", green: "#4d4d4d", ink: "#000000", open: "#ffffff" }
+};
+var PREFIX = { color: "chrt-look-cl-", mono: "chrt-look-cm-" };
+function classicMarkId(ink, name) {
+  return PREFIX[ink] + name;
+}
+function classicMarkInk(id) {
+  for (const ink of ["color", "mono"]) {
+    if (id.startsWith(PREFIX[ink]) && CLASSIC_MARK_NAMES.includes(id.slice(PREFIX[ink].length))) return ink;
+  }
+  return null;
+}
+var COLOURS = ["red", "green", "black", "yellow", "white"];
+var BOARDS = ["triangle-up", "triangle-down", "square", "rhombus"];
+var paints = COLOURS.flatMap((a) => [
+  a,
+  ...COLOURS.filter((b) => b !== a).flatMap((b) => [`${a}-${b}-h`, `${a}-${b}-v`])
+]);
+var BUOY_NAMES = paints.map((p) => `buoy-${p}`);
+var BOARD_NAMES = BOARDS.flatMap((s) => paints.map((p) => `board-${s}-${p}`));
+var CLASSIC_MARK_NAMES = ["flare", "disc", ...BUOY_NAMES, ...BOARD_NAMES];
+var num = (attr) => ["to-number", ["coalesce", ["get", attr], ["get", attr.toLowerCase()], 0], 0];
+var LOZENGE_BUOY = ["!", ["in", num("BOYSHP"), ["literal", [7, 8]]]];
+var DAYBEACON = ["!", ["in", num("BCNSHP"), ["literal", [3, 4, 6]]]];
+var R = 2;
+var S = 64 * R;
+var C0 = S / 2;
+var BUOY_LENGTH = 12.5;
+var BUOY_HALF_WIDTH = 3.4;
+var DISC_RADIUS = 8.5;
+var BOARD_SIDE = 8;
+var SB = 96 * R;
+var CB = SB / 2;
+var FLARE_SCALE = 0.6;
+var FLARE_ANCHOR = 18;
+function paintOf(ink, c) {
+  const t = CLASSIC_MARK_TONES[ink];
+  return c === "red" ? t.magenta : c === "green" ? t.green : c === "black" ? t.ink : t.open;
+}
+function circle(cx, cy, r) {
+  return Array.from({ length: 33 }, (_, i) => [cx + r * Math.cos(i / 32 * 2 * Math.PI), cy + r * Math.sin(i / 32 * 2 * Math.PI)]);
+}
+function flare(ink) {
+  const path = [[16.3, 28], [11.8, 7.1], [11.8, 4.9], [12.4, 3.5], [13.2, 3], [14.3, 2.1], [16, 1.9], [17.4, 2.1], [18.5, 2.4], [19.6, 3.2], [20.2, 4.6], [20.4, 5.7], [20.4, 6.9]];
+  const k = 0.9698;
+  const place = ([x, y]) => {
+    const [rx, ry] = turn([(x - 16.3) * 0.9 * FLARE_SCALE, (y - 28) * 0.9 * FLARE_SCALE], 0, 0, 135);
+    return [((rx + 10 - 16.1) * k + 16) * 2 * R, ((ry + 10 - 14.95) * k + 16) * 2 * R];
+  };
+  const t = CLASSIC_MARK_TONES[ink];
+  return { width: S, height: S, pixelRatio: R, ops: [{ fill: path.map(place), c: t.magenta }, { dot: [FLARE_ANCHOR * R, FLARE_ANCHOR * R], r: 2.6 * R, c: t.ink }] };
+}
+function disc(ink) {
+  return { width: S, height: S, pixelRatio: R, ops: [{ fill: circle(C0, C0, DISC_RADIUS * R), c: CLASSIC_MARK_TONES[ink].magenta }] };
+}
+function buoy(ink, c1, c2, split) {
+  const ops = [];
+  const t = CLASSIC_MARK_TONES[ink];
+  const L = BUOY_LENGTH;
+  const W = BUOY_HALF_WIDTH;
+  const lean = 45;
+  const at = (a, b) => turn([CB + b * R, CB - a * R], CB, CB, lean);
+  const foot = 1.6;
+  const outline = [at(foot, 0), at(foot + L / 2, -W), at(foot + L, 0), at(foot + L / 2, W)];
+  if (split === null) ops.push({ fill: outline, c: paintOf(ink, c1) });
+  else if (split === "h") {
+    ops.push({ fill: [at(foot, 0), at(foot + L / 2, -W), at(foot + L / 2, W)], c: paintOf(ink, c2) });
+    ops.push({ fill: [at(foot + L / 2, -W), at(foot + L, 0), at(foot + L / 2, W)], c: paintOf(ink, c1) });
+  } else {
+    ops.push({ fill: [at(foot, 0), at(foot + L / 2, -W), at(foot + L, 0)], c: paintOf(ink, c1) });
+    ops.push({ fill: [at(foot, 0), at(foot + L, 0), at(foot + L / 2, W)], c: paintOf(ink, c2) });
+  }
+  ops.push({ stroke: [...outline, outline[0]], r: 0.35 * R, c: t.ink });
+  if (split === "v") ops.push({ stroke: [at(foot, 0), at(foot + L, 0)], r: 0.3 * R, c: t.ink });
+  if (split === "h") ops.push({ stroke: [at(foot + L / 2, -W), at(foot + L / 2, W)], r: 0.3 * R, c: t.ink });
+  const ring = circle(CB, CB, 2 * R);
+  ops.push({ fill: ring, c: t.open });
+  ops.push({ stroke: ring, r: 0.35 * R, c: t.ink });
+  return { width: SB, height: SB, pixelRatio: R, ops };
+}
+function boardOutline(shape) {
+  const h = BOARD_SIDE / 2 * R;
+  switch (shape) {
+    case "triangle-up":
+      return [[C0 - h, C0 + h * 0.58], [C0 + h, C0 + h * 0.58], [C0, C0 - h * 1.15]];
+    case "triangle-down":
+      return [[C0 - h, C0 - h * 0.58], [C0, C0 + h * 1.15], [C0 + h, C0 - h * 0.58]];
+    case "square":
+      return [[C0 - h * 0.85, C0 - h * 0.85], [C0 + h * 0.85, C0 - h * 0.85], [C0 + h * 0.85, C0 + h * 0.85], [C0 - h * 0.85, C0 + h * 0.85]];
+    case "rhombus":
+      return [[C0, C0 - h * 1.2], [C0 + h * 1.2, C0], [C0, C0 + h * 1.2], [C0 - h * 1.2, C0]];
+  }
+}
+function half(pts, axis, first) {
+  const inside = (p) => first ? p[axis] <= C0 : p[axis] >= C0;
+  const out = [];
+  for (let i = 0; i < pts.length; i++) {
+    const a = pts[i];
+    const b = pts[(i + 1) % pts.length];
+    if (inside(a)) out.push(a);
+    if (inside(a) !== inside(b)) {
+      const t = (C0 - a[axis]) / (b[axis] - a[axis]);
+      out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+    }
+  }
+  return out;
+}
+function chord(pts, axis) {
+  const top = half(pts, axis, true);
+  return top.filter((p) => Math.abs(p[axis] - C0) < 1e-9);
+}
+function board(ink, shape, c1, c2, split) {
+  const pts = boardOutline(shape);
+  const ops = [];
+  if (split === null) ops.push({ fill: pts, c: paintOf(ink, c1) });
+  else {
+    const axis = split === "h" ? 1 : 0;
+    ops.push({ fill: half(pts, axis, true), c: paintOf(ink, c1) });
+    ops.push({ fill: half(pts, axis, false), c: paintOf(ink, c2) });
+  }
+  const ink0 = CLASSIC_MARK_TONES[ink].ink;
+  ops.push({ stroke: [...pts, pts[0]], r: 0.45 * R, c: ink0 });
+  if (split !== null) ops.push({ stroke: chord(pts, split === "h" ? 1 : 0), r: 0.3 * R, c: ink0 });
+  return { width: S, height: S, pixelRatio: R, ops };
+}
+function classicDrawing(ink, name) {
+  if (name === "flare") return flare(ink);
+  if (name === "disc") return disc(ink);
+  const m = /^(buoy|board-(triangle-up|triangle-down|square|rhombus))-([a-z]+)(?:-([a-z]+)-([hv]))?$/.exec(name);
+  if (!m || !CLASSIC_MARK_NAMES.includes(name)) throw new Error(`classic-marks: no mark ${name}`);
+  const c1 = m[3];
+  const c2 = m[4] ?? m[3];
+  const split = m[5] ?? null;
+  return m[1] === "buoy" ? buoy(ink, c1, c2, split) : board(ink, m[2], c1, c2, split);
+}
+function rgba(hex) {
+  return [parseInt(hex.slice(1, 3), 16), parseInt(hex.slice(3, 5), 16), parseInt(hex.slice(5, 7), 16), 255];
+}
+function paintDrawing(d) {
+  const p = painter(d.width, d.height);
+  for (const op of d.ops) {
+    if ("fill" in op) p.fill(op.fill, rgba(op.c));
+    else if ("stroke" in op) p.stroke(op.stroke, op.r, rgba(op.c));
+    else p.dot(op.dot[0], op.dot[1], op.r, rgba(op.c));
+  }
+  return p.data();
+}
+function drawingSvg(d) {
+  const f = (n) => String(Math.round(n * 100) / 100);
+  const pts = (ps) => ps.map(([x, y]) => `${f(x)},${f(y)}`).join(" ");
+  const body = d.ops.map(
+    (op) => "fill" in op ? `<polygon points="${pts(op.fill)}" fill="${op.c}"/>` : "stroke" in op ? `<polyline points="${pts(op.stroke)}" fill="none" stroke="${op.c}" stroke-width="${f(op.r * 2)}" stroke-linecap="round" stroke-linejoin="round"/>` : `<circle cx="${f(op.dot[0])}" cy="${f(op.dot[1])}" r="${f(op.r)}" fill="${op.c}"/>`
+  ).join("");
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${d.width}" height="${d.height}" viewBox="0 0 ${d.width} ${d.height}">${body}</svg>`;
+}
+function classicMarkSvgs(ink) {
+  return CLASSIC_MARK_NAMES.map((name) => {
+    const d = classicDrawing(ink, name);
+    return { id: classicMarkId(ink, name), svg: drawingSvg(d), width: d.width, height: d.height, pixelRatio: d.pixelRatio };
+  });
+}
+function classicMarkImage(id) {
+  const ink = classicMarkInk(id);
+  if (!ink) throw new Error(`classic-marks: no mark ${id}`);
+  const d = classicDrawing(ink, id.slice(PREFIX[ink].length));
+  return { id, width: d.width, height: d.height, pixelRatio: d.pixelRatio, data: paintDrawing(d) };
+}
+function classicMarkImages(ink) {
+  return CLASSIC_MARK_NAMES.map((name) => classicMarkImage(classicMarkId(ink, name)));
+}
+
 // src/atlas/symbol-image-specs.ts
 var SUPERSAMPLE = 2;
 var BASE_PATTERN_GLYPHS = [
@@ -20385,9 +20642,30 @@ function s101ImageSpecs(palette) {
     return [{ id, svg: svg2, ...declared(id, svg2), pixelRatio: SUPERSAMPLE, sdf: false }];
   });
 }
+function usChart1ImageSpecs(palette) {
+  const ink = palette === "EINK_MONO" ? "mono" : "color";
+  return classicMarkSvgs(ink).map((m) => ({ ...m, sdf: false }));
+}
 function symbolImageSpecs(palette, family) {
-  const own = family === "s101" ? s101ImageSpecs(palette) : family === "raster" ? rasterImageSpecs(palette) : family === "chrt" ? chrtImageSpecs(palette) : [];
-  return [...s52ImageSpecs(palette), ...basePatternImageSpecs(palette), ...own];
+  return [...s52ImageSpecs(palette), ...basePatternImageSpecs(palette), ...familyOwnImageSpecs(palette, family)];
+}
+function familyOwnImageSpecs(palette, family) {
+  switch (family) {
+    case "s52":
+      return [];
+    case "s101":
+      return s101ImageSpecs(palette);
+    case "int1":
+      return rasterImageSpecs(palette);
+    case "uschart1":
+      return [...rasterImageSpecs(palette), ...usChart1ImageSpecs(palette)];
+    case "chrt":
+      return chrtImageSpecs(palette);
+    default: {
+      const unhandled = family;
+      throw new Error(`no symbol family ${String(unhandled)}`);
+    }
+  }
 }
 var IMAGE_PROPS = /* @__PURE__ */ new Set([
   "icon-image",
@@ -20470,6 +20748,380 @@ async function loadChrtRasterSymbolImages(map, colorTable = "DAY") {
 async function reloadChrtRasterSymbolImages(map, colorTable) {
   await rethemeSymbolImages(map, rasterImageSpecs(colorTable));
 }
+
+// src/atlas/look-paper.ts
+var CLASSIC_TONES = {
+  /** Land. */
+  land: "#ebe2c8",
+  /** The blue tint, to the 18 ft curve. */
+  shallow: "#d8f0f5",
+  /** Deep water: the paper. */
+  deep: "#ffffff",
+  /** The foreshore, and salt marsh. */
+  drying: "#c1d1af",
+  /** Magenta: lights, flares, discs, limits, cautions, red aids. */
+  magenta: "#953699",
+  /** Green aids. */
+  green: "#068b00",
+  /** Black: line-work, lettering, soundings, land contours. */
+  ink: "#000000",
+  /** Depth contours and their values. */
+  contour: "#5f5f5f"
+};
+var CLASSIC_IMAGE_NAMES = ["hatch", ...CLASSIC_MARK_NAMES];
+var PREFIX2 = "chrt-look-cl-";
+var DAY_TO_CLASSIC = {
+  // Land: LANDA, CHRTland's land and its cover but wetland, slopes.
+  "#d4c69d": CLASSIC_TONES.land,
+  "#e6d1a1": CLASSIC_TONES.land,
+  "#bcc5a1": CLASSIC_TONES.land,
+  "#cac6bf": CLASSIC_TONES.land,
+  "#dbd0af": CLASSIC_TONES.land,
+  "#c8b078": CLASSIC_TONES.land,
+  // Marsh.
+  "#b6c0b1": CLASSIC_TONES.drying,
+  // The drying foreshore (DEPIT).
+  "#009678": CLASSIC_TONES.drying,
+  // Inland water and the shallow depth tints (DEPVS, DEPMS, DEPMD) where
+  // other classes use them: lakes, rivers, canals, locks, swept areas.
+  "#7fbfdf": CLASSIC_TONES.shallow,
+  "#a7d4e8": CLASSIC_TONES.shallow,
+  "#cae7f3": CLASSIC_TONES.shallow,
+  "#b9cfdd": CLASSIC_TONES.shallow,
+  // Deep water (DEPDW).
+  "#ecf7fc": CLASSIC_TONES.deep,
+  // Magentas (CHMGD, CHMGF).
+  "#d200d2": CLASSIC_TONES.magenta,
+  "#c545c3": CLASSIC_TONES.magenta,
+  // Brown structures (CHBRN): buildings, bridges, dams, in black.
+  "#ab7948": CLASSIC_TONES.ink,
+  // Black and the near-blacks of the lettering.
+  "#000000": CLASSIC_TONES.ink,
+  "#1a1d23": CLASSIC_TONES.ink,
+  "#4a5560": CLASSIC_TONES.ink,
+  "#5b4f3a": CLASSIC_TONES.ink,
+  "#bfa88a": CLASSIC_TONES.ink,
+  // Depth contours and area outlines.
+  "#555555": CLASSIC_TONES.contour,
+  // CHRTland's contours: black, as the paper chart's.
+  "#958666": CLASSIC_TONES.ink,
+  "#78694b": CLASSIC_TONES.ink
+};
+var HATCH_RATIO = 4;
+function hatch() {
+  const d = 12;
+  const w = d * 2;
+  const half2 = 0.9;
+  const data = new Uint8Array(w * w * 4);
+  for (let y = 0; y < w; y++) {
+    for (let x = 0; x < w; x++) {
+      const t = (x + y + 1) % d;
+      const dist = Math.min(t, d - t) / Math.SQRT2;
+      const cov = Math.max(0, Math.min(1, half2 + 0.5 - dist));
+      data[(y * w + x) * 4 + 3] = Math.round(cov * 255);
+    }
+  }
+  return { size: w, data };
+}
+function classicImages() {
+  const h = hatch();
+  return [
+    { name: "hatch", width: h.size, height: h.size, pixelRatio: HATCH_RATIO, data: h.data },
+    ...classicMarkImages("color").map((i) => ({ name: i.id.slice(PREFIX2.length), width: i.width, height: i.height, pixelRatio: i.pixelRatio, data: i.data }))
+  ];
+}
+
+// src/atlas/look-wash-tones.ts
+var WASH_TONES = {
+  paper: [250, 244, 222],
+  land: [165, 186, 118],
+  // A clear light blue against the shore (owner, 2026-11-02): the 1860 sheet's grey-blue read grey-green on the cream.
+  water: [128, 178, 222],
+  flat: [226, 206, 150],
+  town: [186, 72, 52],
+  road: [192, 124, 72]
+};
+function washOver(under, tone, a) {
+  const k = Math.max(0, Math.min(1, a));
+  return [0, 1, 2].map((i) => under[i] * (1 - k * (1 - tone[i] / 255)));
+}
+function rgbHex(rgb) {
+  return `#${rgb.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0")).join("")}`;
+}
+var WASH_TINTS = (() => {
+  const paper = WASH_TONES.paper;
+  const land = washOver(paper, WASH_TONES.land, 0.6);
+  return {
+    paper: rgbHex(paper),
+    land: rgbHex(land),
+    /** Water to the 18 ft curve. */
+    shallow: rgbHex(washOver(paper, WASH_TONES.water, 0.4)),
+    /** A pond or lake. */
+    lake: rgbHex(washOver(paper, WASH_TONES.water, 0.26)),
+    /** Drying flats. */
+    flat: rgbHex(washOver(paper, WASH_TONES.flat, 0.375)),
+    /** A town, laid over the land. */
+    town: rgbHex(washOver(land, WASH_TONES.town, 0.42)),
+    /** A road's core, over the land. */
+    road: rgbHex(washOver(land, WASH_TONES.road, 0.45))
+  };
+})();
+
+// src/atlas/chart-look.ts
+var LOOK_TONES = {
+  // Black on white: the sheet prints in black alone (DeviceGray).
+  engraved: { ink: "#000000", paper: "#ffffff" },
+  // The 1860 sheet's ink, a warm black (#382d20, sampled), on white; the wash,
+  // multiplied over it, tones the paper and colours the land and water
+  // (look-wash-tones.ts WASH_TONES).
+  handcolored: { ink: "#382d20", paper: "#ffffff" }
+};
+var LOOK_IMAGE_NAMES = [
+  "stipple-flats",
+  "stipple-1fm",
+  "stipple-2fm",
+  "stipple-3fm",
+  "marsh",
+  "woods",
+  // The Survey's symbols (lookSymbols).
+  "buoy-nun-red",
+  "buoy-nun-green",
+  "buoy-nun-black",
+  "buoy-nun-yellow",
+  "buoy-can-red",
+  "buoy-can-green",
+  "buoy-can-black",
+  "buoy-can-yellow",
+  "buoy-spar-red",
+  "buoy-spar-green",
+  "buoy-spar-black",
+  "buoy-spar-yellow",
+  "buoy-other-red",
+  "buoy-other-green",
+  "buoy-other-black",
+  "buoy-other-yellow",
+  "beacon",
+  "light",
+  "light-major",
+  "lightship",
+  "landmark",
+  "anchor",
+  "fog"
+];
+var IMAGE_PREFIX = { engraved: "chrt-look-en-", handcolored: "chrt-look-hc-", paper: "chrt-look-cl-" };
+function lookImageId(look, name) {
+  return IMAGE_PREFIX[look] + name;
+}
+function imageNames(look) {
+  return look === "paper" ? CLASSIC_IMAGE_NAMES : LOOK_IMAGE_NAMES;
+}
+function lookOfImageId(id) {
+  for (const look of Object.keys(IMAGE_PREFIX)) {
+    if (id.startsWith(IMAGE_PREFIX[look]) && imageNames(look).includes(id.slice(IMAGE_PREFIX[look].length))) return look;
+  }
+  return null;
+}
+var PAINT = {
+  red: [184, 69, 47, 255],
+  green: [79, 122, 58, 255],
+  yellow: [214, 176, 72, 255],
+  light: [232, 196, 92, 210]
+};
+function lookSymbols(look, ink) {
+  const R2 = 2;
+  const S2 = 64 * R2;
+  const c0 = S2 / 2;
+  const out = [];
+  const coloured = look === "handcolored";
+  const tilt = 28;
+  const line = 0.75 * R2;
+  const B = 1.55;
+  const shapes = {
+    nun: [[0, 0], [-3.2, -6], [0, -16], [3.2, -6]],
+    can: [[-3.4, 0], [-3.4, -9], [3.4, -9], [3.4, 0]],
+    spar: [[-0.9, 0], [-0.9, -16], [0.9, -16], [0.9, 0]],
+    other: Array.from({ length: 20 }, (_, i) => [4.2 * Math.sin(i / 20 * 2 * Math.PI), -5 - 4.6 * Math.cos(i / 20 * 2 * Math.PI)])
+  };
+  for (const shape of ["nun", "can", "spar", "other"]) {
+    for (const colour of ["red", "green", "black", "yellow"]) {
+      const p = painter(S2, S2);
+      const pts = shapes[shape].map(([x, y]) => turn([c0 + x * B * R2, c0 + y * B * R2], c0, c0, tilt));
+      const solid = colour === "black" || colour === "green";
+      if (coloured) p.fill(pts, colour === "black" ? ink : PAINT[colour]);
+      else if (solid) p.fill(pts, ink);
+      p.stroke([...pts, pts[0]], line / 2, ink);
+      p.dot(c0, c0, 1.1 * R2, ink);
+      out.push({ name: `buoy-${shape}-${colour}`, data: p.data(), size: S2 });
+    }
+  }
+  {
+    const p = painter(S2, S2);
+    p.stroke([[c0, c0], [c0, c0 - 22 * R2]], 0.6 * R2, ink);
+    p.dot(c0, c0 - 22 * R2, 2.2 * R2, ink);
+    p.dot(c0, c0, 1.2 * R2, ink);
+    out.push({ name: "beacon", data: p.data(), size: S2 });
+  }
+  for (const [name, r, rays] of [["light", 13, 12], ["light-major", 18, 16]]) {
+    const p = painter(S2, S2);
+    if (coloured) p.dot(c0, c0, r * 0.75 * R2, PAINT.light);
+    for (let i = 0; i < rays; i++) {
+      const a = i / rays * 2 * Math.PI;
+      const len = i % 2 === 0 ? r : r * 0.62;
+      p.stroke([[c0 + Math.cos(a) * 3 * R2, c0 + Math.sin(a) * 3 * R2], [c0 + Math.cos(a) * len * R2, c0 + Math.sin(a) * len * R2]], 0.38 * R2, ink);
+    }
+    p.dot(c0, c0, 2.8 * R2, ink);
+    out.push({ name, data: p.data(), size: S2 });
+  }
+  {
+    const p = painter(S2, S2);
+    const hull = [[-8, 0], [8, 0], [5.5, 3.2], [-5.5, 3.2]].map(([x, y]) => [c0 + x * R2, c0 + y * R2]);
+    p.fill(hull, coloured ? PAINT.red : ink);
+    p.stroke([...hull, hull[0]], 0.35 * R2, ink);
+    p.stroke([[c0, c0], [c0, c0 - 11 * R2]], 0.45 * R2, ink);
+    for (let i = 0; i < 8; i++) {
+      const a = i / 8 * 2 * Math.PI;
+      p.stroke([[c0, c0 - 11 * R2], [c0 + Math.cos(a) * 3.6 * R2, c0 - 11 * R2 + Math.sin(a) * 3.6 * R2]], 0.28 * R2, ink);
+    }
+    out.push({ name: "lightship", data: p.data(), size: S2 });
+  }
+  {
+    const p = painter(S2, S2);
+    const ring = Array.from({ length: 33 }, (_, i) => [c0 + 4.6 * R2 * Math.cos(i / 32 * 2 * Math.PI), c0 + 4.6 * R2 * Math.sin(i / 32 * 2 * Math.PI)]);
+    p.stroke(ring, 0.45 * R2, ink);
+    p.dot(c0, c0, 1.2 * R2, ink);
+    out.push({ name: "landmark", data: p.data(), size: S2 });
+  }
+  {
+    const p = painter(S2, S2);
+    const y0 = c0 - 7 * R2;
+    p.stroke([[c0, y0], [c0, c0 + 7 * R2]], 0.5 * R2, ink);
+    p.stroke([[c0 - 3.5 * R2, y0 + 2.2 * R2], [c0 + 3.5 * R2, y0 + 2.2 * R2]], 0.45 * R2, ink);
+    const ring = Array.from({ length: 17 }, (_, i) => [c0 + 1.3 * R2 * Math.cos(i / 16 * 2 * Math.PI), y0 - 1.3 * R2 + 1.3 * R2 * Math.sin(i / 16 * 2 * Math.PI)]);
+    p.stroke(ring, 0.35 * R2, ink);
+    const arm = Array.from({ length: 13 }, (_, i) => {
+      const a = Math.PI * (0.15 + 0.7 * (i / 12));
+      return [c0 + 5.5 * R2 * Math.cos(a), c0 + 1.5 * R2 + 5.5 * R2 * Math.sin(a)];
+    });
+    p.stroke(arm, 0.5 * R2, ink);
+    p.stroke([arm[0], [arm[0][0] + 1.6 * R2, arm[0][1] - 1.4 * R2]], 0.45 * R2, ink);
+    p.stroke([arm[12], [arm[12][0] - 1.6 * R2, arm[12][1] - 1.4 * R2]], 0.45 * R2, ink);
+    out.push({ name: "anchor", data: p.data(), size: S2 });
+  }
+  {
+    const p = painter(S2, S2);
+    for (const r of [6, 9, 12]) {
+      const arc = Array.from({ length: 13 }, (_, i) => {
+        const a = (-115 + 50 * i / 12) * (Math.PI / 180);
+        return [c0 + r * R2 * Math.cos(a), c0 + r * R2 * Math.sin(a)];
+      });
+      p.stroke(arc, 0.42 * R2, ink);
+    }
+    out.push({ name: "fog", data: p.data(), size: S2 });
+  }
+  return out;
+}
+var IMAGE_RATIO = 4;
+function hash(a, b, seed) {
+  let h = a * 374761393 + b * 668265263 + seed * 2147483647 | 0;
+  h = Math.imul(h ^ h >>> 13, 1274126177);
+  return ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+function canvas(w, h) {
+  const data = new Uint8Array(w * h * 4);
+  const put = (x, y, a) => {
+    const xi = (x % w + w) % w;
+    const yi = (y % h + h) % h;
+    const k = (yi * w + xi) * 4 + 3;
+    data[k] = Math.min(255, Math.max(data[k], Math.round(a * 255)));
+  };
+  const dot = (cx, cy, r, a = 1) => {
+    for (let y = Math.floor(cy - r - 1); y <= Math.ceil(cy + r + 1); y++) {
+      for (let x = Math.floor(cx - r - 1); x <= Math.ceil(cx + r + 1); x++) {
+        const d = Math.hypot(x + 0.5 - cx, y + 0.5 - cy);
+        const cov = Math.max(0, Math.min(1, r + 0.5 - d));
+        if (cov > 0) put(x, y, cov * a);
+      }
+    }
+  };
+  const line = (x0, y0, x1, y1, r) => {
+    const n = Math.max(1, Math.ceil(Math.hypot(x1 - x0, y1 - y0) * 2));
+    for (let i = 0; i <= n; i++) dot(x0 + (x1 - x0) * i / n, y0 + (y1 - y0) * i / n, r);
+  };
+  return { data, dot, line };
+}
+function lookImages(look) {
+  if (look === "paper") return classicImages().map((i) => ({ ...i, id: lookImageId("paper", i.name) }));
+  const [ir, ig, ib] = [1, 3, 5].map((i) => parseInt(LOOK_TONES[look].ink.slice(i, i + 2), 16));
+  const finish = (name, w, h, data) => {
+    for (let k = 0; k < data.length; k += 4) {
+      data[k] = ir;
+      data[k + 1] = ig;
+      data[k + 2] = ib;
+    }
+    return { id: lookImageId(look, name), width: w, height: h, pixelRatio: IMAGE_RATIO, data };
+  };
+  const out = [];
+  for (const [id, step, r, seed] of [
+    ["stipple-flats", 5, 0.95, 1],
+    ["stipple-1fm", 6, 0.9, 2],
+    ["stipple-2fm", 8, 0.85, 3],
+    ["stipple-3fm", 11, 0.8, 4]
+  ]) {
+    const n = 8;
+    const w = step * n;
+    const c = canvas(w, w);
+    for (let j = 0; j < n; j++) for (let i = 0; i < n; i++) {
+      c.dot((i + 0.2 + 0.6 * hash(i, j, seed)) * step, (j + 0.2 + 0.6 * hash(j, i, seed + 7)) * step, r * (0.8 + 0.4 * hash(i, j, seed + 3)));
+    }
+    out.push(finish(id, w, w, c.data));
+  }
+  {
+    const w = 96;
+    const h = 64;
+    const c = canvas(w, h);
+    for (const [x, y] of [[16, 22], [64, 22], [40, 54], [88, 54]]) {
+      c.line(x - 9, y, x + 9, y, 0.55);
+      c.line(x, y, x, y - 9, 0.5);
+      c.line(x - 3, y, x - 7, y - 7, 0.45);
+      c.line(x + 3, y, x + 7, y - 7, 0.45);
+    }
+    out.push(finish("marsh", w, h, c.data));
+  }
+  {
+    const n = 6;
+    const step = 12;
+    const w = n * step;
+    const c = canvas(w, w);
+    for (let j = 0; j < n; j++) for (let i = 0; i < n; i++) {
+      const x = (i + 0.25 + 0.5 * hash(i, j, 31)) * step;
+      const y = (j + 0.25 + 0.5 * hash(j, i, 37)) * step;
+      for (let a = 0; a < 2 * Math.PI; a += 0.25) c.dot(x + 2.4 * Math.cos(a), y + 2.4 * Math.sin(a), 0.4);
+      c.line(x + 1.5, y + 3, x + 3, y + 2.4, 0.55);
+    }
+    out.push(finish("woods", w, w, c.data));
+  }
+  for (const sym of lookSymbols(look, [ir, ig, ib, 255])) {
+    out.push({ id: lookImageId(look, sym.name), width: sym.size, height: sym.size, pixelRatio: 2, data: sym.data });
+  }
+  return out;
+}
+
+// src/atlas/chart-look-images-browser.ts
+var IMAGES = /* @__PURE__ */ new Map();
+function provideChartLookImages(map) {
+  map.on("styleimagemissing", (e) => {
+    const mark = classicMarkInk(e.id) !== null;
+    const look = mark ? null : lookOfImageId(e.id);
+    if (!mark && look === null || map.hasImage(e.id)) return;
+    if (!IMAGES.has(e.id)) {
+      if (mark) IMAGES.set(e.id, classicMarkImage(e.id));
+      else for (const image2 of lookImages(look)) IMAGES.set(image2.id, image2);
+    }
+    const image = IMAGES.get(e.id);
+    if (!image) return;
+    map.addImage(e.id, { width: image.width, height: image.height, data: new Uint8Array(image.data) }, { pixelRatio: image.pixelRatio });
+  });
+}
 export {
   BASE_PATTERN_GLYPHS,
   basePatternImageSpecs,
@@ -20485,6 +21137,7 @@ export {
   loadSymbolImageSpecs,
   loadSymbolImages,
   loadThemedBridgeImages,
+  provideChartLookImages,
   rasterImageSpecs,
   reloadChrtRasterSymbolImages,
   reloadS101SymbolImages,
@@ -20494,6 +21147,7 @@ export {
   s101ImageSpecs,
   s52ImageSpecs,
   styleImageIds,
-  symbolImageSpecs
+  symbolImageSpecs,
+  usChart1ImageSpecs
 };
 //# sourceMappingURL=browser.js.map