ridgescape 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1574 @@
+"use strict";
+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 = (mod3) => __copyProps(__defProp({}, "__esModule", { value: true }), mod3);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ANCHOR_HEIGHTS: () => ANCHOR_HEIGHTS,
+  CLOUD_DEFAULTS: () => CLOUD_DEFAULTS,
+  DEPTH_DEFAULTS: () => DEPTH_DEFAULTS,
+  LAKE_DEFAULTS: () => LAKE_DEFAULTS,
+  PARALLAX_DEFAULTS: () => PARALLAX_DEFAULTS,
+  PROFILE_DEFAULTS: () => PROFILE_DEFAULTS,
+  SAMPLE_STEP: () => SAMPLE_STEP,
+  SCENE_DEFAULTS: () => SCENE_DEFAULTS,
+  SKY_DEFAULTS: () => SKY_DEFAULTS,
+  TREE_DEFAULTS: () => TREE_DEFAULTS,
+  TREE_GROUPS: () => TREE_GROUPS,
+  TREE_SHAPES: () => TREE_SHAPES,
+  attachParallax: () => attachParallax,
+  buildOutline: () => buildOutline,
+  buildProfile: () => buildProfile,
+  capsulePath: () => capsulePath,
+  circlePath: () => circlePath,
+  clipId: () => clipId,
+  clipStyle: () => clipStyle,
+  createRandom: () => createRandom,
+  defsMarkup: () => defsMarkup,
+  drawLayer: () => drawLayer,
+  drawShape: () => drawShape,
+  drawToCanvas: () => drawToCanvas,
+  formatColor: () => format,
+  formatNumber: () => formatNumber,
+  gradientMarkup: () => gradientMarkup,
+  groundPath: () => groundPath,
+  hashString: () => hashString,
+  layerColor: () => layerColor,
+  layerMarkup: () => layerMarkup,
+  mirrorClip: () => mirrorClip,
+  mirrorClipId: () => mirrorClipId,
+  mix: () => mix,
+  octaves: () => octaves,
+  palettes: () => palettes,
+  parallaxDelta: () => parallaxDelta,
+  parallaxOffset: () => parallaxOffset,
+  parseColor: () => parseColor,
+  periodicNoise: () => periodicNoise,
+  placeTrees: () => placeTrees,
+  presets: () => presets,
+  rectPath: () => rectPath,
+  reflectionLayers: () => reflectionLayers,
+  render: () => render,
+  resolve: () => resolve,
+  resolveLength: () => resolveLength,
+  resolvePalette: () => resolvePalette,
+  ridgescapeParentStyle: () => ridgescapeParentStyle,
+  scaleLength: () => scaleLength,
+  serialize: () => serialize,
+  shapeMarkup: () => shapeMarkup,
+  simplify: () => simplify,
+  toSvg: () => toSvg,
+  treeHeightAt: () => treeHeightAt,
+  treeKeyPoints: () => treeKeyPoints,
+  waterBase: () => waterBase,
+  waterSurface: () => waterSurface
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/color/parse.ts
+var NAMED_SOURCE = "aliceblue f0f8ff antiquewhite faebd7 aqua 00ffff aquamarine 7fffd4 azure f0ffff beige f5f5dc bisque ffe4c4 black 000000 blanchedalmond ffebcd blue 0000ff blueviolet 8a2be2 brown a52a2a burlywood deb887 cadetblue 5f9ea0 chartreuse 7fff00 chocolate d2691e coral ff7f50 cornflowerblue 6495ed cornsilk fff8dc crimson dc143c cyan 00ffff darkblue 00008b darkcyan 008b8b darkgoldenrod b8860b darkgray a9a9a9 darkgreen 006400 darkgrey a9a9a9 darkkhaki bdb76b darkmagenta 8b008b darkolivegreen 556b2f darkorange ff8c00 darkorchid 9932cc darkred 8b0000 darksalmon e9967a darkseagreen 8fbc8f darkslateblue 483d8b darkslategray 2f4f4f darkslategrey 2f4f4f darkturquoise 00ced1 darkviolet 9400d3 deeppink ff1493 deepskyblue 00bfff dimgray 696969 dimgrey 696969 dodgerblue 1e90ff firebrick b22222 floralwhite fffaf0 forestgreen 228b22 fuchsia ff00ff gainsboro dcdcdc ghostwhite f8f8ff gold ffd700 goldenrod daa520 gray 808080 green 008000 greenyellow adff2f grey 808080 honeydew f0fff0 hotpink ff69b4 indianred cd5c5c indigo 4b0082 ivory fffff0 khaki f0e68c lavender e6e6fa lavenderblush fff0f5 lawngreen 7cfc00 lemonchiffon fffacd lightblue add8e6 lightcoral f08080 lightcyan e0ffff lightgoldenrodyellow fafad2 lightgray d3d3d3 lightgreen 90ee90 lightgrey d3d3d3 lightpink ffb6c1 lightsalmon ffa07a lightseagreen 20b2aa lightskyblue 87cefa lightslategray 778899 lightslategrey 778899 lightsteelblue b0c4de lightyellow ffffe0 lime 00ff00 limegreen 32cd32 linen faf0e6 magenta ff00ff maroon 800000 mediumaquamarine 66cdaa mediumblue 0000cd mediumorchid ba55d3 mediumpurple 9370db mediumseagreen 3cb371 mediumslateblue 7b68ee mediumspringgreen 00fa9a mediumturquoise 48d1cc mediumvioletred c71585 midnightblue 191970 mintcream f5fffa mistyrose ffe4e1 moccasin ffe4b5 navajowhite ffdead navy 000080 oldlace fdf5e6 olive 808000 olivedrab 6b8e23 orange ffa500 orangered ff4500 orchid da70d6 palegoldenrod eee8aa palegreen 98fb98 paleturquoise afeeee palevioletred db7093 papayawhip ffefd5 peachpuff ffdab9 peru cd853f pink ffc0cb plum dda0dd powderblue b0e0e6 purple 800080 rebeccapurple 663399 red ff0000 rosybrown bc8f8f royalblue 4169e1 saddlebrown 8b4513 salmon fa8072 sandybrown f4a460 seagreen 2e8b57 seashell fff5ee sienna a0522d silver c0c0c0 skyblue 87ceeb slateblue 6a5acd slategray 708090 slategrey 708090 snow fffafa springgreen 00ff7f steelblue 4682b4 tan d2b48c teal 008080 thistle d8bfd8 tomato ff6347 turquoise 40e0d0 violet ee82ee wheat f5deb3 white ffffff whitesmoke f5f5f5 yellow ffff00 yellowgreen 9acd32";
+var named;
+function namedColor(name) {
+  if (!named) {
+    named = /* @__PURE__ */ new Map();
+    const parts = NAMED_SOURCE.split(" ");
+    for (let i = 0; i < parts.length; i += 2) named.set(parts[i], parts[i + 1]);
+  }
+  return named.get(name);
+}
+var clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+function hex(h) {
+  if (!/^[0-9a-f]+$/i.test(h)) return null;
+  if (h.length === 3 || h.length === 4) h = [...h].map((c) => c + c).join("");
+  if (h.length !== 6 && h.length !== 8) return null;
+  const n = (i) => parseInt(h.slice(i, i + 2), 16);
+  return { r: n(0), g: n(2), b: n(4), a: h.length === 8 ? n(6) / 255 : 1 };
+}
+function channel(token, max) {
+  return token.endsWith("%") ? parseFloat(token) / 100 * max : parseFloat(token);
+}
+function alpha(token) {
+  if (token === void 0) return 1;
+  return clamp(token.endsWith("%") ? parseFloat(token) / 100 : parseFloat(token), 0, 1);
+}
+function hslToRgb(h, s, l) {
+  const k = (n) => (n + h / 30) % 12;
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, 9 - k(n), 1));
+  return [f(0) * 255, f(8) * 255, f(4) * 255];
+}
+function parseColor(input) {
+  const c = input.trim().toLowerCase();
+  if (c === "transparent") return { r: 0, g: 0, b: 0, a: 0 };
+  if (c.startsWith("#")) return hex(c.slice(1));
+  const name = namedColor(c);
+  if (name) return hex(name);
+  const m = /^(rgba?|hsla?)\((.*)\)$/.exec(c);
+  if (!m) return null;
+  const parts = m[2].replace(/\s*\/\s*/, " / ").split(/[\s,]+/).filter((p) => p && p !== "/");
+  if (parts.length < 3 || parts.length > 4 || parts.some((p) => !/^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?(%|deg)?$/.test(p))) return null;
+  if (m[1].startsWith("rgb")) {
+    return { r: clamp(channel(parts[0], 255), 0, 255), g: clamp(channel(parts[1], 255), 0, 255), b: clamp(channel(parts[2], 255), 0, 255), a: alpha(parts[3]) };
+  }
+  const h = (parseFloat(parts[0]) % 360 + 360) % 360;
+  const [r, g, b] = hslToRgb(h, clamp(parseFloat(parts[1]) / 100, 0, 1), clamp(parseFloat(parts[2]) / 100, 0, 1));
+  return { r, g, b, a: alpha(parts[3]) };
+}
+
+// src/color/index.ts
+var clamp2 = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+var toLinear = (c) => {
+  const v = c / 255;
+  return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+};
+var fromLinear = (v) => (v <= 31308e-7 ? 12.92 * Math.max(0, v) : 1.055 * v ** (1 / 2.4) - 0.055) * 255;
+function toOklab({ r, g, b, a }) {
+  const lr = toLinear(r), lg = toLinear(g), lb = toLinear(b);
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+    a
+  ];
+}
+function fromOklab([L, A, B, alpha2]) {
+  const l = (L + 0.3963377774 * A + 0.2158037573 * B) ** 3;
+  const m = (L - 0.1055613458 * A - 0.0638541728 * B) ** 3;
+  const s = (L - 0.0894841775 * A - 1.291485548 * B) ** 3;
+  return {
+    r: fromLinear(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+    g: fromLinear(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+    b: fromLinear(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s),
+    a: alpha2
+  };
+}
+function parse(color) {
+  const c = parseColor(color);
+  if (!c) throw new TypeError(`ridgescape: can't mix ${JSON.stringify(color)}; palette and haze colours must be hex, rgb(), hsl() or named`);
+  return c;
+}
+function mix(a, b, t) {
+  const la = toOklab(parse(a)), lb = toOklab(parse(b));
+  const u = clamp2(t, 0, 1);
+  return format(fromOklab(la.map((v, i) => v + (lb[i] - v) * u)));
+}
+function format({ r, g, b, a }) {
+  const h = (n) => Math.round(clamp2(n, 0, 255)).toString(16).padStart(2, "0");
+  if (a >= 1) return `#${h(r)}${h(g)}${h(b)}`;
+  const c = (n) => Math.round(clamp2(n, 0, 255));
+  return `rgba(${c(r)}, ${c(g)}, ${c(b)}, ${Number(clamp2(a, 0, 1).toFixed(3))})`;
+}
+function layerColor(palette, haze, depth) {
+  return mix(mix(palette.near, palette.far, depth), haze.color, haze.strength * depth ** haze.curve);
+}
+
+// src/random/index.ts
+function hashString(str, seed = 0) {
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+  h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+  h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var SEP = "\0";
+function createRandom(seed) {
+  return fromKey(String(seed));
+}
+function fromKey(key) {
+  const gen = mulberry32(hashString(key));
+  const random = {
+    key,
+    next: gen,
+    range: (min, max) => min + gen() * (max - min),
+    int: (min, max) => min + Math.floor(gen() * (max - min + 1)),
+    fork: (...path) => fromKey(key + SEP + path.join(SEP)),
+    value: (...path) => random.fork(...path).next()
+  };
+  return random;
+}
+
+// src/render/paths.ts
+function circlePath(cx, cy, r, fmt) {
+  const R = fmt(r);
+  return `M${fmt(cx - r)} ${fmt(cy)}A${R} ${R} 0 1 1 ${fmt(cx + r)} ${fmt(cy)}A${R} ${R} 0 1 1 ${fmt(cx - r)} ${fmt(cy)}Z`;
+}
+function capsulePath(x0, y0, x1, y1, fmt) {
+  const r = Math.min((y1 - y0) / 2, (x1 - x0) / 2);
+  const R = fmt(r);
+  return `M${fmt(x0 + r)} ${fmt(y0)}H${fmt(x1 - r)}A${R} ${R} 0 0 1 ${fmt(x1 - r)} ${fmt(y1)}H${fmt(x0 + r)}A${R} ${R} 0 0 1 ${fmt(x0 + r)} ${fmt(y0)}Z`;
+}
+function rectPath(x0, y0, x1, y1, fmt) {
+  return `M${fmt(x0)} ${fmt(y0)}H${fmt(x1)}V${fmt(y1)}H${fmt(x0)}Z`;
+}
+function groundPath(points, bottom, fmt) {
+  let d = "M" + fmt(points[0].x) + " " + fmt(points[0].y);
+  for (let i = 1; i < points.length; i++) d += "L" + fmt(points[i].x) + " " + fmt(points[i].y);
+  return d + "L" + fmt(points[points.length - 1].x) + " " + fmt(bottom) + "L" + fmt(points[0].x) + " " + fmt(bottom) + "Z";
+}
+
+// src/spec/length.ts
+var PERCENT = /^\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)%\s*$/i;
+function isLength(value) {
+  return typeof value === "number" && Number.isFinite(value) || typeof value === "string" && PERCENT.test(value);
+}
+function resolveLength(value, total) {
+  if (typeof value === "number") return value;
+  const m = PERCENT.exec(value);
+  if (!m) throw new TypeError(`ridgescape: expected px or a percentage, got ${JSON.stringify(value)}`);
+  return Number(m[1]) / 100 * total;
+}
+function scaleLength(value, k) {
+  if (typeof value === "number") return round(value * k);
+  return `${round(resolveLength(value, 100) * k)}%`;
+}
+var round = (n) => Number(n.toFixed(4));
+
+// src/clouds/index.ts
+function cloudLayers(clouds, palette, ctx) {
+  const top = resolveLength(clouds.top, ctx.height);
+  const bottom = resolveLength(clouds.bottom, ctx.height);
+  const layers = [];
+  if (clouds.cover <= 0) return layers;
+  for (let i = 0; i < clouds.bands; i++) {
+    const t = clouds.bands > 1 ? i / (clouds.bands - 1) : 1;
+    const random = createRandom(clouds.seed).fork("band", i);
+    const size = clouds.size * (0.55 + 0.45 * t);
+    const base = top + (bottom - top) * t;
+    const period = 2400 + 300 * i;
+    const count2 = Math.max(1, Math.round(clouds.cover * period / size));
+    const slot = period / count2;
+    const tile = Array.from({ length: count2 }, (_, k) => ({
+      x: (k + 0.5 + random.range(-0.35, 0.35)) * slot,
+      y: base + random.range(-0.15, 0.15) * size,
+      width: size * random.range(0.6, 1.4),
+      random: random.fork("cloud", k)
+    }));
+    let d = "";
+    let highest = Infinity;
+    for (let copy = -1; copy * period < ctx.width + size * 2; copy++) {
+      for (const c of tile) {
+        const x = c.x + copy * period;
+        if (x + c.width < 0 || x - c.width > ctx.width) continue;
+        const piece = clouds.style === "streaks" ? streaks({ ...c, x, random: c.random.fork("shape") }, ctx) : puffy({ ...c, x, random: c.random.fork("shape") }, ctx);
+        d += piece.d;
+        highest = Math.min(highest, piece.top);
+      }
+    }
+    if (!d) continue;
+    const color = mix(clouds.color, palette.haze, 0.35 * (1 - t));
+    const content = {
+      y1: ctx.round(base - size * 0.45),
+      y2: ctx.round(base + size * 0.05),
+      stops: [
+        { offset: 0, color },
+        { offset: 1, color: mix(color, palette.far, clouds.shade) }
+      ]
+    };
+    const fill = clouds.shade > 0 ? { type: "linear", id: ctx.id(content), x1: 0, x2: 0, ...content } : color;
+    layers.push({
+      key: `clouds-${i}`,
+      kind: "clouds",
+      index: i,
+      depth: Number((1 - 0.15 * t).toFixed(4)),
+      shapes: [{ d, fill, ...clouds.opacity < 1 ? { opacity: clouds.opacity } : {} }],
+      top: ctx.round(highest)
+    });
+  }
+  return layers;
+}
+function puffy({ x, y, width, random }, ctx) {
+  const base = width * 0.14;
+  const x0 = x - width / 2;
+  let d = capsulePath(x0, y - base, x0 + width, y, ctx.fmt);
+  let top = y - base;
+  const puffs = 3 + Math.floor(random.next() * 3);
+  for (let j = 0; j < puffs; j++) {
+    const u = (j + 0.5) / puffs;
+    const r = width * (0.09 + 0.12 * Math.sin(Math.PI * u)) * random.range(0.85, 1.15);
+    const cx = x0 + width * (0.12 + 0.76 * u) + random.range(-0.04, 0.04) * width;
+    const cy = y - base / 2 - r * 0.75;
+    d += circlePath(cx, cy, r, ctx.fmt);
+    top = Math.min(top, cy - r);
+  }
+  return { d, top };
+}
+function streaks({ x, y, width, random }, ctx) {
+  const { fmt } = ctx;
+  let d = "";
+  let top = y;
+  const count2 = 1 + Math.floor(random.next() * 3);
+  for (let j = 0; j < count2; j++) {
+    const length2 = width * random.range(0.5, 1.2);
+    const h = width * random.range(0.018, 0.04);
+    const cx = x + random.range(-0.25, 0.25) * width;
+    const by = y - j * width * 0.07;
+    const peak = cx + random.range(-0.2, 0.2) * length2;
+    const x0 = cx - length2 / 2, x1 = cx + length2 / 2;
+    d += `M${fmt(x0)} ${fmt(by)}Q${fmt(peak)} ${fmt(by - 2 * h)} ${fmt(x1)} ${fmt(by)}Q${fmt(peak)} ${fmt(by + 0.5 * h)} ${fmt(x0)} ${fmt(by)}Z`;
+    top = Math.min(top, by - h);
+  }
+  return { d, top };
+}
+
+// src/lakes/index.ts
+var CLARITY = 0.6;
+var RIPPLES = 0.5;
+function waterBase(spans, bottom, ctx) {
+  return spans.map(({ span, lake }) => ({ d: rectPath(span.x0, span.y, span.x1, bottom, ctx.fmt), fill: lake.color }));
+}
+function reflectionLayers(spans, behind, bottom, key, index, depth, ctx) {
+  const out = [];
+  const byLevel = /* @__PURE__ */ new Map();
+  for (const { span, lake } of spans) {
+    if (!lake.reflection) continue;
+    const rects = byLevel.get(span.y) ?? [];
+    rects.push([span.x0, span.y, span.x1, bottom]);
+    byLevel.set(span.y, rects);
+  }
+  for (const [y, water] of byLevel) {
+    const mirror = [1, 0, 0, -1, 0, ctx.round(2 * y)];
+    const runs = [];
+    for (const layer of behind) {
+      if (layer.mirror) continue;
+      const shapes2 = [];
+      for (const s of layer.shapes) {
+        if (s.clip || s.transform) continue;
+        s.id ?? (s.id = ctx.id({ shape: s.d, fill: s.fill, opacity: s.opacity }));
+        shapes2.push({ d: s.d, fill: s.fill, ...s.opacity !== void 0 ? { opacity: s.opacity } : {}, transform: mirror, href: s.id });
+      }
+      if (shapes2.length === 0) continue;
+      const run = runs[runs.length - 1];
+      if (run && run.source === layer.depth) run.shapes.push(...shapes2);
+      else runs.push({ source: layer.depth, shapes: shapes2 });
+    }
+    for (const { source, shapes: shapes2 } of runs) {
+      out.push({
+        key: `${key}-${out.length}`,
+        kind: "reflection",
+        index,
+        depth,
+        shapes: shapes2,
+        top: ctx.round(y),
+        mirror: { depth: source, water: water.map((r) => r.map(ctx.round)) }
+      });
+    }
+  }
+  return out;
+}
+function waterSurface(spans, bottom, ctx) {
+  const shapes2 = [];
+  for (const { span, lake, seed } of spans) {
+    const { x0, x1, y } = span;
+    const water = rectPath(x0, y, x1, bottom, ctx.fmt);
+    const depth = Math.max(40, (ctx.height - y) * 0.6);
+    const clear = lake.reflection ? CLARITY : 0;
+    const tint = {
+      y1: ctx.round(y),
+      y2: ctx.round(y + depth),
+      stops: [
+        { offset: 0, color: lake.color, opacity: ctx.round(0.5 * (1 - clear) + 0.1) },
+        { offset: 1, color: lake.color, opacity: ctx.round(Math.min(1, 1 - 0.45 * clear)) }
+      ]
+    };
+    shapes2.push({ d: water, fill: { type: "linear", id: ctx.id(tint), x1: 0, x2: 0, ...tint } });
+    const { light, alpha: alpha2 } = shine(lake.color);
+    shapes2.push({ d: capsulePath(x0, y - 0.6, x1, y + 0.9, ctx.fmt), fill: light, opacity: ctx.round(0.55 * alpha2), clip: water });
+    if (lake.ripples) {
+      const random = createRandom(seed);
+      const width = x1 - x0;
+      const count2 = Math.round(RIPPLES * width / 22);
+      let d = "";
+      for (let i = 0; i < count2; i++) {
+        const down = 3 + random.next() ** 1.6 * Math.min(depth, 140);
+        const length2 = random.range(8, 46) * (1 + down / 70);
+        const cx = x0 + random.next() * width;
+        const thick = random.range(0.9, 1.6);
+        d += capsulePath(cx - length2 / 2, y + down, cx + length2 / 2, y + down + thick, ctx.fmt);
+      }
+      if (d) shapes2.push({ d, fill: light, opacity: ctx.round((0.2 + 0.35 * RIPPLES) * alpha2), clip: water });
+    }
+  }
+  return shapes2;
+}
+function shine(color) {
+  try {
+    return { light: mix(color, "#ffffff", 0.55), alpha: 1 };
+  } catch {
+    return { light: "#ffffff", alpha: 0.55 };
+  }
+}
+function mirrorClip(water) {
+  return water.map(([x0, y0, x1, y1]) => rectPath(x0, y0, x1, y1, (n) => String(n + 0))).join("");
+}
+
+// src/profile/noise.ts
+var mod = (a, n) => (a % n + n) % n;
+function periodicNoise(random, cells) {
+  const n = Math.max(1, Math.round(cells));
+  const values = Array.from({ length: n }, () => random.next() * 2 - 1);
+  const at = (i) => values[mod(i, n)];
+  return (u) => {
+    const i = Math.floor(u);
+    const t = u - i;
+    const p0 = at(i - 1), p1 = at(i), p2 = at(i + 1), p3 = at(i + 2);
+    return p1 + 0.5 * t * (p2 - p0 + t * (2 * p0 - 5 * p1 + 4 * p2 - p3 + t * (3 * (p1 - p2) + p3 - p0)));
+  };
+}
+function octaves(random, { cells, count: count2, gain }, shape = (v) => v) {
+  const layers = Array.from({ length: count2 }, (_, k) => ({
+    k,
+    cells: Math.round(cells) * 2 ** k,
+    weight: gain ** k,
+    noise: periodicNoise(random.fork("octave", k), Math.round(cells) * 2 ** k)
+  }));
+  return (x) => {
+    let sum = 0;
+    for (const o of layers) sum += o.weight * shape(o.noise(x * o.cells), o.k);
+    return sum;
+  };
+}
+
+// src/profile/index.ts
+var SAMPLE_STEP = 4;
+var smoothstep = (a, b, x) => {
+  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
+  return t * t * (3 - 2 * t);
+};
+function octavesFor(roughness, cells) {
+  return { cells, count: 2 + Math.round(roughness * 4), gain: 0.3 + 0.3 * roughness };
+}
+var shapes = {
+  rolling(seed, cells, roughness) {
+    return octaves(createRandom(seed), octavesFor(roughness, cells));
+  },
+  peaks(seed, cells, roughness) {
+    return octaves(createRandom(seed), octavesFor(roughness, cells), (v, k) => k < 2 ? (1 - Math.abs(v)) ** 2 : 0.6 * v);
+  },
+  mesa(seed, cells, roughness) {
+    return octaves(createRandom(seed), octavesFor(roughness * 0.5, cells));
+  },
+  dunes(seed, cells, roughness) {
+    const random = createRandom(seed);
+    const slow = Math.max(1, Math.round(cells / 2));
+    const warp = octaves(random.fork("warp"), { cells: slow, count: 2, gain: 0.5 });
+    const swell = octaves(random.fork("swell"), { cells: slow, count: 1, gain: 1 });
+    const detail = octaves(random.fork("detail"), { cells: cells * 4, count: 2, gain: 0.5 });
+    const crest = 0.78;
+    return (x) => {
+      const p = x * cells + 0.35 * warp(x);
+      const s = p - Math.floor(p);
+      const wave = s < crest ? (1 - Math.cos(Math.PI * s / crest)) / 2 : (1 + Math.cos(Math.PI * (s - crest) / (1 - crest))) / 2;
+      return wave * (0.65 + 0.35 * swell(x)) + 0.08 * roughness * detail(x);
+    };
+  }
+};
+var finish = {
+  // Wider valleys, so the peaks stand out.
+  peaks: (v) => v ** 1.3,
+  // Plateau curve: flat tops and floors joined by steep sides.
+  mesa: (v) => 0.82 * smoothstep(0.38, 0.62, v) + 0.18 * v
+};
+var cache = /* @__PURE__ */ new Map();
+var CACHE_SIZE = 64;
+function buildProfile(options) {
+  const key = JSON.stringify([options.profile, options.roughness, options.wavelength, options.period, options.seed]);
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const { profile, roughness, wavelength, period, seed } = options;
+  const count2 = Math.max(8, Math.round(period / SAMPLE_STEP));
+  const cells = Math.max(1, Math.round(period / wavelength));
+  const shape = shapes[profile](seed, cells, roughness);
+  const values = new Float64Array(count2);
+  for (let i = 0; i < count2; i++) values[i] = shape(i / count2);
+  normalise(values);
+  const f = finish[profile];
+  if (f) {
+    for (let i = 0; i < count2; i++) values[i] = f(values[i]);
+    normalise(values);
+  }
+  const result = { period, step: period / count2, values };
+  if (cache.size >= CACHE_SIZE) cache.delete(cache.keys().next().value);
+  cache.set(key, result);
+  return result;
+}
+function normalise(values) {
+  let min = Infinity, max = -Infinity;
+  for (const v of values) {
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const range = max - min || 1;
+  for (let i = 0; i < values.length; i++) values[i] = (values[i] - min) / range;
+}
+
+// src/trees/index.ts
+var lean = (half, r) => {
+  const s = r.range(-0.1, 0.1);
+  return { left: half * (1 + s), right: half * (1 - s) };
+};
+var SHAPES = {
+  // A narrow triangle with jagged sides: short tiers of branches, each one's tips poking out past
+  // the line of the tree, more of them on bigger trees.
+  spruce: {
+    kind: "conifer",
+    width: 0.42,
+    scale: 1,
+    build(h, r) {
+      const half = h * 0.2 * r.range(0.85, 1.15);
+      const sides = lean(half, r);
+      const n = Math.max(1, Math.min(9, Math.round(h / 8)));
+      const step = h * 0.85 / n;
+      const parts = [];
+      for (let k = 0; k < n; k++) {
+        const base = step * k;
+        const out = (1 - base / h) * r.range(1.08, 1.25);
+        parts.push({ type: "cone", offset: 0, left: sides.left * out, right: sides.right * out, base, apex: Math.min(h, base + step * 2.4), bend: 1 });
+      }
+      parts.push({ type: "cone", offset: 0, left: sides.left * 0.3, right: sides.right * 0.3, base: h * 0.7, apex: h, bend: 1 });
+      return parts;
+    }
+  },
+  // One smooth, narrow spire with gently curved sides.
+  fir: {
+    kind: "conifer",
+    width: 0.36,
+    scale: 1.05,
+    build: (h, r) => [{ type: "cone", offset: 0, ...lean(h * 0.2 * r.range(0.85, 1.15), r), base: 0, apex: h, bend: r.range(1.05, 1.2) }]
+  },
+  // Ragged and round-shouldered: a broad body with flat-topped clumps along its top. Each clump
+  // stays inside the body where it stands (anything wider would drop to the ground as a column).
+  pine: {
+    kind: "conifer",
+    width: 0.62,
+    scale: 0.95,
+    build(h, r) {
+      const radius = h * 0.28 * r.range(0.85, 1.15);
+      const body = h * 0.8;
+      const parts = [{ type: "dome", offset: 0, radius, base: 0, height: body, power: 1 }];
+      const halfAt = (y) => y >= body ? 0 : radius * Math.sqrt(1 - y / body);
+      const clumps = h < 16 ? 1 : r.int(3, 5);
+      for (let k = 0; k < clumps; k++) {
+        const top = k === 0 ? h : h * r.range(0.62, 0.9);
+        const base = top - h * (k === 0 ? 0.3 : r.range(0.14, 0.2));
+        const room = halfAt(base);
+        const offset = k === 0 ? room * r.range(-0.25, 0.25) : room * r.range(0.2, 0.6) * (r.next() < 0.5 ? -1 : 1);
+        const size = (room - Math.abs(offset)) * r.range(0.8, 0.95);
+        if (size > 0.8) parts.push({ type: "dome", offset, radius: size, base, height: top, power: 0.3 });
+      }
+      return parts;
+    }
+  },
+  // A tall, narrow column with a rounded point.
+  cypress: {
+    kind: "conifer",
+    width: 0.26,
+    scale: 1.1,
+    build(h, r) {
+      const half = h * 0.13 * r.range(0.85, 1.15);
+      return [
+        { type: "dome", offset: 0, radius: half, base: 0, height: h * 0.9, power: 0.4 },
+        { type: "cone", offset: 0, left: half * 0.4, right: half * 0.4, base: h * 0.82, apex: h, bend: 1 }
+      ];
+    }
+  },
+  // A round crown between two lower, sloping shoulders (a crown's own sides would drop straight down).
+  maple: {
+    kind: "deciduous",
+    width: 0.9,
+    scale: 0.85,
+    build(h, r) {
+      const w = h * 0.9 * r.range(0.85, 1.15);
+      return [
+        { type: "dome", offset: 0, radius: w * 0.35, base: 0, height: h, power: 0.5 },
+        { type: "dome", offset: -w * r.range(0.15, 0.28), radius: w * 0.3 * r.range(0.85, 1.15), base: 0, height: h * r.range(0.65, 0.85), power: 1 },
+        { type: "dome", offset: w * r.range(0.15, 0.28), radius: w * 0.3 * r.range(0.85, 1.15), base: 0, height: h * r.range(0.65, 0.85), power: 1 }
+      ];
+    }
+  },
+  // Broad and lumpy: a cluster of round crowns over wide shoulders.
+  oak: {
+    kind: "deciduous",
+    width: 1.25,
+    scale: 0.8,
+    build(h, r) {
+      const w = h * 1.25 * r.range(0.85, 1.15);
+      const n = h < 14 ? 2 : r.int(3, 5);
+      const parts = [];
+      for (let k = 0; k < n; k++) {
+        const offset = n === 1 ? 0 : w * (-0.26 + 0.52 * k / (n - 1) + r.range(-0.05, 0.05));
+        const middle = 1 - Math.abs(offset) / (w * 0.4);
+        parts.push({ type: "dome", offset, radius: w * r.range(0.17, 0.24), base: 0, height: h * (0.72 + 0.28 * middle) * r.range(0.92, 1), power: 0.5 });
+      }
+      const top = Math.max(...parts.map((p) => p.type === "dome" ? p.height : 0));
+      for (const p of parts) if (p.type === "dome") p.height *= h / top;
+      parts.push(
+        { type: "dome", offset: -w * 0.24, radius: w * 0.27, base: 0, height: h * r.range(0.5, 0.62), power: 1 },
+        { type: "dome", offset: w * 0.24, radius: w * 0.27, base: 0, height: h * r.range(0.5, 0.62), power: 1 }
+      );
+      return parts;
+    }
+  },
+  // Tall and narrow, with a couple of bumps down its sides.
+  poplar: {
+    kind: "deciduous",
+    width: 0.4,
+    scale: 1.05,
+    build(h, r) {
+      const half = h * 0.18 * r.range(0.85, 1.15);
+      return [
+        { type: "dome", offset: 0, radius: half, base: 0, height: h, power: 0.6 },
+        { type: "dome", offset: -half * r.range(0.3, 0.5), radius: half * 0.75, base: 0, height: h * r.range(0.5, 0.7), power: 0.5 },
+        { type: "dome", offset: half * r.range(0.3, 0.5), radius: half * 0.75, base: 0, height: h * r.range(0.5, 0.7), power: 0.5 }
+      ];
+    }
+  }
+};
+var cache2 = /* @__PURE__ */ new Map();
+var CACHE_SIZE2 = 64;
+function placeTrees({ trees, height, period }) {
+  const key = JSON.stringify([trees, height, period]);
+  const cached = cache2.get(key);
+  if (cached) return cached;
+  const mix2 = Object.entries(trees.kind);
+  const mean = (f) => mix2.reduce((t, [shape, w]) => t + f(SHAPES[shape]) * w, 0);
+  const scale = mean((s) => s.scale);
+  const random = createRandom(trees.seed);
+  const typicalWidth = height * mean((s) => s.width * (s.scale / scale));
+  const gap = typicalWidth * (2.4 + (0.55 - 2.4) * trees.density);
+  const spots = [];
+  for (let x = random.next() * gap, i = 0; x < period; i++) {
+    spots.push(x);
+    x += gap * random.fork("gap", i).range(0.6, 1.4);
+  }
+  const cells = Math.max(4, Math.round(period / 400));
+  const patches = periodicNoise(random.fork("patches"), cells);
+  const patch = spots.map((x) => patches(x / period * cells));
+  const ranked = [...patch].sort((a, b) => a - b);
+  const keep = Math.round(trees.cover * spots.length);
+  const threshold = keep === 0 ? -Infinity : ranked[keep - 1];
+  const list = [];
+  for (let i = 0; i < spots.length; i++) {
+    if (patch[i] > threshold) continue;
+    const x = spots[i];
+    const r = random.fork("tree", i);
+    const shape = pick(mix2, r.next());
+    const spec = SHAPES[shape];
+    const h = height * (1 + (r.next() * 2 - 1) * trees.variation) * (spec.scale / scale);
+    const parts = spec.build(h, r.fork("shape"));
+    const reach = Math.max(...parts.map((p) => p.type === "cone" ? Math.max(p.left - p.offset, p.right + p.offset) : Math.abs(p.offset) + p.radius));
+    list.push({ x, kind: spec.kind, shape, height: h, width: reach * 2, parts });
+  }
+  if (cache2.size >= CACHE_SIZE2) cache2.delete(cache2.keys().next().value);
+  cache2.set(key, list);
+  return list;
+}
+function pick(mix2, u) {
+  for (const [shape, w] of mix2) {
+    if (u < w) return shape;
+    u -= w;
+  }
+  return mix2[mix2.length - 1][0];
+}
+function treeHeightAt(tree, dx) {
+  let best = -Infinity;
+  for (const p of tree.parts) {
+    const a = dx - p.offset;
+    if (p.type === "cone") {
+      const t = Math.abs(a) / (a < 0 ? p.left : p.right);
+      if (t < 1) best = Math.max(best, p.base + (p.apex - p.base) * (1 - t) ** p.bend);
+    } else {
+      const u = a / p.radius;
+      if (u > -1 && u < 1) best = Math.max(best, p.base + (p.height - p.base) * (1 - u * u) ** p.power);
+    }
+  }
+  return best;
+}
+function treeKeyPoints(tree) {
+  const points = [];
+  for (const p of tree.parts) {
+    points.push(p.offset);
+    if (p.type === "cone" && p.base > 0) points.push(p.offset - p.left * 0.999, p.offset + p.right * 0.999);
+    if (p.type === "dome" && p.base > 0) points.push(p.offset - p.radius * 0.999, p.offset + p.radius * 0.999);
+  }
+  return points;
+}
+
+// src/outline/index.ts
+var mod2 = (a, n) => (a % n + n) % n;
+function buildOutline(layer, size, { overscan = 0, tolerance = 0.25 } = {}) {
+  const profile = buildProfile(layer);
+  const { step, values, period } = profile;
+  const count2 = values.length;
+  const baseline = resolveLength(layer.baseline, size.height);
+  const amplitude = resolveLength(layer.amplitude, size.height);
+  const profileAt = (x) => {
+    const u = x / step;
+    const i = Math.floor(u);
+    const a = values[mod2(i, count2)], b = values[mod2(i + 1, count2)];
+    return baseline + amplitude * (a + (b - a) * (u - i));
+  };
+  const pointed = layer.profile === "peaks";
+  const anchors = layer.anchors.map((a) => anchorShape(a, size, period, profileAt, pointed));
+  const lakes = layer.lakes.map((l) => lakeShape(l, size, period, baseline));
+  const adjust = (x, h) => {
+    for (const a of anchors) h = a(x, h, baseline);
+    for (const l of lakes) h = l.adjust(x, h);
+    return h;
+  };
+  const water = waterSpans(lakes, size, period);
+  const shores = water.filter((w) => !lakes[w.lake].endless).flatMap((w) => [w.x0 - SHORE, w.x0 + SHORE, w.x1 - SHORE, w.x1 + SHORE]);
+  const bottom = size.height + Math.max(0, overscan);
+  const last = Math.ceil((size.width + step) / step);
+  if (layer.trees) {
+    const groundAt = (x) => adjust(x, profileAt(x));
+    const dry = (x) => lakes.every((l) => !l.wet(x));
+    const { crest: crest2, ground } = withTrees(layer, size, step, last, groundAt, dry, period, tolerance, shores);
+    return { crest: crest2, ground, top: topOf(crest2), baseline: size.height - baseline, bottom, water };
+  }
+  const first = -1;
+  const points = [];
+  for (let i = first; i <= last; i++) {
+    const x = i * step;
+    const h = adjust(x, baseline + amplitude * values[mod2(i, count2)]);
+    points.push({ x, y: size.height - h });
+  }
+  for (const x of shores) if (x > first * step && x < last * step) points.push({ x, y: size.height - adjust(x, profileAt(x)) });
+  points.sort((a, b) => a.x - b.x);
+  const crest = simplifyKeeping(points, tolerance, new Set(shores));
+  return { crest, top: topOf(crest), baseline: size.height - baseline, bottom, water };
+}
+var LAKE_BED = 3;
+var BANK = 3;
+var SHORE = 1e-3;
+var MIN_LAND = 60;
+function lakeShape(lake, size, period, baseline) {
+  const center2 = resolveLength(lake.at, size.width);
+  const width = resolveLength(lake.width, size.width);
+  const half = Math.min(period / 2 - 1, Math.max(1, width / 2));
+  const level = baseline + resolveLength(lake.level, size.height);
+  const bank = Math.min(Math.max(half * 0.3, 10), 80);
+  const endless = center2 - width / 2 <= 0 && center2 + width / 2 >= size.width || period - 2 * half < 2 * bank + MIN_LAND;
+  const distance = (x) => {
+    const d = mod2(x - center2, period);
+    return Math.min(d, period - d);
+  };
+  return {
+    center: center2,
+    half,
+    endless,
+    level,
+    adjust(x, h) {
+      if (endless) return level - LAKE_BED;
+      const d = distance(x);
+      if (d <= half) return level - LAKE_BED;
+      if (d >= half + bank) return h;
+      const t = (d - half) / bank;
+      const ease = t * t * (3 - 2 * t);
+      return level + BANK + (h - level - BANK) * ease;
+    },
+    wet: (x) => endless || distance(x) < half + bank * 0.5
+  };
+}
+function waterSpans(lakes, size, period) {
+  const spans = [];
+  lakes.forEach((l, lake) => {
+    if (l.endless) {
+      spans.push({ lake, copy: 0, x0: -1, x1: size.width + 1, y: size.height - l.level });
+      return;
+    }
+    const start = Math.floor((-l.half - l.center) / period);
+    for (let copy = start; l.center + copy * period - l.half < size.width; copy++) {
+      const x0 = l.center + copy * period - l.half;
+      const x1 = l.center + copy * period + l.half;
+      if (x1 < 0) continue;
+      spans.push({ lake, copy, x0, x1, y: size.height - l.level });
+    }
+  });
+  return spans.sort((a, b) => a.x0 - b.x0);
+}
+function topOf(points) {
+  let top = Infinity;
+  for (const p of points) if (p.y < top) top = p.y;
+  return top;
+}
+var TREE_SUBSTEPS = 4;
+function withTrees(layer, size, step, last, groundAt, dry, period, tolerance, shores) {
+  const trees = placeTrees({ trees: layer.trees, height: resolveLength(layer.trees.height, size.height), period });
+  const x0 = -step, x1 = last * step;
+  const placed = [];
+  const widest = trees.reduce((m, t) => Math.max(m, t.width), 0);
+  for (let copy = Math.floor((x0 - widest) / period); copy * period < x1 + widest; copy++) {
+    for (const tree of trees) {
+      const x = tree.x + copy * period;
+      const half = tree.width / 2;
+      if (x + half < x0 || x - half > x1) continue;
+      if (!dry(x - half) || !dry(x) || !dry(x + half)) continue;
+      if (Math.abs(groundAt(x + half) - groundAt(x - half)) > tree.width) continue;
+      placed.push({ tree, x, foot: groundAt(x) - 0.08 * tree.height });
+    }
+  }
+  const xs = [];
+  for (let i = -TREE_SUBSTEPS; i <= last * TREE_SUBSTEPS; i++) xs.push(i / TREE_SUBSTEPS * step);
+  for (const p of placed) for (const dx of treeKeyPoints(p.tree)) if (p.x + dx > x0 && p.x + dx < x1) xs.push(p.x + dx);
+  for (const x of shores) if (x > x0 && x < x1) xs.push(x);
+  xs.sort((a, b) => a - b);
+  const ground = xs.map(groundAt);
+  const heights = ground.slice();
+  for (const p of placed) {
+    const half = p.tree.width / 2;
+    for (let j = lowerBound(xs, p.x - half); j < xs.length && xs[j] <= p.x + half; j++) {
+      const h = p.foot + treeHeightAt(p.tree, xs[j] - p.x);
+      if (h > heights[j]) heights[j] = h;
+    }
+  }
+  const fixed = new Set(shores);
+  const toPoints = (hs) => simplifyKeeping(xs.map((x, j) => ({ x, y: size.height - hs[j] })), tolerance, fixed);
+  return { crest: toPoints(heights), ground: toPoints(ground) };
+}
+function lowerBound(xs, x) {
+  let lo = 0, hi = xs.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (xs[mid] < x) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function anchorShape(anchor, size, period, profileAt, pointed) {
+  const at = resolveLength(anchor.at, size.width);
+  const radius = Math.min(period / 2, Math.max(1, resolveLength(anchor.width, size.width) / 2));
+  const height = resolveLength(anchor.height, size.height);
+  const flat = anchor.kind === "flat";
+  const inner = flat ? radius / 2 : 0;
+  const lift = pointed && anchor.kind === "peak";
+  const center2 = profileAt(at);
+  return (x, h, baseline) => {
+    let d = mod2(x - at, period);
+    d = Math.min(d, period - d);
+    if (d >= radius) return h;
+    const t = d <= inner ? 0 : (d - inner) / (radius - inner);
+    const w = lift ? (1 - t) ** 2 * (1 + 2 * t) * (1 - t) ** 0.6 : 0.5 * (1 + Math.cos(Math.PI * t));
+    return flat ? h + w * (baseline + height - h) : h + w * (baseline + height - center2);
+  };
+}
+function simplifyKeeping(points, tolerance, xs) {
+  if (xs.size === 0 || points.length < 3) return simplify(points, tolerance);
+  const out = [];
+  let start = 0;
+  for (let i = 1; i < points.length; i++) {
+    if (i < points.length - 1 && !xs.has(points[i].x)) continue;
+    const piece = simplify(points.slice(start, i + 1), tolerance);
+    out.push(...out.length > 0 ? piece.slice(1) : piece);
+    start = i;
+  }
+  return out;
+}
+function simplify(points, tolerance) {
+  if (points.length < 3 || tolerance <= 0) return points;
+  const keep = new Uint8Array(points.length);
+  keep[0] = keep[points.length - 1] = 1;
+  const stack = [[0, points.length - 1]];
+  while (stack.length > 0) {
+    const [a, b] = stack.pop();
+    const p = points[a], q = points[b];
+    const dx = q.x - p.x, dy = q.y - p.y;
+    const len = Math.hypot(dx, dy) || 1;
+    let worst = -1, index = -1;
+    for (let i = a + 1; i < b; i++) {
+      const r = points[i];
+      const dist = Math.abs(dy * (r.x - p.x) - dx * (r.y - p.y)) / len;
+      if (dist > worst) {
+        worst = dist;
+        index = i;
+      }
+    }
+    if (worst > tolerance) {
+      keep[index] = 1;
+      stack.push([a, index], [index, b]);
+    }
+  }
+  return points.filter((_, i) => keep[i]);
+}
+
+// src/sky/index.ts
+var STAR_TILE = 1024;
+function skyLayers(sky, ctx) {
+  const layers = [];
+  if (sky.gradient) {
+    const [top, bottom] = sky.gradient;
+    const content = { y1: 0, y2: ctx.height, stops: [{ offset: 0, color: top }, { offset: 1, color: bottom }] };
+    layers.push({
+      key: "sky",
+      kind: "sky",
+      index: 0,
+      depth: 0,
+      shapes: [{ d: rectPath(0, 0, ctx.width, ctx.height + ctx.overscan, ctx.fmt), fill: { type: "linear", id: ctx.id(content), x1: 0, x2: 0, ...content } }],
+      top: 0
+    });
+  }
+  if (sky.stars) layers.push(starsLayer(sky.stars, ctx));
+  if (sky.sun) layers.push(discLayer("sun", sky.sun, ctx, discPath(sky.sun, ctx)));
+  if (sky.moon) layers.push(discLayer("moon", sky.moon, ctx, moonPath(sky.moon, ctx)));
+  return layers;
+}
+function starsLayer(stars, ctx) {
+  const area = resolveLength(stars.area, ctx.height);
+  const random = createRandom(stars.seed);
+  const count2 = Math.round(stars.density * STAR_TILE * STAR_TILE / 1e4);
+  const tile = Array.from({ length: count2 }, () => ({
+    u: random.next() * STAR_TILE,
+    v: random.next() * STAR_TILE,
+    r: (0.5 + random.next() * 1.1) * stars.size,
+    bucket: Math.floor(random.next() * 3),
+    keep: random.next()
+  }));
+  const paths = ["", "", ""];
+  for (let ty = 0; ty * STAR_TILE < area; ty++) {
+    for (let tx = 0; tx * STAR_TILE < ctx.width; tx++) {
+      for (const s of tile) {
+        const x = tx * STAR_TILE + s.u;
+        const y = ty * STAR_TILE + s.v;
+        if (x > ctx.width + 2 || y > area || s.keep < (y / area) ** 2) continue;
+        paths[s.bucket] += circlePath(x, y, s.r, ctx.fmt);
+      }
+    }
+  }
+  const opacities = [0.45, 0.7, 1];
+  const shapes2 = paths.flatMap((d, i) => d ? [{ d, fill: stars.color, opacity: opacities[i] }] : []);
+  return { key: "stars", kind: "stars", index: 0, depth: 1, shapes: shapes2, top: 0 };
+}
+function center(disc, ctx) {
+  return { x: resolveLength(disc.at[0], ctx.width), y: resolveLength(disc.at[1], ctx.height) };
+}
+function discPath(sun, ctx) {
+  const c = center(sun, ctx);
+  return circlePath(c.x, c.y, sun.radius, ctx.fmt);
+}
+function moonPath(moon, ctx) {
+  const { x, y } = center(moon, ctx);
+  const r = moon.radius;
+  const offset = r * (2 - 1.7 * moon.crescent);
+  if (offset >= 2 * r) return circlePath(x, y, r, ctx.fmt);
+  const ix = x + offset / 2;
+  const h = Math.sqrt(r * r - (offset / 2) ** 2);
+  const { fmt } = ctx;
+  const R = fmt(r);
+  return `M${fmt(ix)} ${fmt(y - h)}A${R} ${R} 0 1 0 ${fmt(ix)} ${fmt(y + h)}A${R} ${R} 0 0 1 ${fmt(ix)} ${fmt(y - h)}Z`;
+}
+function discLayer(kind, disc, ctx, d) {
+  const c = center(disc, ctx);
+  const shapes2 = [];
+  if (disc.glow > 0) {
+    const R = disc.radius * (1 + 3.5 * disc.glow);
+    const content = {
+      cx: ctx.round(c.x),
+      cy: ctx.round(c.y),
+      r: ctx.round(R),
+      stops: [
+        { offset: 0, color: disc.color, opacity: 0.6 * disc.glow },
+        { offset: ctx.round(disc.radius / R), color: disc.color, opacity: 0.45 * disc.glow },
+        { offset: 1, color: disc.color, opacity: 0 }
+      ]
+    };
+    shapes2.push({ d: circlePath(c.x, c.y, R, ctx.fmt), fill: { type: "radial", id: ctx.id(content), ...content } });
+  }
+  shapes2.push({ d, fill: disc.color });
+  return { key: kind, kind, index: 0, depth: 1, shapes: shapes2, top: ctx.round(c.y - disc.radius * (1 + 3.5 * disc.glow)) };
+}
+
+// src/palettes/index.ts
+var palettes = {
+  dusk: { near: "#2b1e3f", far: "#8a5a83", haze: "#f3b38a", sky: ["#3d3466", "#f6c49a"], sun: "#ffd9a8", cloud: "#f2c4b8" },
+  dawn: { near: "#3c3a5e", far: "#c49bb0", haze: "#ffd9c7", sky: ["#a9b8de", "#ffe2cf"], sun: "#fff1d6", cloud: "#ffe6e0" },
+  alpine: { near: "#1f3446", far: "#6f8ea6", haze: "#e4eef5", sky: ["#8fb6d8", "#eaf3f9"], sun: "#fffbe8", cloud: "#ffffff" },
+  forest: { near: "#173a2b", far: "#5f8a6a", haze: "#dfe9d8", sky: ["#bfd8d2", "#eef3e4"], mist: 0.25, sun: "#fff6d8", cloud: "#f7faf4" },
+  desert: { near: "#7a3b24", far: "#d29a6a", haze: "#f6dcb8", sky: ["#f2a65e", "#fbe3c0"], sun: "#fff0c2", cloud: "#fde9cf" },
+  fog: { near: "#3a4148", far: "#9aa3aa", haze: "#e9ecee", sky: ["#d5dadd", "#eff1f2"], mist: 0.6, sun: "#f8f8f6", cloud: "#f4f5f6" },
+  night: { near: "#0b1020", far: "#2b3a5e", haze: "#4a5a86", sky: ["#05070f", "#24325a"], sun: "#f1ecd9", cloud: "#36446b" },
+  mono: { near: "#262626", far: "#a3a3a3", haze: "#e5e5e5", sky: ["#f5f5f5", "#e5e5e5"], sun: "#ffffff", cloud: "#fafafa" }
+};
+
+// src/spec/resolve.ts
+var SCENE_DEFAULTS = {
+  seed: "ridgescape",
+  palette: "dusk",
+  layers: 4,
+  height: "45%",
+  haze: { strength: 0.5, curve: 1.2 }
+};
+var PROFILES = ["rolling", "peaks", "mesa", "dunes"];
+var ANCHOR_KINDS = ["peak", "dip", "flat"];
+var PROFILE_DEFAULTS = {
+  rolling: { roughness: 0.35, wavelength: 1 },
+  peaks: { roughness: 0.75, wavelength: 0.8 },
+  mesa: { roughness: 0.3, wavelength: 1.3 },
+  dunes: { roughness: 0.25, wavelength: 0.55 }
+};
+var DEPTH_DEFAULTS = {
+  /** Valleys: low at the front, high at the back. */
+  baseline: (d) => 0.04 + 0.48 * d,
+  /** Hills: gentle at the front, tall at the back. */
+  amplitude: (d) => 0.28 + 0.3 * d,
+  /** Hill width in px: broad at the front. */
+  wavelength: (d) => 900 - 380 * d,
+  /** Repeat width in px, different per layer so repeats don't line up. */
+  period: (d) => 1800 + 700 * d,
+  /** Far layers are smoother. */
+  roughness: (d) => 1 - 0.3 * d
+};
+var SKY_DEFAULTS = {
+  sun: { at: ["72%", "28%"], radius: 56, glow: 0.6 },
+  moon: { at: ["24%", "22%"], radius: 36, glow: 0.35, crescent: 0 },
+  stars: { density: 1, size: 1, area: "70%", color: "#ffffff" }
+};
+var CLOUD_DEFAULTS = {
+  style: "puffy",
+  bands: 2,
+  cover: 0.4,
+  top: "14%",
+  bottom: "40%",
+  size: 240,
+  shade: 0.2,
+  opacity: 0.92
+};
+var TREE_DEFAULTS = {
+  kind: "conifer",
+  density: 0.6,
+  cover: 1,
+  variation: 0.3,
+  /** Height in px by depth: 44 at the front, 12 at the horizon. */
+  height: (d) => Math.round(44 * (1 - 0.72 * d))
+};
+var TREE_GROUPS = {
+  conifer: { spruce: 0.4, fir: 0.32, pine: 0.16, cypress: 0.12 },
+  deciduous: { maple: 0.4, oak: 0.38, poplar: 0.22 },
+  mixed: { spruce: 0.2, fir: 0.16, pine: 0.08, cypress: 0.06, maple: 0.2, oak: 0.19, poplar: 0.11 }
+};
+var TREE_SHAPES = ["spruce", "fir", "pine", "cypress", "maple", "oak", "poplar"];
+var LAKE_DEFAULTS = { width: "30%", level: 0.12, reflection: true, ripples: true };
+var ANCHOR_HEIGHTS = { peak: 1.15, dip: 0, flat: 0.2 };
+function resolve(input = {}) {
+  const seed = String(input.seed ?? SCENE_DEFAULTS.seed);
+  const palette = resolvePalette(input.palette ?? SCENE_DEFAULTS.palette);
+  const height = input.height ?? SCENE_DEFAULTS.height;
+  if (!isLength(height)) throw new TypeError(`ridgescape: height must be px or a percentage, got ${JSON.stringify(height)}`);
+  const haze = {
+    color: input.haze?.color ?? palette.haze,
+    strength: unit(input.haze?.strength ?? SCENE_DEFAULTS.haze.strength, "haze.strength"),
+    curve: positive(input.haze?.curve ?? SCENE_DEFAULTS.haze.curve, "haze.curve")
+  };
+  const raw = input.layers ?? SCENE_DEFAULTS.layers;
+  const list = typeof raw === "number" ? Array.from({ length: count(raw) }, () => ({})) : raw;
+  const n = list.length;
+  const layers = list.map((layer, i) => resolveLayer(layer, { index: i, depth: n > 1 ? (n - 1 - i) / (n - 1) : 0, seed, palette, haze, height }));
+  const sky = input.sky ? resolveSky(input.sky === true ? {} : input.sky, palette, seed) : null;
+  const clouds = input.clouds ? resolveClouds(input.clouds === true ? {} : input.clouds, palette, seed) : null;
+  return { seed, palette, height, haze, sky, clouds, layers };
+}
+function resolveLayer(input, ctx) {
+  const profile = input.profile ?? "rolling";
+  if (!PROFILES.includes(profile)) throw new TypeError(`ridgescape: unknown profile ${JSON.stringify(profile)}; expected ${PROFILES.join(", ")}`);
+  const depth = unit(input.depth ?? ctx.depth, "depth");
+  const p = PROFILE_DEFAULTS[profile];
+  const amplitude = length(input.amplitude ?? scaleLength(ctx.height, DEPTH_DEFAULTS.amplitude(depth)), "amplitude");
+  const seed = String(input.seed ?? `${ctx.seed}:${ctx.index}`);
+  const color = input.color ?? layerColor(ctx.palette, ctx.haze, depth);
+  return {
+    profile,
+    depth,
+    baseline: length(input.baseline ?? scaleLength(ctx.height, DEPTH_DEFAULTS.baseline(depth)), "baseline"),
+    amplitude,
+    roughness: unit(input.roughness ?? round2(p.roughness * DEPTH_DEFAULTS.roughness(depth)), "roughness"),
+    wavelength: positive(input.wavelength ?? Math.round(DEPTH_DEFAULTS.wavelength(depth) * p.wavelength), "wavelength"),
+    period: positive(input.period ?? Math.round(DEPTH_DEFAULTS.period(depth)), "period"),
+    color,
+    mist: unit(input.mist ?? ctx.palette.mist, "mist"),
+    anchors: (input.anchors ?? []).map((a) => resolveAnchor(a, amplitude)),
+    trees: input.trees ? resolveTrees(input.trees === true ? {} : input.trees, depth, seed) : null,
+    lakes: (input.lakes ?? []).map((l) => resolveLake(l, amplitude, color, ctx.palette)),
+    seed
+  };
+}
+function flag(value, name) {
+  if (typeof value !== "boolean") throw new TypeError(`ridgescape: ${name} must be true or false, got ${JSON.stringify(value)}`);
+  return value;
+}
+function resolveLake(input, amplitude, layerColor2, palette) {
+  return {
+    at: length(input.at, "lake at"),
+    width: length(input.width ?? LAKE_DEFAULTS.width, "lake width"),
+    level: length(input.level ?? scaleLength(amplitude, LAKE_DEFAULTS.level), "lake level"),
+    color: input.color ?? waterColor(palette.sky[1], layerColor2),
+    reflection: flag(input.reflection ?? LAKE_DEFAULTS.reflection, "lake reflection"),
+    ripples: flag(input.ripples ?? LAKE_DEFAULTS.ripples, "lake ripples")
+  };
+}
+function waterColor(sky, land) {
+  try {
+    return mix(sky, land, 0.35);
+  } catch {
+    return land;
+  }
+}
+function resolveTrees(input, depth, layerSeed) {
+  return {
+    kind: resolveTreeKind(input.kind ?? TREE_DEFAULTS.kind),
+    density: unit(input.density ?? TREE_DEFAULTS.density, "trees.density"),
+    height: positiveLength(input.height ?? TREE_DEFAULTS.height(depth), "trees.height"),
+    cover: unit(input.cover ?? TREE_DEFAULTS.cover, "trees.cover"),
+    variation: unit(input.variation ?? TREE_DEFAULTS.variation, "trees.variation"),
+    color: input.color ?? null,
+    seed: String(input.seed ?? `${layerSeed}:trees`)
+  };
+}
+function resolveTreeKind(input) {
+  const fail = (kind) => {
+    throw new TypeError(`ridgescape: unknown tree kind ${JSON.stringify(kind)}; expected one of ${[...Object.keys(TREE_GROUPS), ...TREE_SHAPES].join(", ")}`);
+  };
+  const weights = {};
+  const add = (name, weight) => {
+    if (name in TREE_GROUPS) {
+      for (const [shape, w] of Object.entries(TREE_GROUPS[name])) weights[shape] = (weights[shape] ?? 0) + w * weight;
+    } else if (TREE_SHAPES.includes(name)) {
+      weights[name] = (weights[name] ?? 0) + weight;
+    } else fail(name);
+  };
+  if (typeof input === "string") add(input, 1);
+  else if (Array.isArray(input)) for (const name of input) add(name, 1);
+  else if (input && typeof input === "object") {
+    for (const [name, w] of Object.entries(input)) {
+      if (!TREE_SHAPES.includes(name)) fail(name);
+      if (typeof w !== "number" || !(w >= 0) || !Number.isFinite(w)) throw new TypeError(`ridgescape: trees.kind.${name} must be a number \u2265 0`);
+      add(name, w);
+    }
+  } else fail(input);
+  const total = Object.values(weights).reduce((t, w) => t + w, 0);
+  if (!(total > 0)) fail(input);
+  const out = {};
+  for (const shape of TREE_SHAPES) if (weights[shape]) out[shape] = Number((weights[shape] / total).toFixed(6));
+  return out;
+}
+function resolveAnchor(input, amplitude) {
+  const kind = input.kind ?? "peak";
+  if (!ANCHOR_KINDS.includes(kind)) throw new TypeError(`ridgescape: unknown anchor kind ${JSON.stringify(kind)}; expected ${ANCHOR_KINDS.join(", ")}`);
+  return {
+    at: length(input.at, "anchor at"),
+    kind,
+    height: length(input.height ?? scaleLength(amplitude, ANCHOR_HEIGHTS[kind]), "anchor height"),
+    width: length(input.width ?? "20%", "anchor width")
+  };
+}
+function resolveSky(input, palette, seed) {
+  const gradient = input.gradient === false || input.gradient === null ? null : input.gradient ?? palette.sky;
+  const disc = (value, defaults, name) => {
+    if (!value) return null;
+    const v = value === true ? {} : value;
+    const at = v.at ?? defaults.at;
+    if (!Array.isArray(at) || at.length !== 2 || !isLength(at[0]) || !isLength(at[1])) throw new TypeError(`ridgescape: ${name}.at must be [x, y] in px or percentages, got ${JSON.stringify(at)}`);
+    return { at: [at[0], at[1]], radius: positive(v.radius ?? defaults.radius, `${name}.radius`), color: v.color ?? palette.sun, glow: unit(v.glow ?? defaults.glow, `${name}.glow`) };
+  };
+  const sun = disc(input.sun, SKY_DEFAULTS.sun, "sun");
+  const moonDisc = disc(input.moon, SKY_DEFAULTS.moon, "moon");
+  const moonInput = typeof input.moon === "object" && input.moon ? input.moon : {};
+  const moon = moonDisc && { ...moonDisc, crescent: unit(moonInput.crescent ?? SKY_DEFAULTS.moon.crescent, "moon.crescent") };
+  let stars = null;
+  if (input.stars) {
+    const s = input.stars === true ? {} : input.stars;
+    stars = {
+      density: positive(s.density ?? SKY_DEFAULTS.stars.density, "stars.density"),
+      size: positive(s.size ?? SKY_DEFAULTS.stars.size, "stars.size"),
+      area: length(s.area ?? SKY_DEFAULTS.stars.area, "stars.area"),
+      color: s.color ?? SKY_DEFAULTS.stars.color,
+      seed: String(s.seed ?? `${seed}:stars`)
+    };
+  }
+  return { gradient: gradient ? [gradient[0], gradient[1]] : null, sun, moon, stars };
+}
+var CLOUD_STYLES = ["puffy", "streaks"];
+function resolveClouds(input, palette, seed) {
+  const style = input.style ?? CLOUD_DEFAULTS.style;
+  if (!CLOUD_STYLES.includes(style)) throw new TypeError(`ridgescape: unknown cloud style ${JSON.stringify(style)}; expected ${CLOUD_STYLES.join(", ")}`);
+  const bands = input.bands ?? CLOUD_DEFAULTS.bands;
+  if (!Number.isInteger(bands) || bands < 1 || bands > 8) throw new RangeError(`ridgescape: clouds.bands must be a whole number from 1 to 8, got ${bands}`);
+  return {
+    style,
+    bands,
+    cover: unit(input.cover ?? CLOUD_DEFAULTS.cover, "clouds.cover"),
+    top: length(input.top ?? CLOUD_DEFAULTS.top, "clouds.top"),
+    bottom: length(input.bottom ?? CLOUD_DEFAULTS.bottom, "clouds.bottom"),
+    size: positive(input.size ?? CLOUD_DEFAULTS.size, "clouds.size"),
+    color: input.color ?? palette.cloud,
+    shade: unit(input.shade ?? CLOUD_DEFAULTS.shade, "clouds.shade"),
+    opacity: unit(input.opacity ?? CLOUD_DEFAULTS.opacity, "clouds.opacity"),
+    seed: String(input.seed ?? `${seed}:clouds`)
+  };
+}
+function resolvePalette(input) {
+  const p = typeof input === "string" ? palettes[input] : input;
+  if (!p) throw new TypeError(`ridgescape: unknown palette ${JSON.stringify(input)}; expected ${Object.keys(palettes).join(", ")} or your own colours`);
+  const haze = p.haze ?? p.far;
+  return { near: p.near, far: p.far, haze, sky: p.sky ?? [haze, haze], mist: p.mist ?? 0, sun: p.sun ?? lighten(haze, 0.5), cloud: p.cloud ?? lighten(haze, 0.6) };
+}
+function lighten(color, t) {
+  try {
+    return mix(color, "#ffffff", t);
+  } catch {
+    return "#ffffff";
+  }
+}
+function count(n) {
+  if (!Number.isInteger(n) || n < 1 || n > 32) throw new RangeError(`ridgescape: layers must be a whole number from 1 to 32, got ${n}`);
+  return n;
+}
+function unit(n, name) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n < 0 || n > 1) throw new RangeError(`ridgescape: ${name} must be from 0 to 1, got ${n}`);
+  return n;
+}
+function positive(n, name) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n <= 0) throw new RangeError(`ridgescape: ${name} must be greater than 0, got ${n}`);
+  return n;
+}
+function length(value, name) {
+  if (!isLength(value)) throw new TypeError(`ridgescape: ${name} must be px or a percentage, got ${JSON.stringify(value)}`);
+  return value;
+}
+function positiveLength(value, name) {
+  const l = length(value, name);
+  if (!(resolveLength(l, 100) > 0)) throw new RangeError(`ridgescape: ${name} must be greater than 0, got ${JSON.stringify(value)}`);
+  return l;
+}
+var round2 = (n) => Number(n.toFixed(4));
+
+// src/render/index.ts
+function render(scene, { width, height, overscan = 0, idPrefix = "ridgescape", precision = 2 }) {
+  if (!(width > 0) || !(height > 0)) throw new RangeError(`ridgescape: width and height must be greater than 0, got ${width} \xD7 ${height}`);
+  const resolved = resolve(scene);
+  const fmt = (n) => formatNumber(n, precision);
+  const ctx = {
+    width,
+    height,
+    overscan: Math.max(0, overscan),
+    fmt,
+    round: (n) => Number(fmt(n)),
+    // Ids from the content, so two scenes on one page never pick up each other's gradients.
+    id: (content) => `${idPrefix}-${hashString(JSON.stringify(content)).toString(36)}`
+  };
+  const layers = [];
+  if (resolved.sky) layers.push(...skyLayers(resolved.sky, ctx));
+  if (resolved.clouds) layers.push(...cloudLayers(resolved.clouds, resolved.palette, ctx));
+  resolved.layers.forEach((layer, index) => {
+    const outline = buildOutline(layer, { width, height }, { overscan: ctx.overscan });
+    let fill = layer.color;
+    if (layer.mist > 0) {
+      const content = {
+        y1: ctx.round(outline.top),
+        y2: ctx.round(Math.max(outline.baseline, outline.top + 1)),
+        stops: [
+          { offset: 0, color: layer.color },
+          { offset: 1, color: mix(layer.color, resolved.haze.color, layer.mist) }
+        ]
+      };
+      fill = { type: "linear", id: ctx.id(content), x1: 0, x2: 0, ...content };
+    }
+    const shapes2 = layer.trees?.color && outline.ground ? [{ d: groundPath(outline.crest, outline.bottom, fmt), fill: layer.trees.color }, { d: groundPath(outline.ground, outline.bottom, fmt), fill }] : [{ d: groundPath(outline.crest, outline.bottom, fmt), fill }];
+    const spans = outline.water.map((span) => ({ span, lake: layer.lakes[span.lake], seed: `${layer.seed}:lake:${span.lake}` }));
+    shapes2.push(...waterBase(spans, outline.bottom, ctx));
+    const reflections = reflectionLayers(spans, layers, outline.bottom, `reflection-${index}`, index, layer.depth, ctx);
+    layers.push({ key: `ground-${index}`, kind: "ground", index, depth: layer.depth, shapes: shapes2, top: ctx.round(outline.top) });
+    if (spans.length > 0) {
+      layers.push(...reflections);
+      const surface = waterSurface(spans, outline.bottom, ctx);
+      layers.push({ key: `water-${index}`, kind: "water", index, depth: layer.depth, shapes: surface, top: ctx.round(Math.min(...spans.map((s) => s.span.y))) });
+    }
+  });
+  return { width, height, overscan: ctx.overscan, layers };
+}
+function formatNumber(n, precision = 2) {
+  const s = String(Number(n.toFixed(precision)));
+  return s === "-0" ? "0" : s;
+}
+var escape = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+function stopsMarkup(fill) {
+  return fill.stops.map((s) => `<stop offset="${s.offset}" stop-color="${escape(s.color)}"${s.opacity !== void 0 && s.opacity !== 1 ? ` stop-opacity="${s.opacity}"` : ""}/>`).join("");
+}
+function gradientMarkup(fill) {
+  if (fill.type === "radial") {
+    return `<radialGradient id="${escape(fill.id)}" gradientUnits="userSpaceOnUse" cx="${fill.cx}" cy="${fill.cy}" r="${fill.r}">${stopsMarkup(fill)}</radialGradient>`;
+  }
+  return `<linearGradient id="${escape(fill.id)}" gradientUnits="userSpaceOnUse" x1="${fill.x1}" y1="${fill.y1}" x2="${fill.x2}" y2="${fill.y2}">${stopsMarkup(fill)}</linearGradient>`;
+}
+function clipId(shape, idPrefix) {
+  return `${idPrefix}-clip-${hashString(shape.clip).toString(36)}`;
+}
+function mirrorClipId(layer, idPrefix) {
+  return `${idPrefix}-clip-${hashString(mirrorClip(layer.mirror.water)).toString(36)}`;
+}
+function defsMarkup(layers, idPrefix = "ridgescape", { clipMirrors = true } = {}) {
+  const defs = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    if (layer.mirror && clipMirrors) {
+      const id = mirrorClipId(layer, idPrefix);
+      if (!defs.has(id)) defs.set(id, `<clipPath id="${id}"><path d="${mirrorClip(layer.mirror.water)}"/></clipPath>`);
+    }
+    for (const shape of layer.shapes) {
+      if (typeof shape.fill !== "string" && !defs.has(shape.fill.id)) defs.set(shape.fill.id, gradientMarkup(shape.fill));
+      if (shape.clip) {
+        const id = clipId(shape, idPrefix);
+        if (!defs.has(id)) defs.set(id, `<clipPath id="${id}"><path d="${shape.clip}"/></clipPath>`);
+      }
+    }
+  }
+  return defs.size > 0 ? `<defs>${[...defs.values()].join("")}</defs>` : "";
+}
+function shapeMarkup(shape, idPrefix = "ridgescape") {
+  const fill = typeof shape.fill === "string" ? escape(shape.fill) : `url(#${escape(shape.fill.id)})`;
+  const opacity = shape.opacity !== void 0 && shape.opacity !== 1 ? ` opacity="${shape.opacity}"` : "";
+  const transform = shape.transform ? ` transform="matrix(${shape.transform.join(" ")})"` : "";
+  const path = shape.href ? `<use href="#${escape(shape.href)}"${transform}/>` : `<path${shape.id ? ` id="${escape(shape.id)}"` : ""} d="${shape.d}" fill="${fill}"${opacity}${transform}/>`;
+  return shape.clip ? `<g clip-path="url(#${clipId(shape, idPrefix)})">${path}</g>` : path;
+}
+function layerMarkup(layer, idPrefix = "ridgescape", { clipMirrors = true } = {}) {
+  const shapes2 = layer.shapes.map((s) => shapeMarkup(s, idPrefix)).join("");
+  return layer.mirror && clipMirrors ? `<g clip-path="url(#${mirrorClipId(layer, idPrefix)})">${shapes2}</g>` : shapes2;
+}
+function serialize(rendered, idPrefix = "ridgescape") {
+  const { width, height, layers } = rendered;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">` + defsMarkup(layers, idPrefix) + layers.map((l) => layerMarkup(l, idPrefix)).join("") + `</svg>`;
+}
+function toSvg(scene, options) {
+  return serialize(render(scene, options), options.idPrefix);
+}
+
+// src/presets/index.ts
+var presets = {
+  /** Mountains at dusk behind rolling foothills. */
+  sierra: { seed: 1, palette: "dusk", layers: [{ profile: "peaks" }, { profile: "peaks" }, {}, {}, {}] },
+  /** A low, green footer. */
+  meadow: { seed: 2, palette: "forest", height: "30%", layers: 3 },
+  /** Many soft ridges sinking into fog. */
+  misty: { seed: 3, palette: "fog", layers: 7, haze: { strength: 0.9 } },
+  /** Mesas behind dunes. */
+  mesa: { seed: 4, palette: "desert", layers: [{ profile: "mesa" }, { profile: "dunes" }, { profile: "dunes" }] },
+  /** Snowy peaks, tall and pale. */
+  glacier: { seed: 5, palette: "alpine", height: "60%", layers: [{ profile: "peaks" }, { profile: "peaks" }, { profile: "peaks" }, {}] },
+  /** Dark hills under a night sky. */
+  nightfall: { seed: 6, palette: "night", layers: 4 },
+  /** A bright day: sun and puffy clouds over green hills. Draws its own sky. */
+  summer: { seed: 7, palette: "alpine", sky: { sun: { at: ["78%", "22%"] } }, clouds: { bands: 2, cover: 0.45 }, layers: [{ profile: "peaks" }, {}, { color: "#4f7a4a" }, { color: "#355c37" }] },
+  /** A crescent moon, stars and wisps of cloud. Draws its own sky. */
+  starlight: { seed: 8, palette: "night", sky: { moon: { crescent: 0.55 }, stars: true }, clouds: { style: "streaks", cover: 0.3, opacity: 0.7 }, layers: [{ profile: "peaks" }, { trees: true }, { trees: { density: 0.8 } }] },
+  /** A mountain lake mirroring the peaks behind it. Draws its own sky. */
+  lakeside: {
+    seed: 5,
+    palette: "alpine",
+    height: "60%",
+    sky: { sun: { at: ["70%", "25%"] } },
+    clouds: { bands: 1 },
+    layers: [{ profile: "peaks" }, { profile: "peaks" }, { lakes: [{ at: "50%", width: "100%", level: "18%" }] }]
+  },
+  /** Pine forest climbing the hills, with misty valleys. */
+  pinewood: { seed: 9, palette: "forest", layers: [{ profile: "peaks" }, { trees: true }, { trees: true }, { trees: { density: 0.85 } }] }
+};
+
+// src/canvas/index.ts
+function fillStyle(ctx, fill) {
+  if (typeof fill === "string") return fill;
+  const gradient = fill.type === "radial" ? ctx.createRadialGradient(fill.cx, fill.cy, 0, fill.cx, fill.cy, fill.r) : ctx.createLinearGradient(fill.x1, fill.y1, fill.x2, fill.y2);
+  for (const stop of fill.stops) gradient.addColorStop(stop.offset, stop.opacity === void 0 || stop.opacity === 1 ? stop.color : withAlpha(stop.color, stop.opacity));
+  return gradient;
+}
+function withAlpha(color, alpha2) {
+  const c = parseColor(color);
+  if (c) return format({ ...c, a: c.a * alpha2 });
+  return `color-mix(in srgb, ${color} ${Number((alpha2 * 100).toFixed(2))}%, transparent)`;
+}
+function drawShape(ctx, shape) {
+  ctx.save();
+  if (shape.clip) ctx.clip(new Path2D(shape.clip));
+  if (shape.transform) ctx.transform(...shape.transform);
+  if (shape.opacity !== void 0) ctx.globalAlpha *= shape.opacity;
+  ctx.fillStyle = fillStyle(ctx, shape.fill);
+  ctx.fill(new Path2D(shape.d));
+  ctx.restore();
+}
+function drawLayer(ctx, layer, { clipMirrors = true } = {}) {
+  const clip = layer.mirror && clipMirrors;
+  if (clip) {
+    ctx.save();
+    ctx.clip(new Path2D(mirrorClip(layer.mirror.water)));
+  }
+  for (const shape of layer.shapes) drawShape(ctx, shape);
+  if (clip) ctx.restore();
+}
+function drawToCanvas(ctx, rendered, { pixelRatio = 1, clear = true } = {}) {
+  const layers = Array.isArray(rendered) ? rendered : rendered.layers;
+  ctx.save();
+  ctx.setTransform(1, 0, 0, 1, 0, 0);
+  if (clear) ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+  ctx.scale(pixelRatio, pixelRatio);
+  for (const layer of layers) drawLayer(ctx, layer);
+  ctx.restore();
+}
+
+// src/parallax/index.ts
+var PARALLAX_DEFAULTS = { strength: 0.3 };
+function parallaxDelta(rect, viewportHeight) {
+  if (rect.bottom > viewportHeight) return rect.bottom - viewportHeight;
+  return Math.max(Math.min(rect.top, 0), rect.bottom - viewportHeight);
+}
+function parallaxOffset(depth, strength, delta, viewportHeight) {
+  const d = Math.min(viewportHeight, Math.max(-viewportHeight, delta));
+  const k = Math.min(1, Math.max(0, strength * depth));
+  return round3(-k * d);
+}
+function attachParallax(container, { strength = PARALLAX_DEFAULTS.strength } = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const depth = (el, name) => Number(el.getAttribute(name)) || 0;
+  const layers = Array.from(container.querySelectorAll("[data-depth]"), (el) => ({ el, depth: depth(el, "data-depth") }));
+  const mirrors = Array.from(container.querySelectorAll("[data-mirror]"), (el) => {
+    const lake = el.parentElement?.closest("[data-depth]");
+    return { el, depth: depth(el, "data-mirror"), lake: lake && container.contains(lake) ? depth(lake, "data-depth") : 0 };
+  });
+  const all = [...layers, ...mirrors];
+  const reset = () => {
+    for (const { el } of all) {
+      el.style.transform = "";
+      el.style.willChange = "";
+    }
+  };
+  const reduced = typeof matchMedia === "function" ? matchMedia("(prefers-reduced-motion: reduce)") : null;
+  const move = (el, offset) => {
+    el.style.willChange = "transform";
+    el.style.transform = offset === 0 ? "" : `translate3d(0, ${offset}px, 0)`;
+  };
+  let frame = 0;
+  const update = () => {
+    frame = 0;
+    if (reduced?.matches) return reset();
+    const vh = window.innerHeight;
+    const delta = parallaxDelta(container.getBoundingClientRect(), vh);
+    const offset = (d) => parallaxOffset(d, strength, delta, vh);
+    for (const l of layers) move(l.el, offset(l.depth));
+    for (const m of mirrors) move(m.el, round3(offset(m.lake) - offset(m.depth)));
+  };
+  const schedule = () => {
+    if (!frame) frame = requestAnimationFrame(update);
+  };
+  update();
+  window.addEventListener("scroll", schedule, { passive: true });
+  window.addEventListener("resize", schedule);
+  reduced?.addEventListener?.("change", schedule);
+  return () => {
+    window.removeEventListener("scroll", schedule);
+    window.removeEventListener("resize", schedule);
+    reduced?.removeEventListener?.("change", schedule);
+    if (frame) cancelAnimationFrame(frame);
+    reset();
+  };
+}
+var round3 = (n) => Math.round(n * 100) / 100 + 0;
+function clipStyle(water) {
+  return `path("${mirrorClip(water)}")`;
+}
+
+// src/parent.ts
+var ridgescapeParentStyle = { position: "relative", isolation: "isolate" };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANCHOR_HEIGHTS,
+  CLOUD_DEFAULTS,
+  DEPTH_DEFAULTS,
+  LAKE_DEFAULTS,
+  PARALLAX_DEFAULTS,
+  PROFILE_DEFAULTS,
+  SAMPLE_STEP,
+  SCENE_DEFAULTS,
+  SKY_DEFAULTS,
+  TREE_DEFAULTS,
+  TREE_GROUPS,
+  TREE_SHAPES,
+  attachParallax,
+  buildOutline,
+  buildProfile,
+  capsulePath,
+  circlePath,
+  clipId,
+  clipStyle,
+  createRandom,
+  defsMarkup,
+  drawLayer,
+  drawShape,
+  drawToCanvas,
+  formatColor,
+  formatNumber,
+  gradientMarkup,
+  groundPath,
+  hashString,
+  layerColor,
+  layerMarkup,
+  mirrorClip,
+  mirrorClipId,
+  mix,
+  octaves,
+  palettes,
+  parallaxDelta,
+  parallaxOffset,
+  parseColor,
+  periodicNoise,
+  placeTrees,
+  presets,
+  rectPath,
+  reflectionLayers,
+  render,
+  resolve,
+  resolveLength,
+  resolvePalette,
+  ridgescapeParentStyle,
+  scaleLength,
+  serialize,
+  shapeMarkup,
+  simplify,
+  toSvg,
+  treeHeightAt,
+  treeKeyPoints,
+  waterBase,
+  waterSurface
+});
+//# sourceMappingURL=index.cjs.map