dsh-inkpond 0.1.0 → 0.2.0

package/lib/client.js

@@ -29,7 +29,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/client/preferences.ts
 var STORAGE_KEY = "dsh-inkpond.preferences.v1";
-var SCENES = ["lotus", "shanshui", "qingming"];
+var SCENES = ["lotus", "shanshui", "qingming", "jieqi", "beiming"];
 var DEFAULTS = Object.freeze({
   enabled: true,
   scene: "lotus",
@@ -193,10 +193,2415 @@ var glyphTable = (ramps, loose = "") => {
   };
 };
 
+// node_modules/inkpond/dist/scenes/beiming.js
+var BEIMING_FONT_FAMILY = "Inkpond Glyphs Beiming";
+var BEIMING_FONT_URL = "data:font/woff2;base64,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";
+var SEA = 0;
+var WHALE = 1;
+var BEIMING_LEVELS = [
+  "\u4E00",
+  "\u4E00",
+  "\u4E00\uFF5E",
+  "\uFF5E",
+  "\uFF5E\u4E8C",
+  "\u51AB\u6C34",
+  "\u6CE2\u6D6A",
+  "\u6CA7\u6D77"
+];
+var WHALE_LEVELS = [
+  "\u4E36",
+  "\u51AB",
+  "\u6C35\u6C89",
+  "\u6DF1\u6CA1",
+  "\u5E7D\u6F5C",
+  "\u51A5\u6E0A",
+  "\u6E9F\u9CB2",
+  "\u9CB8\u9CB2"
+];
+var MOTE = "\u4E36";
+var SEA_INK = 2.6;
+var WHALE_INK = 2.8;
+var SPINE = 14;
+var DEPTH_PERIOD = 56;
+var BEAT_PERIOD = 7;
+var SLICKS = 18;
+var SLICK_EVERY_S = 1.8;
+var SLICK_LIFE_S = 32;
+var angleTo = (from, to) => {
+  let d = to - from;
+  while (d > Math.PI)
+    d -= Math.PI * 2;
+  while (d < -Math.PI)
+    d += Math.PI * 2;
+  return d;
+};
+var createBeiming = (levels = BEIMING_LEVELS) => {
+  const table = glyphTable([levels, WHALE_LEVELS], MOTE);
+  const mote = table.index(MOTE);
+  let cols = 0;
+  let rows = 0;
+  let cell = 16;
+  let width = 0;
+  let height = 0;
+  let warp = coarseField(0, 0);
+  let patch = coarseField(0, 0);
+  let length = 0;
+  let girth = 0;
+  let seg = 0;
+  let spine = [];
+  let halfWidth = new Float32Array(0);
+  let heading = 0;
+  let depth = 0.5;
+  let dive = 0;
+  let beat = 0;
+  let slicks = [];
+  let nextSlick = 0;
+  let lastSlick = Number.NEGATIVE_INFINITY;
+  let motes = [];
+  let rim = false;
+  const layoutWhale = () => {
+    length = clamp(Math.min(Math.max(width * 0.5, height * 0.62), width * 0.9), 240, 860);
+    girth = length * 0.11;
+    seg = length / (SPINE - 1);
+    heading = -0.12;
+    halfWidth = new Float32Array(SPINE);
+    spine = [];
+    for (let i = 0; i < SPINE; i++) {
+      const s = i / (SPINE - 1);
+      halfWidth[i] = s < 0.26 ? girth * (0.42 + 0.58 * Math.sqrt(Math.sin(s / 0.26 * (Math.PI / 2)))) : girth * (0.1 + 0.9 * Math.cos((s - 0.26) / 0.74 * (Math.PI / 2)) ** 1.7);
+      spine.push({
+        x: width * 0.32 - Math.cos(heading) * seg * i,
+        y: height * 0.6 - Math.sin(heading) * seg * i
+      });
+    }
+    slicks = Array.from({ length: SLICKS }, () => ({ k: 0, t: 0, x: 0, y: 0 }));
+    nextSlick = 0;
+    lastSlick = Number.NEGATIVE_INFINITY;
+    dive = 0;
+    const rand = rng(cols * 29 + rows * 13);
+    motes = Array.from({ length: clamp(Math.round(width * height / 52e3), 12, 48) }, () => ({
+      phase: rand() * 6.28,
+      x: rand() * width,
+      y: rand() * height,
+      z: 0.4 + rand() * 0.6
+    }));
+  };
+  const taper = (px, py, ax, ay, dx, dy, len, r0, r1) => {
+    const t = clamp(((px - ax) * dx + (py - ay) * dy) / len, 0, 1);
+    const ex = px - ax - dx * t * len;
+    const ey = py - ay - dy * t * len;
+    return Math.sqrt(ex * ex + ey * ey) - (r0 + (r1 - r0) * t);
+  };
+  let blur = 0;
+  let span = 0;
+  let tailX = 0;
+  let tailY = 0;
+  let tailDX = 1;
+  let tailDY = 0;
+  const fin = new Float64Array(8);
+  const pose = (time) => {
+    blur = (0.6 + 2.2 * depth) * cell;
+    span = length * 0.17 * (0.86 + 0.14 * Math.cos(beat));
+    const tail = spine[SPINE - 1];
+    const stock = spine[SPINE - 2];
+    const tl = Math.hypot(tail.x - stock.x, tail.y - stock.y) || 1;
+    tailX = tail.x;
+    tailY = tail.y;
+    tailDX = (tail.x - stock.x) / tl;
+    tailDY = (tail.y - stock.y) / tl;
+    const f0 = spine[3];
+    const f1 = spine[4];
+    const fl = Math.hypot(f1.x - f0.x, f1.y - f0.y) || 1;
+    const bx = (f1.x - f0.x) / fl;
+    const by = (f1.y - f0.y) / fl;
+    for (let side = -1, k = 0; side <= 1; side += 2, k += 4) {
+      const a = 0.72 + 0.12 * Math.sin(time * 0.32 + side);
+      const ca = Math.cos(a);
+      const sa = Math.sin(a) * side;
+      const root = (halfWidth[3] ?? 0) * 0.75 * side;
+      fin[k] = f0.x + (f1.x - f0.x) * 0.25 - by * root;
+      fin[k + 1] = f0.y + (f1.y - f0.y) * 0.25 + bx * root;
+      fin[k + 2] = bx * ca - by * sa;
+      fin[k + 3] = by * ca + bx * sa;
+    }
+  };
+  const whaleAt = (x, y, time) => {
+    let body = 1e9;
+    let bodyHalf = 1;
+    for (let i = 0; i < SPINE - 1; i++) {
+      const a = spine[i];
+      const b = spine[i + 1];
+      const vx = b.x - a.x;
+      const vy = b.y - a.y;
+      const k = clamp(((x - a.x) * vx + (y - a.y) * vy) / (vx * vx + vy * vy || 1), 0, 1);
+      const h = (halfWidth[i] ?? 0) + ((halfWidth[i + 1] ?? 0) - (halfWidth[i] ?? 0)) * k;
+      const ex = x - a.x - vx * k;
+      const ey = y - a.y - vy * k;
+      const d2 = Math.sqrt(ex * ex + ey * ey) - h;
+      if (d2 < body) {
+        body = d2;
+        bodyHalf = h;
+      }
+    }
+    if (body > length * 0.3 + blur) {
+      rim = false;
+      return 0;
+    }
+    const u = (x - tailX) * tailDX + (y - tailY) * tailDY;
+    const w = -(x - tailX) * tailDY + (y - tailY) * tailDX;
+    const chord = length * 0.075;
+    const aw = Math.abs(w) / span;
+    const lead = -chord * 0.2 + chord * 0.85 * aw ** 1.8;
+    const trail = lead + chord * Math.sqrt(Math.max(0, 1 - aw * aw)) * (1 - 0.45 * Math.exp(-((w / (span * 0.1)) ** 2)));
+    const flukes = Math.max(Math.abs(w) - span, lead - u, u - trail);
+    let fins = 1e9;
+    for (let k = 0; k < 8; k += 4) {
+      fins = Math.min(fins, taper(x, y, fin[k] ?? 0, fin[k + 1] ?? 0, fin[k + 2] ?? 0, fin[k + 3] ?? 0, length * 0.27, length * 0.042, length * 0.012));
+    }
+    const d = Math.min(body, flukes, fins);
+    if (d > blur) {
+      rim = false;
+      return 0;
+    }
+    rim = d > -blur * 0.55 - depth * girth * 0.5;
+    const core = body <= d ? 0.5 + 0.5 * Math.sqrt(clamp(-body / (bodyHalf * 0.9), 0, 1)) : flukes <= d ? 0.8 * (0.85 + 0.15 * Math.cos(beat)) : 0.8;
+    const mottle = 0.78 + 0.4 * (noise(x / 46, y / 46) - 0.5);
+    const c = noise(x / 68 + time * 0.12, y / 68 - time * 0.08);
+    const lit = 1 - 0.32 * smoothstep(0.78, 1, 1 - Math.abs(2 * c - 1)) * (1 - depth);
+    return (1 - smoothstep(-blur, blur, d)) * (1 - 0.5 * depth) * core * mottle * lit;
+  };
+  const calmAt = (x, y, time) => {
+    let calm = 0;
+    for (const s of slicks) {
+      if (s.k <= 0)
+        continue;
+      const age = time - s.t;
+      if (age > SLICK_LIFE_S)
+        continue;
+      const r = girth * (1.5 + age * 0.06);
+      const d2 = ((x - s.x) ** 2 + (y - s.y) ** 2) / (r * r);
+      if (d2 < 4) {
+        calm = Math.max(calm, Math.exp(-d2 * d2) * s.k * smoothstep(SLICK_LIFE_S, SLICK_LIFE_S * 0.56, age));
+      }
+    }
+    return calm;
+  };
+  return {
+    fontFamily: BEIMING_FONT_FAMILY,
+    fontUrl: BEIMING_FONT_URL,
+    glyphs: table.glyphs,
+    moving: true,
+    panSpeed: 0,
+    ramps: table.ramps,
+    compose(grid, _offset, time) {
+      for (let cy = 0; cy < warp.h; cy++) {
+        for (let cx = 0; cx < warp.w; cx++) {
+          const x = cx * COARSE * cell;
+          const y = cy * COARSE * cell;
+          const j = cy * warp.w + cx;
+          warp.data[j] = 3.2 * fbm(x / 300, y / 300 + time * 0.015);
+          patch.data[j] = smoothstep(0.45, 0.75, fbm(x / 230 + time * 8e-3 + 9, y / 230));
+        }
+      }
+      let x0 = Number.POSITIVE_INFINITY;
+      let y0 = Number.POSITIVE_INFINITY;
+      let x1 = Number.NEGATIVE_INFINITY;
+      let y1 = Number.NEGATIVE_INFINITY;
+      for (const p of spine) {
+        x0 = Math.min(x0, p.x);
+        y0 = Math.min(y0, p.y);
+        x1 = Math.max(x1, p.x);
+        y1 = Math.max(y1, p.y);
+      }
+      const reach = length * 0.36;
+      pose(time);
+      const slicked = slicks.some((s) => s.k > 0 && time - s.t < SLICK_LIFE_S);
+      grid.wet.fill(1);
+      for (let y = 0; y < rows; y++) {
+        const py = (y - 0.5) * cell;
+        for (let x = 0, i = y * cols; x < cols; x++, i++) {
+          const px = (x - 0.5) * cell;
+          const a = Math.sin((py * 0.96 + px * 0.28) / (cell * 2.4) + warp.at(x, y) - time * 0.42);
+          let sea = smoothstep(0.9, 1, a) * (0.25 + 0.75 * patch.at(x, y)) * 0.42;
+          if (sea > 0 && slicked)
+            sea *= 1 - calmAt(px, py, time);
+          const near = px > x0 - reach && px < x1 + reach && py > y0 - reach && py < y1 + reach;
+          const whale = near ? whaleAt(px, py, time) * (1 - 0.3 * sea) : 0;
+          if (whale > 0.02 && whale >= sea) {
+            grid.kind[i] = WHALE;
+            grid.ground[i] = whale * WHALE_INK;
+            grid.pigment[i] = rim ? HUAQING : INK;
+          } else {
+            grid.kind[i] = SEA;
+            grid.ground[i] = sea * SEA_INK;
+            grid.pigment[i] = INK;
+          }
+        }
+      }
+    },
+    layout(view) {
+      cols = view.cols;
+      rows = view.rows;
+      cell = view.cell;
+      width = view.width;
+      height = view.height;
+      warp = coarseField(cols, rows);
+      patch = coarseField(cols, rows);
+      layoutWhale();
+    },
+    stamps(_env, emit) {
+      for (const m of motes) {
+        emit(mote, m.x, m.y, 0.22 * m.z, 0.6 + m.z * 0.4, INK);
+      }
+    },
+    step(dt, env) {
+      dt = Math.min(dt, 0.1);
+      const time = env.time;
+      const head = spine[0];
+      if (!head)
+        return;
+      let turn = (noise(time * 0.02, 7.3) - 0.5) * 0.14;
+      const R = Math.min(env.width, env.height) * 0.5;
+      const dx = env.width / 2 - head.x;
+      const dy = env.height / 2 - head.y;
+      turn += angleTo(heading, Math.atan2(dy, dx)) * 0.2 * smoothstep(R * 0.25, R * 1.1, Math.hypot(dx, dy));
+      for (const d of env.drops) {
+        if (d.age < 10) {
+          turn += angleTo(heading, Math.atan2(d.y - head.y, d.x - head.x)) * 0.25;
+          break;
+        }
+      }
+      heading += clamp(turn, -0.5, 0.5) * dt;
+      const speed = length * 0.06;
+      head.x += Math.cos(heading) * speed * dt;
+      head.y += Math.sin(heading) * speed * dt;
+      for (let i = 1; i < SPINE; i++) {
+        const p2 = spine[i];
+        const q = spine[i - 1];
+        const d = Math.hypot(p2.x - q.x, p2.y - q.y) || 1;
+        p2.x = q.x + (p2.x - q.x) / d * seg;
+        p2.y = q.y + (p2.y - q.y) / d * seg;
+      }
+      const p = env.pointer;
+      let touched = false;
+      if (p) {
+        for (const s of spine) {
+          if (Math.hypot(p.x - s.x, p.y - s.y) < girth * 2.5) {
+            touched = true;
+            break;
+          }
+        }
+      }
+      dive = touched ? Math.min(1, dive + dt * 1.5) : Math.max(0, dive - dt * 0.06);
+      depth = clamp(0.5 + 0.45 * Math.sin(time * 2 * Math.PI / DEPTH_PERIOD - 0.9) + dive * 0.6, 0, 1);
+      beat = time * 2 * Math.PI / BEAT_PERIOD;
+      if (depth < 0.5 && time - lastSlick > SLICK_EVERY_S) {
+        const tail = spine[SPINE - 1];
+        const s = slicks[nextSlick];
+        s.x = tail.x;
+        s.y = tail.y;
+        s.t = time;
+        s.k = 1 - depth * 2;
+        nextSlick = (nextSlick + 1) % SLICKS;
+        lastSlick = time;
+      }
+      for (const m of motes) {
+        m.x += (6 + 4 * m.z) * dt;
+        m.y += Math.sin(time * 0.3 + m.phase) * 2 * dt;
+        if (m.x > env.width + cell) {
+          m.x = -cell;
+          m.y = (m.y + env.height * 0.618) % env.height;
+        }
+      }
+    }
+  };
+};
+
+// node_modules/inkpond/dist/scenes/jieqi/term.js
+var TAU = Math.PI * 2;
+var ring = (d, r, w) => {
+  const k = (d - r) / w;
+  return Math.exp(-k * k);
+};
+var angleTo2 = (from, to) => {
+  let d = to - from;
+  while (d > Math.PI)
+    d -= TAU;
+  while (d < -Math.PI)
+    d += TAU;
+  return d;
+};
+var pool = (n) => Array.from({ length: n }, () => ({
+  a: 0,
+  b: 0,
+  life: 0,
+  vx: 0,
+  vy: 0,
+  x: 0,
+  y: 0
+}));
+var spawn = (ps) => {
+  let pick = ps[0];
+  for (const p of ps) {
+    if (p.life <= 0)
+      return p;
+    if (pick && p.life < pick.life)
+      pick = p;
+  }
+  return pick;
+};
+var WATER = ["\u4E36", "\u4E00", "\u4E8C", "\u6C35", "\u6C34", "\u6C40", "\u6CE2", "\u6F9C"];
+
+// node_modules/inkpond/dist/scenes/jieqi/autumn.js
+var liqiu = {
+  create({ glyph, rand }) {
+    const leafGlyph = glyph("\u53F6");
+    let rings = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let shore = 0;
+    const leaf = { a: 0, b: 0, life: 1, vx: 0, vy: -1, x: 0, y: 0 };
+    const fall = (t) => {
+      leaf.a = v.width * (0.35 + rand() * 0.35);
+      leaf.b = rand() * TAU;
+      leaf.vx = t;
+      leaf.vy = -1;
+      leaf.x = leaf.a;
+      leaf.y = v.height * 0.12;
+    };
+    return {
+      cell(x, y, t, out) {
+        const bx = v.width * 0.55;
+        if (x > bx && y < v.height * 0.3) {
+          const by = v.height * 0.06 + (x - bx) * 0.18 + Math.sin(x * 0.03) * 6;
+          const thick = 3 + 6 * (x - bx) / (v.width - bx);
+          if (Math.abs(y - by) < thick) {
+            out.v = 0.85;
+            out.wet = 0.2;
+            return;
+          }
+          if (Math.abs(y - by) < 46 && fbm(x * 0.04, y * 0.05) > 0.56) {
+            out.v = 0.45;
+            out.p = ZHE;
+            out.wet = 0.2;
+            return;
+          }
+        }
+        if (y < shore)
+          return;
+        let val = 0.12 + 0.06 * noise(x * 0.02, y * 0.08 + t * 0.2);
+        for (const r of rings) {
+          if (r.life <= 0)
+            continue;
+          const age = t - r.a;
+          val += 0.8 * Math.exp(-age * 0.7) * ring(Math.hypot(x - r.x, (y - r.y) * 3), age * 70, 12);
+        }
+        out.v = val;
+      },
+      layout(view) {
+        v = view;
+        shore = v.height * 0.76;
+        rings = pool(3);
+        fall(0);
+      },
+      stamps(t, emit) {
+        const a = leaf.vy < 0 ? 0.95 : 0.95 * (1 - (t - leaf.vy) / 5);
+        emit(leafGlyph, leaf.x, leaf.y, a, 2.2, ZHE);
+      },
+      step(dt, t, env) {
+        for (const r2 of rings)
+          r2.life -= dt;
+        if (leaf.vy >= 0) {
+          leaf.x += 6 * dt;
+          if (t - leaf.vy > 5)
+            fall(t);
+          return;
+        }
+        const ph = (t - leaf.vx) * 1.4 + leaf.b;
+        leaf.y += (26 + Math.cos(ph) * 14) * dt;
+        leaf.x = leaf.a + Math.sin(ph) * 64;
+        const p = env.pointer;
+        if (p && Math.hypot(p.x - leaf.x, p.y - leaf.y) < 130) {
+          leaf.a += (leaf.x > p.x ? 1 : -1) * 90 * dt;
+        }
+        if (leaf.y < shore)
+          return;
+        leaf.vy = t;
+        const r = spawn(rings);
+        if (!r)
+          return;
+        r.life = 5;
+        r.x = leaf.x;
+        r.y = leaf.y;
+        r.a = t;
+      }
+    };
+  },
+  id: "liqiu",
+  loose: "\u53F6",
+  ramps: [["\u4E36", "\u4E00", "\u51AB", "\u6C34", "\u6C40", "\u51C9", "\u6E05", "\u6F88"]],
+  warm: 2
+};
+var chushu = {
+  create({ glyph, rand }) {
+    const fire = glyph("\u706B");
+    const hawk = glyph("\u9E70");
+    let sparks = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let front = 0;
+    let px = -1e4;
+    let py = -1e4;
+    return {
+      cell(x, y, t, out) {
+        const fx = front + (fbm(y * 0.01, t * 0.3) - 0.5) * 180;
+        const hot = x > fx && Math.hypot(x - px, y - py) > 110;
+        if (hot) {
+          out.v = x - fx < 26 ? 0.95 : 0.08 + 0.75 * smoothstep(0.45, 0.78, fbm(x * 0.015 + t * 0.1, y * 0.015));
+          out.p = ZHU;
+        } else {
+          out.v = 0.04 + 0.16 * fbm(x * 0.015 - t * 0.05, y * 0.015);
+          out.p = HUAQING;
+        }
+      },
+      layout(view) {
+        v = view;
+        sparks = pool(40);
+      },
+      stamps(t, emit) {
+        for (const s of sparks)
+          if (s.life > 0)
+            emit(fire, s.x, s.y, s.life, 0.7, s.life > 0.5 ? ZHU : ZHE);
+        emit(hawk, v.width * 0.5 + Math.cos(t * 0.4) * v.width * 0.28, v.height * 0.22 + Math.sin(t * 0.8) * 30, 0.95, 1.3, INK);
+      },
+      step(dt, t, env) {
+        px = env.pointer?.x ?? -1e4;
+        py = env.pointer?.y ?? -1e4;
+        front = t * 50 % (v.width + 300) - 150;
+        if (rand() < dt * 14) {
+          const s = spawn(sparks);
+          if (s && s.life <= 0) {
+            s.life = 1;
+            s.x = front + (rand() - 0.5) * 40;
+            s.y = rand() * v.height;
+          }
+        }
+        for (const s of sparks) {
+          if (s.life <= 0)
+            continue;
+          s.y -= 30 * dt;
+          s.x -= 20 * dt;
+          s.life -= dt * 0.7;
+        }
+      }
+    };
+  },
+  id: "chushu",
+  loose: "\u706B\u9E70",
+  ramps: [["\u4E36", "\u4E00", "\u51AB", "\u51C9", "\u8083", "\u6691", "\u708E", "\u7131"]],
+  warm: 3
+};
+var bailu = {
+  create({ glyph, rand }) {
+    const bead = glyph("\u73E0");
+    const dot = glyph("\u4E36");
+    const TRAIL = 10;
+    let drops = pool(0);
+    let trails = new Float32Array(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    const bead0 = (d, i, y) => {
+      d.x = rand() * v.width;
+      d.y = y;
+      d.b = 14 + rand() * 16;
+      d.a = 0.6 + rand() * 0.8;
+      d.vy = 0;
+      d.life = 0;
+      trails.fill(-1e4, i * TRAIL * 2, (i + 1) * TRAIL * 2);
+    };
+    return {
+      cell(x, y, _t, out) {
+        const w = (x * 0.9 - y * 0.42) * 0.045;
+        out.v = smoothstep(0.94, 1, Math.abs(Math.sin(w + noise(x * 0.01, y * 0.01) * 3))) * 0.42;
+        out.wet = 0.6;
+        for (const d of drops) {
+          if (d.vy !== 0)
+            continue;
+          const dist = Math.hypot(x - d.x, y - d.y);
+          if (dist > d.b)
+            continue;
+          if (Math.hypot(x - (d.x - d.b * 0.35), y - (d.y - d.b * 0.35)) < d.b * 0.3) {
+            out.v = 0;
+            return;
+          }
+          out.v = 0.35 + 0.6 * smoothstep(d.b * 0.45, d.b, dist);
+          out.p = HUAQING;
+          out.wet = 1;
+          return;
+        }
+      },
+      layout(view) {
+        v = view;
+        drops = pool(14);
+        trails = new Float32Array(14 * TRAIL * 2);
+        drops.forEach((d, i) => {
+          bead0(d, i, rand() * v.height);
+        });
+      },
+      stamps(_t, emit) {
+        drops.forEach((d, i) => {
+          if (d.vy === 0)
+            return;
+          for (let k = 0; k < TRAIL; k++) {
+            const x = trails[(i * TRAIL + k) * 2] ?? -1e4;
+            if (x < -1e3)
+              continue;
+            emit(dot, x, trails[(i * TRAIL + k) * 2 + 1] ?? 0, 0.5 * ((k + 1) / TRAIL), 0.7, HUAQING);
+          }
+          emit(bead, d.x, d.y, 0.95, Math.min(2.4, d.b / 20), HUAQING);
+        });
+      },
+      step(dt, _t, env) {
+        const p = env.pointer;
+        drops.forEach((d, i) => {
+          if (d.vy === 0) {
+            d.b += d.a * dt * 2.2;
+            if (d.b > 56 || p && Math.hypot(p.x - d.x, p.y - d.y) < d.b + 12)
+              d.vy = 1;
+            return;
+          }
+          d.vy += 160 * dt;
+          d.y += d.vy * dt;
+          d.x += d.vy * 0.25 * dt;
+          d.life += dt;
+          if (d.life > 0.06) {
+            d.life = 0;
+            trails.copyWithin(i * TRAIL * 2, i * TRAIL * 2 + 2, (i + 1) * TRAIL * 2);
+            trails[(i + 1) * TRAIL * 2 - 2] = d.x;
+            trails[(i + 1) * TRAIL * 2 - 1] = d.y - d.b * 0.6;
+          }
+          if (d.y - d.b > v.height)
+            bead0(d, i, rand() * v.height * 0.8);
+        });
+      }
+    };
+  },
+  id: "bailu",
+  loose: "\u73E0\u4E36",
+  ramps: [["\u4E36", "\u51AB", "\u6C35", "\u767D", "\u6CCA", "\u73E0", "\u9732", "\u6EF4"]],
+  warm: 3
+};
+var qiufen = {
+  create() {
+    let v = { cell: 16, height: 0, width: 0 };
+    let ang = 0;
+    return {
+      cell(x, y, t, out, cx, cy) {
+        const dx = x - v.width / 2;
+        const dy = y - v.height / 2;
+        const d = Math.hypot(dx, dy);
+        const R = Math.min(v.width, v.height) * 0.36;
+        const across = -dx * Math.sin(ang) + dy * Math.cos(ang);
+        if (d < R) {
+          out.wet = 0.4;
+          if (Math.abs(across) < v.cell * 0.45) {
+            out.v = 1;
+            out.p = ZHU;
+            return;
+          }
+          if (across > 0)
+            out.v = 0.66 + 0.25 * fbm(x * 0.03, y * 0.03);
+          else {
+            out.v = 0.22 + 0.22 * fbm(x * 0.03 + 9, y * 0.03);
+            out.p = ZHE;
+          }
+          out.v = Math.max(out.v, ring(d, R, 6) * 0.9);
+          return;
+        }
+        if (Math.abs(across) < v.cell * 0.3 && d < R * 1.45) {
+          out.v = 0.4 * (1 - (d - R) / (R * 0.45));
+          out.p = ZHU;
+          return;
+        }
+        const star = hash2(cx, cy) > 0.99 ? 0.3 + 0.25 * Math.sin(t * 2 + cx) : 0;
+        out.v = ring(d, R, 6) * 0.9 + star;
+      },
+      layout(view) {
+        v = view;
+      },
+      stamps() {
+      },
+      step(dt, t, env) {
+        const p = env.pointer;
+        const target = p ? Math.atan2(p.y - v.height / 2, p.x - v.width / 2) : t * TAU / 24;
+        ang += angleTo2(ang, target) * Math.min(1, dt * (p ? 4 : 10));
+      }
+    };
+  },
+  id: "qiufen",
+  loose: "",
+  ramps: [["\u4E36", "\u4E00", "\u5915", "\u6708", "\u8083", "\u79CB", "\u723D", "\u7A46"]],
+  warm: 1
+};
+var hanlu = {
+  create({ glyph }) {
+    const goose = glyph("\u96C1");
+    let geese = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let lx = 0;
+    let ly = 0;
+    let lift = 0;
+    const slot = (i, m, out) => {
+      const k = Math.ceil(i / 2);
+      const side = i % 2 ? 1 : -1;
+      const vx = lx - k * 24;
+      const vy = ly + side * k * 15;
+      out.x = vx + (lx - i * 22 - vx) * m;
+      out.y = vy + (ly - vy) * m;
+    };
+    const at = { x: 0, y: 0 };
+    return {
+      cell(x, y, t, out) {
+        const cloud = smoothstep(0.6, 0.8, fbm(x * 8e-3 - t * 0.03, y * 0.02)) * 0.3 * (1 - y / v.height);
+        const mum = smoothstep(0.5, 0.78, fbm(x * 0.03, y * 0.05 + Math.sin(t * 0.8 + x * 0.01) * 0.15)) * smoothstep(v.height * 0.7, v.height, y);
+        if (mum > 0.1) {
+          out.v = 0.3 + mum * 0.7;
+          out.p = ZHE;
+          out.wet = 0.4;
+        } else
+          out.v = cloud + 0.04;
+      },
+      layout(view) {
+        v = view;
+        lx = v.width * 0.3;
+        ly = v.height * 0.35;
+        geese = pool(13);
+        geese.forEach((g, i) => {
+          slot(i, 0.5, at);
+          g.x = at.x;
+          g.y = at.y;
+        });
+      },
+      stamps(t, emit) {
+        geese.forEach((g, i) => {
+          emit(goose, g.x, g.y + Math.sin(t * 5 + i) * 1.5, 0.92, 1, INK);
+        });
+      },
+      step(dt, t, env) {
+        lx += 55 * dt;
+        if (lx > v.width + 320)
+          lx = -60;
+        const p = env.pointer;
+        const push = p && Math.abs(p.x - (lx - 120)) < 200 ? p.y > ly ? -1 : 1 : 0;
+        lift += (push * v.height * 0.18 - lift) * Math.min(1, dt * 1.5);
+        ly = v.height * 0.33 + Math.sin(t * 0.25) * v.height * 0.06 + lift;
+        const m = 0.5 + 0.5 * Math.sin(t * 0.35);
+        geese.forEach((g, i) => {
+          slot(i, m, at);
+          g.x += (at.x - g.x) * Math.min(1, dt * 3);
+          g.y += (at.y - g.y) * Math.min(1, dt * 3);
+        });
+      }
+    };
+  },
+  id: "hanlu",
+  loose: "\u96C1",
+  ramps: [["\u4E36", "\u4E00", "\u4E8C", "\u4E91", "\u5BD2", "\u9732", "\u83CA", "\u971C"]],
+  warm: 1
+};
+var shuangjiang = {
+  create({ glyph, rand }) {
+    const maple = glyph("\u67AB");
+    const SPOTS = [
+      [0.02, 0.05],
+      [0.98, 0.1],
+      [0.05, 0.95],
+      [0.95, 0.92],
+      [0.5, 1.02],
+      [0.55, -0.02]
+    ];
+    let seeds = pool(0);
+    let leaves = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let px = -1e4;
+    let py = -1e4;
+    let now = 0;
+    return {
+      cell(x, y, _t, out) {
+        let val = 0;
+        let pig = INK;
+        for (const s of seeds) {
+          const age = now - s.a;
+          const G = smoothstep(0, 16, age) * (1 - smoothstep(23, 26, age)) * s.b;
+          if (G <= 0)
+            continue;
+          const dx = x - s.x;
+          const dy = y - s.y;
+          const d = Math.hypot(dx, dy);
+          if (d > G)
+            continue;
+          const a = Math.atan2(dy, dx) + s.vx;
+          const arm = Math.abs(Math.cos(3 * a)) ** 14;
+          const sub = Math.abs(Math.cos(3 * a + 1.05)) ** 16 * 0.5 * (d / G);
+          const len = G * (0.1 + 0.9 * Math.max(arm, sub)) * (0.85 + 0.3 * noise(d * 0.05, a * 3));
+          if (d >= len)
+            continue;
+          const w = 0.25 + 0.5 * (d / len) + 0.25 * ring(d, len, 9);
+          if (w > val) {
+            val = w;
+            pig = d / len > 0.75 ? HUAQING : INK;
+          }
+        }
+        const warm = Math.hypot(x - px, y - py);
+        if (warm < 110)
+          val *= warm / 110;
+        out.v = val;
+        out.p = pig;
+        out.wet = 0.5;
+      },
+      layout(view) {
+        v = view;
+        seeds = pool(SPOTS.length);
+        seeds.forEach((s, i) => {
+          s.x = (SPOTS[i]?.[0] ?? 0) * v.width;
+          s.y = (SPOTS[i]?.[1] ?? 0) * v.height;
+          s.a = -i * 1.5;
+          s.vx = rand() * TAU;
+          s.b = Math.min(v.width, v.height) * (0.3 + rand() * 0.14);
+        });
+        leaves = pool(12);
+        for (const l of leaves) {
+          l.x = rand() * v.width;
+          l.y = rand() * v.height;
+          l.vy = 30 + rand() * 30;
+          l.b = rand() * TAU;
+        }
+      },
+      stamps(_t, emit) {
+        for (const l of leaves)
+          emit(maple, l.x, l.y, 0.92, 1.15, ZHU);
+      },
+      step(dt, t, env) {
+        now = t;
+        px = env.pointer?.x ?? -1e4;
+        py = env.pointer?.y ?? -1e4;
+        for (const s of seeds) {
+          if (t - s.a > 26) {
+            s.a = t;
+            s.vx = rand() * TAU;
+          }
+        }
+        for (const l of leaves) {
+          l.y += l.vy * dt;
+          l.x += Math.sin(t * 1.2 + l.b) * 30 * dt;
+          if (l.y > v.height + 20) {
+            l.y = -20;
+            l.x = rand() * v.width;
+          }
+        }
+      }
+    };
+  },
+  id: "shuangjiang",
+  loose: "\u67AB",
+  ramps: [["\u4E36", "\u51AB", "\u51B0", "\u51C7", "\u971C", "\u51DB", "\u51DD", "\u9730"]],
+  warm: 10
+};
+
+// node_modules/inkpond/dist/scenes/jieqi/calendar.js
+var JIEQI = [
+  { id: "lichun", longitude: 315, name: "\u7ACB\u6625" },
+  { id: "yushui", longitude: 330, name: "\u96E8\u6C34" },
+  { id: "jingzhe", longitude: 345, name: "\u60CA\u86F0" },
+  { id: "chunfen", longitude: 0, name: "\u6625\u5206" },
+  { id: "qingming", longitude: 15, name: "\u6E05\u660E" },
+  { id: "guyu", longitude: 30, name: "\u8C37\u96E8" },
+  { id: "lixia", longitude: 45, name: "\u7ACB\u590F" },
+  { id: "xiaoman", longitude: 60, name: "\u5C0F\u6EE1" },
+  { id: "mangzhong", longitude: 75, name: "\u8292\u79CD" },
+  { id: "xiazhi", longitude: 90, name: "\u590F\u81F3" },
+  { id: "xiaoshu", longitude: 105, name: "\u5C0F\u6691" },
+  { id: "dashu", longitude: 120, name: "\u5927\u6691" },
+  { id: "liqiu", longitude: 135, name: "\u7ACB\u79CB" },
+  { id: "chushu", longitude: 150, name: "\u5904\u6691" },
+  { id: "bailu", longitude: 165, name: "\u767D\u9732" },
+  { id: "qiufen", longitude: 180, name: "\u79CB\u5206" },
+  { id: "hanlu", longitude: 195, name: "\u5BD2\u9732" },
+  { id: "shuangjiang", longitude: 210, name: "\u971C\u964D" },
+  { id: "lidong", longitude: 225, name: "\u7ACB\u51AC" },
+  { id: "xiaoxue", longitude: 240, name: "\u5C0F\u96EA" },
+  { id: "daxue", longitude: 255, name: "\u5927\u96EA" },
+  { id: "dongzhi", longitude: 270, name: "\u51AC\u81F3" },
+  { id: "xiaohan", longitude: 285, name: "\u5C0F\u5BD2" },
+  { id: "dahan", longitude: 300, name: "\u5927\u5BD2" }
+];
+var DAY_MS = 864e5;
+var UNIX_JD = 24405875e-1;
+var J2000 = 2451545;
+var sunLongitude = (date) => {
+  const d = +date / DAY_MS + UNIX_JD - J2000;
+  const g = (357.529 + 0.98560028 * d) * Math.PI / 180;
+  const l = 280.459 + 0.98564736 * d + 1.915 * Math.sin(g) + 0.02 * Math.sin(2 * g);
+  return (l % 360 + 360) % 360;
+};
+var jieqiIndexAt = (date) => Math.floor(((sunLongitude(date) - 315) % 360 + 360) % 360 / 15);
+
+// node_modules/inkpond/dist/scenes/jieqi/spring.js
+var crackAt = (x, y) => Math.abs(noise(x * 95e-4 + y * 55e-4, y * 95e-4 - x * 55e-4) - 0.5);
+var lichun = {
+  create({ glyph, rand }) {
+    const sprout = glyph("\u82BD");
+    const sprouts = new Float32Array(92);
+    let n = 0;
+    let v = { cell: 16, height: 0, width: 0 };
+    let ox = 0;
+    let oy = 0;
+    let t0 = 0;
+    const reach = (t) => (t - t0) * 80;
+    return {
+      cell(x, y, t, out) {
+        const d = Math.hypot(x - ox, y - oy);
+        const r = reach(t);
+        const ridge = crackAt(x, y);
+        const fine = Math.abs(noise(x * 0.024 + y * 0.016 + 50, y * 0.024 - x * 0.016) - 0.5);
+        const open = smoothstep(r, r - 90, d);
+        out.v = 0.08 + 0.3 * smoothstep(0.35, 0.75, fbm(x * 0.012, y * 0.012));
+        out.wet = 0.4;
+        if (open > 0 && (ridge < 0.045 || fine < 0.02)) {
+          out.v = 0.98 * open;
+          out.wet = 1;
+        } else if (open > 0.5)
+          out.v *= 0.55;
+        const edge = ring(d, r, 14);
+        if (edge > 0.2 && ridge < 0.1) {
+          out.v = Math.max(out.v, edge);
+          out.p = HUAQING;
+        }
+      },
+      drop(x, y, t) {
+        ox = x;
+        oy = y;
+        t0 = t;
+      },
+      layout(view) {
+        v = view;
+        ox = v.width * 0.42;
+        oy = v.height * 0.55;
+        t0 = 0;
+        n = 0;
+        for (let k = 0; k < 4e3 && n < 46; k++) {
+          const x = rand() * v.width;
+          const y = rand() * v.height;
+          if (crackAt(x, y) < 0.04) {
+            sprouts[n * 2] = x;
+            sprouts[n * 2 + 1] = y;
+            n++;
+          }
+        }
+      },
+      stamps(t, emit) {
+        const r = reach(t);
+        for (let k = 0; k < n; k++) {
+          const x = sprouts[k * 2] ?? 0;
+          const y = sprouts[k * 2 + 1] ?? 0;
+          const d = Math.hypot(x - ox, y - oy);
+          if (d > r - 40)
+            continue;
+          const g = clamp((r - 40 - d) / 140, 0, 1);
+          emit(sprout, x, y - g * 8, g * 0.9, 0.6 + g * 0.6, HUAQING);
+        }
+      },
+      step(_dt, t) {
+        if (reach(t) > Math.hypot(v.width, v.height) + 260) {
+          t0 = t;
+          ox = v.width * (0.2 + rand() * 0.6);
+          oy = v.height * (0.3 + rand() * 0.5);
+        }
+      }
+    };
+  },
+  id: "lichun",
+  loose: "\u82BD",
+  ramps: [["\u4E36", "\u51AB", "\u4E8C", "\u51B0", "\u51BB", "\u51CC", "\u51C7", "\u51DD"]],
+  warm: 3
+};
+var yushui = {
+  create({ glyph, rand }) {
+    const rain = glyph("\u96E8");
+    const dot = glyph("\u4E36");
+    let drops = pool(0);
+    let rings = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let wind = 0.25;
+    let acc = 0;
+    let shore = 0;
+    return {
+      cell(x, y, t, out) {
+        if (y < shore) {
+          out.v = 0.1 * fbm(x * 0.01 + t * 0.1, y * 0.02);
+          return;
+        }
+        let r = 0;
+        for (const p of rings) {
+          if (p.life <= 0 || Math.abs(x - p.x) > 120)
+            continue;
+          const age = t - p.a;
+          const d = Math.hypot(x - p.x, (y - p.y) * 2.6);
+          r += Math.exp(-age * 1.5) * 0.75 * ring(d, age * 55, 10);
+        }
+        out.v = 0.16 + 0.12 * noise(x * 0.03, y * 0.09 + t * 0.4) + r;
+        if (r > 0.22)
+          out.p = HUAQING;
+      },
+      layout(view) {
+        v = view;
+        shore = v.height * 0.66;
+        drops = pool(110);
+        rings = pool(40);
+      },
+      stamps(_t, emit) {
+        const n = Math.hypot(wind, 1);
+        const gap = Math.max(16, v.cell);
+        const ux = wind / n * gap;
+        const uy = gap / n;
+        for (const d of drops) {
+          if (d.life <= 0)
+            continue;
+          emit(rain, d.x, d.y, 0.85, 0.75, INK);
+          emit(dot, d.x - ux, d.y - uy, 0.55, 0.6, HUAQING);
+          emit(dot, d.x - ux * 2, d.y - uy * 2, 0.3, 0.6, HUAQING);
+        }
+      },
+      step(dt, t, env) {
+        const target = env.pointer ? (env.pointer.x / v.width - 0.5) * 1.3 : 0.25 + Math.sin(t * 0.3) * 0.1;
+        wind += (target - wind) * Math.min(1, dt * 2);
+        acc += dt * v.width / 14;
+        for (; acc > 1; acc--) {
+          const d = spawn(drops);
+          if (!d || d.life > 0)
+            break;
+          d.life = 1;
+          d.x = rand() * (v.width + 300) - 150;
+          d.y = -20 - rand() * 60;
+          d.vy = 360 + rand() * 220;
+          d.a = shore + rand() * (v.height - shore);
+        }
+        for (const d of drops) {
+          if (d.life <= 0)
+            continue;
+          d.y += d.vy * dt;
+          d.x += d.vy * wind * dt;
+          if (d.y < d.a)
+            continue;
+          d.life = 0;
+          const r = spawn(rings);
+          if (!r)
+            continue;
+          r.life = 2.2;
+          r.x = d.x;
+          r.y = d.a;
+          r.a = t;
+        }
+        for (const r of rings)
+          r.life -= dt;
+      }
+    };
+  },
+  id: "yushui",
+  loose: "\u96E8\u4E36",
+  ramps: [WATER],
+  warm: 3
+};
+var jingzhe = {
+  create({ glyph, rand }) {
+    const spark = glyph("\u7535");
+    const bug = glyph("\u866B");
+    const bolt = new Float32Array(130);
+    let boltAt = -9;
+    let bugs = pool(0);
+    let craters = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let ground = 0;
+    let next = 0.8;
+    let flash = 0;
+    const strike = (x, t) => {
+      bolt[0] = x + (rand() - 0.5) * v.width * 0.3;
+      bolt[1] = 0;
+      bolt[128] = x;
+      bolt[129] = ground;
+      for (let s = 32, off = v.width * 0.12; s >= 1; s /= 2, off *= 0.55) {
+        for (let i = s; i < 64; i += s * 2) {
+          bolt[i * 2] = ((bolt[(i - s) * 2] ?? 0) + (bolt[(i + s) * 2] ?? 0)) / 2 + (rand() - 0.5) * off;
+          bolt[i * 2 + 1] = ((bolt[(i - s) * 2 + 1] ?? 0) + (bolt[(i + s) * 2 + 1] ?? 0)) / 2;
+        }
+      }
+      boltAt = t;
+      flash = 1;
+      const c = spawn(craters);
+      if (c) {
+        c.life = 4;
+        c.x = x;
+        c.a = t;
+      }
+      for (let k = 0; k < 24; k++) {
+        const b = spawn(bugs);
+        if (!b)
+          break;
+        b.life = 1;
+        b.x = x;
+        b.y = ground;
+        b.vx = (rand() - 0.5) * 420;
+        b.vy = -160 - rand() * 360;
+      }
+      next = t + 2.6 + rand() * 2;
+    };
+    return {
+      cell(x, y, t, out) {
+        const g = ground + 14 * (noise(x * 0.02, 3) - 0.5);
+        const earth = y > g;
+        let val = earth ? 0.12 + 0.55 * smoothstep(0.4, 0.75, fbm(x * 0.02, y * 0.04)) : 0.06 * fbm(x * 0.01, y * 0.02 + t * 0.05);
+        out.wet = earth ? 0.3 : 1;
+        for (const c of craters) {
+          if (c.life <= 0)
+            continue;
+          const age = t - c.a;
+          const d = Math.hypot(x - c.x, (y - ground) * 1.4);
+          const shock = ring(d, age * 150, 26) * Math.exp(-age * 1.2);
+          if (shock > 0.25)
+            out.p = ZHU;
+          val += shock * 0.7;
+          if (earth) {
+            const hole = smoothstep(0, 70 * (1 - Math.exp(-age * 4)), d);
+            val *= Math.min(1, 0.35 + 0.65 * hole + 0.65 * smoothstep(2, 3.5, age));
+          }
+        }
+        if (flash > 0)
+          val = val * (1 - flash) + (1 - val) * flash * 0.7;
+        out.v = val;
+      },
+      drop(x, _y, t) {
+        strike(x, t);
+      },
+      layout(view) {
+        v = view;
+        ground = v.height * 0.6;
+        bugs = pool(120);
+        craters = pool(4);
+        boltAt = -9;
+        next = 0.8;
+      },
+      stamps(t, emit) {
+        const age = t - boltAt;
+        if (age < 0.4) {
+          const a = 1 - age / 0.4;
+          let left = 0;
+          for (let i = 1; i < 65; i++) {
+            const px = bolt[(i - 1) * 2] ?? 0;
+            const py = bolt[(i - 1) * 2 + 1] ?? 0;
+            const qx = bolt[i * 2] ?? 0;
+            const qy = bolt[i * 2 + 1] ?? 0;
+            const len = Math.hypot(qx - px, qy - py);
+            for (; left < len; left += 14) {
+              const f = left / len;
+              emit(spark, px + (qx - px) * f, py + (qy - py) * f, a, 0.9, i % 3 ? ZHU : INK);
+            }
+            left -= len;
+          }
+        }
+        for (const b of bugs)
+          if (b.life > 0)
+            emit(bug, b.x, b.y, b.life, 0.7, INK);
+      },
+      step(dt, t) {
+        if (t > next)
+          strike(v.width * (0.15 + rand() * 0.7), t);
+        flash = Math.max(0, flash - dt * 4);
+        for (const c of craters)
+          c.life -= dt;
+        for (const b of bugs) {
+          if (b.life <= 0)
+            continue;
+          b.vy += 520 * dt;
+          b.x += b.vx * dt;
+          b.y += b.vy * dt;
+          if (b.y > ground + 20 && b.vy > 0) {
+            b.vy *= -0.3;
+            b.vx *= 0.6;
+          }
+          b.life -= dt * 0.45;
+        }
+      }
+    };
+  },
+  id: "jingzhe",
+  loose: "\u7535\u866B",
+  ramps: [["\u4E36", "\u571F", "\u866B", "\u5730", "\u867A", "\u86F0", "\u8822", "\u9707"]],
+  warm: 1.5
+};
+var chunfen = {
+  create({ glyph, rand }) {
+    const swallow = glyph("\u71D5");
+    const dot = glyph("\u4E36");
+    let birds = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let seam = 0;
+    const line = (y, t) => seam + Math.sin(y * 0.012 + t * 0.8) * 26 + Math.sin(y * 0.031 - t * 1.3) * 10;
+    let now = 0;
+    return {
+      cell(x, y, t, out) {
+        const l = line(y, t);
+        out.v = x > l ? 0.2 + 0.55 * smoothstep(0.35, 0.72, fbm(x * 0.012 + t * 0.05, y * 0.015)) : 0.08 + 0.08 * fbm(x * 0.02 - t * 0.05, y * 0.02);
+        const e = ring(x, l, 9);
+        if (e > 0.3) {
+          out.v = Math.max(out.v, e);
+          out.p = ZHU;
+        }
+      },
+      layout(view) {
+        v = view;
+        seam = v.width / 2;
+        birds = pool(7);
+        birds.forEach((b, i) => {
+          b.life = 1;
+          b.x = rand() * v.width;
+          b.a = v.height * (0.15 + rand() * 0.7);
+          b.vx = (50 + rand() * 60) * (i % 2 ? 1 : -1);
+          b.b = rand() * TAU;
+        });
+      },
+      stamps(t, emit) {
+        for (const b of birds) {
+          const night = b.x > line(b.y, t);
+          const dir = b.vx > 0 ? 1 : -1;
+          emit(swallow, b.x, b.y, 0.95, 1.15, night ? ZHU : INK);
+          emit(dot, b.x - dir * 16, b.y + 2, 0.4, 0.7, night ? ZHU : INK);
+        }
+      },
+      step(dt, t, env) {
+        now = t;
+        const target = env.pointer ? env.pointer.x : v.width / 2 + Math.sin(now * 0.3) * v.width * 0.08;
+        seam += (target - seam) * Math.min(1, dt * 2.5);
+        for (const b of birds) {
+          b.x += b.vx * dt;
+          if (b.x > v.width + 30)
+            b.x = -30;
+          if (b.x < -30)
+            b.x = v.width + 30;
+          b.y = b.a + Math.sin(b.x * 0.02 + b.b) * 26;
+        }
+      }
+    };
+  },
+  id: "chunfen",
+  loose: "\u71D5\u4E36",
+  ramps: [["\u4E00", "\u4E8C", "\u5206", "\u5E73", "\u663C", "\u591C", "\u669D", "\u9EEF"]],
+  warm: 1
+};
+var qingming = {
+  create({ glyph, rand }) {
+    const willow = glyph("\u67F3");
+    const thread = glyph("\u4E1D");
+    const kite = glyph("\u9E22");
+    const dot = glyph("\u4E36");
+    let strands = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let px = -1e4;
+    let py = -1e4;
+    return {
+      cell(x, y, t, out, cx, cy) {
+        out.v = 0.1 * fbm(x * 0.015 - t * 0.05, y * 0.01);
+        if (hash2(cx, cy + Math.floor(t * 5) * 131) > 0.988) {
+          out.v = 0.4;
+          out.p = HUAQING;
+        }
+      },
+      layout(view) {
+        v = view;
+        const n = Math.max(5, Math.floor(v.width / 56));
+        strands = pool(n);
+        strands.forEach((s, i) => {
+          s.x = (i + 0.3 + rand() * 0.4) * v.width / n;
+          s.a = v.height * (0.3 + rand() * 0.35);
+          s.b = rand() * TAU;
+        });
+      },
+      stamps(t, emit) {
+        const step = Math.max(14, v.cell);
+        for (const s of strands) {
+          for (let y = 0, k = 0; y < s.a; y += step, k++) {
+            const f = y / s.a;
+            let x = s.x + Math.sin(t * 1.1 + s.b + f * 1.6) * f ** 1.6 * 28 + Math.sin(t * 0.4) * f * 10;
+            const d = Math.hypot(x - px, y - py);
+            if (d < 100)
+              x += (x >= px ? 1 : -1) * (100 - d) * 0.5 * f;
+            const top = k % 4 === 0;
+            emit(top ? willow : thread, x, y + 6, 0.85 - f * 0.35, 0.75, top ? INK : HUAQING);
+          }
+        }
+        const kx = v.width * 0.74 + Math.sin(t * 0.4) * 40;
+        const ky = v.height * 0.2 + Math.sin(t * 0.7) * 18;
+        for (let j = 1; j < 24; j++) {
+          const f = j / 24;
+          emit(dot, kx + (v.width * 0.4 - kx) * f, ky + (v.height - ky) * f + Math.sin(f * Math.PI) * 30, 0.35, 0.5, INK);
+        }
+        emit(kite, kx, ky, 0.95, 1.5, ZHU);
+      },
+      step(_dt, _t, env) {
+        px = env.pointer?.x ?? -1e4;
+        py = env.pointer?.y ?? -1e4;
+      }
+    };
+  },
+  id: "qingming",
+  loose: "\u67F3\u4E1D\u9E22\u4E36",
+  ramps: [["\u4E36", "\u51AB", "\u6C35", "\u96E8", "\u6E05", "\u660E", "\u9701", "\u972D"]],
+  warm: 1
+};
+var guyu = {
+  create({ glyph, rand }) {
+    const petal = glyph("\u74E3");
+    let blooms = pool(0);
+    let petals = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    const open = (p, x, y, t) => {
+      p.x = x;
+      p.y = y;
+      p.b = Math.min(v.width, v.height) * (0.16 + rand() * 0.1);
+      p.a = t;
+      p.vx = 5 + Math.floor(rand() * 2);
+      p.vy = rand() * TAU;
+      p.life = 1;
+    };
+    return {
+      cell(x, y, t, out) {
+        let val = 0.06 * fbm(x * 0.02, y * 0.01 - t * 0.3);
+        let pig = INK;
+        for (const b of blooms) {
+          const age = t - b.a;
+          const g = smoothstep(0, 4, age) * (1 - smoothstep(13, 16, age));
+          if (g <= 0)
+            continue;
+          const dx = x - b.x;
+          const dy = y - b.y;
+          const d = Math.hypot(dx, dy);
+          if (d > b.b * 1.05)
+            continue;
+          if (d < b.b * 0.13 * g) {
+            val = 0.95;
+            pig = ZHU;
+            break;
+          }
+          const th = Math.atan2(dy, dx);
+          const spin = b.vy + age * 0.06;
+          const r1 = b.b * g * (0.55 + 0.45 * Math.abs(Math.cos(b.vx * th / 2 + spin)));
+          const r2 = b.b * g * 0.62 * (0.6 + 0.4 * Math.abs(Math.cos(b.vx * th / 2 - spin * 1.5 + 0.6)));
+          let w = 0;
+          if (d < r1)
+            w = 0.3 + 0.6 * smoothstep(r1 * 0.7, r1, d);
+          if (d < r2)
+            w = Math.max(w, 0.35 + 0.6 * smoothstep(r2 * 0.6, r2, d));
+          if (w > val) {
+            val = w;
+            pig = YANZHI;
+          }
+        }
+        out.v = val;
+        out.p = pig;
+      },
+      drop(x, y, t) {
+        let oldest = blooms[0];
+        for (const b of blooms)
+          if (oldest && b.a < oldest.a)
+            oldest = b;
+        if (oldest)
+          open(oldest, x, y, t);
+      },
+      layout(view) {
+        v = view;
+        blooms = pool(3);
+        petals = pool(40);
+        blooms.forEach((b, i) => {
+          open(b, v.width * (0.2 + 0.3 * i + rand() * 0.1), v.height * (0.35 + rand() * 0.3), -rand() * 5);
+        });
+      },
+      stamps(_t, emit) {
+        for (const p of petals)
+          if (p.life > 0)
+            emit(petal, p.x, p.y, p.life * 0.9, 0.8, YANZHI);
+      },
+      step(dt, t) {
+        for (const b of blooms) {
+          if (t - b.a > 16)
+            open(b, v.width * (0.15 + rand() * 0.7), v.height * (0.25 + rand() * 0.5), t);
+          if (t - b.a > 3 && rand() < dt * 2.5) {
+            const p = spawn(petals);
+            if (p && p.life <= 0) {
+              p.life = 1;
+              p.x = b.x + (rand() - 0.5) * b.b;
+              p.y = b.y;
+              p.vy = 20 + rand() * 20;
+              p.b = rand() * TAU;
+            }
+          }
+        }
+        for (const p of petals) {
+          if (p.life <= 0)
+            continue;
+          p.y += p.vy * dt;
+          p.x += Math.sin(t + p.b) * 20 * dt;
+          p.life -= dt * 0.12;
+          if (p.y > v.height + 20)
+            p.life = 0;
+        }
+      }
+    };
+  },
+  id: "guyu",
+  loose: "\u74E3",
+  ramps: [["\u4E36", "\u535C", "\u8279", "\u82B1", "\u82B3", "\u8469", "\u854A", "\u7E41"]],
+  warm: 4
+};
+
+// node_modules/inkpond/dist/scenes/jieqi/summer.js
+var lixia = {
+  create({ glyph, rand }) {
+    const frog = glyph("\u86D9");
+    const croak = glyph("\u5471");
+    let frogs = pool(0);
+    let rings = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    const call = (x, y, t) => {
+      const r = spawn(rings);
+      if (!r)
+        return;
+      r.life = 6;
+      r.x = x;
+      r.y = y;
+      r.a = t;
+    };
+    return {
+      cell(x, y, t, out) {
+        let sum = 0;
+        for (const r of rings) {
+          if (r.life <= 0)
+            continue;
+          const age = t - r.a;
+          const d = Math.hypot(x - r.x, y - r.y);
+          const R = age * 90;
+          if (d > R + 60)
+            continue;
+          sum += Math.cos((d - R) * 0.16) * ring(d, R - 30, 50) * Math.exp(-age * 0.55);
+        }
+        out.v = 0.06 + 0.06 * noise(x * 0.02, y * 0.02 + t * 0.2) + Math.max(0, sum) * 0.85;
+        if (sum > 0.25)
+          out.p = HUAQING;
+      },
+      drop(x, y, t) {
+        call(x, y, t);
+      },
+      layout(view) {
+        v = view;
+        frogs = pool(5);
+        rings = pool(22);
+        for (const f of frogs) {
+          f.x = v.width * (0.12 + rand() * 0.76);
+          f.y = v.height * (0.18 + rand() * 0.64);
+          f.a = rand() * 2;
+          f.b = -9;
+        }
+      },
+      stamps(t, emit) {
+        for (const f of frogs) {
+          const age = t - f.b;
+          emit(frog, f.x, f.y, 0.95, age < 0.25 ? 1.5 : 1.3, INK);
+          if (age < 0.5)
+            emit(croak, f.x + 20, f.y - 20 - age * 30, 1 - age * 2, 0.8, ZHU);
+        }
+      },
+      step(dt, t, env) {
+        const p = env.pointer;
+        for (const f of frogs) {
+          if (p && Math.hypot(p.x - f.x, p.y - f.y) < 130)
+            f.a = Math.min(f.a, f.b + 0.5);
+          if (t > f.a) {
+            call(f.x, f.y, t);
+            f.b = t;
+            f.a = t + 1.6 + rand() * 2.4;
+          }
+        }
+        for (const r of rings)
+          r.life -= dt;
+      }
+    };
+  },
+  id: "lixia",
+  loose: "\u86D9\u5471",
+  ramps: [["\u4E36", "\u4E00", "\u53E3", "\u53EB", "\u5471", "\u9E23", "\u566A", "\u56A3"]],
+  warm: 4
+};
+var xiaoman = {
+  create({ glyph, rand }) {
+    const awn = glyph("\u8292");
+    let chaff = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let px = -1e4;
+    let py = -1e4;
+    return {
+      cell(x, y, t, out) {
+        const hz = v.height * 0.3 + Math.sin(x * 4e-3) * 10;
+        if (y < hz) {
+          out.v = 0.05 * fbm(x * 0.01 - t * 0.05, y * 0.03);
+          return;
+        }
+        const f = (y - hz) / (v.height - hz);
+        const wave = Math.sin(x * 0.022 - t * 1.7 + fbm(x * 4e-3, y * 0.012) * 2.5 + y * 0.012);
+        let val = 0.12 + 0.1 * f + 0.6 * Math.max(0, wave) * (0.5 + f * 0.5);
+        const d = Math.hypot(x - px, y - py);
+        if (d < 140)
+          val -= (1 - d / 140) * 0.45;
+        out.v = val;
+        out.wet = 0.5;
+        if (wave > 0.45)
+          out.p = ZHE;
+      },
+      layout(view) {
+        v = view;
+        chaff = pool(24);
+        for (const c of chaff) {
+          c.x = rand() * v.width;
+          c.y = v.height * (0.3 + rand() * 0.6);
+          c.b = rand() * TAU;
+        }
+      },
+      stamps(_t, emit) {
+        for (const c of chaff)
+          emit(awn, c.x, c.y, 0.6, 0.6, ZHE);
+      },
+      step(dt, t, env) {
+        px = env.pointer?.x ?? -1e4;
+        py = env.pointer?.y ?? -1e4;
+        for (const c of chaff) {
+          c.x += (40 + Math.sin(t + c.b) * 20) * dt;
+          c.y += Math.sin(t * 1.3 + c.b) * 12 * dt;
+          if (c.x > v.width + 20) {
+            c.x = -20;
+            c.y = v.height * (0.3 + rand() * 0.6);
+          }
+        }
+      }
+    };
+  },
+  id: "xiaoman",
+  loose: "\u8292",
+  ramps: [["\u4E36", "\u79BE", "\u672A", "\u7C73", "\u9EA6", "\u79C0", "\u7A57", "\u7A70"]],
+  warm: 1
+};
+var mangzhong = {
+  create({ glyph, rand }) {
+    const awn = glyph("\u8292");
+    let needles = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let front = 0;
+    return {
+      cell(x, y, t, out, cx, cy) {
+        out.v = 0.06 + 0.1 * noise(x * 0.03, y * 0.03 + t * 0.25);
+        if (y < v.height * 0.12)
+          return;
+        if (cx % 3 === 1 && cy % 2 === 1 && x < front - hash2(cx, cy) * 50) {
+          out.v = 0.68 + 0.18 * Math.sin(t * 2.2 + cx * 0.4 + cy * 0.2);
+          out.p = HUAQING;
+          out.wet = 0.6;
+        }
+        if (Math.abs(x - front) < v.cell * 0.6) {
+          out.v = 0.92;
+          out.p = ZHU;
+        }
+      },
+      drop(x) {
+        front = x;
+      },
+      layout(view) {
+        v = view;
+        front = v.width * 0.2;
+        needles = pool(30);
+      },
+      stamps(_t, emit) {
+        for (const n of needles)
+          if (n.life > 0)
+            emit(awn, n.x, n.y, n.life * 0.8, 0.8, ZHE);
+      },
+      step(dt) {
+        front += dt * 70;
+        if (front > v.width + 160)
+          front = -60;
+        if (rand() < dt * 6) {
+          const n = spawn(needles);
+          if (n && n.life <= 0) {
+            n.life = 1;
+            n.x = rand() * v.width;
+            n.y = -10;
+          }
+        }
+        for (const n of needles) {
+          if (n.life <= 0)
+            continue;
+          n.x += 160 * dt;
+          n.y += 220 * dt;
+          n.life -= dt * 0.5;
+        }
+      }
+    };
+  },
+  id: "mangzhong",
+  loose: "\u8292",
+  ramps: [["\u4E36", "\u4E00", "\u6C35", "\u7530", "\u79BE", "\u79E7", "\u7A3B", "\u7A51"]],
+  warm: 5
+};
+var xiazhi = {
+  create() {
+    let v = { cell: 16, height: 0, width: 0 };
+    let sx = 0;
+    let sy = 0;
+    return {
+      cell(x, y, t, out) {
+        const hz = v.height * 0.8;
+        if (y > hz) {
+          const xs = x + Math.sin(y * 0.09 + t * 5) * 6;
+          out.v = y < hz + v.cell ? 0.55 : 0.16 + 0.22 * fbm(xs * 0.03, y * 0.08 - t * 0.6);
+          out.p = y < hz + v.cell ? INK : ZHE;
+          out.wet = 0.4;
+          return;
+        }
+        const dx = x - sx;
+        const dy = y - sy;
+        const d = Math.hypot(dx, dy);
+        const R = Math.min(v.width, v.height) * 0.2;
+        if (d < R) {
+          out.v = 0.72 + 0.22 * fbm(x * 0.03 + t * 0.3, y * 0.03);
+          out.p = ZHU;
+          out.wet = 0.3;
+          return;
+        }
+        const fall = Math.exp(-(d - R) / (R * 0.9));
+        const ray = Math.abs(Math.cos(Math.atan2(dy, dx) * 12 + t * 0.25)) ** 6 * fall;
+        const pulse = ring(d - R, t * 70 % (R * 2.2), 16) * fall;
+        const val = ray * 0.55 + pulse * 0.6 + ring(d, R, 6) * 0.9;
+        out.v = val;
+        out.p = val > 0.22 ? ZHU : ZHE;
+      },
+      layout(view) {
+        v = view;
+        sx = v.width * 0.5;
+        sy = v.height * 0.4;
+      },
+      stamps() {
+      },
+      step(dt, _t, env) {
+        const p = env.pointer;
+        const tx = p ? p.x : v.width * 0.5;
+        const ty = p ? Math.min(p.y, v.height * 0.6) : v.height * 0.4;
+        sx += (tx - sx) * Math.min(1, dt * 0.8);
+        sy += (ty - sy) * Math.min(1, dt * 0.8);
+      }
+    };
+  },
+  id: "xiazhi",
+  loose: "",
+  ramps: [["\u4E36", "\u4E00", "\u65E5", "\u65E6", "\u660A", "\u708E", "\u7131", "\u66DC"]],
+  warm: 1
+};
+var xiaoshu = {
+  create({ glyph }) {
+    const cicada = glyph("\u8749");
+    const call = glyph("\u9E23");
+    const perches = [0.25, 0.55, 0.8];
+    let v = { cell: 16, height: 0, width: 0 };
+    let px = -1e4;
+    let py = -1e4;
+    return {
+      cell(x, y, t, out) {
+        const X = x + Math.sin(y * 0.015 + t * 1.2) * 18;
+        const q = fbm(X * 0.012, (y + t * 45) * 0.012);
+        let plume = smoothstep(0.42, 0.75, q) * (0.3 + 0.7 * (y / v.height));
+        const d = Math.hypot(x - px, y - py);
+        if (d < 160)
+          plume *= d / 160;
+        out.v = 0.04 + plume * 0.95;
+        out.p = plume > 0.5 ? ZHU : ZHE;
+      },
+      layout(view) {
+        v = view;
+      },
+      stamps(t, emit) {
+        perches.forEach((f, i) => {
+          const x = 30 + i % 2 * 16;
+          const y = v.height * f;
+          emit(cicada, x, y, 0.95, 1.2, INK);
+          for (let k = 0; k < 3; k++) {
+            const ph = (t * 70 + k * 55 + i * 30) % 165;
+            emit(call, x + 26 + ph, y, (1 - ph / 165) * 0.8, 0.7 + ph / 330, INK);
+          }
+        });
+      },
+      step(_dt, _t, env) {
+        px = env.pointer?.x ?? -1e4;
+        py = env.pointer?.y ?? -1e4;
+      }
+    };
+  },
+  id: "xiaoshu",
+  loose: "\u8749\u9E23",
+  ramps: [["\u4E36", "\u706B", "\u706C", "\u70ED", "\u70D8", "\u7116", "\u71E0", "\u7207"]],
+  warm: 1
+};
+var dashu = {
+  create({ glyph, rand }) {
+    const fly = glyph("\u8424");
+    const dot = glyph("\u4E36");
+    const TRAIL = 7;
+    let flies = pool(0);
+    let trails = new Float32Array(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let tick = 0;
+    let head = 0;
+    return {
+      cell(x, y, t, out) {
+        const top = v.height * 0.55 + 40 * noise(x * 0.015, 1);
+        if (y <= top) {
+          out.v = 0.03;
+          return;
+        }
+        const blade = Math.abs(Math.sin(x * 0.11 + noise(x * 0.05, 4) * 6)) ** 2;
+        out.v = smoothstep(top, v.height, y) * (0.45 + 0.4 * blade) + 0.12 * fbm(x * 0.04 + t * 0.1, y * 0.03);
+        out.wet = 0.4;
+      },
+      layout(view) {
+        v = view;
+        flies = pool(30);
+        trails = new Float32Array(30 * TRAIL * 2);
+        for (const [i, f] of flies.entries()) {
+          f.x = rand() * v.width;
+          f.y = v.height * (0.2 + rand() * 0.7);
+          f.b = rand() * TAU;
+          f.a = i * 3.1;
+          for (let k = 0; k < TRAIL; k++) {
+            trails[(i * TRAIL + k) * 2] = f.x;
+            trails[(i * TRAIL + k) * 2 + 1] = f.y;
+          }
+        }
+      },
+      stamps(t, emit) {
+        flies.forEach((f, i) => {
+          const glow = 0.5 + 0.5 * Math.sin(t * 2.6 + f.b);
+          for (let k = 1; k < TRAIL; k++) {
+            const j = (head + k) % TRAIL;
+            emit(dot, trails[(i * TRAIL + j) * 2] ?? 0, trails[(i * TRAIL + j) * 2 + 1] ?? 0, glow * 0.45 * (k / TRAIL), 0.6, ZHE);
+          }
+          emit(fly, f.x, f.y, 0.3 + 0.7 * glow, 0.65 + glow * 0.3, ZHE);
+        });
+      },
+      step(dt, t, env) {
+        const p = env.pointer;
+        for (const f of flies) {
+          const ang = noise(f.x * 4e-3 + f.a, t * 0.15) * TAU * 2;
+          let ax = Math.cos(ang) * 60;
+          let ay = Math.sin(ang) * 60;
+          if (p) {
+            ax += (p.x - f.x) * 0.9;
+            ay += (p.y - f.y) * 0.9;
+          }
+          f.vx = (f.vx + ax * dt) * 0.97;
+          f.vy = (f.vy + ay * dt) * 0.97;
+          const sp = Math.hypot(f.vx, f.vy);
+          if (sp > 70) {
+            f.vx *= 70 / sp;
+            f.vy *= 70 / sp;
+          }
+          f.x += f.vx * dt;
+          f.y += f.vy * dt;
+          if (f.x < -10)
+            f.x = v.width + 10;
+          if (f.x > v.width + 10)
+            f.x = -10;
+          if (f.y < v.height * 0.08)
+            f.vy += 200 * dt;
+          if (f.y > v.height - 10)
+            f.vy -= 200 * dt;
+        }
+        tick += dt;
+        if (tick < 0.09)
+          return;
+        tick = 0;
+        head = (head + 1) % TRAIL;
+        flies.forEach((f, i) => {
+          trails[(i * TRAIL + head) * 2] = f.x;
+          trails[(i * TRAIL + head) * 2 + 1] = f.y;
+        });
+      }
+    };
+  },
+  id: "dashu",
+  loose: "\u8424\u4E36",
+  ramps: [["\u4E36", "\u8279", "\u8349", "\u8305", "\u83BD", "\u840B", "\u8473", "\u8564"]],
+  warm: 2
+};
+
+// node_modules/inkpond/dist/scenes/jieqi/winter.js
+var lidong = {
+  create({ rand }) {
+    let sources = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let phase = 0;
+    let freeze = 0;
+    let crack = 0;
+    let count = 3;
+    return {
+      cell(x, y, _t, out) {
+        let w = 0;
+        for (const s of sources) {
+          if (s.life <= 0)
+            continue;
+          const d = Math.hypot(x - s.x, y - s.y);
+          w += Math.sin(d * 0.06 - phase) / (1 + d * 4e-3);
+        }
+        w = Math.max(0, Math.min(1, 0.5 + w / count));
+        out.v = 0.02 + 0.88 * w ** 2.5;
+        if (freeze > 0.5) {
+          out.k = 1;
+          out.p = HUAQING;
+          out.wet = 0.3;
+        }
+        if (crack > 0 && Math.abs(noise(x * 0.02, y * 0.02) - 0.5) < 0.02 * crack) {
+          out.v = 0.95;
+          out.p = INK;
+        }
+      },
+      drop(x, y) {
+        const s = spawn(sources);
+        if (!s)
+          return;
+        s.life = 1 + rand();
+        s.x = x;
+        s.y = y;
+      },
+      layout(view) {
+        v = view;
+        sources = pool(5);
+        const at = [
+          [0.3, 0.4],
+          [0.7, 0.6],
+          [0.5, 0.15]
+        ];
+        at.forEach(([fx = 0, fy = 0], i) => {
+          const s = sources[i];
+          if (!s)
+            return;
+          s.life = 1;
+          s.x = fx * v.width;
+          s.y = fy * v.height;
+        });
+      },
+      stamps() {
+      },
+      step(dt, t) {
+        const c = t % 18 / 18;
+        freeze = smoothstep(0.15, 0.65, c) * (1 - smoothstep(0.9, 1, c));
+        crack = smoothstep(0.62, 0.85, c) * (1 - smoothstep(0.9, 1, c));
+        phase += dt * 3.2 * (1 - freeze);
+        count = 0;
+        for (const s of sources)
+          if (s.life > 0)
+            count++;
+        count = Math.max(1, count);
+      }
+    };
+  },
+  id: "lidong",
+  loose: "",
+  ramps: [WATER, ["\u4E36", "\u51AB", "\u51AB", "\u51B1", "\u51B0", "\u51BB", "\u51CC", "\u51DB"]],
+  warm: 1
+};
+var xiaoxue = {
+  create({ glyph, rand }) {
+    const snow = glyph("\u96EA");
+    const dot = glyph("\u4E36");
+    let flakes = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    return {
+      cell(x, y, t, out) {
+        out.v = smoothstep(v.height - 30 - 14 * noise(x * 0.01, 0), v.height, y) * 0.6 + 0.04 * fbm(x * 0.01, y * 0.01 + t * 0.03);
+      },
+      layout(view) {
+        v = view;
+        flakes = pool(70);
+        for (const f of flakes) {
+          f.x = rand() * v.width;
+          f.y = rand() * v.height;
+          f.a = rand();
+          f.b = rand() * TAU;
+        }
+      },
+      stamps(t, emit) {
+        for (const f of flakes) {
+          emit(f.a > 0.35 ? snow : dot, f.x, f.y + Math.sin(t + f.b) * 2, 0.3 + 0.6 * f.a, 0.45 + f.a * 0.8, INK);
+        }
+      },
+      step(dt, t, env) {
+        const p = env.pointer;
+        for (const f of flakes) {
+          f.y += (10 + f.a * 26) * dt;
+          f.x += (Math.sin(t * 0.6 + f.b) * 10 * (0.4 + f.a) + f.vx) * dt;
+          f.vx *= 0.96;
+          if (p) {
+            const dx = f.x - p.x;
+            const dy = f.y - p.y;
+            const d = Math.hypot(dx, dy);
+            if (d < 110 && d > 0) {
+              f.vx += dx / d * 400 * dt;
+              f.y += dy / d * 40 * dt;
+            }
+          }
+          if (f.y > v.height + 10) {
+            f.y = -10;
+            f.x = rand() * v.width;
+          }
+          if (f.x < -20)
+            f.x = v.width + 10;
+          if (f.x > v.width + 20)
+            f.x = -10;
+        }
+      }
+    };
+  },
+  id: "xiaoxue",
+  loose: "\u96EA\u4E36",
+  ramps: [["\u4E36", "\u4E00", "\u4E8C", "\u51AB", "\u96EA", "\u970F", "\u9701", "\u7691"]],
+  warm: 1
+};
+var daxue = {
+  create({ glyph, rand }) {
+    const snow = glyph("\u96EA");
+    const dot = glyph("\u4E36");
+    let flakes = pool(0);
+    let bank = new Float32Array(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let wind = 120;
+    return {
+      cell(x, y, t, out, cx) {
+        const h = bank[cx + 1] ?? 0;
+        if (y > v.height - h) {
+          out.v = 0.45 + 0.35 * fbm(x * 0.03, y * 0.04);
+          out.wet = 0.3;
+          return;
+        }
+        out.v = 0.08 * fbm(x * 0.01 - t * wind * 2e-3, y * 0.012);
+      },
+      layout(view) {
+        v = view;
+        bank = new Float32Array(Math.ceil(v.width / v.cell) + 3);
+        flakes = pool(150);
+        for (const f of flakes) {
+          f.x = rand() * v.width;
+          f.y = rand() * v.height;
+          f.a = rand();
+        }
+      },
+      stamps(_t, emit) {
+        for (const f of flakes) {
+          emit(f.a > 0.6 ? snow : dot, f.x, f.y, 0.3 + 0.6 * f.a, 0.45 + f.a * 0.65, INK);
+        }
+      },
+      step(dt, t, env) {
+        const target = env.pointer ? (env.pointer.x / v.width - 0.5) * 520 : 140 * Math.sin(t * 0.2) + 60;
+        wind += (target - wind) * Math.min(1, dt * 1.5);
+        for (const f of flakes) {
+          f.x += wind * (0.5 + f.a) * dt;
+          f.y += (110 + f.a * 90) * dt;
+          const c = Math.max(0, Math.min(bank.length - 1, Math.floor(f.x / v.cell) + 1));
+          if (f.y > v.height - (bank[c] ?? 0)) {
+            if (f.x > 0 && f.x < v.width)
+              bank[c] = (bank[c] ?? 0) + 0.9;
+            f.y = -10;
+            f.x = rand() * (v.width + 400) - 200;
+          }
+          if (f.x > v.width + 220)
+            f.x -= v.width + 420;
+          if (f.x < -220)
+            f.x += v.width + 420;
+        }
+        let top = 0;
+        for (let k = 1; k < bank.length - 1; k++) {
+          const h = bank[k] ?? 0;
+          const avg = ((bank[k - 1] ?? 0) + (bank[k + 1] ?? 0)) / 2;
+          bank[k] = h + (avg - h) * dt * 0.8;
+          top = Math.max(top, bank[k] ?? 0);
+        }
+        if (top > v.height * 0.42)
+          bank.fill(0);
+      }
+    };
+  },
+  id: "daxue",
+  loose: "\u96EA\u4E36",
+  ramps: [["\u4E36", "\u51AB", "\u4E8C", "\u96EA", "\u970F", "\u7691", "\u9730", "\u51DB"]],
+  warm: 8
+};
+var dongzhi = {
+  create({ glyph }) {
+    const sun = glyph("\u9633");
+    const plum = glyph("\u6885");
+    const dot = glyph("\u4E36");
+    let v = { cell: 16, height: 0, width: 0 };
+    let px = 0;
+    let py = 0;
+    let days = 0;
+    return {
+      cell(x, y, t, out) {
+        const d = Math.hypot(x - px, y - py);
+        const R = t * 80 % (Math.max(v.width, v.height) * 1.1);
+        let val = 0.72 * smoothstep(0.42, 0.78, fbm(x * 9e-3 + t * 0.02, y * 9e-3)) - ring(d, R, 60) * 0.45;
+        const glow = 1 - d / 90;
+        if (glow > 0) {
+          val = val * (1 - glow) + 0.6 * glow;
+          if (glow > 0.3)
+            out.p = ZHU;
+        }
+        if (ring(d, R, 8) > 0.4) {
+          val = Math.max(val, 0.7);
+          out.p = ZHU;
+        }
+        out.v = val;
+      },
+      layout(view) {
+        v = view;
+        px = v.width / 2;
+        py = v.height / 2;
+      },
+      stamps(t, emit) {
+        const R = Math.min(v.width, v.height) * 0.4;
+        const fit = Math.min(1, TAU * R / 81 / (v.cell * 1.25 * 0.8));
+        for (let i = 0; i < 81; i++) {
+          const a = -Math.PI / 2 + i / 81 * TAU;
+          const on = i < days;
+          emit(on ? plum : dot, v.width / 2 + Math.cos(a) * R, v.height / 2 + Math.sin(a) * R, on ? 0.95 : 0.45, (on ? 0.8 : 0.5) * fit, on ? ZHU : INK);
+        }
+        emit(sun, px, py, 1, 1.3 + 0.15 * Math.sin(t * 3), ZHU);
+      },
+      step(dt, t, env) {
+        const p = env.pointer;
+        px += ((p ? p.x : v.width / 2) - px) * Math.min(1, dt * 2);
+        py += ((p ? p.y : v.height / 2) - py) * Math.min(1, dt * 2);
+        days = Math.min(81, Math.floor(t * 3 % 96));
+      }
+    };
+  },
+  id: "dongzhi",
+  loose: "\u9633\u6885\u4E36",
+  ramps: [["\u4E36", "\u4E00", "\u51AB", "\u51AC", "\u591C", "\u7384", "\u51A5", "\u9EEF"]],
+  warm: 6
+};
+var xiaohan = {
+  create({ glyph, rand }) {
+    const plum = glyph("\u6885");
+    const MAX_SEGS = 600;
+    const segs = new Float32Array(MAX_SEGS * 7);
+    const tips = new Float32Array(MAX_SEGS * 3);
+    let nSegs = 0;
+    let nTips = 0;
+    let bursts = pool(0);
+    let birth = new Float32Array(0);
+    let depthAt = new Uint8Array(0);
+    let mapCols = 0;
+    let v = { cell: 16, height: 0, width: 0 };
+    let t0 = 0;
+    const tip = (x, y, at) => {
+      if (nTips >= MAX_SEGS)
+        return;
+      tips[nTips * 3] = x;
+      tips[nTips * 3 + 1] = y;
+      tips[nTips * 3 + 2] = at;
+      nTips++;
+    };
+    const grow = (x, y, a, len, depth, at) => {
+      if (nSegs >= MAX_SEGS)
+        return;
+      const x1 = x + Math.cos(a) * len;
+      const y1 = y + Math.sin(a) * len;
+      const dur = len / 110;
+      segs.set([x, y, x1, y1, at, dur, depth], nSegs * 7);
+      nSegs++;
+      const step = v.cell * 0.5;
+      for (let s = 0; s <= len; s += step) {
+        const f = s / len;
+        const cx = Math.floor((x + (x1 - x) * f) / v.cell) + 1;
+        const cy = Math.floor((y + (y1 - y) * f) / v.cell) + 1;
+        if (cx < 0 || cy < 0 || cx >= mapCols)
+          continue;
+        const i = cy * mapCols + cx;
+        if (i >= birth.length)
+          continue;
+        const when = at + dur * f;
+        if (when < (birth[i] ?? Number.POSITIVE_INFINITY)) {
+          birth[i] = when;
+          depthAt[i] = depth;
+        }
+      }
+      if (depth >= 5 || len < 16) {
+        tip(x1, y1, at + dur);
+        return;
+      }
+      const n = rand() < 0.2 ? 3 : 2;
+      for (let k = 0; k < n; k++) {
+        grow(x1, y1, a + (k - (n - 1) / 2) * (0.5 + rand() * 0.4) + (rand() - 0.5) * 0.3, len * (0.66 + rand() * 0.12), depth + 1, at + dur);
+      }
+      if (depth > 1 && rand() < 0.5)
+        tip(x1, y1, at + dur + 0.4);
+    };
+    const reset = (t) => {
+      t0 = t;
+      nSegs = 0;
+      nTips = 0;
+      birth.fill(Number.POSITIVE_INFINITY);
+      grow(v.width * 0.1, v.height, -Math.PI / 2 + 0.35, v.height * 0.24, 0, 0);
+      grow(v.width * 0.92, v.height, -Math.PI / 2 - 0.4, v.height * 0.18, 0, 1.2);
+    };
+    return {
+      cell(x, y, t, out, cx, cy) {
+        const i = (cy + 1) * mapCols + cx + 1;
+        const when = birth[i] ?? Number.POSITIVE_INFINITY;
+        if (t - t0 >= when) {
+          out.v = 0.9 - (depthAt[i] ?? 0) * 0.08;
+          out.k = 1;
+          out.wet = 0.2;
+          return;
+        }
+        out.v = smoothstep(v.height - 22, v.height, y) * 0.45 + 0.05 * fbm(x * 0.01, y * 0.01 - t * 0.05);
+      },
+      drop(x, y) {
+        for (let k = 0; k < 6; k++) {
+          const b = spawn(bursts);
+          if (!b)
+            return;
+          const a = k / 6 * TAU + rand();
+          b.life = 4;
+          b.x = x + Math.cos(a) * 26;
+          b.y = y + Math.sin(a) * 26;
+        }
+      },
+      layout(view) {
+        v = view;
+        mapCols = Math.ceil(v.width / v.cell) + 2;
+        const n = mapCols * (Math.ceil(v.height / v.cell) + 2);
+        birth = new Float32Array(n);
+        depthAt = new Uint8Array(n);
+        bursts = pool(18);
+        reset(0);
+      },
+      stamps(t, emit) {
+        const T = t - t0;
+        for (let k = 0; k < nTips; k++) {
+          const age = T - (tips[k * 3 + 2] ?? 0);
+          if (age <= 0)
+            continue;
+          emit(plum, tips[k * 3] ?? 0, tips[k * 3 + 1] ?? 0, 0.95, smoothstep(0, 0.6, age) * 0.95, k % 3 ? YANZHI : ZHU);
+        }
+        for (const b of bursts) {
+          if (b.life > 0)
+            emit(plum, b.x, b.y, Math.min(1, b.life), smoothstep(4, 3.4, b.life) * 0.95, YANZHI);
+        }
+      },
+      step(dt, t) {
+        for (const b of bursts)
+          b.life -= dt;
+        if (t - t0 > 15)
+          reset(t);
+      }
+    };
+  },
+  id: "xiaohan",
+  loose: "\u6885",
+  ramps: [
+    ["\u4E36", "\u4E00", "\u4E8C", "\u51AB", "\u5BD2", "\u51DB", "\u51BD", "\u51DD"],
+    ["\u4E36", "\u4E28", "\u6728", "\u679D", "\u6748", "\u6792", "\u67EF", "\u5E72"]
+  ],
+  warm: 9
+};
+var dahan = {
+  create({ glyph, rand }) {
+    const fire = glyph("\u706B");
+    const star = glyph("\u661F");
+    let bursts = pool(0);
+    let parts = pool(0);
+    let v = { cell: 16, height: 0, width: 0 };
+    let next = 0.5;
+    const burst = (x, y, t) => {
+      const b = spawn(bursts);
+      if (b) {
+        b.life = 1.4;
+        b.x = x;
+        b.y = y;
+        b.a = t;
+      }
+      for (let i = 0; i < 40; i++) {
+        const p = spawn(parts);
+        if (!p)
+          return;
+        const a = i / 40 * TAU + rand() * 0.1;
+        const speed = 90 + rand() * 150;
+        p.life = 1;
+        p.x = x;
+        p.y = y;
+        p.vx = Math.cos(a) * speed;
+        p.vy = Math.sin(a) * speed;
+        p.b = i;
+      }
+    };
+    return {
+      cell(x, y, t, out) {
+        let val = 0.06 + 0.32 * smoothstep(0.38, 0.75, fbm(x * 0.012, y * 0.012));
+        out.wet = 0.4;
+        if (Math.abs(noise(x * 0.015, y * 0.015) - 0.5) < 0.016)
+          val = 0.7;
+        for (const b of bursts) {
+          if (b.life <= 0)
+            continue;
+          const age = t - b.a;
+          const f = ring(Math.hypot(x - b.x, y - b.y), age * 120, 34) * (1 - age / 1.4);
+          if (f > 0.15) {
+            val = val * (1 - f) + f * 0.8;
+            out.p = ZHU;
+          }
+        }
+        out.v = val;
+      },
+      drop(x, y, t) {
+        burst(x, y, t);
+      },
+      layout(view) {
+        v = view;
+        bursts = pool(4);
+        parts = pool(240);
+        next = 0.5;
+      },
+      stamps(_t, emit) {
+        for (const p of parts) {
+          if (p.life <= 0)
+            continue;
+          emit(p.b % 3 ? fire : star, p.x, p.y, p.life, 0.5 + p.life * 0.45, p.b % 2 ? ZHU : ZHE);
+        }
+      },
+      step(dt, t) {
+        if (t > next) {
+          burst(v.width * (0.15 + rand() * 0.7), v.height * (0.15 + rand() * 0.45), t);
+          next = t + 0.9 + rand() * 1.4;
+        }
+        for (const b of bursts)
+          b.life -= dt;
+        for (const p of parts) {
+          if (p.life <= 0)
+            continue;
+          p.vx *= 0.97;
+          p.vy = p.vy * 0.97 + 70 * dt;
+          p.x += p.vx * dt;
+          p.y += p.vy * dt;
+          p.life -= dt * 0.6;
+        }
+      }
+    };
+  },
+  id: "dahan",
+  loose: "\u706B\u661F",
+  ramps: [["\u4E36", "\u51AB", "\u51B0", "\u51BB", "\u51DB", "\u5BD2", "\u51DD", "\u51BD"]],
+  warm: 3
+};
+
+// node_modules/inkpond/dist/scenes/jieqi/index.js
+var JIEQI_FONT_FAMILY = "Inkpond Glyphs Jieqi";
+var JIEQI_FONT_URL = "data:font/woff2;base64,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";
+var TERM_SPECS = [
+  lichun,
+  yushui,
+  jingzhe,
+  chunfen,
+  qingming,
+  guyu,
+  lixia,
+  xiaoman,
+  mangzhong,
+  xiazhi,
+  xiaoshu,
+  dashu,
+  liqiu,
+  chushu,
+  bailu,
+  qiufen,
+  hanlu,
+  shuangjiang,
+  lidong,
+  xiaoxue,
+  daxue,
+  dongzhi,
+  xiaohan,
+  dahan
+];
+var INK_SCALE = 2.1;
+var PAPER = 0.15;
+var MIX_S = 1.6;
+var CHECK_S = 60;
+var WARM_DT = 1 / 20;
+var stillEnv = (view) => ({
+  cell: view.cell,
+  drops: [],
+  height: view.height,
+  maskAt: () => 1,
+  pan: 0,
+  pointer: null,
+  time: 0,
+  width: view.width
+});
+var createJieqi = (options = {}) => {
+  const firstKind = [];
+  const ramps = [];
+  for (const spec of TERM_SPECS) {
+    firstKind.push(ramps.length);
+    ramps.push(...spec.ramps);
+  }
+  const EDGE = ramps.length;
+  ramps.push(["\u58A8"]);
+  const table = glyphTable(ramps, TERM_SPECS.map((spec) => spec.loose).join(""));
+  const fixed = options.term ? Math.max(0, JIEQI.findIndex((term) => term.id === options.term)) : null;
+  const follow = fixed === null && options.date === void 0;
+  const pick = () => fixed ?? jieqiIndexAt(options.date === void 0 ? Date.now() : options.date);
+  let view = null;
+  const cellOut = { k: 0, p: INK, v: 0, wet: 1 };
+  const start = (index) => {
+    const spec = TERM_SPECS[index] ?? TERM_SPECS[0];
+    if (!spec)
+      throw new Error("inkpond: no solar terms");
+    const live = {
+      clock: 0,
+      index,
+      kinds: firstKind[index] ?? 0,
+      term: spec.create({
+        glyph: table.index,
+        rand: rng(index * 7919 + 977)
+      })
+    };
+    if (view)
+      place(live, spec);
+    return live;
+  };
+  const place = (live, spec) => {
+    if (!view)
+      return;
+    live.term.layout({
+      cell: view.cell,
+      height: view.height,
+      width: view.width
+    });
+    live.clock = 0;
+    const env = stillEnv(view);
+    for (let t = 0; t < spec.warm; t += WARM_DT) {
+      live.clock += WARM_DT;
+      live.term.step(WARM_DT, live.clock, env);
+    }
+  };
+  let cur = start(pick());
+  let prev = null;
+  let mixAt = 0;
+  let nextCheck = CHECK_S;
+  const readCell = (live, x, y, cx, cy) => {
+    cellOut.v = 0;
+    cellOut.p = INK;
+    cellOut.k = 0;
+    cellOut.wet = 1;
+    live.term.cell(x, y, live.clock, cellOut, cx, cy);
+    return cellOut;
+  };
+  return {
+    fontFamily: JIEQI_FONT_FAMILY,
+    fontUrl: JIEQI_FONT_URL,
+    glyphs: table.glyphs,
+    moving: true,
+    panSpeed: 0,
+    ramps: table.ramps,
+    compose(grid, _offset, time) {
+      if (!view)
+        return;
+      const { cols, rows, cell } = view;
+      const mix = prev ? clamp((time - mixAt) / MIX_S, 0, 1) : 1;
+      if (mix >= 1)
+        prev = null;
+      for (let y = 0, i = 0; y < rows; y++) {
+        const py = (y - 1) * cell + cell / 2;
+        for (let x = 0; x < cols; x++, i++) {
+          const px = (x - 1) * cell + cell / 2;
+          let live = cur;
+          if (prev) {
+            const m = noise(x * 0.13, y * 0.13) * 0.78 + hash2(x, y) * 0.22;
+            if (m > mix)
+              live = prev;
+            else if (m > mix - 0.05) {
+              grid.ground[i] = 0.9 * INK_SCALE;
+              grid.kind[i] = EDGE;
+              grid.pigment[i] = ZHU;
+              grid.wet[i] = 1;
+              continue;
+            }
+          }
+          const c = readCell(live, px, py, x - 1, y - 1);
+          grid.ground[i] = Math.max(0, (c.v - PAPER) / (1 - PAPER)) * INK_SCALE;
+          grid.kind[i] = live.kinds + c.k;
+          grid.pigment[i] = c.p;
+          grid.wet[i] = c.wet;
+        }
+      }
+    },
+    layout(next) {
+      view = next;
+      const spec = TERM_SPECS[cur.index];
+      if (spec)
+        place(cur, spec);
+      prev = null;
+    },
+    stamps(env, emit) {
+      const fade = prev ? clamp((env.time - mixAt) / MIX_S, 0, 1) : 1;
+      if (prev) {
+        const out = 1 - fade;
+        prev.term.stamps(prev.clock, (g, x, y, a, s, p) => emit(g, x, y, a * out, s, p));
+      }
+      if (fade >= 1)
+        cur.term.stamps(cur.clock, emit);
+      else
+        cur.term.stamps(cur.clock, (g, x, y, a, s, p) => emit(g, x, y, a * fade, s, p));
+    },
+    step(dt, env) {
+      const now = env.time;
+      if (follow && now >= nextCheck) {
+        nextCheck = now + CHECK_S;
+        const index = pick();
+        if (index !== cur.index) {
+          prev = cur;
+          cur = start(index);
+          mixAt = now;
+        }
+      }
+      if (prev)
+        advance(prev, dt, env);
+      advance(cur, dt, env);
+    }
+  };
+};
+var advance = (live, dt, env) => {
+  live.clock += dt;
+  for (const d of env.drops) {
+    if (d.age <= dt + 1e-6)
+      live.term.drop?.(d.x, d.y, live.clock);
+  }
+  live.term.step(dt, live.clock, env);
+};
+
 // node_modules/inkpond/dist/scenes/lotus.js
 var LOTUS_FONT_FAMILY = "Inkpond Glyphs Lotus";
 var LOTUS_FONT_URL = "data:font/woff2;base64,d09GMk9UVE8AAD74AA4AAAAAV3QAAD6lAAIAxAAAAAAAAAAAAAAAAAAAAAAAAAAADYGQNxsgHEgGYA4IAIQ8ATYCJAOBCAQGBZMMByAXJBiBCBuCVlEEGwdk+GGcH0UdSqQwooqzcPCXAduAUarfDyEcXC3WfJSYR9PiPRyNxEdNtRQ3dP3wLX4fZwp/cSkd97eHSjDZdEtxj9DYJ7kD/Ln+eQBrrSl6ywvCEnRiB7AD0fGLHTU1V+a+wJJgDziXY3zCzRPsJRvgyeZZ2K8jUEiKjKyvL6vKFh5qv1S9zApT2DDgMQaI/qUaXYWqZeHIaFoenj/cn/ta0yigOMA5wOOtkY5pAUX2/fvP/1/2/1/62lcvB2yQoVqBKulU0FRQAdsFJS44UgtpJifggTBX9Vj1/qTN/luSb8ZMzl3gTCmswAJlszUdE/TU/dF59d9/Z7kFv3el/jbSLSUtfy0gmcK2wzMZpOBwZnfjJSwz/vWs5KpT7+b3lbJnwswuOZdfc3nuNQ2UhCCtP4p6EE2hZvL25pg5v3+c2u+HzugT3Jz1QhloiSiWbKcEAXJKaReohDzSuS9/5fTr5ElX7TlVkn9VehAxw8knCJAddtSSul+DWjLJQHGIhwBPe0NvlRf+XlVd3wdTACnDg+unlQKlQproDJvXjQZJFQBqoApFqplwhVx4pCqUPnkYs2bYPGeiP1zoTgOWLgZdQcuXA1Pd2rJnzLRmnlzGTLkM65J1jm+/TOn+MSA+Ztq+CzOHN5LWO7p336XLcmtrs96S9SUdHwwKDKAZoyCPUaCciWlk2SmNCzWOKvZCHs9b9s5vTPT3mVawEgglQdbduW2F2evmMCIyiMggXkm+dbkgJAFggNyQCtUyDb5f27YkEruNkfKMm+D6UfRRPEqWfpSATAoxKcx4iNr+c+mnn5FqgXr1fclvEstXzWumsbVkpdhIJFt83M0ADiUAhKHa4agnwJeQtMJ1VDt95UtUZKkNa6/NZFlSBwnSCrYfHuSk8csjJAaRO/w7NImaF4M28v/4PHLKJtQSIZ/w8+IKxf9RTgUfr6y5gVA+Lk2wkw/YHUAGxNKmANuxH6bUiFWwtddFziG/ydeTtt66MyQfm7edf44QigLQs1KlrFGOKFcrf1e+sWyhXWk9bjPX5Zq3zwfZTthJifKIOqjv1mcMYHIAH8RnWaaFKzYjzbh431GkRyyPrbxP/kg5Z1Wtfk/HI18FqabwdtazRTOzSln/972c/XLOBzl3jLWWVijn5daC0yuqVk4ufF4LLB3taUuv2Bft/x0o/XN6ZwkEA4sAgBIAJcBfUeU/xzC9ZbuBAwvBpZAtdBK6BENwNfwU+U86WO49yab39drPiT8P/yXw1/f/Nvfvwb9/94+X/3TR3/nH/O/gmbO9sl/f/EZ3efE7K9/794z3Zq2a9Urx0Jz/znEpr106eVlzXWu99gavLYldWt/Y0DR2pbaFrtWWdX+7bVpc3WHt5u+Xb9n+r53VvVnA1LaVRIG2hO4Yfv7w9z8CSeNvHO4954df/cutd17QKhHDOnRlb/vufv3Yxe/3dH339WpyyYr4RQHvV1mJ/jXt1klScD4MJxGwzM1VJIoFxCtIqpJtZeP4nmUvXJFAD8IPeFtu0JqajNoS5MWI1uZ3HHLF5uYJbHO0CWCsnocCKphONvEx395wvworczDU8mKNLo9RhQhzPcgvVnpHRtY516br3lSF73j0j8DemBZu6SfAn6tpoKJJ3npvIDSM51KyCXkSeVeOG21FMC44A2nSQF4jMw9m83Mfr8zQjeAPn3Vo4xcb5QkER82Qmwk2JdyKvzGG2hlI9uYn3/6Bi+6nISHTqcu59KC4URa4CpFvXQw+eS7CY5U5+eFdT3Q/lgs0faufu3Rn/ih8zDk02PO84oAqOONTThEh9L0Syi2E87skk1xp4+S2dTFXFLrRzcUMz0AmoLeoQVBR6/qIx4itboJzKDqNaF/4MZGZCaenaN+CpjZv8a8mBG4C+UXPf9Cy+Eb7N9Hxuqp8SzE/AtIZk5p8+19VeR644oS7zEo/mqa1bArwUd7GuHS4okz2IUIBI+tu9SxQ9uV+ipsRiAsOAwZjL+P8XFgsyHmyIkc37XqtxoBjWr4nsHnRaugFl0Q3aQleiZe+Sj90fM4JeiB9s767MWdmYzineeZ4ut2WUxHsqISrlCgD/5umIc1+8V+CJ7CYqAZgzZebP7fFOaYxLqa2N0Ys6gR2LW48iVk8QG2FqL3It+mWLe/O/7hu9Q5bJiNiNYF6fs6hwkCl6erSrgn49HxlWnsaCR2RsgE9LdO6yazD7OGsxKw9lOogQCpEykVudcM8uyfmGCAsv8lIcA6qMBrFgX9IqMOfFphwZlZDxUyb08zCtN+63IZUizWckZgN2lLVJB5oRpPq/5H2+gKZnRWDwaStm8QExwy7zKh1hg+Mnz7EonjAlPVpQlW9nnFbmoW26rgk2v1So5SOTfsRxyY60TKmtP8U6Wrje9DzUNdSXb/ZsA9h3Hre5K1tljYQgwQsR2MFYx2O/O/WQRZw88OrlmPSULzA6zvAT/+I4+PAa5mzOb0YzBcnOXUlEpy7o15A5s6bTDdlm7Bakfq2V1wJhvJqOUJ+5u7DoEXcN3zy/MOsNGzxqYXJsyP/0nEGpw9yahJ8pyxJk4EyPZSL8aLCCJgamldc9BNFKLz42Jw/InaVB8qBUi6f5o3cnN0p506MTAwUUuXa305tEnhJUQ9kMZGVvn6fIIJZ0txv3GZzo8nequcxguhKJ5ezhDNLmBkG3exGRQEq8hkIUSl7keDlfl2Mp6YEP2eC58cipbdyfuxqGU4eGGYG5AB4xcAjTBduzVdAV4Hdjo4AlIC4lnJpuFb1hhC236QkOD+juUr10nj8r59D29YIe107i9rCKYGdeDUYIGzdpAScX+fKqEb1BufER4LTNboI4OYuuTsK9O6+UiVt1VZX5jdN/RRdo7nlrcGquCUZ8gokcPELZ1+k7evh/HSP9K5MWKWWNNZoWxu6WZ71Ol+efrOuWNqMXzLEcUnARzR5XkHkkSHeFQQDpRaNwQhFyIkJ1rmV5fn3jYZOG1EwRwE4IGuYojILQTH1YRSZmSBDTTSKzEJQJXUpagoEgIll9WYqI/iANeLkEyJKSFfNW1TaSw+ZbetnRXvZ+QJhon4BmmPmi03ex6YfqU4Atz2Ee1aN+UrC0zXKobBftaE+EfGOV3IXVcMd9X87laurJA5En3BjeKqe02r7zsc7ukgNzqg0P71hpJ6vBIsSTF+kAbNl2vgB4QkUGG0DXihiXlAxJFNaXmNv+BizGLI/R0qMLqreYNzWiIKefuaqTElLMMWxU6ekAUl+8ym/kO8YyoieKemdBxKcZeEHEHURhiqLyPZddEERkGAhLwFc+mlVjp/XhXBCgStP6uBXRMQQiZgUkcatgbX37DF76dQhFiWgt6yqnSsTrCrDoR5OBr579cAQbdR4fk8qFG4BlEw290jB2kKNM9wz/gonAIEOneP3+O9baBo7/CjNshtePi7ofaOx7RqISCaJsSfL12owuLAMDz2iUT9EvrO/6tbFJs4NmD2QAtwE74YlpGFz8qtLV7XWCAJlZ3zAqYngT9lQTKb4M4hi7/gPxTX6AmxmGFu3Zpu4T4LZ3uvTdyCjiyaNG9M9r7uvnWnvexAlGwsd3jH4lkG+smLbvyImbpvuf5/oHTB1iWw66K0gIi7xtUlichSckVElkOTwlgRDcO1py3xKBVJPaXmVDfucfwNz54IkxtjslvPOyYNHFC0zui3H4+572liyXzksGSzrAYTzUxbfFTl9td4IOIVTRjg1DryQxWnCUngQyHB0vb6LbG1GH0vB+WfkgShfMM8SZYIHTEpwdDqdys0EzUgAplHAAnpRGtgghRpiMrM/hWCPH8xqsYZAvw4/tJvdRmeE6SpqNtcKM44tDTgd9lzNrwlleowQXoEkwnLAgvNNWAt7AsFqIUgNgguim8SAQ+McVG4h6LH4Io900mjfFjgaErYZymu/YraH31ICayjJMQN1mloTEDFtX+UDpWKdEmlAU4KeZ6YT6jHUrFoJFju0v6f8figB8Drj8RnQN39PHkXQ0H4NFtwU7sM29uve5FKPf6xOEDU3bcaPs/3SQKkeKaQVanxibCyeGN1WKe0r6ifD3E+49ilMhVorlMvY+UOckggWyNI0EZzCaAFAyl6ddh4N24Gz3tRIf063YmEJOMQavYI7CpFH2uRnGx0rNat+9NQG1oopivLVnLSlsah/LaY/RLwZGZ4vFNpZdhR5JXffZ9+k3YRg+SbEb7crfbo5Y3Y/ATjbI8EVTdLP/BAIDVjSvdizSNmf60a7EIgbHECZpM4Dbt7TWsUzsmaqdXbFC+Rzn8V4nBS6INEfMSRJXiJ+EwtyXXQEz7B4chStR8C2DYgJGxx6NzrsmAE8LUuaA0mBWZnapxhNOtkdbIY5i88QMU2hmoRt/qAjxEn53lGE0YCUvno1qqxMEFtiEG1ZDUCn+zIkdPW5vpYFgM2pFlNQA6b72oq0jbWnNfreMF91LWmsbW3+kbVCZAQG0Rb2eAph1TWhFyCIh/iOZCvkDP/q1eoko0bk/M07lWU49XRTkusGGE22mF4rBUw7tWmBzWEbupw4JCwtJRvYbdFiOYtTIon8iM33ZU4aERZqASo/vz9jt3jXBq4Bhf11sdD2JxDs/WkjuNGgNMO06tuWCZKM24B4I2V353NVagkD7Fy02THnC6Ibok7aipk2wxYbDDqOCkNUWF8PCc67kQZpQXXzfHbM/25eHcBE7xPVG8CJbhIC7tqvFxy1riOK9N1EF95Xd4OOQ2XdYSF+6uJ7IvZO13PamNSbF1mJjaXSjOsIA4SNJJxrTqrzLywOJKI1ucKhAv0/ZbLJwuo3KmKMbop4WpGWaYOUZ8TLlrAKCfN2cwf4BaOckIBwC/a96rbqliQkNiRAVk9ZFZJhPRAD1xpnni4I4xd9wPFJkEN4GiVzLozvNQNYydo04dqA2UMphhsgyuE011nrOqrgDsHtO3XYHwBam6RQ3Af+np9afkNED3WIhcYjYM4dFBtz5Toj0lhqrNXVZvAr22QgtJQbBQf4Sc94/77GxvbR0Y+JVOcQaSFuSkQaN6fAwjSFKDmAhIuckOl91cUaHN/EDScGEcMMEpVnmApEyF4SBBV+sHxI5hW5+LRHg9uf8OK5PmphzmzPbHF5T9U5rTnldYKv3t/jrm8hfWwdam3afd/g9iVgvnKV4eu0n0V3/yHO2HcmBsnqUhjvKUudgZDKQR87QTiwLZf8sBaFyuIOV0yWRJPxBGxYlUNsKt2KdGryGXl6jVsRyYqQt1Q2QXqW10oR0pjZYkj/Go7eAzEgtrTxg5Vb18/xB2eMrALJIg3QmuO9La8Oh1eyivvL+TmXCGO2pUlP56cf9AfmTBtrv0BR9+aFExwbz0xLNycpnHF+dLednTSsvhdfVevTliIMzv2Y4+OBrVHEZAhJ/CbR53BRiGRFEWH2PIxja/Zv3uPX+90e7Fgi4VfLGTesdwckhoty5mxmXN5deU5bXiV65d4eF9XF1bik3vE1LkLs1Rg0OFjo+qvijqkBch+zQKG8tNMfVSQN7PZObJpHUxa73BEw5Bb6OErd2VV4i+nmmiRqvdMQLkugMbMXGuatIrrmyjFbSThb4xOKvL+Pfr5IWfEm+CFpoByE5fJowagL/QfVvPGJxEgCVWpDU/3kEfcctxMnT9lCEIXw4hMhgIDgAR/oCyiisOF7ChuOOnw71n4BxNhJqdOZSLKYhs99M5SERyWlyR+xEQ5ybjlQashAbBB8brRz79VL2qiqdSEHRaHWm+9GHc2v68xxmUk+2aDJfV1dvV3VJukEnwwLI5BLDl3KNAwrGjrq2tKKt1H0TrPSG5bxUGA1HPeYIy5u4jQDhYJD/0MEtif6BQXq9HZLhE6hMSsFS+akiRvLeCbNaX2JiqBnTWteGe7i49HK8nVR0y/+gttWgPZqbIhRTqX9qdNWPxnGJNIo3xkyVQn0kROGLTstM26tBCyvPh9TKy30acoPJw4UI+cl9wxrJlOfjgzOLcuE2/lkfw9R6GOaMGwMkiS8qfV9gJ8erTOyspi4HPW0c/L5U/F36ssNKZhvfv/SZMKjHfOMkJPd/vFVQaeNojex7M4XmHcb9cZiru4SaSyytu7t0/p8bbMpZq0eFgQ44o2hHBaYJp/TCsc/E9emyVWBOUZPbPAmPO/W6Bj6OJKEGxuXUStSQCggrlMpgdEXcOzsQsileO0CSBaMpFYHClxI5vdf0UtzW27RvT3O+mZClKurlz/CnUVgvXINdHAO0Gucls65CKbW8owvIvPCD+Mx2LHBxUGr3LbSETR9wSdWBG7szPOikg5e6BXIZfWVhcsFrdZ1PFcKmFV0O3IxfwipbVSxpB/8EpfN2qAzaFyfdXbmB4wgNw0ITWdCQZY1gvf4Lc05KRc/h7CfUuqDGW5hhqlWaOqyS/tZvB8QhJhPekFMoYlVYO+if6D2QPS+HbOjwqTK/j032tM2iuqdmlKORn4WStQ3Pu2Zqe+Fvoj5EMgtVwF/5urGa0O9W5fO8TxgXNFdYXBgb/33VNZMtwYVtfE+zi8Aeha1/KH+I9pMDZBxTPH+4k53jCXxSnXZNG4NKJCXOn0ma5eFoSY4sH05rEbHxr4goDFGLKD4SyV6QVduB7OPOolGcU1ISK3vr4ck2APw2h5M9PBfgqTgRhTovcWnPdJN/+D+YmGAKIf8hPTbwUbzaLZBwvsOznCYdc4N6chxL+92fMEc6iojv7HhP5Ee08tJxCXUcnntxULFrPNKwtj5H3F8OsQqzxhPjWaQ8E103wBtHVxQaaFpq3ezWkooBht9wmvM8axZmUu3yxSQzJ+87VQs7BMvnC1OdFed05wbiAY8T8B0p6HqbX2Cq4tAMj20d2zooWekHVOh0evwC+SV3nKPfuGlAahfbYeMAcbxgBgMR1dEvaqiGsKsvEZqSI2XA+mfIyFGf2MPVSCgftmnsfYrO1ZjJhko7QVJvbmqKPjFWx3DwbkB09fE4EtKzNh6r492bs3Ils0d8GeXkb1ucFd5LHEdzOfJaPanc85pjTFF3URWVaizc9c/c2LtyWhZpayur32kb0VVSS53MHr1SFHO5EbTdrNd6K7qOIXf8SthNIQNn3vQdCyYqDxeevPKWhzwKTKzwJ9dzmCrcgUgPjlMKHGmO6vjZTn0LDgMMgM2Elv7duu8m8vfd3T4lqRWXqxurM+vmnWaZq5E+LvoryvKdNbFqSx6Ee4DnUFriBe7SYmQuoO0j1NPYIJIHtzjd21iXJ3bNHu+xU3LQFUIBjo51xVH2XDmi3d54/IU+sgOka6bY9zyQnl5eyiojPkkHoUbe3Jk/e4x4iIepVi5numk7HRoKWYH56j4N5cPKpKM/BAzKB4C02N9cGf30ljc0K9V99Z2pRXvoui9BmVgsRLstn8frBn2KQW0dkP3sRXnnFOi7L3XalIaR8FsdGhw4IzbXJxR5O3jF8Wu4MR3tq2SUpeb48e75Tz7VMLSpC0nPCXagQJF3tNUKiijjuS7aNfO3M7sboRNPu7GL5SMRps3w3f4TRVS86q/p5xX8AG1dBi4iDyGXns81MvcUgYCi2c+yfFEmwVvi5nW8C7hEyuAD8Hll8v0iRfkzPbMEid6LNucUxpq+mCvr75AF1tllTbFjrM1Jx/wy6jg+/6ev1Flrc9oSjHOS13s8IaVDpqyo7BifTFFY701an6nLc6k0Hg8AS0L84juMRfkXAXOQvw///6hWTUPNBsPeBIXmIt9hrXbmhRGmv8tFcTMQDTn+Q6mMFPqmZ6WrrGhpzGDJFcfwhIfzDxiclJytFrPqXJpdNsFjzZnGPcGgcruHCrtA99nMrNvipwJWiuCdB8HWJxZKBuiMZymSz9qenbDe4dNzVo3mhJGAlBWWuTCWOg7BNMirRKaMbg+xQfS2QOgmYl6FOkhS9xdnBJOynvRgF6WeEcoOMSUf/Ow+QSnUW+/wo6YAoglxWKVKKwEkknTSwFrph79UQpMEQVgrpK4VqVajCVJwM48rTcYj4QOcdPVQLIQ1ktj2X5qfs48GyisPKclt7xGwAd7PQoUMWhNvPA6Ls8GUaDIMaz+v8UpWVSKZ0IUKXM7nRabRtMxbLasXECPrRvsF+/wReUO+ijGU9CaS7TyE2TKcodXlwUzaoehYekqIoWTIbfkml2VVmEeOea6Pn9ggugXuwPspePztLcsRQ657pNFoRI6cNiL7ZbcntIhWr5jpl+NI1EK575ks2iP5F0E04+1XvS79CQFB55BoeMW8emyyT20WMGRzBZ9nnZx4xHBwdaxG0NCtTJ88Vg06kwBlPmyKTvpYirTngV+pzLX3qoFl4UrqO3hfqmsK9F4J5uk1R99NHZlnLMy2LoLbtQhPWyJ2YOFN6MA9wbkrqTK+DabEZ8/vuPE8LpBlv+kchSqhbqfM6973CnHQnPJ77C+hwtRIJX3yrPiXnRrchIEarJ/Nqa3Lr9t+XaqzbAklfbX9S0B+6zZoIBNAZET54HvobtEZulBOBB6yOiYRr88XSRE9myJ+44rjoagrutA1DrX84C4nLQqRuBmj7O+hQyxMzDTpjnYi2cvbYh3aHCRRs8ffh0SGMnkhrLoAHvSqZBZO5MGEKRsZUcwpLTldgiu7FpUsJRKJIR5bKh0FazPV4uZu8UCuHiYU1KAi5h3FybBcYQJfM7sNNiO4vbb3lRJaZXSKd8ETyvR9zUVTYDCpN0gC8PlgfEb+HpsAHzqeKwx3zAKmWpnr6eZIcWMnsWN0ZosKI9nCbbtcDbcPJ+SVbhc1TibZttCruwqfplVJGNMhPzZAWPjZFK3wSfxPuumVV4FLr0knvozd8qWAoKVfoslEDAMNAqAsaQwnZtGFCQXFvp1AZdAjAjfWd44t8azfdQCyBZ6KlMeRvWAHzumDtU25a73cEkecGJU5Qis/UucLhvLZChQFnd6YmwSw4qOMzc/IUR/WL6KsRhc2JFL9KUqYCdSC0GaTirRkiMpfghxV7XsyPRcfBeOXMjYIVOc786HXhCN5OpnvSMVfCbE2+W9cNQe6uF6iGkMBoOhZ/IOaLYsu0nVxCtZaeaL/JgkrG9x+MJkRRn+tvWiqy8myTTC189YPy9eyv5XUwSkTftbmMNw5yLw64I6Iq5cAu1n5275qUvy7oVRr1cUO4YTQ9tOBVztfe7OXA+7Oh2XcRWj/cX94GGhNMziO7t1gz6AoDXzoBmpa5t9ozL30UduFja3fpldebJ6M6ynsyPcZuIcqVVoGxhY9H3oMOYarvID/3sc0cmu0IMmyxosLzE/5Fyq3XJwyRKSkVvJcWoRPD0WLqfaqdVCenkuDM1aryTALh0zUxsPk4qUCX+ch36iusNI5Bfd1k5vK21GnaP7gVBzimD63JdXdOsT9HaqCbWP7QVI5RnimWyDxFLk4lMedW49qWKZfmpe7jzPbP1Ed8U5TdnlVYKv3N/vr28kik6V1mBjs1G8ALiXDAbmMJcLSvhD266WQnhHnt/hCrNJNGJHoWDBckrGGhSo1Q5DWJpGg9EWiJj0K7EEM4MoikMAi14ITvQRhCslqjKvf1k+7h5UouB7XA35vosbWDNiFORPTsdgYSCaswPXwhR7QoYletyQNTlnJFAImJjmyYQuL5DB8p81RgxsXti94ppGTTUfLB91yu9MZ4quJYyNtvYD6endxYbODa4rDm/npxbvAblda8+owx1/kvHhw7/BiR6xxB3Lpjr3FP2bpQdtb1Kaz/8mkKc5zlov+EO7/7geQiq7210yCL7KpOuviFi+1gjNKLuonw/sZ1FiVZefWCK7Jk0su0MCCe/7HqyXHrK9hDT7fyWQqLlarfdMXTCXmpyZYZVWSm/c/Ml3awtV2x5tW9P+O/Mu9bcvL8reKVPL3jWxM0JGVQhv4kzIdkB4/cN9kudv7BKduznzZdqOpYRiwWq86MaAeX8LN2INHiEchVLxPd4qefz28AxZNzS2tRUGdhndc5mW+yRmE2mtd3uTnib2xxlxvIe8I6e05jBi93G7NpA+pkZRvusVaTEIr4gc0+EvcZQ0dDSdialQ3atLShrQUKQNMiah2UV+cScXo14EKwottdJVXoBETXWrWgu70INk279fqs//mZzGeon2gMnJ3fsWk6DJtvkOxyMUqMWdDRaVQ/12CmTqfyGmi3yREAUadIjxJ/bxpFwjJweOaVkTL2BrhhnHgp08zhr8JMFlMEirhM9cdnmCM8XMlIbN+dcq/IgkdhrNtkYdXtncDFgfg7XAmkLUg/UjCtkQLMKSGndJoIA2bMr/DKTi41fwKC4wRXjbyNpcH+iXD7sLhb27DcWOpl7zXVP9Z3uv1V+LzZUa4UMiRrqLC2Aqk5l9KUqGZd20rPf7dzlHq3TNHIj6zQQy8fMpqIzLazRvpKMhNf6xCh/d532nPpCbMO+Xy0UOXmckhRMluMQE+JpZ13AXKMLcUNl+V+R4wLu16r/vAarF9p311Eul1/v/xlyPbD4w5ZVdeTe7pKAferbyJ2joaQKPgr/y5Zc8eLd3gbQvmtrcDR+2GehRxlc+ifLepwMzaju/+ZUWRSKnrgF+wGaAp6qijlAacHMkd+gTP0pY62ytj9GvnTYjwZT2XUJfNsOuZejBv7jX8GKKETkBnua7fq7wkTVp8hE3gvLDXOar0FfajkisXlckBhPIZREdaZFpNz5/YaCjdRDwsKRsL0hTPHIysImamb7EJTN7bYhJccZPGuPkOLi1pKe9ORNcNa4hlifaxEqN9KZgxcXlnMdv4J8u0P5UwflvtBYxfoB8RgwG58Zng8NK/Vof4HF+js1FeHj5s8hKUmtAMUyAVbbQMmtQUjyA7mBHsxyG31Ue1yDKBwxbhPzoT7PdcvVQOunr3E8YypHYPizd/NJlERJihG+SGkgFBjrdx1Cm4BfaWZihO34OGdqBbNOWADEnekQsxmynxZQk0KTRE/0uKSUwD/gw6okzfYR6bJPfA/wVJipl2r3lbG/0UzRoboxm2zXfkphAAB4XXfBNdHIGjRPHBfr7AXNgJ3gYe/1xtbJGzEuSgyljlZHrKGY+7s5ZxxYxYxnoPFol+ch7fuaR06LQHpvsIo+vkMXcd+cFjz7lpcGKKqi2UUNHo+94llUl3FqoNagJsJ+jK5fB+UOcmATmiGI723S3EEvnIKNih8oB9RV2znNFNXX4JMdfYFVVDWsrVBx/jEZV77NZdr3wAUEUOib6hICAUrnqGCewiQY4m2NWIKjcLG8UxJtO8Fl4Il3zblXsgyFzW2WO7/vUDw6mGgaTwu0+26ilnYpHn9+mEsfwZDd5dtt10X5nYoarsQC0J+07Ht0VhiCHmwrUB9Tuir7K2AUDLBIZK27nnZNFGtVOsHbHMCfg5ofLou4558X9UU5kYmqQcNCXE5ACf42lFdWs1VtRPPoZmuoJaLZN5wb2BZ5wXOFAOuS5xVJXtJ1rAfxvwz5SZgSq6N6UaAcTc1k9qWCUhUETcxumebCck7erqpPtXoubkc2fdmZmGh2LuJw9DUqwlNkfepz7CV4KtHU7/SDVr84ViJzdQXA/ywr9hPtxG/ou1J7ZcC5Ql5dJhhjNQk9xB1nrFicEzA4c9RHoSFQGzBapmaDhOmrq8EuOJzBRX83avGUF0RG0mL/Mwgdshm/evmCA7VMx+FGUE/s6+xtcvasH2T5BpAmXcksRLDBHt3nRd44OXyyiLlYExEVTHB0P339ms0mBkDwOVEXfkOjQg2EeXFaAeBNRbmOv2DB4l05Y65jiXHYjzm+tBKomRwjat9xSbFhombjeEtpL69E1YbzpwoAEPCipv2UmtBXlnqNTKBNRMDwQQsk7RL+WW7oNwP4dAl1Kpq4BLarhJfIpWrQyUjEMCS75ent9siaPl9nSjz5tq+oxhbDO0p8v3lXZywdotUqbIuVV2Ju1WdysIfyaElgDqVADT08mJLP5kwq2FdQqlVqW08kLVP5Tv6ev8rnklgMJtUyux/33G2KpAaA1caCk5/PxtLW3RfSL2fRIy7RA2GcJ9DDcNwZ7WYhrlEKcAX77VtIttRgPCjQ28VBJL7gguZphLeennjCsuiFc8nTKgSe+wOJPAh6EeR+l1G0I35S6tQbg1j3/GaenApZsLSCj7AMFmjkDFY/DIETDojEU7dap7EaPf31xdR3xuKS0+FOMYFak1YJTh7cr2LKxtFxYzU544MonKhlbjIHrEs/XUVG74s40icz6GtbirXgsOoJ5Kz1LGyEIpLrB6gg+gzGT1P0c5lsFokQw3lHnn3ZtoaNoMtQCO9asJ4q4xeFq+czssppqLxLnAqYltdV3n12k7Dlv3NBJaCUz7vnMuMBESLd2WMwaHf7ufdgcjpCQEHc87RQb6JSkFr/PMYltxCl8rWklzzHIQl7SPQqmZ18Iy06L1geCnoVNjtbtLLxVHQb0Wd6ImCR2ma1SvTs/ocCRptoTaSnyGB7HmMNtzrZBsMA/kOg/QXfi2HZAdCP5bUovG0H66RHdsv/TwjdkMTabAGTasvFadT1XkvgDYMnRn/fh1DsvPpsmr/lSpRmGVKwU8bU+Q/R+xhMJLjz3Ps1Xo6EB4OQpTokCxFGsnSkCzQ+zIVFWngtpyjgataOwZONv1AybgPliibLGKmr3ifwwFjSDUHlRsehLdOhJ0MKbbj42zKTIsO6obiLxdwEu2Amw6RQ4Vq3XUp5dxlfmrYa0Jt1EW6y856rVzInhP7+A5s0RJ72fVpj9AcesXcsG/j3kquZOvFgij6HCUub0q8mQbwlBoxJtfOBs+/UcY6HDmYyLmByy4zYcAp9/y0y/LiKlDkwc3miMjDeo4cipreAaG8pe84Z1VaPSduDMl5ya2toxMieIro1CMOIPW8bI9X36mLra8iyAsyc5Jh7eUFFaRZJkLZq3LLp7bxgBCnRIVaU0JAQ6EVUNGrGo9R0xiN1jkgYaZcnL5AfoCjgJLYPgQfKeNWiIs2AO7BEYBEji3R/o5H8w3lYXHrOvLdXRyLYeOLD0JLGtDwln9675dLlAFCXVNv6RVJuRM5FsEZXI9SlFKrjY67bpNJpyArBjSRa9MFsqx9jjy2cfcTrlhT3LZ1JlWULhsapTHrUef9wbyQ5Q2y4Uex4Wl/epTMzJL7k5t99cX0QNcWVRbFOHf8CB6R9W6MPj5qF94lxW2HSWh8VQH4mebudFnpyJnmWKOxOHdealXEyLbZ+rSzhtEjvbYBetVzSOwTBdnhunogoYAvMP626gpvtqzIBZlc1yyWjPWizMlxDX+6w3O+XGLkdkclStWM/7JoKtEJHWSTpOd1HM2nvsJbR0k2ZpFSCv0HuC2Wpgyi5ANZp8nJps4FLBqLJcdvYwHzw2uDhsra7jz5+Kx9wRQMflyNSlIZdZmzTu3THBu6wh6SVdNs1xia73SXVuxJTEpIv97IpUtx07OoIFTRDjoUuSRwdQr/7kCAxDu62e4N6FuGA3YHnh90//0gBbu2sjHUETQcd3uurtNOqOIf3kmEEX/LTAFWzOkXnr1mtVlwVL94PFR3/ai5Nvz6zW+5NFggEsJRBKXOov18k1q3HMpJOmOTmSEuT6IkeGsFk/tc5Rks1Mj+Ja4nurQNO7DzqVetTGDhpqCgYc34ah+JweMEXN/Umxs8RsE/Si2tLDhoR+dnoSGzcjVM70oNExeBIlsPp7WisoEIE4Zp/AdRNHmmytonYE/Mx/Wf+o5XlTn1m3dPPuNxVRjTfxtuCKaVpo6LL1PRe7JG3+UZwRNnk2AIXP/MO/LHWtFsR3ZsIyQ0q24ruGVW30W8tzteps3lI28MvbOF4EgkWdLD2hvAk+5dqoLDoqLSkafYxxFYHdYwWyMYi3iPgbsPlzUKYv1eCga6brfIMxtemaVvVRYVCKnFzkdFu8QqDLUTewBlit5X1kwuE0aS9UDJjVVigZ7vzEHsJYqjGi5zcQUJR/YBkq9P468IAnuIzoHhXPtLamkenIfRbqF6+VIAX5UM8DRhrgSSB6gXRvXb8nW6hB+aYm5hdI+Q6B2Ze1TeaYu95KEoCLhjkxFX4bh4emzmAiiZkxYOlwljd2N4Q9RNstD8s9YH1OUEsGcRqAIzh/Trgc4nOSNdks7Obq3zhVqoqon1pj3BioLpkSFlA46yWnpsD5O+9Y7bfYgkmKO3+6H6qHevAmjkAdufF0HSWhiGgtMNsZA5yWDD8WybZFnS9tocCH87l1Iq/kjns1C8v6omebB2DDcKN6cKFd/vO7vV2/qTSMnoTbIGToKYKEJLxaefiuE90utzybtz1AD8oHTAdSmXLV//yvVSKXOaZFCoLZmpBYafQ/Ej8vZst6jHWVB8qeEvm0cFZmQ/bo+MhEYjiBStYVFchk93OuvRJTltbonBMP4eo7wvwSpXFOrf5t9ONwF+h0O0iQGYS3Sm5+Uru5OIoehzrAod8ZonQ7gwJ14Vm3Jo2jkUgzVCxfS7RyoLBAeeHx4CrJVvSJ1gojR3YA/tRBeNX92uCDnU53YG27nxlS9JsOZLLV6fRXezfxNz7+Ea9emrj7xylDSJ7MW/ff9zM9VrcQLBWWPjq5Rj34PxYrCeZoUmKZ9z8UPy5iS3oMDkkC5TeJfFo0/1JzzjgqcY0nRkZ7CwukqI9EnFohYthzzFMS6HVvenWqzZ0aCo5NC2zvSa4REiqZd7Eze3R0ZCyxbbL+KsNkv7bXY9C0RghuKTSHqdEWT+Xtc1q5q2OFTc/R1U5eEhB9jN4k0BvWIPxD6Dhji0irALVmo2uL4G5l5P2hPhGehkdQKM13WRuYFjSSDsCMaV/RqBGyhHsOWnNMvnT2w5yp31EFHkd+Kkt/jWvcajIYzcTdHZkaOB9z+aDynPbMVNnClzftrbo2qk1Meek2be4fGMrf0S8daKCPte+YyLNWz+RJH1LtmEj5ZT3QWsLPdhv6estki7cgabQPxmIetAZdfFz4uGS1qPwrBH2+BH2rPdk9AJ3ZSfcEu/3BZMlhRrfSdXTsl6dFmJ4kE2wh54RI8HAv3vo0K/SbuasVQlotNFB67gtOE4E1OzOYzaeEWCPh7vi7XvfI0hKCN/q2YzCzNvLbp/CSHoktcwFwxh3Z2gqEbigYW3e2+p7FYLnxrxmA8pS0h3zAVJkpp6oTtysppskeKJbqzJIGJCm0LW38gugNkqXpTdt8XjjL+kFbm2OrCHQpagAWjZXDbIliM3wym7KCnMmrBbrXMPE16XRHQAw5WD9ucfBOrQqfPxHhna0AY1kthkCKY5qj9vkmS5rptPjvy8/8kR6YWlXxtnDwJc8UsQg6XOSY3WhaDFHvwB44esSYMs1Oi0P0FurH4jpJ8KmxLs+JBgGMKJSfLG3FHPBD9HRhpQhq8i56lgx0hyCxw6z1CSNAUwvQs55Old7iNOSWQMt+bQWeeAfq/0HKKai5JABM201cxyNWy+T3FN53/hsKAS71fqxPVrt9epAaLC6ArumRX9KsE8O5LLNKi5LCJ4f8tSQJUyVXm+q549xaaTTZMejIMuHodJWW/zqTqb8qonTV6h5791/8CEcxYB8RPz9OC11wvqn1pW5I2YVEzJiQnQEF/8YFFsL0JvyKRVg2/ztJnhk/z1joHogU1Pj2n4yBBl7f/vWkh/C9OUd82TqPLuDvHqS2ni8lY5zoI9qSXVhQzwtIMCpQ9ha+wtEFvzX/iY68be0R56Sd5Xs+UuNKWdrjsWRpNJHhoGXRTApGZ/S5e5/TZjKlzA7BmsVjFbBsRsi3VSuouKsfrgNfVuIDzE+BQyr88opNKYYwzr55yNwk1dSNXl+Yxx9f/g34x6UlGDBcBa0Pa1LnlVQgg/CYgMvOe8riNFAuW/IJnaMcaD2AVuGO9AVi49Lk0xTrGVEfSRY1hYJxfEUnxIoSSauFB5Re/JjF6QAQX59CcbQEqCeMKmROObZLiTeea3C3dUhkhxW+M+Jaop3pJQCu3t8HEJWUFisD02Ef1f1x7UZO5n1hrkJH6YJ6xH/fK1WrlOw6WsJ2Pj7aCk2Lan1GnUa1/POSauA8opSN4cxlLFFrDM1cdiHJKMaLt0+h1K8HHDZHBOoOG1Akr3WGK64qjFkRaNiyksrQhILSxXPh7fIomojGYcOO34le2q6azY6EWWmh8SQHNbtL0SXMo0jZeDayjX3RSXjo2LMO8Go7D5dmqRhk7GzG1pWBCdbBEhezv2yDW6a5/Oajqew+RyHmDwJtFFUo7aMl+Nm39QWNFEdnp45wWjyYNEWooO3ofsc27/TuQFxzytqPvRUVXC5rSojg3BVOATVP/qkRTs02oUEOQYPSixscxj35J07wMhdIefJPiiSjCKZkKlwMYOnU1zOWzd77ptw2ccOQI+VG7fMCnbHeNH0slA9B9sL1EiRmJjBmA5azScyrWdUgTQHZsyR9U3p3KlfFUEBuMMdHwpzj6ojOO4fMyYQD3j4W/BHckSzLM3omooWTzmF3Q23f+riOKJ8hAH6Ge3du96VuhFlxlr1FUtuv2IGkcVnThi8p/dvzFdOARqW4X2by3DaVOuKTveQZ/+t9T99Zuc5aW4jpQaS124dORHeEwM/h5vzke5LFqlLpMLjgJd159zfKtVRH2zpngSAScVo4BxcqDz18cMG+Ko9LisfvuoF8kblW0rUgtzzyDqDDDE+K9nzfweRuV7RozvnZ3Q7ZpOEoXNssTKeJtBi7cJoTE8H51fiYbq7JtAXNKPhBzO+4aXAGTkhZyrge1VfrAOX2A9MrXji6w9oq4+/osdWJchbfHti47N6iAPBbA2vRSmODP703tdiLsdLu5jWq7X2GFWx6mSn9rrGvYaS2wANHIb7I7MARRcwbCwNvE0F5jRyhUOMkIdHC7qPHYaGW4fRX6Q9WlVB6gbOgvkl54+UDtmMN93sl3lj7pfwFoyyx5u0clF4wMYm/JKxvXguO7bRpToiBRy7ku0UE487W7joKwbmrTHL4HejKO8Z834D/w0r/uO8uOYHIA3CtR65K7hl/fmlRxZ1wvIKYYEIoOdyK96UuhF9lzELrjECpS/G8PwXMle0FhC8JWizFScA3XqYdaNxOGxjARbrde4LiFO06BwEfYxZgRnSYnvLYZjSY4wXPUYczdnKrRl5AFfzcSb1DIoPFaIKMKRFpKPBdguldpZEM2LVJzgp3rbSGN18qV7NEWsAuHeHkFFaIMluEPAwnFXfk4c08E+K+EPVdp5GM+sxsJpND3CJgtpymmOubYQPwI8kOgaaVPn0wP59dRH9hr83yT4b0Yovk478g9Q5PrX4QCN3Rk6jQvqe1q7ZciKGN1f0KsPSGvkDLvB6H+1P+A3TpjodQUm8UjBsqIU7iwHmhNzLXqrI1ITFc42zisIKnWImd0XGvRLGs5aaAMSiIqdUSXc4NPGeJ8abN4fWXytUMURbr69o1omjOJmRNPBuigdH+a6tkMZNNv2UZtzdB5BRN6vP9PLjfPG1Omw1mUiiD+aRV5vxUIJ8tUlXkmL2bDlQcbDr/uczZQzkTqMQxUFQgYZJ09+48VrCvkvOX+bq64eQU5xcMcHJWRdLmQ549rKtgubJQQdTILJhHjAlL5BLkXHnxazRuj9RkC4cJtPaHtQeCDq9THtPnNW6Ucx0efd1JslGiVAFceJTfsTdmBSdWDWLrimyOBJPNN5KFWygqAGeIXKVZM/W6JYMgsXsC9N768J6gly4wQ+8IRuqJXnWz7gJoZydcBupaXnhOQZsvuY16Le4BcsUSWHa0t0U/kOfsutRBg1YCIqZsIO5WNoCuunIhwPVMkvz8zt2hk7kfmydg/VToHjnvRnQk7yaItgdX1udWs5NqGfZJu/nRIHOraz54yhSkOjGfKj1cxVHCMhMorxNRt96W1rHHCqxNXJ7KlOx6JHuxOPjVmFGTEWSCkB8U9xcPujL8pw8+OlHj5WUBjcgxtO0LERXNZOsghR39CJsXgvMMryCMkrjxg6fu5V5/p65ACkeaa/TO3RdmdvIop6ycPTrywWfQ6ou8ZGZCNBZ6DFPoTQJDPGrIzBbHcRLUZ1u+jOPGxyDDyDuBKsMG2ztJwZfM8bgiRUIO5359qEdCaM2eTEJxW5kbGo5aQuvLL5hwSzKjzwNMwdrbbHTDeFZyTxhW2PVQUn2j3uHNEMslaAfYJ9d8ymUjmnSrBfQsgQP0U1VSl6/1Vf80ESR2YyNnQxANrb1cKrbkFMDlXdfYd21iYY7I8VyYkJyqjrDzQ+APAn/weq1k1Gak0skMoDWsWZM9Rm+DiCbZakiVdIFwLlPhR8mZFZha1befcx5eWoxuvafTcDBS2XpPdgdQbfQUBWptnz5dnkfDiTikjJlF7GhZHCTq5n2JhVX90XSQhyfHLoM9s54tuGl5o6fAZ7dUWuceHO7wNJKSQXKE7daHZQqCXXpBq+04F9/cUW4oQZNm/6MJnzoc9QwA4yBxjYoiCfGsoemqD8Zz4qGoFwKIRtB09zqcxPnHosHgQLxTlfxtT9TSUWlo7YZm98bVxXTS+r2zo4m/GwQ9p281noQNt/eC1EQmlZlh75UnaXjNl8xJF10NtHuL0ww0O/bZqbsoj0Qf1g3xmCndRhwD8ZRyoo9iwZNSJb42CkYX/HR/f+kP0Ck1uqKCDYh0J9ZaiTc2GHigcPoCDUOUqHy1EvnJmF9DkKnvoz2P0aK2BlFzjf6pQ68Luckm5rKo1hkQeYGcz43yGFEyJ2fJC+89QFT7ojUWqSRS7SvinIa6+DeiiLVGACXrnjx7QuMQEOarQnCO2XUUKuvPx9VKG01kndCxZSnx6tALEmXmOZcpS6H+RBREJuwi2uS8IVHL2/WR8ix6bjWBxfBfCYMft+aXXt1RHS3NovvRHgB03EsgfG66cGm0/fsVy7o8lb/uvx9geixuXs+F829eHAP3LBtGMLXEXS2Mpdvz/Myw898rZNAacSxJjARb9uNLD57MwkcMaeM4S1IPLAflp90KTm336hhnZMBrZVMhwW++wOZPzW6zHUOEn8D0UERK4y0bcGoM2GBngDgWWZzS1gwq6he1fOXKX43NrgWpkJdq73K6slnn4o7DEOgs0k58BeICMpcPvqx1g5jziu36XzHOVHmNaMaewM8oweycqJMe7SxBD0Zuuhax2ENCe2k+qFXXKwkG1B5UHH+Jgspq1lKiAX+CWQkQEfEndF/ZGQQp/q8bj0hlQfJ+Dju5sk4mImKj33bvQEF92lCAGlCouyL4X8PG9y0NWe8q8OG1fEPCAAJIg/MKc37CCRmWHJ8LRvgeOlAGNuXyaU6fzb7dYs7o6MRgIVWu++s0Qc5yT1EPhpiM+s26qb7+qdosuTzH11srj1B4VIJd7eUqyRh8sDXOtwNun2LmIDJxwUK1WufM4Q9XsD6UX8guLTyvkkok6ATgAIks8UcZed5ssdGK+VF+ARNgHzE7jBPzcxv7Pefzn89iRYALABCJXeJqB42w1GGI5r+EN5GSfRCgz6Fy9KjZ1qjcrAars2WeY4ggwwoQXec4xjdZEeD0cOYJ+BYAAO2gZIACwk5lYBdIxZpvQwn9kI4/Fuiob7s1fppI/zPhqh87AcgGlOIpagGazsodXMe1xAmB9sAAgL1p4KW4P6lfJgO6YLAOMNaKNI7Nj+2pc9TDRilswr+xTXFOuk969dKfxNO8rKBBPFyoLnQu7JB+tTuVXWr/pcNXV/THHa86iRVbuirMu12Huh53C6uirA9th7Z7Po0vxJfib2f2ZF1f1CdrKOv+4V+zryv+q/hNzi0l/XMiOR/lpBeeZ/5fvFVVn/xQNVYp+X8yob8AnP8LwAa1nrX6F+oLPdZBq2q6uv6uQWhKLTXWbquryOPGFppPS2bov6jfsBMsq06QPSn/qHyR9JbExg5KpktN11dSD7hjbge1mTrj6vWy/fnzc+uq4uqJDd3G5EZCzrcVT+X8+uB6Ws6cC4Fryed/Kk2W7EPeTq04Vq4WVnC3ctUcQq+mrQV6ohyfDHL2NjNt/Eea1zs8DP91tOmXC5Kvjn/8oLgBJ/7VmQdwLGs6pFbY5L9//71Jl6+8b5GkqlhD3wJm/gLypdCxAUiZFRdc/ueysEE5fv1CvCJmMLwuOn3YBW40mKtHxOVTPZ8NdQPOCSFhNjQo6rIL6lNqESGldbvE09Q37ATeYpd552tUNMofBbB8g+0EUfNVhOBQI4zpZBWRKlY2gg2byBKOpcW8VhEk9iVCqF5GmIV/VUQaUclhHjHaOB9xFsa6iEdMHpEQT6CASIw+RB5JnHL6SEkL0Ye/oXIqHv4JsPwn0R549xeAvY3dd6f9/Sm5lISkvNjCUjLV+SaeqQtnZYjEWbotJfGOzRUGktZduaG6YmH0zdomWSXXKUnJarYNV77QvhtmcHx/DKI7WRAsdV0OXBnEGByusjSBL/tptnOXEGsTrX/aR2zFZSCJkTAD4oQspuC0sX6UaWXSdAd3nzaU8vxymQ5RYeGuANsiN0HO6D7C/YsWMdj7MR2QEQ0BDXaewJ5qHwFUhSJElxmULC/DdJDlTmECdCLWBKTxB2AbipZW4EBgOENWVRkvm7KNq8x6ykHQwFYumDYsXwbbzuQF/bMdTQVUNwqBACId10xiQil4WLlw2Iqgpn53/woUlU+XsE3DCJygiZYHnFQXb9s2MI22Jc7BZuEBLf/3iYAFA5rG9AM9uWnwGvmJd5kVQU82mRYJZgXTmpxICD0jOhEocsjIOz677C1tvx2ptyXbgQt1p2IAbaQmLtnW/huY0DRlGHhwTvOvIdK9eZgSjqGv9wJf5Dz+0tnjZicAMyhkSozj4Je+97O+i90DkmId1jGNFeAiQbwyjfspjIuDE9vxHOnKqBLtEBgMmzgwgp/4jqvlZlJScO0EohUSabKJPEdFxtkLWEFGEKKOydkJDMzWEwWStXh18tYLhZQSRkGyB+JLEhnOYo2bMnhtRpn91568vQeRH7Z7Go0PZ5c7hwVwJ2bbzn3SehQyBBQAN1Yy85ANxZic7BIgDNmHivyhhhRO3ooTsGVUyXQKgyo0bMIVkyItYfQmmYei6qo9ICU0aASMO700HF6OGGX0g+NZDOTXA4CBT2R8VrrW50usgV4d9miCwPyop6G1potA62xykTVg3DT2hHuHqeYoq6DXgrihVut4mXVIwCu5z/pYh/k+YFAKmpWKPJU89LBCgFzImO7JdFbSFIBzAJyqD52vUHS/GhCtcnJDUFClxQAsIWIlHVbQx0gxxewLByxq4czYLJFTbquMZnN7l8SsCJrseL7UKbcVQ7QTXMGwmgYG0TVMVBfFC8DIFxb6ytTGfg6HpgeagOvvO/kgs+tHsSuDNj18/DYAPIGFIAVQQK7yU1IRHWVAXnXTmczi+sdrjJCgMI/ooSLtui0gkpsfvYaI1wQOTUlDr+ppzcevviQEu6MCKp7ie1ZnISMAAA==";
-var WATER = 0;
+var WATER2 = 0;
 var LEAF = 1;
 var FLOWER = 2;
 var WEED = 3;
@@ -207,11 +2612,11 @@ var RAMPS = [
   ["\u4E36", "\u70B9", "\u840D", "\u85FB"]
 ];
 var LOOSE = "\u9CA4\u9CDE\u9CCD\u5C3E\uFF5E";
-var SPINE = 5;
+var SPINE2 = 5;
 var LEAF_INK = 1.8;
 var KOI_SIZE = 1.35;
 var KOI_COLORS = [ZHU, INK, ZHU, ZHE, ZHU, INK];
-var angleTo = (from, to) => {
+var angleTo3 = (from, to) => {
   let d = to - from;
   while (d > Math.PI)
     d -= Math.PI * 2;
@@ -283,7 +2688,7 @@ var createLotus = (levels = DEFAULT_LEVELS) => {
           if (d > 1.05)
             continue;
           const a = Math.atan2(dy, dx);
-          if (d > 0.18 && Math.abs(angleTo(a, notch)) < 0.16)
+          if (d > 0.18 && Math.abs(angleTo3(a, notch)) < 0.16)
             continue;
           const vein = d > 0.2 && d < 0.88 ? smoothstep(0.9, 0.99, Math.cos((a + twist) * veins)) : 0;
           const rimInk = Math.exp(-(((d - 0.88) / 0.1) ** 2));
@@ -326,7 +2731,7 @@ var createLotus = (levels = DEFAULT_LEVELS) => {
     }
     for (let y = 0; y < rows; y++) {
       for (let x = 0, i = y * cols; x < cols; x++, i++) {
-        if (kinds[i] !== WATER)
+        if (kinds[i] !== WATER2)
           continue;
         const f = fbm(x * 0.21 + 50, y * 0.27);
         if (f < 0.7)
@@ -367,7 +2772,7 @@ var createLotus = (levels = DEFAULT_LEVELS) => {
     const gap = cell * 0.7 * fish.size;
     fish.x = x;
     fish.y = y;
-    fish.spine = Array.from({ length: SPINE }, (_, j) => ({
+    fish.spine = Array.from({ length: SPINE2 }, (_, j) => ({
       x: x - Math.cos(fish.heading) * gap * j,
       y: y - Math.sin(fish.heading) * gap * j
     }));
@@ -404,7 +2809,7 @@ var createLotus = (levels = DEFAULT_LEVELS) => {
     if (food) {
       const dist = Math.hypot(food.x - fish.x, food.y - fish.y);
       if (dist > cell * 2.5) {
-        turn += angleTo(fish.heading, Math.atan2(food.y - fish.y, food.x - fish.x)) * 2.4;
+        turn += angleTo3(fish.heading, Math.atan2(food.y - fish.y, food.x - fish.x)) * 2.4;
         target = 46;
       } else
         target = 14;
@@ -421,7 +2826,7 @@ var createLotus = (levels = DEFAULT_LEVELS) => {
       const dist = Math.hypot(p.x - fish.x, p.y - fish.y);
       if (dist < cell * 7) {
         fish.fright = 1;
-        turn += angleTo(fish.heading, Math.atan2(fish.y - p.y, fish.x - p.x)) * 4;
+        turn += angleTo3(fish.heading, Math.atan2(fish.y - p.y, fish.x - p.x)) * 4;
       }
     }
     fish.fright = Math.max(0, fish.fright - dt * 0.8);
@@ -472,11 +2877,11 @@ var createLotus = (levels = DEFAULT_LEVELS) => {
       }
       for (let y = 0; y < rows; y++) {
         for (let x = 0, i = y * cols; x < cols; x++, i++) {
-          const k = kinds[i] ?? WATER;
+          const k = kinds[i] ?? WATER2;
           grid.kind[i] = k;
           grid.pigment[i] = pigments[i] ?? INK;
           grid.wet[i] = k === LEAF || k === FLOWER ? 0.5 : 1;
-          grid.ground[i] = k === WATER ? sheen.at(x, y) : base[i] ?? 0;
+          grid.ground[i] = k === WATER2 ? sheen.at(x, y) : base[i] ?? 0;
         }
       }
     },
@@ -543,7 +2948,7 @@ var createLotus = (levels = DEFAULT_LEVELS) => {
 // node_modules/inkpond/dist/scenes/qingming.js
 var QINGMING_FONT_FAMILY = "Inkpond Glyphs Qingming";
 var QINGMING_FONT_URL = "data:font/woff2;base64,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";
-var WATER2 = 0;
+var WATER3 = 0;
 var LAND = 1;
 var ROOF = 2;
 var WALL = 3;
@@ -643,7 +3048,7 @@ var createQingming = (levels = DEFAULT_LEVELS) => {
       return;
     const i = y * W + wrap(Math.round(x), W);
     const ink = kind === LAND ? v : v * INK_WEIGHT;
-    if (ink < (base[i] ?? 0) && kinds[i] !== LAND && kinds[i] !== WATER2) {
+    if (ink < (base[i] ?? 0) && kinds[i] !== LAND && kinds[i] !== WATER3) {
       return;
     }
     base[i] = ink;
@@ -774,7 +3179,7 @@ var createQingming = (levels = DEFAULT_LEVELS) => {
       for (let y = 0; y < rows; y++) {
         const i = y * W + x;
         if (y >= top && y <= bottom) {
-          kinds[i] = WATER2;
+          kinds[i] = WATER3;
           continue;
         }
         if (y < rows * 0.3) {
@@ -926,7 +3331,7 @@ var createQingming = (levels = DEFAULT_LEVELS) => {
     }
     fixtures.sort((a, b) => a.x - b.x);
   };
-  const spawn = (width) => {
+  const spawn2 = (width) => {
     const rand = rng(W * 7 + rows * 13);
     boats = Array.from({ length: Math.max(6, Math.round(W / 26)) }, (_, id) => ({
       big: rand() < 0.6,
@@ -1011,10 +3416,10 @@ var createQingming = (levels = DEFAULT_LEVELS) => {
         for (let x = 0, i = y * cols; x < cols; x++, i++) {
           const wx = wrap(x + offset, W);
           const j = y * W + wx;
-          const k = kinds[j] ?? WATER2;
+          const k = kinds[j] ?? WATER3;
           grid.kind[i] = k;
           grid.pigment[i] = pigments[j] ?? INK;
-          if (k === WATER2) {
+          if (k === WATER3) {
             grid.wet[i] = 1;
             grid.ground[i] = smoothstep(0.62, 0.86, fbmTiled(wx / W * P * 3 - flow, y * 0.55, P * 3)) * 0.34;
           } else {
@@ -1031,7 +3436,7 @@ var createQingming = (levels = DEFAULT_LEVELS) => {
       cell = view.cell;
       haze = coarseField(cols, rows);
       layoutWorld();
-      spawn(view.width);
+      spawn2(view.width);
     },
     stamps(env, emit) {
       const span = W * cell;
@@ -1267,8 +3672,12 @@ var createShanshui = (levels = DEFAULT_LEVELS) => {
 };
 
 // node_modules/inkpond/dist/scenes/index.js
-var createScene = (name2 = "shanshui", levels) => {
+var createScene = (name2 = "shanshui", levels, jieqi) => {
   switch (name2) {
+    case "beiming":
+      return createBeiming(levels);
+    case "jieqi":
+      return createJieqi(jieqi);
     case "lotus":
       return createLotus(levels);
     case "qingming":
@@ -1347,7 +3756,7 @@ var InkPondEngine = class {
   constructor(canvas, options = {}) {
     this.canvas = canvas;
     this.ctx = canvas?.getContext("2d") ?? null;
-    this.scene = createScene(options.scene, options.levels?.length ? options.levels : void 0);
+    this.scene = createScene(options.scene, options.levels?.length ? options.levels : void 0, { date: options.date, term: options.term });
     this.strength = options.strength ?? 0.45;
     this.c2 = Math.min(0.24, WAVE_C2 * (options.waveSpeed ?? 1) ** 2);
     this.avoidPad = options.avoidPadding ?? 20;
@@ -1812,6 +4221,15 @@ var TIERS = [
   { cell: 22, dprCap: 1.25, fps: 0 }
 ];
 var STILL_TIER = TIERS.length - 1;
+var MIN_CELL = 12;
+var MAX_CELL = 48;
+var cellFor = (tier, requested) => {
+  const own = TIERS[tier]?.cell ?? TIERS[0]?.cell ?? 16;
+  if (requested === void 0 || !Number.isFinite(requested))
+    return own;
+  const asked = Math.min(MAX_CELL, Math.max(MIN_CELL, requested));
+  return tier === 0 ? asked : Math.max(asked, own);
+};
 var BUDGET_MS = 8;
 var WINDOW = 60;
 var RECENT = 10;
@@ -2013,7 +4431,7 @@ var createInkPond = (canvas, options = {}) => {
     if (!t)
       return;
     const dpr = Math.min(window.devicePixelRatio || 1, t.dprCap);
-    engine.resize(rect.width, rect.height, dpr, t.cell);
+    engine.resize(rect.width, rect.height, dpr, cellFor(tier, options.cellSize));
     syncAvoid(true);
   };
   const paintOnce = () => {
@@ -2369,7 +4787,9 @@ function createSettings(store) {
                 children: [
                   /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "lotus", children: t("\u83B2\u6C60", "Lotus pond") }),
                   /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "shanshui", children: t("\u5C71\u6C34", "Misty hills") }),
-                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "qingming", children: t("\u6E05\u660E\u4E0A\u6CB3", "Qingming handscroll") })
+                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "qingming", children: t("\u6E05\u660E\u4E0A\u6CB3", "Qingming handscroll") }),
+                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "jieqi", children: t("\u4E8C\u5341\u56DB\u8282\u6C14", "24 solar terms") }),
+                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "beiming", children: t("\u5317\u51A5", "Northern sea") })
                 ]
               }
             )