@idle-screens/saver-metaquarium 0.4.1 → 0.5.0

package/dist/{chunk-52CJC2KV.js → chunk-23P73MYY.js}

@@ -107,29 +107,87 @@ function fishVariation(index, variance) {
 }
 var FISH_LENGTH = 18;
 var FORMATION_HALF_WIDTH = 62;
-function formationSlot(index, count, variance, halfWidth = FORMATION_HALF_WIDTH) {
+var FORMATION_SHAPES = ["phalanx", "line", "ring", "wedge", "ball"];
+function formationSlot(index, count, variance, halfWidth = FORMATION_HALF_WIDTH, shape = "phalanx") {
+  const j = 0.35 + 0.65 * Math.max(0, Math.min(1, variance));
+  if (shape === "line") {
+    const FILE = 6;
+    const files = Math.ceil(Math.max(1, count) / FILE);
+    const col2 = Math.floor(index / FILE);
+    const within = index % FILE;
+    const fileLen = Math.min(FILE, count - col2 * FILE);
+    return {
+      side: (col2 - (files - 1) / 2) * FISH_LENGTH * 1.6 + (fishHash(index, 4) - 0.5) * FISH_LENGTH * 0.4 * j,
+      up: (fishHash(index, 5) - 0.5) * FISH_LENGTH * 0.5 * j,
+      back: (within - (fileLen - 1) / 2) * FISH_LENGTH * 1.7
+    };
+  }
+  if (shape === "ring") {
+    const r = Math.max(FISH_LENGTH * 1.6, count * FISH_LENGTH * 1.35 / (Math.PI * 2));
+    const a = index / Math.max(1, count) * Math.PI * 2;
+    return {
+      side: Math.cos(a) * r,
+      up: (fishHash(index, 5) - 0.5) * FISH_LENGTH * 0.6 * j,
+      back: Math.sin(a) * r
+    };
+  }
+  if (shape === "wedge") {
+    const VSIZE = 9;
+    const layers = Math.ceil(Math.max(1, count) / VSIZE);
+    const layer = Math.floor(index / VSIZE);
+    const within = index % VSIZE;
+    const rank = within + 1 >> 1;
+    const wing = within === 0 ? 0 : within % 2 === 1 ? -1 : 1;
+    return {
+      side: wing * rank * FISH_LENGTH * 1.25 + (fishHash(index, 4) - 0.5) * FISH_LENGTH * 0.3 * j,
+      // 1.5 body lengths per layer with a small jitter: adjacent layers seat
+      // the same rank directly above each other, so pitch minus worst-case
+      // jitter closure must clear one body length.
+      up: (layer - (layers - 1) / 2) * FISH_LENGTH * 1.5 + (fishHash(index, 5) - 0.5) * FISH_LENGTH * 0.2 * j,
+      back: (rank - 2) * FISH_LENGTH * 1.35
+    };
+  }
+  if (shape === "ball") {
+    const r = FISH_LENGTH * (1.1 + 0.34 * Math.sqrt(count));
+    const g = (1 + Math.sqrt(5)) / 2;
+    const u = count <= 1 ? 0 : index / (count - 1);
+    const incl = Math.acos(1 - 2 * u);
+    const az = 2 * Math.PI * index / (g * g);
+    return {
+      side: r * Math.sin(incl) * Math.cos(az),
+      // Vertically squashed, hard-capped at 28: the water column is 57 units
+      // and the carrier's y-clamp needs the shell's top inside it whatever
+      // the cast size makes of the radius.
+      up: Math.cos(incl) * Math.min(r * 0.62, 28),
+      back: r * Math.sin(incl) * Math.sin(az)
+    };
+  }
   const cols = Math.max(1, Math.ceil(Math.sqrt(Math.max(1, count))));
   const col = index % cols;
   const row = Math.floor(index / cols);
-  const j = 0.35 + 0.65 * Math.max(0, Math.min(1, variance));
   const span = Math.max(1, cols - 1);
   const pitch = Math.min(FISH_LENGTH * 1.9, halfWidth * 2 / span);
   const jit = pitch * 0.35;
+  const rows = Math.ceil(Math.max(1, count) / cols);
   return {
     side: (col - (cols - 1) / 2) * pitch + (fishHash(index, 4) - 0.5) * jit * j,
     up: (fishHash(index, 5) - 0.5) * FISH_LENGTH * j,
-    back: row * FISH_LENGTH * 1.6 + fishHash(index, 6) * FISH_LENGTH * 0.4 * j
+    // Centred fore-aft like every other shape — a 24-fish lattice trailing
+    // its whole depth behind the carrier pushed the extent past what the
+    // centre-clamp could absorb.
+    back: (row - (rows - 1) / 2) * FISH_LENGTH * 1.6 + fishHash(index, 6) * FISH_LENGTH * 0.4 * j
   };
 }
-function formationExtent(count, variance) {
-  let side = 0, up = 0, back = 0;
+function formationExtent(count, variance, shape = "phalanx") {
+  let side = 0, up = 0, back = 0, reach = 0;
   for (let i = 0; i < count; i += 1) {
-    const s = formationSlot(i, count, variance);
+    const s = formationSlot(i, count, variance, void 0, shape);
     side = Math.max(side, Math.abs(s.side));
     up = Math.max(up, Math.abs(s.up));
     back = Math.max(back, Math.abs(s.back));
+    reach = Math.max(reach, Math.hypot(s.side, s.back));
   }
-  return { side, up, back };
+  return { side, up, back, reach };
 }
 function bandRange(band) {
   switch (band) {
@@ -147,6 +205,225 @@ function bandRange(band) {
   }
 }
 
+// src/plan.ts
+var ARC_SAMPLES = 1024;
+function catmullRom(p0, p1, p2, p3, u) {
+  const u2 = u * u;
+  const u3 = u2 * u;
+  return 0.5 * (2 * p1 + (-p0 + p2) * u + (2 * p0 - 5 * p1 + 4 * p2 - p3) * u2 + (-p0 + 3 * p1 - 3 * p2 + p3) * u3);
+}
+function splineAt(points, g) {
+  const n = points.length;
+  const i = Math.floor(g) % n;
+  const u = g - Math.floor(g);
+  const p0 = points[(i - 1 + n) % n];
+  const p1 = points[i];
+  const p2 = points[(i + 1) % n];
+  const p3 = points[(i + 2) % n];
+  return [
+    catmullRom(p0[0], p1[0], p2[0], p3[0], u),
+    catmullRom(p0[1], p1[1], p2[1], p3[1], u),
+    catmullRom(p0[2], p1[2], p2[2], p3[2], u)
+  ];
+}
+var PATH_SHAPES = ["wander", "orbit", "eight", "helix", "canyon"];
+function shapeWaypoints(shape, rng, bounds) {
+  const points = [];
+  const ySpan = bounds.yMax - bounds.yMin;
+  if (shape === "orbit") {
+    const n2 = 14 + rng.int(0, 4);
+    const r0 = bounds.radius * rng.range(0.45, 0.8);
+    const y0 = bounds.yMin + ySpan * rng.range(0.25, 0.75);
+    const dir = rng.next() < 0.5 ? 1 : -1;
+    for (let i = 0; i < n2; i++) {
+      const a = dir * (i / n2) * Math.PI * 2;
+      const r = r0 * (1 + rng.range(-0.08, 0.08));
+      points.push([Math.cos(a) * r, y0 + ySpan * rng.range(-0.08, 0.08), Math.sin(a) * r]);
+    }
+    return points;
+  }
+  if (shape === "eight") {
+    const n2 = 20 + rng.int(0, 4);
+    const rx = bounds.radius * rng.range(0.6, 0.85);
+    const rz = bounds.radius * rng.range(0.35, 0.55);
+    const y0 = bounds.yMin + ySpan * rng.range(0.3, 0.7);
+    const phase = rng.range(0, Math.PI * 2);
+    for (let i = 0; i < n2; i++) {
+      const u = i / n2 * Math.PI * 2;
+      points.push([
+        Math.sin(u + phase) * rx,
+        y0 + Math.sin(u * 2 + phase) * ySpan * 0.12,
+        Math.sin(u * 2 + phase * 2) * rz
+      ]);
+    }
+    return points;
+  }
+  if (shape === "helix") {
+    const n2 = 24;
+    const r0 = bounds.radius * rng.range(0.35, 0.6);
+    const phase = rng.range(0, Math.PI * 2);
+    for (let i = 0; i < n2; i++) {
+      const u = i / n2;
+      const a = phase + u * Math.PI * 4;
+      const climb = 1 - Math.abs(1 - 2 * u);
+      points.push([
+        Math.cos(a) * r0,
+        bounds.yMin + ySpan * (0.1 + climb * 0.8),
+        Math.sin(a) * r0
+      ]);
+    }
+    return points;
+  }
+  if (shape === "canyon") {
+    const n2 = 16;
+    const axis = rng.range(0, Math.PI);
+    const ax = Math.cos(axis), az = Math.sin(axis);
+    const y0 = bounds.yMin + ySpan * rng.range(0.08, 0.28);
+    const len = bounds.radius * 0.85;
+    const width = bounds.radius * rng.range(0.12, 0.3);
+    for (let i = 0; i < n2; i++) {
+      const u = i / n2 * Math.PI * 2;
+      const along = Math.sin(u) * len;
+      const across = Math.cos(u) * width;
+      points.push([
+        ax * along - az * across,
+        y0 + ySpan * rng.range(0, 0.08),
+        az * along + ax * across
+      ]);
+    }
+    return points;
+  }
+  const n = 16 + rng.int(0, 4);
+  for (let i = 0; i < n; i++) {
+    const baseAngle = i / n * Math.PI * 2;
+    const angle = baseAngle + rng.range(-0.25, 0.25);
+    const inner = i % 2 === 0;
+    const radius = inner ? bounds.radius * rng.range(0.15, 0.45) : bounds.radius * rng.range(0.55, 0.85);
+    const y = bounds.yMin + ySpan * rng.range(0.2, 0.8);
+    points.push([Math.cos(angle) * radius, y, Math.sin(angle) * radius]);
+  }
+  return points;
+}
+function compileSwimPlan(rng, bounds, shape = "wander") {
+  const points = shapeWaypoints(shape, rng, bounds);
+  const n = points.length;
+  const arc = new Float32Array(ARC_SAMPLES + 1);
+  let prev = splineAt(points, 0);
+  let total = 0;
+  for (let s = 1; s <= ARC_SAMPLES; s++) {
+    const g = s / ARC_SAMPLES * n;
+    const p = splineAt(points, g);
+    total += Math.hypot(p[0] - prev[0], p[1] - prev[1], p[2] - prev[2]);
+    arc[s] = total;
+    prev = p;
+  }
+  const cruise = 8 + rng.range(0, 4);
+  const wobble = [
+    { amp: cruise * 0.18, w: 0.11 + rng.range(0, 0.05), phase: rng.range(0, Math.PI * 2) },
+    { amp: cruise * 0.1, w: 0.043 + rng.range(0, 0.02), phase: rng.range(0, Math.PI * 2) }
+  ];
+  return { points, arc, totalLength: total, cruise, wobble };
+}
+function distanceAt(plan, tSec, speed) {
+  let d = plan.cruise * tSec;
+  for (const h of plan.wobble) {
+    d += h.amp / h.w * (Math.cos(h.phase) - Math.cos(h.w * tSec + h.phase));
+  }
+  return d * speed;
+}
+function paramForDistance(plan, dist) {
+  const n = plan.points.length;
+  const d = (dist % plan.totalLength + plan.totalLength) % plan.totalLength;
+  const arc = plan.arc;
+  let lo = 0;
+  let hi = ARC_SAMPLES;
+  while (lo + 1 < hi) {
+    const mid = lo + hi >> 1;
+    if (arc[mid] <= d) lo = mid;
+    else hi = mid;
+  }
+  const seg = arc[hi] - arc[lo] || 1;
+  const frac = (d - arc[lo]) / seg;
+  return (lo + frac) / ARC_SAMPLES * n;
+}
+function swimPoseAtDistance(plan, dist) {
+  const g = paramForDistance(plan, dist);
+  const [x, y, z] = splineAt(plan.points, g);
+  const step = plan.points.length / ARC_SAMPLES * 8;
+  const ahead = splineAt(plan.points, g + step);
+  const behind = splineAt(plan.points, g - step + plan.points.length);
+  let fx = ahead[0] - behind[0];
+  let fy = ahead[1] - behind[1];
+  let fz = ahead[2] - behind[2];
+  const m = Math.hypot(fx, fy, fz) || 1;
+  fx /= m;
+  fy /= m;
+  fz /= m;
+  const h0 = Math.atan2(z - behind[2], x - behind[0]);
+  const h1 = Math.atan2(ahead[2] - z, ahead[0] - x);
+  let turn = h1 - h0;
+  if (turn > Math.PI) turn -= Math.PI * 2;
+  if (turn < -Math.PI) turn += Math.PI * 2;
+  const roll = Math.max(-0.35, Math.min(0.35, turn * 3.5));
+  return { x, y, z, fx, fy, fz, roll, dist };
+}
+
+// src/maneuver.ts
+var MANEUVERS = ["none", "dart", "startle", "graze", "curious", "zoomies"];
+var SPECS = {
+  dart: { name: "dart", dur: 2.4, interval: 14, advance: 4.5, kick: 0.5, lift: 0, flurry: 1.1, bursts: 1 },
+  startle: { name: "startle", dur: 1.8, interval: 18, advance: 1.2, kick: 2.8, lift: 0.4, flurry: 1.3, bursts: 1 },
+  graze: { name: "graze", dur: 5.5, interval: 16, advance: -3.2, kick: 0.6, lift: -0.7, flurry: 0.3, bursts: 1 },
+  curious: { name: "curious", dur: 4, interval: 15, advance: 0.8, kick: 2, lift: 0.2, flurry: 0.5, bursts: 1 },
+  zoomies: { name: "zoomies", dur: 3.2, interval: 20, advance: 7.5, kick: 0.9, lift: 0.15, flurry: 1.5, bursts: 3 }
+};
+function maneuverSpecOf(name) {
+  return Object.hasOwn(SPECS, name) ? SPECS[name] : null;
+}
+var smooth = (u) => u <= 0 ? 0 : u >= 1 ? 1 : u * u * (3 - 2 * u);
+var bump = (u) => {
+  if (u <= 0 || u >= 1) return 0;
+  const b = 4 * u * (1 - u);
+  return b * b;
+};
+function surges(u, bursts) {
+  if (u <= 0) return 0;
+  if (u >= 1) return 1;
+  const x = u * bursts;
+  return (Math.floor(x) + smooth(x - Math.floor(x))) / bursts;
+}
+var IDLE = { along: 0, alongBump: 0, side: 0, up: 0, flurry: 0 };
+function maneuverAt(spec, index, tSec, rate, intensity) {
+  if (!spec || rate <= 0 || intensity <= 0 || tSec < 0) return IDLE;
+  const interval = spec.interval * (3 - 2 * Math.min(1, rate));
+  const k0 = Math.floor(tSec / interval);
+  let along = 0;
+  let side = 0;
+  let up = 0;
+  let flurry = 0;
+  let alongBump = 0;
+  const done = Math.max(0, k0 - 1);
+  along += done * spec.advance * intensity;
+  for (const k of [k0 - 1, k0, k0 + 1]) {
+    if (k < 0) continue;
+    const start = (k + fishHash(index, 11 + k)) * interval;
+    const u = (tSec - start) / spec.dur;
+    if (u <= 0) continue;
+    if (u >= 1) {
+      if (k >= done) along += spec.advance * intensity;
+      continue;
+    }
+    const sign = fishHash(index, 23 + k) < 0.5 ? -1 : 1;
+    const env = bump(u) * intensity;
+    along += spec.advance * surges(u, spec.bursts) * intensity;
+    alongBump += spec.advance * bump(u) * intensity;
+    side += sign * spec.kick * env;
+    up += spec.lift * spec.kick * env;
+    flurry += spec.flurry * env;
+  }
+  return { along, alongBump, side, up, flurry };
+}
+
 // src/asset-cids.ts
 var ASSET_CIDS = [
   "QmZCzKVLJ1MYRzaZEFyuMCVmrPR3urQYMFR9RWerJYpCEr",
@@ -702,14 +979,19 @@ var BREEDS = [
     metadataCid: "QmZTntNpvwxe8Mii7s1XTpTrbaci4ZgYUXs9sEbsBodtaF",
     model: "sea-turtle"
   },
-  { breed: "blowfish", minted: false, count: 0, model: "blow-fish" },
-  { breed: "hackerfish", minted: false, count: 0, model: "hacker-fish" },
-  { breed: "glowfish", minted: false, count: 0, model: "glow-fish" },
-  { breed: "babyfish", minted: false, count: 0, model: "baby-fish" },
-  { breed: "shark", minted: false, count: 0, model: "shark" },
-  { breed: "crab", minted: false, count: 0, model: "crab" },
+  // Unminted: `model` names the CURRENT basename in the original aquarium's
+  // NPC set (versioned there; these are the ones its entity classes load,
+  // except glow-fish, where the app loads the 503 KB glow-fish5 while an
+  // identical-material 30 KB Draco glow-fish4 sits beside it — we take the
+  // small one). All are clip-less and unrigged, so they swim on `bodyWiggle`.
+  { breed: "blowfish", minted: false, count: 0, model: "blow-fish4" },
+  { breed: "hackerfish", minted: false, count: 0, model: "hacker-fish3" },
+  { breed: "glowfish", minted: false, count: 0, model: "glow-fish4" },
+  { breed: "babyfish", minted: false, count: 0, model: "baby-fish2" },
+  { breed: "shark", minted: false, count: 0, model: "shark3" },
+  { breed: "crab", minted: false, count: 0, model: "crab3" },
   { breed: "jellyfish", minted: false, count: 0, model: "jellyfish" },
-  { breed: "dori", minted: false, count: 0, model: "dori" }
+  { breed: "dori", minted: false, count: 0, model: "dori3" }
 ];
 function breedOf(id) {
   if (!isMintedId(id)) return null;
@@ -800,6 +1082,16 @@ var FISH_CATALOG = [
   { id: 497, name: "Fish 497", breed: "seaturtle", ipfs3d: "ipfs://QmTBNvoUiwPw9HSUmy1qKCWPBKkBRAensgooYVqMmsviaE/fish_497_of_the_metaquarium_3d.glb", localGlb: "" }
 ];
 var DEFAULT_FISH = FISH_CATALOG[0];
+var NPC_CATALOG = [
+  { id: 601, name: "Blowfish", breed: "blowfish", ipfs3d: "", localGlb: "/assets/metaquarium/npc-blowfish.glb" },
+  { id: 602, name: "Hackerfish", breed: "hackerfish", ipfs3d: "", localGlb: "/assets/metaquarium/npc-hackerfish.glb" },
+  { id: 603, name: "Glowfish", breed: "glowfish", ipfs3d: "", localGlb: "/assets/metaquarium/npc-glowfish.glb" },
+  { id: 604, name: "Babyfish", breed: "babyfish", ipfs3d: "", localGlb: "/assets/metaquarium/npc-babyfish.glb" },
+  { id: 605, name: "Shark", breed: "shark", ipfs3d: "", localGlb: "/assets/metaquarium/shark3.glb" },
+  { id: 606, name: "Crab", breed: "crab", ipfs3d: "", localGlb: "/assets/metaquarium/npc-crab.glb" },
+  { id: 607, name: "Jellyfish", breed: "jellyfish", ipfs3d: "", localGlb: "/assets/metaquarium/npc-jellyfish.glb" },
+  { id: 608, name: "Dori", breed: "dori", ipfs3d: "", localGlb: "/assets/metaquarium/npc-dori.glb" }
+];
 function parseFishMix(mix, catalog = FISH_CATALOG) {
   const entries = [];
   const problems = [];
@@ -815,16 +1107,22 @@ function parseFishMix(mix, catalog = FISH_CATALOG) {
     let fish = /^\d+$/.test(key) ? catalog.find((f) => f.id === Number(key)) : catalog.find((f) => f.breed.toLowerCase() === key);
     if (!fish && catalog === FISH_CATALOG && /^\d+$/.test(key)) {
       const n = Number(key);
-      const url = fishAsset(n, "3d");
+      const url2 = fishAsset(n, "3d");
       const breed = breedOf(n);
-      if (url && breed) fish = { id: n, name: `Fish ${n}`, breed, ipfs3d: url, localGlb: "" };
+      if (url2 && breed) fish = { id: n, name: `Fish ${n}`, breed, ipfs3d: url2, localGlb: "" };
     }
     if (!fish) {
+      const breeds = [...new Set(catalog.map((f) => f.breed))].join(", ");
       problems.push(
-        /^\d+$/.test(key) ? catalog === FISH_CATALOG ? `"${key}": not a minted token id (1-${TOTAL_SUPPLY})` : `"${key}": not a catalog id` : `"${key}": not a breed (${BREEDS.filter((b) => b.minted).map((b) => b.breed).join(", ")})`
+        /^\d+$/.test(key) ? catalog === FISH_CATALOG ? `"${key}": not a minted token id (1-${TOTAL_SUPPLY})` : `"${key}": not a catalog id` : `"${key}": not a breed (${breeds})`
       );
       continue;
     }
+    const url = fish.ipfs3d;
+    if (!url) {
+      problems.push(`"${key}": model not hosted here (catalog carries no URL for it)`);
+      continue;
+    }
     let count = 1;
     if (countRaw !== void 0) {
       const n = Number(countRaw.trim());
@@ -839,7 +1137,7 @@ function parseFishMix(mix, catalog = FISH_CATALOG) {
         count = n;
       }
     }
-    entries.push({ id: fish.id, url: fish.ipfs3d, count });
+    entries.push({ id: fish.id, url, count });
   }
   return { entries, problems };
 }
@@ -921,10 +1219,30 @@ var METAQUARIUM_PARAMS = {
    *  default changes nothing. A small named set on purpose: a silhouette of
    *  movement you can name is one you can choose from. */
   swimStyle: { type: "enum", default: "loop", options: [...SWIM_STYLE_NAMES], ease: "step" },
+  /** The shape a fish's loop is drawn on. `wander` is the original roaming
+   *  itinerary, so the default changes nothing. `orbit` laps, `eight` crosses
+   *  the middle, `helix` tours the water column, `canyon` sweeps low — same
+   *  spline engine, different itinerary. */
+  pathShape: { type: "enum", default: "wander", options: [...PATH_SHAPES], ease: "step" },
+  /** How a `school` holds together: the original lattice, single file, a
+   *  carousel ring, the migratory V, or a bait-ball. Ignored by every
+   *  non-formation style; the same no-pair-inside-a-body-length law holds
+   *  for all of them. */
+  formationShape: { type: "enum", default: "phalanx", options: [...FORMATION_SHAPES], ease: "step" },
   /** Per-fish spread: 0 a uniform shoal, 1 every fish visibly its own animal
    *  (±40% speed, ±25% size, own phase). The uniqueness dial — one number
    *  instead of per-fish values nobody wants to author. */
   swimVariance: { type: "number", default: 0, min: 0, max: 1, ease: "smooth" },
+  /** Named event layered over the swim style — the thing that turns uniform
+   *  cruising into behaviour a viewer recognizes. Each fish runs its own
+   *  seeded schedule of the chosen event; displacement-based, so frames stay
+   *  addressable. `none` (default) changes nothing. */
+  maneuver: { type: "enum", default: "none", options: [...MANEUVERS], ease: "step" },
+  /** How often events fire: 0 never, 1 the maneuver's own tempo (roughly
+   *  every 14-20s per fish, desynchronised). */
+  maneuverRate: { type: "number", default: 0.5, min: 0, max: 1, ease: "smooth" },
+  /** How hard: scales the surge, the kick, and the tail flurry together. */
+  maneuverIntensity: { type: "number", default: 0.7, min: 0, max: 1, ease: "smooth" },
   /** Procedural body yaw for models that carry NO animation clip — most of
    *  the breed library. Distance-driven like the tail beat, so it speeds up
    *  with the fish and stays frame-addressable. Clipped models ignore it:
@@ -1038,9 +1356,16 @@ export {
   fishHash,
   fishVariation,
   FISH_LENGTH,
+  FORMATION_SHAPES,
   formationSlot,
   formationExtent,
   bandRange,
+  PATH_SHAPES,
+  compileSwimPlan,
+  distanceAt,
+  swimPoseAtDistance,
+  maneuverSpecOf,
+  maneuverAt,
   ASSET_CIDS,
   TOTAL_SUPPLY,
   isMintedId,
@@ -1058,6 +1383,7 @@ export {
   resolveIpfsUrls,
   FISH_CATALOG,
   DEFAULT_FISH,
+  NPC_CATALOG,
   parseFishMix,
   expandFishMix,
   METAQUARIUM_PARAMS,
@@ -1068,4 +1394,4 @@ export {
   paramSpaceWith,
   coerceNum
 };
-//# sourceMappingURL=chunk-52CJC2KV.js.map
+//# sourceMappingURL=chunk-23P73MYY.js.map