moshcode 0.40.0 → 0.42.0

package/src/games-kong.mjs

@@ -0,0 +1,191 @@
+// Kong. Girders, ladders, barrels, and a climb you have done before.
+//
+// The girders here are flat. The originals slope, and a slope is the one thing
+// this board cannot honestly draw — a terminal row is a terminal row, and faking
+// it with half-blocks would make a game that looks like the arcade and plays
+// like a bug report. What the slope actually *does* is kept: each girder has a
+// direction, they alternate, and the ladder down sits at the far end of each
+// one. So barrels cross a whole girder and drop, and a player climbing the same
+// ladders walks every girder the opposite way — which is why you meet them head
+// on instead of following them around.
+import { acid, amber, ash, bone, danger, rgb } from "./ui.mjs";
+
+export const WIDTH = 34;
+export const HEIGHT = 17;
+
+/**
+ * Top to bottom: the row, the way barrels roll along it, the column of the
+ * ladder barrels come down, and a second ladder that only you use.
+ *
+ * The second one is not decoration. With a single ladder per girder, the only
+ * way up is the chute the barrels fall down, and climbing it is a coin toss you
+ * cannot jump out of — the board becomes unplayable rather than hard.
+ */
+export const GIRDERS = [
+  { y: 3, dir: -1, ladder: 3, climb: WIDTH - 12 },
+  { y: 6, dir: 1, ladder: WIDTH - 4, climb: 8 },
+  { y: 9, dir: -1, ladder: 3, climb: WIDTH - 12 },
+  { y: 12, dir: 1, ladder: WIDTH - 4, climb: 8 },
+  { y: 15, dir: -1, ladder: null, climb: null },
+];
+
+export const TOP = GIRDERS[0].y;
+export const FLOOR = GIRDERS[GIRDERS.length - 1].y;
+
+/** Where Kong stands and throws from, and the way out beside him. */
+export const KONG_X = WIDTH - 3;
+const GOAL_X = WIDTH - 6;
+
+const LIVES = 3;
+const JUMP_TICKS = 6;
+const kong = rgb(190, 130, 255);
+
+export const girderAt = (y) => GIRDERS.find((g) => g.y === y) ?? null;
+
+/** The ladders, derived from the girders so the two can never disagree. */
+export const LADDERS = GIRDERS.slice(0, -1).flatMap((g, i) => (
+  [g.ladder, g.climb].map((x) => ({ x, top: g.y, bottom: GIRDERS[i + 1].y, barrels: x === g.ladder }))
+));
+
+export const ladderAt = (x, y) => LADDERS.find((l) => l.x === x && y >= l.top && y <= l.bottom) ?? null;
+
+/** A barrel starts at Kong's end of the top girder and works its way down. */
+export const newBarrel = () => ({ x: KONG_X, y: TOP, falling: null, jumped: false });
+
+/**
+ * One barrel step: along its girder in that girder's direction, and down the
+ * ladder at the end of it. Rolling off the bottom girder is how a barrel leaves.
+ */
+export function rollBarrel(state, barrel) {
+  if (barrel.falling !== null) {
+    barrel.y += 1;
+    if (barrel.y >= barrel.falling) barrel.falling = null;
+    return barrel;
+  }
+  const girder = girderAt(barrel.y);
+  if (!girder) { barrel.done = true; return barrel; }
+  if (girder.ladder !== null && barrel.x === girder.ladder) {
+    // Mostly it takes the ladder; sometimes it carries on and rolls off the end,
+    // which is the only thing that makes two barrels behave differently.
+    if (state.rng() < 0.8) {
+      barrel.falling = GIRDERS[GIRDERS.indexOf(girder) + 1].y;
+      return barrel;
+    }
+  }
+  barrel.x += girder.dir;
+  if (barrel.x < 0 || barrel.x >= WIDTH) barrel.done = true;
+  return barrel;
+}
+
+function lose(state, why) {
+  state.lives--;
+  if (state.lives <= 0) {
+    state.lives = 0;
+    state.over = `${why} · ${state.score} points`;
+    return state;
+  }
+  state.player = { x: 1, y: FLOOR, jump: 0 };
+  state.barrels = [];
+  return state;
+}
+
+/** Barrels roll this often, and a level makes them quicker. */
+export const rollEvery = (state) => Math.max(2, 5 - Math.floor(state.level / 2));
+export const throwEvery = (state) => Math.max(14, 40 - state.level * 5);
+
+/** One tick. Exported so a test can climb the whole board with no clock. */
+export function step(state) {
+  state.clock++;
+  if (state.player.jump > 0) state.player.jump--;
+
+  if (state.clock % rollEvery(state) === 0) {
+    for (const barrel of state.barrels) rollBarrel(state, barrel);
+    state.barrels = state.barrels.filter((b) => !b.done);
+  }
+  if (state.clock % throwEvery(state) === 0) state.barrels.push(newBarrel());
+
+  for (const barrel of state.barrels) {
+    if (barrel.x !== state.player.x || barrel.y !== state.player.y) continue;
+    // A barrel you are in the air over is a barrel you have jumped.
+    if (!state.player.jump) return lose(state, "flattened by a barrel");
+    if (!barrel.jumped) { barrel.jumped = true; state.score += 100; }
+  }
+
+  if (state.player.y === TOP && state.player.x >= GOAL_X) {
+    state.level++;
+    state.score += 1000;
+    state.player = { x: 1, y: FLOOR, jump: 0 };
+    state.barrels = [];
+  }
+  return state;
+}
+
+export const KONG = {
+  key: "kong",
+  aliases: ["dk", "barrels", "climb"],
+  title: "KONG",
+  blurb: "five girders, four ladders, and a barrel with your name on it",
+  keys: "← → walk · ↑ ↓ ladders · space jump · q quit",
+  tickMs: 60,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      player: { x: 1, y: FLOOR, jump: 0 },
+      barrels: [],
+      score: 0,
+      lives: LIVES,
+      level: 1,
+      clock: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    const p = state.player;
+    if (pressed === "space" || pressed === "enter") {
+      if (!p.jump) p.jump = JUMP_TICKS;
+      return state;
+    }
+    if (pressed === "left" && p.x > 0) p.x -= 1;
+    else if (pressed === "right" && p.x < WIDTH - 1) p.x += 1;
+    else if (pressed === "up" || pressed === "down") {
+      // Ladders are the only way between girders, and you have to be standing on
+      // one to use it.
+      const ladder = ladderAt(p.x, p.y);
+      if (!ladder) return state;
+      const next = pressed === "up" ? p.y - 1 : p.y + 1;
+      if (next >= ladder.top && next <= ladder.bottom) p.y = next;
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over
+      ? state.over
+      : `${state.score} · level ${state.level} · ${"▲".repeat(state.lives)}`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const girder of GIRDERS) for (let x = 0; x < WIDTH; x++) put(x, girder.y, ash("═"));
+    for (const ladder of LADDERS) {
+      for (let y = ladder.top; y <= ladder.bottom; y++) put(ladder.x, y, bone("╫"));
+    }
+    put(KONG_X, TOP - 1, kong("♜"));
+    put(GOAL_X, TOP - 1, amber("♥"));
+
+    for (const barrel of state.barrels) put(barrel.x, barrel.y, danger("◍"));
+    const p = state.player;
+    put(p.x, p.jump ? p.y - 1 : p.y, state.over ? danger("✷") : acid(p.jump ? "⌃" : "◉"));
+
+    return grid.map((row) => row.map((cell) => cell ?? " ").join(""));
+  },
+};

package/src/games-outrun.mjs

@@ -0,0 +1,208 @@
+// OutRun. A road drawn in perspective, a clock that is always losing, and a
+// checkpoint that gives you a bit of it back.
+//
+// This is the one game in the cabinet that fakes a third dimension, and it does
+// it the way the eighties did: the road is not an object, it is a rule for
+// drawing each row. Rows near the top are far away, so the tarmac is narrow
+// there and the bend is wide; rows near the bottom are under your bumper, so the
+// tarmac is wide and dead centre. Nothing is ever transformed — `roadHalf` and
+// `centreAt` are the whole renderer, and the same two functions decide what you
+// have hit.
+import { acid, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 48;
+export const HEIGHT = 16;
+
+const NEAR_HALF = 20;   // half the road's width under your bumper
+const FAR_HALF = 3;     // and up at the horizon
+const BEND = 15;        // how far a full-lock corner throws the far end sideways
+
+const MAX_SPEED = 1.9;
+const ACCEL = 0.06;
+const BRAKE = 0.12;
+const DRAG = 0.012;
+const OFF_ROAD = 0.55;  // the fastest you will ever go with two wheels on the grass
+const DRIFT = 0.5;      // how hard a corner pushes you towards the outside
+const START_TIME = 900; // ticks
+const CHECKPOINT = 320; // and how far apart the checkpoints are
+const CHECK_BONUS = 220; // flat out, a checkpoint takes about 170 ticks to reach
+
+const grass = rgb(60, 140, 70);
+const road = rgb(90, 90, 95);
+
+/** How far from the middle the tarmac reaches on a given row. */
+export const roadHalf = (row) => {
+  const p = (row + 1) / HEIGHT;
+  return FAR_HALF + (NEAR_HALF - FAR_HALF) * p ** 1.7;
+};
+
+/**
+ * Where the middle of the road is on a given row.
+ *
+ * The bend is squared against distance so it opens up towards the horizon and
+ * closes to nothing under the car — which is exactly what a corner looks like
+ * from the driver's seat, and why the bottom row never moves.
+ */
+export const centreAt = (row, curve) => {
+  const p = (row + 1) / HEIGHT;
+  return WIDTH / 2 + curve * BEND * (1 - p) ** 2;
+};
+
+export const PLAYER_ROW = HEIGHT - 1;
+export const CAR_W = 3;
+
+/** A stretch of road: how long it runs, and how hard it bends. */
+export function nextSegment(rng) {
+  return { left: 40 + Math.floor(rng() * 60), curve: (rng() * 2 - 1) * (rng() < 0.35 ? 1 : 0.45) };
+}
+
+/** Whether the car is on the tarmac at all. */
+export const onRoad = (x, curve) => Math.abs(x - centreAt(PLAYER_ROW, curve)) <= roadHalf(PLAYER_ROW) - 1;
+
+/** Where a car at depth `z` (1 at the horizon, 0 at your bumper) is drawn. */
+export const rowAt = (z) => Math.round(PLAYER_ROW - z * (PLAYER_ROW - 1));
+
+function spin(state) {
+  state.speed = 0;
+  state.spins++;
+  state.stunned = 30;
+  return state;
+}
+
+/** One tick of road. Exported so a test can drive the whole stage with no clock. */
+export function step(state) {
+  state.clock--;
+  if (state.clock <= 0) {
+    state.clock = 0;
+    state.over = `time up · ${Math.round(state.dist)} miles`;
+    return state;
+  }
+  if (state.stunned > 0) state.stunned--;
+
+  // The road ahead, one segment at a time, eased towards rather than snapped to.
+  state.segment.left -= state.speed;
+  if (state.segment.left <= 0) state.segment = nextSegment(state.rng);
+  state.curve += (state.segment.curve - state.curve) * 0.04;
+
+  state.speed = Math.max(0, state.speed - DRAG);
+  const off = !onRoad(state.car, state.curve);
+  if (off) state.speed = Math.min(state.speed, OFF_ROAD);
+  if (state.stunned) state.speed = Math.min(state.speed, 0.2);
+
+  state.dist += state.speed;
+  // A corner throws you at the outside of it. Steering is how you stay in.
+  state.car += state.curve * state.speed * DRIFT;
+  state.car = Math.max(0, Math.min(WIDTH - 1, state.car));
+
+  for (const car of state.traffic) car.z -= (state.speed - car.speed) * 0.012;
+  state.traffic = state.traffic.filter((c) => c.z > -0.05 && c.z < 1.2);
+  if (state.traffic.length < 3 && state.rng() < 0.03) {
+    state.traffic.push({ z: 1.1, lane: state.rng() * 1.4 - 0.7, speed: 0.35 + state.rng() * 0.5 });
+  }
+
+  if (!state.stunned) {
+    const hit = state.traffic.find((c) => {
+      if (c.z > 0.08) return false;
+      const at = centreAt(PLAYER_ROW, state.curve) + c.lane * roadHalf(PLAYER_ROW);
+      return Math.abs(at - state.car) < CAR_W;
+    });
+    if (hit) {
+      state.traffic = state.traffic.filter((c) => c !== hit);
+      spin(state);
+    }
+  }
+
+  if (state.dist >= state.nextCheck) {
+    state.nextCheck += CHECKPOINT;
+    state.clock += CHECK_BONUS;
+    state.checks++;
+    state.score += 1000;
+  }
+  state.score += Math.floor(state.dist) - state.scored;
+  state.scored = Math.floor(state.dist);
+  return state;
+}
+
+export const OUTRUN = {
+  key: "outrun",
+  aliases: ["run", "coast", "racer"],
+  title: "OUTRUN",
+  blurb: "a road that bends, traffic that doesn't, and a clock that always wins",
+  keys: "← → steer · ↑ throttle · ↓ brake · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    return {
+      car: WIDTH / 2,
+      speed: 0,
+      curve: 0,
+      segment: nextSegment(rng),
+      traffic: [],
+      dist: 0,
+      scored: 0,
+      nextCheck: CHECKPOINT,
+      checks: 0,
+      clock: START_TIME,
+      stunned: 0,
+      spins: 0,
+      score: 0,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, pressed) {
+    if (pressed === "left") state.car -= 0.9;
+    else if (pressed === "right") state.car += 0.9;
+    else if (pressed === "up") state.speed = Math.min(MAX_SPEED, state.speed + ACCEL * 4);
+    else if (pressed === "down") state.speed = Math.max(0, state.speed - BRAKE * 2);
+    state.car = Math.max(0, Math.min(WIDTH - 1, state.car));
+    return state;
+  },
+
+  status(state) {
+    if (state.over) return state.over;
+    const kph = Math.round(state.speed * 120);
+    return `${kph} kph · ${Math.round(state.clock / 20)}s · check ${state.checks} · ${Math.round(state.dist)} mi`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return;
+      grid[y][x] = glyph;
+    };
+
+    for (const car of state.traffic) {
+      const row = rowAt(car.z);
+      if (row < 1 || row > PLAYER_ROW) continue;
+      const at = centreAt(row, state.curve) + car.lane * roadHalf(row);
+      // Cars shrink with distance, the same way the road does.
+      const w = Math.max(1, Math.round(CAR_W * ((row + 1) / HEIGHT)));
+      for (let i = 0; i < w; i++) put(Math.round(at) - Math.floor(w / 2) + i, row, danger("▀"));
+    }
+
+    const nose = state.stunned ? danger("✷") : acid("▟▙");
+    put(Math.round(state.car) - 1, PLAYER_ROW, state.stunned ? nose : acid("▟"));
+    put(Math.round(state.car), PLAYER_ROW, state.stunned ? nose : acid("█"));
+    put(Math.round(state.car) + 1, PLAYER_ROW, state.stunned ? nose : acid("▙"));
+
+    return grid.map((row, y) => {
+      const centre = centreAt(y, state.curve);
+      const half = roadHalf(y);
+      return row.map((cell, x) => {
+        if (cell) return cell;
+        const from = centre - half;
+        const to = centre + half;
+        if (x < from || x > to) return grass("░");
+        // Kerbs, and a centre line that moves with you so the road runs.
+        if (x < from + 1 || x > to - 1) return ((y + Math.floor(state.dist)) % 4 < 2 ? bone : danger)("│");
+        const middle = Math.round(centre);
+        if (x === middle && (y + Math.floor(state.dist * 1.5)) % 4 < 2) return dim("┆");
+        return road(" ");
+      }).join("");
+    });
+  },
+};

package/src/games-pacman.mjs

@@ -0,0 +1,205 @@
+// Pac-Man, arcade-sized. One maze, 240-odd dots, four power pellets and three
+// ghosts that are not quite as clever as the ones in 1980 — on purpose. This is
+// a game you can win on a coffee break.
+import { acid, amber, ash, dim, rgb } from "./ui.mjs";
+
+/**
+ * `#` wall · `.` dot · `o` power pellet · `P` where pac starts · `G` the pen.
+ *
+ * Symmetric, fully connected, and small enough that the whole board fits above
+ * the pit's prompt without scrolling.
+ */
+export const MAZE = [
+  "###################",
+  "#........#........#",
+  "#o##.###.#.###.##o#",
+  "#.................#",
+  "#.##.#.#####.#.##.#",
+  "#....#...G...#....#",
+  "####.##.###.##.####",
+  "#........P........#",
+  "#.##.####.####.##.#",
+  "#o...............o#",
+  "###################",
+];
+
+export const WIDTH = MAZE[0].length;
+export const HEIGHT = MAZE.length;
+
+const WALL = ash("██");
+const DOT = dim("· ");
+const POWER = amber("✳ ");
+const PAC = acid("● ");
+const BLANK = "  ";
+const GHOST_COLORS = [rgb(255, 77, 61), rgb(255, 120, 180), rgb(90, 220, 250)];
+const SCARED = rgb(90, 140, 255);
+
+const DIRS = { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] };
+const OPPOSITE = { up: "down", down: "up", left: "right", right: "left" };
+const FRIGHT_TICKS = 40;
+
+export const isWall = (x, y) => MAZE[y]?.[x] === "#" || MAZE[y]?.[x] === undefined;
+const cellKey = (x, y) => `${x},${y}`;
+const distance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+
+/** Every dot and pellet in the maze, as a fresh map. */
+export function pellets() {
+  const map = new Map();
+  for (let y = 0; y < HEIGHT; y++) {
+    for (let x = 0; x < WIDTH; x++) {
+      const cell = MAZE[y][x];
+      if (cell === "." || cell === "o") map.set(cellKey(x, y), cell);
+    }
+  }
+  return map;
+}
+
+function find(char) {
+  for (let y = 0; y < HEIGHT; y++) {
+    const x = MAZE[y].indexOf(char);
+    if (x >= 0) return { x, y };
+  }
+  return { x: 1, y: 1 };
+}
+
+/** Where everything stands at the start of a life. */
+function positions() {
+  const pen = find("G");
+  const pac = find("P");
+  return {
+    pac: { ...pac, dir: "left", want: "left" },
+    // Three ghosts abreast in the pen — the two beside it are open corridor in
+    // this maze, which is what keeps them from stepping on each other at spawn.
+    ghosts: [
+      { x: pen.x, y: pen.y },
+      { x: pen.x - 1, y: pen.y },
+      { x: pen.x + 1, y: pen.y },
+    ].map((g, i) => ({ ...g, home: { x: g.x, y: g.y }, dir: "up", color: i })),
+  };
+}
+
+/** Directions a ghost may take from where it stands. */
+export function options(ghost, { allowReverse = false } = {}) {
+  const open = Object.entries(DIRS)
+    .filter(([name, [dx, dy]]) => !isWall(ghost.x + dx, ghost.y + dy)
+      && (allowReverse || name !== OPPOSITE[ghost.dir]));
+  // A dead end is the one place reversing is the only move there is.
+  return open.length ? open : Object.entries(DIRS).filter(([, [dx, dy]]) => !isWall(ghost.x + dx, ghost.y + dy));
+}
+
+/**
+ * One ghost step. Chases by Manhattan distance, flees while you are lit up,
+ * and takes a random legal turn one time in five so the three of them do not
+ * arrive in a single-file line.
+ */
+export function moveGhost(ghost, pac, { frightened = false, rng = Math.random } = {}) {
+  const open = options(ghost);
+  if (!open.length) return ghost;
+  const scored = open.map(([name, [dx, dy]]) => ({
+    name,
+    dx,
+    dy,
+    d: distance({ x: ghost.x + dx, y: ghost.y + dy }, pac),
+  }));
+  let choice;
+  if (rng() < 0.2) choice = scored[Math.floor(rng() * scored.length) % scored.length];
+  else {
+    const sorted = scored.slice().sort((a, b) => (frightened ? b.d - a.d : a.d - b.d));
+    choice = sorted[0];
+  }
+  ghost.dir = choice.name;
+  ghost.x += choice.dx;
+  ghost.y += choice.dy;
+  return ghost;
+}
+
+function caught(state) {
+  const hits = state.ghosts.filter((g) => g.x === state.pac.x && g.y === state.pac.y);
+  if (!hits.length) return false;
+  if (state.fright > 0) {
+    for (const g of hits) {
+      state.score += 200;
+      Object.assign(g, { x: g.home.x, y: g.home.y, dir: "up" });
+    }
+    return false;
+  }
+  state.lives--;
+  if (state.lives <= 0) { state.over = "game over"; return true; }
+  Object.assign(state, positions(), { fright: 0 });
+  return true;
+}
+
+export const PACMAN = {
+  key: "pacman",
+  aliases: ["pac", "pacmam", "puckman"],
+  title: "PAC-MAN",
+  blurb: "eat the dots, dodge the ghosts, ✳ makes them edible",
+  keys: "← ↑ ↓ → steer · q quit",
+  tickMs: 150,
+
+  create({ rng = Math.random } = {}) {
+    return { ...positions(), dots: pellets(), score: 0, lives: 3, fright: 0, frame: 0, over: null, rng };
+  },
+
+  tick(state) {
+    state.frame++;
+    const pac = state.pac;
+    // A turn is remembered until it becomes legal, which is what makes a corner
+    // feel like a corner rather than a keypress you have to time.
+    const wanted = DIRS[pac.want];
+    if (wanted && !isWall(pac.x + wanted[0], pac.y + wanted[1])) pac.dir = pac.want;
+    const [dx, dy] = DIRS[pac.dir];
+    if (!isWall(pac.x + dx, pac.y + dy)) { pac.x += dx; pac.y += dy; }
+
+    const here = state.dots.get(cellKey(pac.x, pac.y));
+    if (here) {
+      state.dots.delete(cellKey(pac.x, pac.y));
+      state.score += here === "o" ? 50 : 10;
+      if (here === "o") state.fright = FRIGHT_TICKS;
+    }
+    if (!state.dots.size) { state.over = "maze cleared 🤘"; return state; }
+    if (caught(state)) return state;
+
+    // Ghosts move at half speed, and slower still while they are running away.
+    const beat = state.fright > 0 ? 3 : 2;
+    if (state.frame % beat === 0) {
+      for (const ghost of state.ghosts) {
+        moveGhost(ghost, pac, { frightened: state.fright > 0, rng: state.rng });
+      }
+      caught(state);
+    }
+    if (state.fright > 0) state.fright--;
+    return state;
+  },
+
+  onKey(state, pressed) {
+    if (DIRS[pressed]) state.pac.want = pressed;
+    return state;
+  },
+
+  status(state) {
+    const left = state.dots.size;
+    if (state.over) return `${state.over} · ${state.score} points`;
+    return `score ${state.score} · lives ${"●".repeat(Math.max(0, state.lives))} · dots ${left}`
+      + (state.fright > 0 ? " · RUN" : "");
+  },
+
+  render(state) {
+    const rows = [];
+    for (let y = 0; y < HEIGHT; y++) {
+      let row = "";
+      for (let x = 0; x < WIDTH; x++) {
+        const ghost = state.ghosts.find((g) => g.x === x && g.y === y);
+        if (state.pac.x === x && state.pac.y === y) row += PAC;
+        else if (ghost) row += (state.fright > 0 ? SCARED : GHOST_COLORS[ghost.color])("▲ ");
+        else if (MAZE[y][x] === "#") row += WALL;
+        else {
+          const pellet = state.dots.get(cellKey(x, y));
+          row += pellet === "o" ? POWER : pellet === "." ? DOT : BLANK;
+        }
+      }
+      rows.push(row);
+    }
+    return rows;
+  },
+};