Initial Commit

Signed-off-by: Naomi Roberts <[e-mail]>

.envrc

···
+use flake

.gitignore

···
+*.beam
+*.ez
+/build
+erl_crash.dump
+.direnv

README.md

···
+# voyagers_bingo
+
+[![Package Version](https://img.shields.io/hexpm/v/voyagers_bingo)](https://hex.pm/packages/voyagers_bingo)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/voyagers_bingo/)
+
+```sh
+gleam add voyagers_bingo@1
+```
+```gleam
+import voyagers_bingo
+
+pub fn main() -> Nil {
+  // TODO: An example of the project in use
+}
+```
+
+Further documentation can be found at <https://hexdocs.pm/voyagers_bingo>.
+
+## Development
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+```

flake.lock

···
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1754278406,
+        "narHash": "sha256-jvIQTMN5EzoOP5RaGztpVese8a3wqy0M/h6tNzycW28=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "6a489c9482ca676ce23c0bcd7f2e1795383325fa",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

···
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+  };
+
+  outputs = {nixpkgs, ...} @ inputs: let
+    lib = nixpkgs.lib;
+    supportedSystems = ["x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin"];
+    forEachSupportedSystem = f:
+      lib.genAttrs supportedSystems (system:
+        f {
+          pkgs = import nixpkgs {inherit system;};
+        });
+  in {
+    devShells = forEachSupportedSystem ({pkgs}: {
+      default = pkgs.mkShell {
+        packages = with pkgs; [
+          gleam
+          erlang_28
+          beam28Packages.rebar3
+        ];
+      };
+    });
+  };
+}

gleam.toml

···
+name = "voyagers_bingo"
+version = "1.0.0"
+
+# Fill out these fields if you intend to generate HTML documentation or publish
+# your project to the Hex package manager.
+#
+# description = ""
+# licences = ["Apache-2.0"]
+# repository = { type = "github", user = "", repo = "" }
+# links = [{ title = "Website", href = "" }]
+#
+# For a full reference of all the available options, you can have a look at
+# https://gleam.run/writing-gleam/gleam-toml/.
+
+[dependencies]
+gleam_stdlib = ">= 0.44.0 and < 2.0.0"
+
+[dev-dependencies]
+gleeunit = ">= 1.0.0 and < 2.0.0"

manifest.toml

···
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "gleam_stdlib", version = "0.62.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "DC8872BC0B8550F6E22F0F698CFE7F1E4BDA7312FDEB40D6C3F44C5B706C8310" },
+  { name = "gleeunit", version = "1.6.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "FDC68A8C492B1E9B429249062CD9BAC9B5538C6FBF584817205D0998C42E1DAC" },
+]
+
+[requirements]
+gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
+gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

priv/static/voyagers_bingo.mjs

···
+// build/dev/javascript/gleam_stdlib/gleam/bool.mjs
+function guard(requirement, consequence, alternative) {
+  if (requirement) {
+    return consequence;
+  } else {
+    return alternative();
+  }
+}
+function lazy_guard(requirement, consequence, alternative) {
+  if (requirement) {
+    return consequence();
+  } else {
+    return alternative();
+  }
+}
+
+// build/dev/javascript/prelude.mjs
+var CustomType = class {
+  withFields(fields) {
+    let properties = Object.keys(this).map(
+      (label) => label in fields ? fields[label] : this[label]
+    );
+    return new this.constructor(...properties);
+  }
+};
+var List = class {
+  static fromArray(array4, tail) {
+    let t = tail || new Empty();
+    for (let i = array4.length - 1; i >= 0; --i) {
+      t = new NonEmpty(array4[i], t);
+    }
+    return t;
+  }
+  [Symbol.iterator]() {
+    return new ListIterator(this);
+  }
+  toArray() {
+    return [...this];
+  }
+  // @internal
+  atLeastLength(desired) {
+    let current = this;
+    while (desired-- > 0 && current) current = current.tail;
+    return current !== void 0;
+  }
+  // @internal
+  hasLength(desired) {
+    let current = this;
+    while (desired-- > 0 && current) current = current.tail;
+    return desired === -1 && current instanceof Empty;
+  }
+  // @internal
+  countLength() {
+    let current = this;
+    let length4 = 0;
+    while (current) {
+      current = current.tail;
+      length4++;
+    }
+    return length4 - 1;
+  }
+};
+function prepend(element4, tail) {
+  return new NonEmpty(element4, tail);
+}
+function toList(elements, tail) {
+  return List.fromArray(elements, tail);
+}
+var ListIterator = class {
+  #current;
+  constructor(current) {
+    this.#current = current;
+  }
+  next() {
+    if (this.#current instanceof Empty) {
+      return { done: true };
+    } else {
+      let { head, tail } = this.#current;
+      this.#current = tail;
+      return { value: head, done: false };
+    }
+  }
+};
+var Empty = class extends List {
+};
+var NonEmpty = class extends List {
+  constructor(head, tail) {
+    super();
+    this.head = head;
+    this.tail = tail;
+  }
+};
+var BitArray = class {
+  /**
+   * The size in bits of this bit array's data.
+   *
+   * @type {number}
+   */
+  bitSize;
+  /**
+   * The size in bytes of this bit array's data. If this bit array doesn't store
+   * a whole number of bytes then this value is rounded up.
+   *
+   * @type {number}
+   */
+  byteSize;
+  /**
+   * The number of unused high bits in the first byte of this bit array's
+   * buffer prior to the start of its data. The value of any unused high bits is
+   * undefined.
+   *
+   * The bit offset will be in the range 0-7.
+   *
+   * @type {number}
+   */
+  bitOffset;
+  /**
+   * The raw bytes that hold this bit array's data.
+   *
+   * If `bitOffset` is not zero then there are unused high bits in the first
+   * byte of this buffer.
+   *
+   * If `bitOffset + bitSize` is not a multiple of 8 then there are unused low
+   * bits in the last byte of this buffer.
+   *
+   * @type {Uint8Array}
+   */
+  rawBuffer;
+  /**
+   * Constructs a new bit array from a `Uint8Array`, an optional size in
+   * bits, and an optional bit offset.
+   *
+   * If no bit size is specified it is taken as `buffer.length * 8`, i.e. all
+   * bytes in the buffer make up the new bit array's data.
+   *
+   * If no bit offset is specified it defaults to zero, i.e. there are no unused
+   * high bits in the first byte of the buffer.
+   *
+   * @param {Uint8Array} buffer
+   * @param {number} [bitSize]
+   * @param {number} [bitOffset]
+   */
+  constructor(buffer, bitSize, bitOffset) {
+    if (!(buffer instanceof Uint8Array)) {
+      throw globalThis.Error(
+        "BitArray can only be constructed from a Uint8Array"
+      );
+    }
+    this.bitSize = bitSize ?? buffer.length * 8;
+    this.byteSize = Math.trunc((this.bitSize + 7) / 8);
+    this.bitOffset = bitOffset ?? 0;
+    if (this.bitSize < 0) {
+      throw globalThis.Error(`BitArray bit size is invalid: ${this.bitSize}`);
+    }
+    if (this.bitOffset < 0 || this.bitOffset > 7) {
+      throw globalThis.Error(
+        `BitArray bit offset is invalid: ${this.bitOffset}`
+      );
+    }
+    if (buffer.length !== Math.trunc((this.bitOffset + this.bitSize + 7) / 8)) {
+      throw globalThis.Error("BitArray buffer length is invalid");
+    }
+    this.rawBuffer = buffer;
+  }
+  /**
+   * Returns a specific byte in this bit array. If the byte index is out of
+   * range then `undefined` is returned.
+   *
+   * When returning the final byte of a bit array with a bit size that's not a
+   * multiple of 8, the content of the unused low bits are undefined.
+   *
+   * @param {number} index
+   * @returns {number | undefined}
+   */
+  byteAt(index4) {
+    if (index4 < 0 || index4 >= this.byteSize) {
+      return void 0;
+    }
+    return bitArrayByteAt(this.rawBuffer, this.bitOffset, index4);
+  }
+  /** @internal */
+  equals(other) {
+    if (this.bitSize !== other.bitSize) {
+      return false;
+    }
+    const wholeByteCount = Math.trunc(this.bitSize / 8);
+    if (this.bitOffset === 0 && other.bitOffset === 0) {
+      for (let i = 0; i < wholeByteCount; i++) {
+        if (this.rawBuffer[i] !== other.rawBuffer[i]) {
+          return false;
+        }
+      }
+      const trailingBitsCount = this.bitSize % 8;
+      if (trailingBitsCount) {
+        const unusedLowBitCount = 8 - trailingBitsCount;
+        if (this.rawBuffer[wholeByteCount] >> unusedLowBitCount !== other.rawBuffer[wholeByteCount] >> unusedLowBitCount) {
+          return false;
+        }
+      }
+    } else {
+      for (let i = 0; i < wholeByteCount; i++) {
+        const a = bitArrayByteAt(this.rawBuffer, this.bitOffset, i);
+        const b = bitArrayByteAt(other.rawBuffer, other.bitOffset, i);
+        if (a !== b) {
+          return false;
+        }
+      }
+      const trailingBitsCount = this.bitSize % 8;
+      if (trailingBitsCount) {
+        const a = bitArrayByteAt(
+          this.rawBuffer,
+          this.bitOffset,
+          wholeByteCount
+        );
+        const b = bitArrayByteAt(
+          other.rawBuffer,
+          other.bitOffset,
+          wholeByteCount
+        );
+        const unusedLowBitCount = 8 - trailingBitsCount;
+        if (a >> unusedLowBitCount !== b >> unusedLowBitCount) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Returns this bit array's internal buffer.
+   *
+   * @deprecated Use `BitArray.byteAt()` or `BitArray.rawBuffer` instead.
+   *
+   * @returns {Uint8Array}
+   */
+  get buffer() {
+    bitArrayPrintDeprecationWarning(
+      "buffer",
+      "Use BitArray.byteAt() or BitArray.rawBuffer instead"
+    );
+    if (this.bitOffset !== 0 || this.bitSize % 8 !== 0) {
+      throw new globalThis.Error(
+        "BitArray.buffer does not support unaligned bit arrays"
+      );
+    }
+    return this.rawBuffer;
+  }
+  /**
+   * Returns the length in bytes of this bit array's internal buffer.
+   *
+   * @deprecated Use `BitArray.bitSize` or `BitArray.byteSize` instead.
+   *
+   * @returns {number}
+   */
+  get length() {
+    bitArrayPrintDeprecationWarning(
+      "length",
+      "Use BitArray.bitSize or BitArray.byteSize instead"
+    );
+    if (this.bitOffset !== 0 || this.bitSize % 8 !== 0) {
+      throw new globalThis.Error(
+        "BitArray.length does not support unaligned bit arrays"
+      );
+    }
+    return this.rawBuffer.length;
+  }
+};
+function bitArrayByteAt(buffer, bitOffset, index4) {
+  if (bitOffset === 0) {
+    return buffer[index4] ?? 0;
+  } else {
+    const a = buffer[index4] << bitOffset & 255;
+    const b = buffer[index4 + 1] >> 8 - bitOffset;
+    return a | b;
+  }
+}
+var UtfCodepoint = class {
+  constructor(value) {
+    this.value = value;
+  }
+};
+var isBitArrayDeprecationMessagePrinted = {};
+function bitArrayPrintDeprecationWarning(name, message) {
+  if (isBitArrayDeprecationMessagePrinted[name]) {
+    return;
+  }
+  console.warn(
+    `Deprecated BitArray.${name} property used in JavaScript FFI code. ${message}.`
+  );
+  isBitArrayDeprecationMessagePrinted[name] = true;
+}
+function toBitArray(segments) {
+  if (segments.length === 0) {
+    return new BitArray(new Uint8Array());
+  }
+  if (segments.length === 1) {
+    const segment = segments[0];
+    if (segment instanceof BitArray) {
+      return segment;
+    }
+    if (segment instanceof Uint8Array) {
+      return new BitArray(segment);
+    }
+    return new BitArray(new Uint8Array(
+      /** @type {number[]} */
+      segments
+    ));
+  }
+  let bitSize = 0;
+  let areAllSegmentsNumbers = true;
+  for (const segment of segments) {
+    if (segment instanceof BitArray) {
+      bitSize += segment.bitSize;
+      areAllSegmentsNumbers = false;
+    } else if (segment instanceof Uint8Array) {
+      bitSize += segment.byteLength * 8;
+      areAllSegmentsNumbers = false;
+    } else {
+      bitSize += 8;
+    }
+  }
+  if (areAllSegmentsNumbers) {
+    return new BitArray(new Uint8Array(
+      /** @type {number[]} */
+      segments
+    ));
+  }
+  const buffer = new Uint8Array(Math.trunc((bitSize + 7) / 8));
+  let cursor = 0;
+  for (let segment of segments) {
+    const isCursorByteAligned = cursor % 8 === 0;
+    if (segment instanceof BitArray) {
+      if (isCursorByteAligned && segment.bitOffset === 0) {
+        buffer.set(segment.rawBuffer, cursor / 8);
+        cursor += segment.bitSize;
+        const trailingBitsCount = segment.bitSize % 8;
+        if (trailingBitsCount !== 0) {
+          const lastByteIndex = Math.trunc(cursor / 8);
+          buffer[lastByteIndex] >>= 8 - trailingBitsCount;
+          buffer[lastByteIndex] <<= 8 - trailingBitsCount;
+        }
+      } else {
+        appendUnalignedBits(
+          segment.rawBuffer,
+          segment.bitSize,
+          segment.bitOffset
+        );
+      }
+    } else if (segment instanceof Uint8Array) {
+      if (isCursorByteAligned) {
+        buffer.set(segment, cursor / 8);
+        cursor += segment.byteLength * 8;
+      } else {
+        appendUnalignedBits(segment, segment.byteLength * 8, 0);
+      }
+    } else {
+      if (isCursorByteAligned) {
+        buffer[cursor / 8] = segment;
+        cursor += 8;
+      } else {
+        appendUnalignedBits(new Uint8Array([segment]), 8, 0);
+      }
+    }
+  }
+  function appendUnalignedBits(unalignedBits, size3, offset) {
+    if (size3 === 0) {
+      return;
+    }
+    const byteSize = Math.trunc(size3 + 7 / 8);
+    const highBitsCount = cursor % 8;
+    const lowBitsCount = 8 - highBitsCount;
+    let byteIndex = Math.trunc(cursor / 8);
+    for (let i = 0; i < byteSize; i++) {
+      let byte = bitArrayByteAt(unalignedBits, offset, i);
+      if (size3 < 8) {
+        byte >>= 8 - size3;
+        byte <<= 8 - size3;
+      }
+      buffer[byteIndex] |= byte >> highBitsCount;
+      let appendedBitsCount = size3 - Math.max(0, size3 - lowBitsCount);
+      size3 -= appendedBitsCount;
+      cursor += appendedBitsCount;
+      if (size3 === 0) {
+        break;
+      }
+      buffer[++byteIndex] = byte << lowBitsCount;
+      appendedBitsCount = size3 - Math.max(0, size3 - highBitsCount);
+      size3 -= appendedBitsCount;
+      cursor += appendedBitsCount;
+    }
+  }
+  return new BitArray(buffer, bitSize);
+}
+function sizedInt(value, size3, isBigEndian) {
+  if (size3 <= 0) {
+    return new Uint8Array();
+  }
+  if (size3 === 8) {
+    return new Uint8Array([value]);
+  }
+  if (size3 < 8) {
+    value <<= 8 - size3;
+    return new BitArray(new Uint8Array([value]), size3);
+  }
+  const buffer = new Uint8Array(Math.trunc((size3 + 7) / 8));
+  const trailingBitsCount = size3 % 8;
+  const unusedBitsCount = 8 - trailingBitsCount;
+  if (size3 <= 32) {
+    if (isBigEndian) {
+      let i = buffer.length - 1;
+      if (trailingBitsCount) {
+        buffer[i--] = value << unusedBitsCount & 255;
+        value >>= trailingBitsCount;
+      }
+      for (; i >= 0; i--) {
+        buffer[i] = value;
+        value >>= 8;
+      }
+    } else {
+      let i = 0;
+      const wholeByteCount = Math.trunc(size3 / 8);
+      for (; i < wholeByteCount; i++) {
+        buffer[i] = value;
+        value >>= 8;
+      }
+      if (trailingBitsCount) {
+        buffer[i] = value << unusedBitsCount;
+      }
+    }
+  } else {
+    const bigTrailingBitsCount = BigInt(trailingBitsCount);
+    const bigUnusedBitsCount = BigInt(unusedBitsCount);
+    let bigValue = BigInt(value);
+    if (isBigEndian) {
+      let i = buffer.length - 1;
+      if (trailingBitsCount) {
+        buffer[i--] = Number(bigValue << bigUnusedBitsCount);
+        bigValue >>= bigTrailingBitsCount;
+      }
+      for (; i >= 0; i--) {
+        buffer[i] = Number(bigValue);
+        bigValue >>= 8n;
+      }
+    } else {
+      let i = 0;
+      const wholeByteCount = Math.trunc(size3 / 8);
+      for (; i < wholeByteCount; i++) {
+        buffer[i] = Number(bigValue);
+        bigValue >>= 8n;
+      }
+      if (trailingBitsCount) {
+        buffer[i] = Number(bigValue << bigUnusedBitsCount);
+      }
+    }
+  }
+  if (trailingBitsCount) {
+    return new BitArray(buffer, size3);
+  }
+  return buffer;
+}
+var Result = class _Result extends CustomType {
+  // @internal
+  static isResult(data) {
+    return data instanceof _Result;
+  }
+};
+var Ok = class extends Result {
+  constructor(value) {
+    super();
+    this[0] = value;
+  }
+  // @internal
+  isOk() {
+    return true;
+  }
+};
+var Error = class extends Result {
+  constructor(detail) {
+    super();
+    this[0] = detail;
+  }
+  // @internal
+  isOk() {
+    return false;
+  }
+};
+function isEqual(x, y) {
+  let values3 = [x, y];
+  while (values3.length) {
+    let a = values3.pop();
+    let b = values3.pop();
+    if (a === b) continue;
+    if (!isObject(a) || !isObject(b)) return false;
+    let unequal = !structurallyCompatibleObjects(a, b) || unequalDates(a, b) || unequalBuffers(a, b) || unequalArrays(a, b) || unequalMaps(a, b) || unequalSets(a, b) || unequalRegExps(a, b);
+    if (unequal) return false;
+    const proto = Object.getPrototypeOf(a);
+    if (proto !== null && typeof proto.equals === "function") {
+      try {
+        if (a.equals(b)) continue;
+        else return false;
+      } catch {
+      }
+    }
+    let [keys2, get4] = getters(a);
+    for (let k of keys2(a)) {
+      values3.push(get4(a, k), get4(b, k));
+    }
+  }
+  return true;
+}
+function getters(object4) {
+  if (object4 instanceof Map) {
+    return [(x) => x.keys(), (x, y) => x.get(y)];
+  } else {
+    let extra = object4 instanceof globalThis.Error ? ["message"] : [];
+    return [(x) => [...extra, ...Object.keys(x)], (x, y) => x[y]];
+  }
+}
+function unequalDates(a, b) {
+  return a instanceof Date && (a > b || a < b);
+}
+function unequalBuffers(a, b) {
+  return !(a instanceof BitArray) && a.buffer instanceof ArrayBuffer && a.BYTES_PER_ELEMENT && !(a.byteLength === b.byteLength && a.every((n, i) => n === b[i]));
+}
+function unequalArrays(a, b) {
+  return Array.isArray(a) && a.length !== b.length;
+}
+function unequalMaps(a, b) {
+  return a instanceof Map && a.size !== b.size;
+}
+function unequalSets(a, b) {
+  return a instanceof Set && (a.size != b.size || [...a].some((e) => !b.has(e)));
+}
+function unequalRegExps(a, b) {
+  return a instanceof RegExp && (a.source !== b.source || a.flags !== b.flags);
+}
+function isObject(a) {
+  return typeof a === "object" && a !== null;
+}
+function structurallyCompatibleObjects(a, b) {
+  if (typeof a !== "object" && typeof b !== "object" && (!a || !b))
+    return false;
+  let nonstructural = [Promise, WeakSet, WeakMap, Function];
+  if (nonstructural.some((c) => a instanceof c)) return false;
+  return a.constructor === b.constructor;
+}
+function makeError(variant, file, module, line, fn, message, extra) {
+  let error = new globalThis.Error(message);
+  error.gleam_error = variant;
+  error.file = file;
+  error.module = module;
+  error.line = line;
+  error.function = fn;
+  error.fn = fn;
+  for (let k in extra) error[k] = extra[k];
+  return error;
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/order.mjs
+var Lt = class extends CustomType {
+};
+var Eq = class extends CustomType {
+};
+var Gt = class extends CustomType {
+};
+
+// build/dev/javascript/gleam_stdlib/gleam/option.mjs
+var Some = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var None = class extends CustomType {
+};
+function unwrap(option, default$) {
+  if (option instanceof Some) {
+    let x = option[0];
+    return x;
+  } else {
+    return default$;
+  }
+}
+function lazy_unwrap(option, default$) {
+  if (option instanceof Some) {
+    let x = option[0];
+    return x;
+  } else {
+    return default$();
+  }
+}
+
+// build/dev/javascript/gleam_stdlib/dict.mjs
+var referenceMap = /* @__PURE__ */ new WeakMap();
+var tempDataView = /* @__PURE__ */ new DataView(
+  /* @__PURE__ */ new ArrayBuffer(8)
+);
+var referenceUID = 0;
+function hashByReference(o) {
+  const known = referenceMap.get(o);
+  if (known !== void 0) {
+    return known;
+  }
+  const hash = referenceUID++;
+  if (referenceUID === 2147483647) {
+    referenceUID = 0;
+  }
+  referenceMap.set(o, hash);
+  return hash;
+}
+function hashMerge(a, b) {
+  return a ^ b + 2654435769 + (a << 6) + (a >> 2) | 0;
+}
+function hashString(s) {
+  let hash = 0;
+  const len = s.length;
+  for (let i = 0; i < len; i++) {
+    hash = Math.imul(31, hash) + s.charCodeAt(i) | 0;
+  }
+  return hash;
+}
+function hashNumber(n) {
+  tempDataView.setFloat64(0, n);
+  const i = tempDataView.getInt32(0);
+  const j = tempDataView.getInt32(4);
+  return Math.imul(73244475, i >> 16 ^ i) ^ j;
+}
+function hashBigInt(n) {
+  return hashString(n.toString());
+}
+function hashObject(o) {
+  const proto = Object.getPrototypeOf(o);
+  if (proto !== null && typeof proto.hashCode === "function") {
+    try {
+      const code = o.hashCode(o);
+      if (typeof code === "number") {
+        return code;
+      }
+    } catch {
+    }
+  }
+  if (o instanceof Promise || o instanceof WeakSet || o instanceof WeakMap) {
+    return hashByReference(o);
+  }
+  if (o instanceof Date) {
+    return hashNumber(o.getTime());
+  }
+  let h = 0;
+  if (o instanceof ArrayBuffer) {
+    o = new Uint8Array(o);
+  }
+  if (Array.isArray(o) || o instanceof Uint8Array) {
+    for (let i = 0; i < o.length; i++) {
+      h = Math.imul(31, h) + getHash(o[i]) | 0;
+    }
+  } else if (o instanceof Set) {
+    o.forEach((v) => {
+      h = h + getHash(v) | 0;
+    });
+  } else if (o instanceof Map) {
+    o.forEach((v, k) => {
+      h = h + hashMerge(getHash(v), getHash(k)) | 0;
+    });
+  } else {
+    const keys2 = Object.keys(o);
+    for (let i = 0; i < keys2.length; i++) {
+      const k = keys2[i];
+      const v = o[k];
+      h = h + hashMerge(getHash(v), hashString(k)) | 0;
+    }
+  }
+  return h;
+}
+function getHash(u) {
+  if (u === null) return 1108378658;
+  if (u === void 0) return 1108378659;
+  if (u === true) return 1108378657;
+  if (u === false) return 1108378656;
+  switch (typeof u) {
+    case "number":
+      return hashNumber(u);
+    case "string":
+      return hashString(u);
+    case "bigint":
+      return hashBigInt(u);
+    case "object":
+      return hashObject(u);
+    case "symbol":
+      return hashByReference(u);
+    case "function":
+      return hashByReference(u);
+    default:
+      return 0;
+  }
+}
+var SHIFT = 5;
+var BUCKET_SIZE = Math.pow(2, SHIFT);
+var MASK = BUCKET_SIZE - 1;
+var MAX_INDEX_NODE = BUCKET_SIZE / 2;
+var MIN_ARRAY_NODE = BUCKET_SIZE / 4;
+var ENTRY = 0;
+var ARRAY_NODE = 1;
+var INDEX_NODE = 2;
+var COLLISION_NODE = 3;
+var EMPTY = {
+  type: INDEX_NODE,
+  bitmap: 0,
+  array: []
+};
+function mask(hash, shift) {
+  return hash >>> shift & MASK;
+}
+function bitpos(hash, shift) {
+  return 1 << mask(hash, shift);
+}
+function bitcount(x) {
+  x -= x >> 1 & 1431655765;
+  x = (x & 858993459) + (x >> 2 & 858993459);
+  x = x + (x >> 4) & 252645135;
+  x += x >> 8;
+  x += x >> 16;
+  return x & 127;
+}
+function index(bitmap, bit) {
+  return bitcount(bitmap & bit - 1);
+}
+function cloneAndSet(arr, at, val) {
+  const len = arr.length;
+  const out = new Array(len);
+  for (let i = 0; i < len; ++i) {
+    out[i] = arr[i];
+  }
+  out[at] = val;
+  return out;
+}
+function spliceIn(arr, at, val) {
+  const len = arr.length;
+  const out = new Array(len + 1);
+  let i = 0;
+  let g = 0;
+  while (i < at) {
+    out[g++] = arr[i++];
+  }
+  out[g++] = val;
+  while (i < len) {
+    out[g++] = arr[i++];
+  }
+  return out;
+}
+function spliceOut(arr, at) {
+  const len = arr.length;
+  const out = new Array(len - 1);
+  let i = 0;
+  let g = 0;
+  while (i < at) {
+    out[g++] = arr[i++];
+  }
+  ++i;
+  while (i < len) {
+    out[g++] = arr[i++];
+  }
+  return out;
+}
+function createNode(shift, key1, val1, key2hash, key2, val2) {
+  const key1hash = getHash(key1);
+  if (key1hash === key2hash) {
+    return {
+      type: COLLISION_NODE,
+      hash: key1hash,
+      array: [
+        { type: ENTRY, k: key1, v: val1 },
+        { type: ENTRY, k: key2, v: val2 }
+      ]
+    };
+  }
+  const addedLeaf = { val: false };
+  return assoc(
+    assocIndex(EMPTY, shift, key1hash, key1, val1, addedLeaf),
+    shift,
+    key2hash,
+    key2,
+    val2,
+    addedLeaf
+  );
+}
+function assoc(root3, shift, hash, key, val, addedLeaf) {
+  switch (root3.type) {
+    case ARRAY_NODE:
+      return assocArray(root3, shift, hash, key, val, addedLeaf);
+    case INDEX_NODE:
+      return assocIndex(root3, shift, hash, key, val, addedLeaf);
+    case COLLISION_NODE:
+      return assocCollision(root3, shift, hash, key, val, addedLeaf);
+  }
+}
+function assocArray(root3, shift, hash, key, val, addedLeaf) {
+  const idx = mask(hash, shift);
+  const node2 = root3.array[idx];
+  if (node2 === void 0) {
+    addedLeaf.val = true;
+    return {
+      type: ARRAY_NODE,
+      size: root3.size + 1,
+      array: cloneAndSet(root3.array, idx, { type: ENTRY, k: key, v: val })
+    };
+  }
+  if (node2.type === ENTRY) {
+    if (isEqual(key, node2.k)) {
+      if (val === node2.v) {
+        return root3;
+      }
+      return {
+        type: ARRAY_NODE,
+        size: root3.size,
+        array: cloneAndSet(root3.array, idx, {
+          type: ENTRY,
+          k: key,
+          v: val
+        })
+      };
+    }
+    addedLeaf.val = true;
+    return {
+      type: ARRAY_NODE,
+      size: root3.size,
+      array: cloneAndSet(
+        root3.array,
+        idx,
+        createNode(shift + SHIFT, node2.k, node2.v, hash, key, val)
+      )
+    };
+  }
+  const n = assoc(node2, shift + SHIFT, hash, key, val, addedLeaf);
+  if (n === node2) {
+    return root3;
+  }
+  return {
+    type: ARRAY_NODE,
+    size: root3.size,
+    array: cloneAndSet(root3.array, idx, n)
+  };
+}
+function assocIndex(root3, shift, hash, key, val, addedLeaf) {
+  const bit = bitpos(hash, shift);
+  const idx = index(root3.bitmap, bit);
+  if ((root3.bitmap & bit) !== 0) {
+    const node2 = root3.array[idx];
+    if (node2.type !== ENTRY) {
+      const n = assoc(node2, shift + SHIFT, hash, key, val, addedLeaf);
+      if (n === node2) {
+        return root3;
+      }
+      return {
+        type: INDEX_NODE,
+        bitmap: root3.bitmap,
+        array: cloneAndSet(root3.array, idx, n)
+      };
+    }
+    const nodeKey = node2.k;
+    if (isEqual(key, nodeKey)) {
+      if (val === node2.v) {
+        return root3;
+      }
+      return {
+        type: INDEX_NODE,
+        bitmap: root3.bitmap,
+        array: cloneAndSet(root3.array, idx, {
+          type: ENTRY,
+          k: key,
+          v: val
+        })
+      };
+    }
+    addedLeaf.val = true;
+    return {
+      type: INDEX_NODE,
+      bitmap: root3.bitmap,
+      array: cloneAndSet(
+        root3.array,
+        idx,
+        createNode(shift + SHIFT, nodeKey, node2.v, hash, key, val)
+      )
+    };
+  } else {
+    const n = root3.array.length;
+    if (n >= MAX_INDEX_NODE) {
+      const nodes = new Array(32);
+      const jdx = mask(hash, shift);
+      nodes[jdx] = assocIndex(EMPTY, shift + SHIFT, hash, key, val, addedLeaf);
+      let j = 0;
+      let bitmap = root3.bitmap;
+      for (let i = 0; i < 32; i++) {
+        if ((bitmap & 1) !== 0) {
+          const node2 = root3.array[j++];
+          nodes[i] = node2;
+        }
+        bitmap = bitmap >>> 1;
+      }
+      return {
+        type: ARRAY_NODE,
+        size: n + 1,
+        array: nodes
+      };
+    } else {
+      const newArray = spliceIn(root3.array, idx, {
+        type: ENTRY,
+        k: key,
+        v: val
+      });
+      addedLeaf.val = true;
+      return {
+        type: INDEX_NODE,
+        bitmap: root3.bitmap | bit,
+        array: newArray
+      };
+    }
+  }
+}
+function assocCollision(root3, shift, hash, key, val, addedLeaf) {
+  if (hash === root3.hash) {
+    const idx = collisionIndexOf(root3, key);
+    if (idx !== -1) {
+      const entry = root3.array[idx];
+      if (entry.v === val) {
+        return root3;
+      }
+      return {
+        type: COLLISION_NODE,
+        hash,
+        array: cloneAndSet(root3.array, idx, { type: ENTRY, k: key, v: val })
+      };
+    }
+    const size3 = root3.array.length;
+    addedLeaf.val = true;
+    return {
+      type: COLLISION_NODE,
+      hash,
+      array: cloneAndSet(root3.array, size3, { type: ENTRY, k: key, v: val })
+    };
+  }
+  return assoc(
+    {
+      type: INDEX_NODE,
+      bitmap: bitpos(root3.hash, shift),
+      array: [root3]
+    },
+    shift,
+    hash,
+    key,
+    val,
+    addedLeaf
+  );
+}
+function collisionIndexOf(root3, key) {
+  const size3 = root3.array.length;
+  for (let i = 0; i < size3; i++) {
+    if (isEqual(key, root3.array[i].k)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function find(root3, shift, hash, key) {
+  switch (root3.type) {
+    case ARRAY_NODE:
+      return findArray(root3, shift, hash, key);
+    case INDEX_NODE:
+      return findIndex(root3, shift, hash, key);
+    case COLLISION_NODE:
+      return findCollision(root3, key);
+  }
+}
+function findArray(root3, shift, hash, key) {
+  const idx = mask(hash, shift);
+  const node2 = root3.array[idx];
+  if (node2 === void 0) {
+    return void 0;
+  }
+  if (node2.type !== ENTRY) {
+    return find(node2, shift + SHIFT, hash, key);
+  }
+  if (isEqual(key, node2.k)) {
+    return node2;
+  }
+  return void 0;
+}
+function findIndex(root3, shift, hash, key) {
+  const bit = bitpos(hash, shift);
+  if ((root3.bitmap & bit) === 0) {
+    return void 0;
+  }
+  const idx = index(root3.bitmap, bit);
+  const node2 = root3.array[idx];
+  if (node2.type !== ENTRY) {
+    return find(node2, shift + SHIFT, hash, key);
+  }
+  if (isEqual(key, node2.k)) {
+    return node2;
+  }
+  return void 0;
+}
+function findCollision(root3, key) {
+  const idx = collisionIndexOf(root3, key);
+  if (idx < 0) {
+    return void 0;
+  }
+  return root3.array[idx];
+}
+function without(root3, shift, hash, key) {
+  switch (root3.type) {
+    case ARRAY_NODE:
+      return withoutArray(root3, shift, hash, key);
+    case INDEX_NODE:
+      return withoutIndex(root3, shift, hash, key);
+    case COLLISION_NODE:
+      return withoutCollision(root3, key);
+  }
+}
+function withoutArray(root3, shift, hash, key) {
+  const idx = mask(hash, shift);
+  const node2 = root3.array[idx];
+  if (node2 === void 0) {
+    return root3;
+  }
+  let n = void 0;
+  if (node2.type === ENTRY) {
+    if (!isEqual(node2.k, key)) {
+      return root3;
+    }
+  } else {
+    n = without(node2, shift + SHIFT, hash, key);
+    if (n === node2) {
+      return root3;
+    }
+  }
+  if (n === void 0) {
+    if (root3.size <= MIN_ARRAY_NODE) {
+      const arr = root3.array;
+      const out = new Array(root3.size - 1);
+      let i = 0;
+      let j = 0;
+      let bitmap = 0;
+      while (i < idx) {
+        const nv = arr[i];
+        if (nv !== void 0) {
+          out[j] = nv;
+          bitmap |= 1 << i;
+          ++j;
+        }
+        ++i;
+      }
+      ++i;
+      while (i < arr.length) {
+        const nv = arr[i];
+        if (nv !== void 0) {
+          out[j] = nv;
+          bitmap |= 1 << i;
+          ++j;
+        }
+        ++i;
+      }
+      return {
+        type: INDEX_NODE,
+        bitmap,
+        array: out
+      };
+    }
+    return {
+      type: ARRAY_NODE,
+      size: root3.size - 1,
+      array: cloneAndSet(root3.array, idx, n)
+    };
+  }
+  return {
+    type: ARRAY_NODE,
+    size: root3.size,
+    array: cloneAndSet(root3.array, idx, n)
+  };
+}
+function withoutIndex(root3, shift, hash, key) {
+  const bit = bitpos(hash, shift);
+  if ((root3.bitmap & bit) === 0) {
+    return root3;
+  }
+  const idx = index(root3.bitmap, bit);
+  const node2 = root3.array[idx];
+  if (node2.type !== ENTRY) {
+    const n = without(node2, shift + SHIFT, hash, key);
+    if (n === node2) {
+      return root3;
+    }
+    if (n !== void 0) {
+      return {
+        type: INDEX_NODE,
+        bitmap: root3.bitmap,
+        array: cloneAndSet(root3.array, idx, n)
+      };
+    }
+    if (root3.bitmap === bit) {
+      return void 0;
+    }
+    return {
+      type: INDEX_NODE,
+      bitmap: root3.bitmap ^ bit,
+      array: spliceOut(root3.array, idx)
+    };
+  }
+  if (isEqual(key, node2.k)) {
+    if (root3.bitmap === bit) {
+      return void 0;
+    }
+    return {
+      type: INDEX_NODE,
+      bitmap: root3.bitmap ^ bit,
+      array: spliceOut(root3.array, idx)
+    };
+  }
+  return root3;
+}
+function withoutCollision(root3, key) {
+  const idx = collisionIndexOf(root3, key);
+  if (idx < 0) {
+    return root3;
+  }
+  if (root3.array.length === 1) {
+    return void 0;
+  }
+  return {
+    type: COLLISION_NODE,
+    hash: root3.hash,
+    array: spliceOut(root3.array, idx)
+  };
+}
+function forEach(root3, fn) {
+  if (root3 === void 0) {
+    return;
+  }
+  const items = root3.array;
+  const size3 = items.length;
+  for (let i = 0; i < size3; i++) {
+    const item = items[i];
+    if (item === void 0) {
+      continue;
+    }
+    if (item.type === ENTRY) {
+      fn(item.v, item.k);
+      continue;
+    }
+    forEach(item, fn);
+  }
+}
+var Dict = class _Dict {
+  /**
+   * @template V
+   * @param {Record<string,V>} o
+   * @returns {Dict<string,V>}
+   */
+  static fromObject(o) {
+    const keys2 = Object.keys(o);
+    let m = _Dict.new();
+    for (let i = 0; i < keys2.length; i++) {
+      const k = keys2[i];
+      m = m.set(k, o[k]);
+    }
+    return m;
+  }
+  /**
+   * @template K,V
+   * @param {Map<K,V>} o
+   * @returns {Dict<K,V>}
+   */
+  static fromMap(o) {
+    let m = _Dict.new();
+    o.forEach((v, k) => {
+      m = m.set(k, v);
+    });
+    return m;
+  }
+  static new() {
+    return new _Dict(void 0, 0);
+  }
+  /**
+   * @param {undefined | Node<K,V>} root
+   * @param {number} size
+   */
+  constructor(root3, size3) {
+    this.root = root3;
+    this.size = size3;
+  }
+  /**
+   * @template NotFound
+   * @param {K} key
+   * @param {NotFound} notFound
+   * @returns {NotFound | V}
+   */
+  get(key, notFound) {
+    if (this.root === void 0) {
+      return notFound;
+    }
+    const found = find(this.root, 0, getHash(key), key);
+    if (found === void 0) {
+      return notFound;
+    }
+    return found.v;
+  }
+  /**
+   * @param {K} key
+   * @param {V} val
+   * @returns {Dict<K,V>}
+   */
+  set(key, val) {
+    const addedLeaf = { val: false };
+    const root3 = this.root === void 0 ? EMPTY : this.root;
+    const newRoot = assoc(root3, 0, getHash(key), key, val, addedLeaf);
+    if (newRoot === this.root) {
+      return this;
+    }
+    return new _Dict(newRoot, addedLeaf.val ? this.size + 1 : this.size);
+  }
+  /**
+   * @param {K} key
+   * @returns {Dict<K,V>}
+   */
+  delete(key) {
+    if (this.root === void 0) {
+      return this;
+    }
+    const newRoot = without(this.root, 0, getHash(key), key);
+    if (newRoot === this.root) {
+      return this;
+    }
+    if (newRoot === void 0) {
+      return _Dict.new();
+    }
+    return new _Dict(newRoot, this.size - 1);
+  }
+  /**
+   * @param {K} key
+   * @returns {boolean}
+   */
+  has(key) {
+    if (this.root === void 0) {
+      return false;
+    }
+    return find(this.root, 0, getHash(key), key) !== void 0;
+  }
+  /**
+   * @returns {[K,V][]}
+   */
+  entries() {
+    if (this.root === void 0) {
+      return [];
+    }
+    const result = [];
+    this.forEach((v, k) => result.push([k, v]));
+    return result;
+  }
+  /**
+   *
+   * @param {(val:V,key:K)=>void} fn
+   */
+  forEach(fn) {
+    forEach(this.root, fn);
+  }
+  hashCode() {
+    let h = 0;
+    this.forEach((v, k) => {
+      h = h + hashMerge(getHash(v), getHash(k)) | 0;
+    });
+    return h;
+  }
+  /**
+   * @param {unknown} o
+   * @returns {boolean}
+   */
+  equals(o) {
+    if (!(o instanceof _Dict) || this.size !== o.size) {
+      return false;
+    }
+    try {
+      this.forEach((v, k) => {
+        if (!isEqual(o.get(k, !v), v)) {
+          throw unequalDictSymbol;
+        }
+      });
+      return true;
+    } catch (e) {
+      if (e === unequalDictSymbol) {
+        return false;
+      }
+      throw e;
+    }
+  }
+};
+var unequalDictSymbol = /* @__PURE__ */ Symbol();
+
+// build/dev/javascript/gleam_stdlib/gleam/dict.mjs
+function insert(dict2, key, value) {
+  return map_insert(key, value, dict2);
+}
+function reverse_and_concat(loop$remaining, loop$accumulator) {
+  while (true) {
+    let remaining = loop$remaining;
+    let accumulator = loop$accumulator;
+    if (remaining instanceof Empty) {
+      return accumulator;
+    } else {
+      let first2 = remaining.head;
+      let rest = remaining.tail;
+      loop$remaining = rest;
+      loop$accumulator = prepend(first2, accumulator);
+    }
+  }
+}
+function do_values_loop(loop$list, loop$acc) {
+  while (true) {
+    let list4 = loop$list;
+    let acc = loop$acc;
+    if (list4 instanceof Empty) {
+      return reverse_and_concat(acc, toList([]));
+    } else {
+      let rest = list4.tail;
+      let value = list4.head[1];
+      loop$list = rest;
+      loop$acc = prepend(value, acc);
+    }
+  }
+}
+function values(dict2) {
+  let list_of_pairs = map_to_list(dict2);
+  return do_values_loop(list_of_pairs, toList([]));
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/int.mjs
+function square_root2(x) {
+  let _pipe = identity(x);
+  return square_root(_pipe);
+}
+function min(a, b) {
+  let $ = a < b;
+  if ($) {
+    return a;
+  } else {
+    return b;
+  }
+}
+function add(a, b) {
+  return a + b;
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/list.mjs
+var Ascending = class extends CustomType {
+};
+var Descending = class extends CustomType {
+};
+function length_loop(loop$list, loop$count) {
+  while (true) {
+    let list4 = loop$list;
+    let count = loop$count;
+    if (list4 instanceof Empty) {
+      return count;
+    } else {
+      let list$1 = list4.tail;
+      loop$list = list$1;
+      loop$count = count + 1;
+    }
+  }
+}
+function length(list4) {
+  return length_loop(list4, 0);
+}
+function reverse_and_prepend(loop$prefix, loop$suffix) {
+  while (true) {
+    let prefix = loop$prefix;
+    let suffix = loop$suffix;
+    if (prefix instanceof Empty) {
+      return suffix;
+    } else {
+      let first$1 = prefix.head;
+      let rest$1 = prefix.tail;
+      loop$prefix = rest$1;
+      loop$suffix = prepend(first$1, suffix);
+    }
+  }
+}
+function reverse(list4) {
+  return reverse_and_prepend(list4, toList([]));
+}
+function is_empty2(list4) {
+  return isEqual(list4, toList([]));
+}
+function first(list4) {
+  if (list4 instanceof Empty) {
+    return new Error(void 0);
+  } else {
+    let first$1 = list4.head;
+    return new Ok(first$1);
+  }
+}
+function map_loop(loop$list, loop$fun, loop$acc) {
+  while (true) {
+    let list4 = loop$list;
+    let fun = loop$fun;
+    let acc = loop$acc;
+    if (list4 instanceof Empty) {
+      return reverse(acc);
+    } else {
+      let first$1 = list4.head;
+      let rest$1 = list4.tail;
+      loop$list = rest$1;
+      loop$fun = fun;
+      loop$acc = prepend(fun(first$1), acc);
+    }
+  }
+}
+function map(list4, fun) {
+  return map_loop(list4, fun, toList([]));
+}
+function append_loop(loop$first, loop$second) {
+  while (true) {
+    let first2 = loop$first;
+    let second = loop$second;
+    if (first2 instanceof Empty) {
+      return second;
+    } else {
+      let first$1 = first2.head;
+      let rest$1 = first2.tail;
+      loop$first = rest$1;
+      loop$second = prepend(first$1, second);
+    }
+  }
+}
+function append(first2, second) {
+  return append_loop(reverse(first2), second);
+}
+function prepend2(list4, item) {
+  return prepend(item, list4);
+}
+function flatten_loop(loop$lists, loop$acc) {
+  while (true) {
+    let lists = loop$lists;
+    let acc = loop$acc;
+    if (lists instanceof Empty) {
+      return reverse(acc);
+    } else {
+      let list4 = lists.head;
+      let further_lists = lists.tail;
+      loop$lists = further_lists;
+      loop$acc = reverse_and_prepend(list4, acc);
+    }
+  }
+}
+function flatten(lists) {
+  return flatten_loop(lists, toList([]));
+}
+function flat_map(list4, fun) {
+  return flatten(map(list4, fun));
+}
+function fold(loop$list, loop$initial, loop$fun) {
+  while (true) {
+    let list4 = loop$list;
+    let initial = loop$initial;
+    let fun = loop$fun;
+    if (list4 instanceof Empty) {
+      return initial;
+    } else {
+      let first$1 = list4.head;
+      let rest$1 = list4.tail;
+      loop$list = rest$1;
+      loop$initial = fun(initial, first$1);
+      loop$fun = fun;
+    }
+  }
+}
+function sequences(loop$list, loop$compare, loop$growing, loop$direction, loop$prev, loop$acc) {
+  while (true) {
+    let list4 = loop$list;
+    let compare4 = loop$compare;
+    let growing = loop$growing;
+    let direction = loop$direction;
+    let prev = loop$prev;
+    let acc = loop$acc;
+    let growing$1 = prepend(prev, growing);
+    if (list4 instanceof Empty) {
+      if (direction instanceof Ascending) {
+        return prepend(reverse(growing$1), acc);
+      } else {
+        return prepend(growing$1, acc);
+      }
+    } else {
+      let new$1 = list4.head;
+      let rest$1 = list4.tail;
+      let $ = compare4(prev, new$1);
+      if (direction instanceof Ascending) {
+        if ($ instanceof Lt) {
+          loop$list = rest$1;
+          loop$compare = compare4;
+          loop$growing = growing$1;
+          loop$direction = direction;
+          loop$prev = new$1;
+          loop$acc = acc;
+        } else if ($ instanceof Eq) {
+          loop$list = rest$1;
+          loop$compare = compare4;
+          loop$growing = growing$1;
+          loop$direction = direction;
+          loop$prev = new$1;
+          loop$acc = acc;
+        } else {
+          let _block;
+          if (direction instanceof Ascending) {
+            _block = prepend(reverse(growing$1), acc);
+          } else {
+            _block = prepend(growing$1, acc);
+          }
+          let acc$1 = _block;
+          if (rest$1 instanceof Empty) {
+            return prepend(toList([new$1]), acc$1);
+          } else {
+            let next = rest$1.head;
+            let rest$2 = rest$1.tail;
+            let _block$1;
+            let $1 = compare4(new$1, next);
+            if ($1 instanceof Lt) {
+              _block$1 = new Ascending();
+            } else if ($1 instanceof Eq) {
+              _block$1 = new Ascending();
+            } else {
+              _block$1 = new Descending();
+            }
+            let direction$1 = _block$1;
+            loop$list = rest$2;
+            loop$compare = compare4;
+            loop$growing = toList([new$1]);
+            loop$direction = direction$1;
+            loop$prev = next;
+            loop$acc = acc$1;
+          }
+        }
+      } else if ($ instanceof Lt) {
+        let _block;
+        if (direction instanceof Ascending) {
+          _block = prepend(reverse(growing$1), acc);
+        } else {
+          _block = prepend(growing$1, acc);
+        }
+        let acc$1 = _block;
+        if (rest$1 instanceof Empty) {
+          return prepend(toList([new$1]), acc$1);
+        } else {
+          let next = rest$1.head;
+          let rest$2 = rest$1.tail;
+          let _block$1;
+          let $1 = compare4(new$1, next);
+          if ($1 instanceof Lt) {
+            _block$1 = new Ascending();
+          } else if ($1 instanceof Eq) {
+            _block$1 = new Ascending();
+          } else {
+            _block$1 = new Descending();
+          }
+          let direction$1 = _block$1;
+          loop$list = rest$2;
+          loop$compare = compare4;
+          loop$growing = toList([new$1]);
+          loop$direction = direction$1;
+          loop$prev = next;
+          loop$acc = acc$1;
+        }
+      } else if ($ instanceof Eq) {
+        let _block;
+        if (direction instanceof Ascending) {
+          _block = prepend(reverse(growing$1), acc);
+        } else {
+          _block = prepend(growing$1, acc);
+        }
+        let acc$1 = _block;
+        if (rest$1 instanceof Empty) {
+          return prepend(toList([new$1]), acc$1);
+        } else {
+          let next = rest$1.head;
+          let rest$2 = rest$1.tail;
+          let _block$1;
+          let $1 = compare4(new$1, next);
+          if ($1 instanceof Lt) {
+            _block$1 = new Ascending();
+          } else if ($1 instanceof Eq) {
+            _block$1 = new Ascending();
+          } else {
+            _block$1 = new Descending();
+          }
+          let direction$1 = _block$1;
+          loop$list = rest$2;
+          loop$compare = compare4;
+          loop$growing = toList([new$1]);
+          loop$direction = direction$1;
+          loop$prev = next;
+          loop$acc = acc$1;
+        }
+      } else {
+        loop$list = rest$1;
+        loop$compare = compare4;
+        loop$growing = growing$1;
+        loop$direction = direction;
+        loop$prev = new$1;
+        loop$acc = acc;
+      }
+    }
+  }
+}
+function merge_ascendings(loop$list1, loop$list2, loop$compare, loop$acc) {
+  while (true) {
+    let list1 = loop$list1;
+    let list22 = loop$list2;
+    let compare4 = loop$compare;
+    let acc = loop$acc;
+    if (list1 instanceof Empty) {
+      let list4 = list22;
+      return reverse_and_prepend(list4, acc);
+    } else if (list22 instanceof Empty) {
+      let list4 = list1;
+      return reverse_and_prepend(list4, acc);
+    } else {
+      let first1 = list1.head;
+      let rest1 = list1.tail;
+      let first2 = list22.head;
+      let rest2 = list22.tail;
+      let $ = compare4(first1, first2);
+      if ($ instanceof Lt) {
+        loop$list1 = rest1;
+        loop$list2 = list22;
+        loop$compare = compare4;
+        loop$acc = prepend(first1, acc);
+      } else if ($ instanceof Eq) {
+        loop$list1 = list1;
+        loop$list2 = rest2;
+        loop$compare = compare4;
+        loop$acc = prepend(first2, acc);
+      } else {
+        loop$list1 = list1;
+        loop$list2 = rest2;
+        loop$compare = compare4;
+        loop$acc = prepend(first2, acc);
+      }
+    }
+  }
+}
+function merge_ascending_pairs(loop$sequences, loop$compare, loop$acc) {
+  while (true) {
+    let sequences2 = loop$sequences;
+    let compare4 = loop$compare;
+    let acc = loop$acc;
+    if (sequences2 instanceof Empty) {
+      return reverse(acc);
+    } else {
+      let $ = sequences2.tail;
+      if ($ instanceof Empty) {
+        let sequence = sequences2.head;
+        return reverse(prepend(reverse(sequence), acc));
+      } else {
+        let ascending1 = sequences2.head;
+        let ascending2 = $.head;
+        let rest$1 = $.tail;
+        let descending = merge_ascendings(
+          ascending1,
+          ascending2,
+          compare4,
+          toList([])
+        );
+        loop$sequences = rest$1;
+        loop$compare = compare4;
+        loop$acc = prepend(descending, acc);
+      }
+    }
+  }
+}
+function merge_descendings(loop$list1, loop$list2, loop$compare, loop$acc) {
+  while (true) {
+    let list1 = loop$list1;
+    let list22 = loop$list2;
+    let compare4 = loop$compare;
+    let acc = loop$acc;
+    if (list1 instanceof Empty) {
+      let list4 = list22;
+      return reverse_and_prepend(list4, acc);
+    } else if (list22 instanceof Empty) {
+      let list4 = list1;
+      return reverse_and_prepend(list4, acc);
+    } else {
+      let first1 = list1.head;
+      let rest1 = list1.tail;
+      let first2 = list22.head;
+      let rest2 = list22.tail;
+      let $ = compare4(first1, first2);
+      if ($ instanceof Lt) {
+        loop$list1 = list1;
+        loop$list2 = rest2;
+        loop$compare = compare4;
+        loop$acc = prepend(first2, acc);
+      } else if ($ instanceof Eq) {
+        loop$list1 = rest1;
+        loop$list2 = list22;
+        loop$compare = compare4;
+        loop$acc = prepend(first1, acc);
+      } else {
+        loop$list1 = rest1;
+        loop$list2 = list22;
+        loop$compare = compare4;
+        loop$acc = prepend(first1, acc);
+      }
+    }
+  }
+}
+function merge_descending_pairs(loop$sequences, loop$compare, loop$acc) {
+  while (true) {
+    let sequences2 = loop$sequences;
+    let compare4 = loop$compare;
+    let acc = loop$acc;
+    if (sequences2 instanceof Empty) {
+      return reverse(acc);
+    } else {
+      let $ = sequences2.tail;
+      if ($ instanceof Empty) {
+        let sequence = sequences2.head;
+        return reverse(prepend(reverse(sequence), acc));
+      } else {
+        let descending1 = sequences2.head;
+        let descending2 = $.head;
+        let rest$1 = $.tail;
+        let ascending = merge_descendings(
+          descending1,
+          descending2,
+          compare4,
+          toList([])
+        );
+        loop$sequences = rest$1;
+        loop$compare = compare4;
+        loop$acc = prepend(ascending, acc);
+      }
+    }
+  }
+}
+function merge_all(loop$sequences, loop$direction, loop$compare) {
+  while (true) {
+    let sequences2 = loop$sequences;
+    let direction = loop$direction;
+    let compare4 = loop$compare;
+    if (sequences2 instanceof Empty) {
+      return toList([]);
+    } else if (direction instanceof Ascending) {
+      let $ = sequences2.tail;
+      if ($ instanceof Empty) {
+        let sequence = sequences2.head;
+        return sequence;
+      } else {
+        let sequences$1 = merge_ascending_pairs(sequences2, compare4, toList([]));
+        loop$sequences = sequences$1;
+        loop$direction = new Descending();
+        loop$compare = compare4;
+      }
+    } else {
+      let $ = sequences2.tail;
+      if ($ instanceof Empty) {
+        let sequence = sequences2.head;
+        return reverse(sequence);
+      } else {
+        let sequences$1 = merge_descending_pairs(sequences2, compare4, toList([]));
+        loop$sequences = sequences$1;
+        loop$direction = new Ascending();
+        loop$compare = compare4;
+      }
+    }
+  }
+}
+function sort(list4, compare4) {
+  if (list4 instanceof Empty) {
+    return toList([]);
+  } else {
+    let $ = list4.tail;
+    if ($ instanceof Empty) {
+      let x = list4.head;
+      return toList([x]);
+    } else {
+      let x = list4.head;
+      let y = $.head;
+      let rest$1 = $.tail;
+      let _block;
+      let $1 = compare4(x, y);
+      if ($1 instanceof Lt) {
+        _block = new Ascending();
+      } else if ($1 instanceof Eq) {
+        _block = new Ascending();
+      } else {
+        _block = new Descending();
+      }
+      let direction = _block;
+      let sequences$1 = sequences(
+        rest$1,
+        compare4,
+        toList([x]),
+        direction,
+        y,
+        toList([])
+      );
+      return merge_all(sequences$1, new Ascending(), compare4);
+    }
+  }
+}
+function sized_chunk_loop(loop$list, loop$count, loop$left, loop$current_chunk, loop$acc) {
+  while (true) {
+    let list4 = loop$list;
+    let count = loop$count;
+    let left = loop$left;
+    let current_chunk = loop$current_chunk;
+    let acc = loop$acc;
+    if (list4 instanceof Empty) {
+      if (current_chunk instanceof Empty) {
+        return reverse(acc);
+      } else {
+        let remaining = current_chunk;
+        return reverse(prepend(reverse(remaining), acc));
+      }
+    } else {
+      let first$1 = list4.head;
+      let rest$1 = list4.tail;
+      let chunk$1 = prepend(first$1, current_chunk);
+      let $ = left > 1;
+      if ($) {
+        loop$list = rest$1;
+        loop$count = count;
+        loop$left = left - 1;
+        loop$current_chunk = chunk$1;
+        loop$acc = acc;
+      } else {
+        loop$list = rest$1;
+        loop$count = count;
+        loop$left = count;
+        loop$current_chunk = toList([]);
+        loop$acc = prepend(reverse(chunk$1), acc);
+      }
+    }
+  }
+}
+function sized_chunk(list4, count) {
+  return sized_chunk_loop(list4, count, count, toList([]), toList([]));
+}
+function shuffle_pair_unwrap_loop(loop$list, loop$acc) {
+  while (true) {
+    let list4 = loop$list;
+    let acc = loop$acc;
+    if (list4 instanceof Empty) {
+      return acc;
+    } else {
+      let elem_pair = list4.head;
+      let enumerable = list4.tail;
+      loop$list = enumerable;
+      loop$acc = prepend(elem_pair[1], acc);
+    }
+  }
+}
+function do_shuffle_by_pair_indexes(list_of_pairs) {
+  return sort(
+    list_of_pairs,
+    (a_pair, b_pair) => {
+      return compare(a_pair[0], b_pair[0]);
+    }
+  );
+}
+function shuffle(list4) {
+  let _pipe = list4;
+  let _pipe$1 = fold(
+    _pipe,
+    toList([]),
+    (acc, a) => {
+      return prepend([random_uniform(), a], acc);
+    }
+  );
+  let _pipe$2 = do_shuffle_by_pair_indexes(_pipe$1);
+  return shuffle_pair_unwrap_loop(_pipe$2, toList([]));
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/string.mjs
+function append2(first2, second) {
+  return first2 + second;
+}
+function concat_loop(loop$strings, loop$accumulator) {
+  while (true) {
+    let strings = loop$strings;
+    let accumulator = loop$accumulator;
+    if (strings instanceof Empty) {
+      return accumulator;
+    } else {
+      let string5 = strings.head;
+      let strings$1 = strings.tail;
+      loop$strings = strings$1;
+      loop$accumulator = accumulator + string5;
+    }
+  }
+}
+function concat2(strings) {
+  return concat_loop(strings, "");
+}
+function repeat_loop(loop$string, loop$times, loop$acc) {
+  while (true) {
+    let string5 = loop$string;
+    let times = loop$times;
+    let acc = loop$acc;
+    let $ = times <= 0;
+    if ($) {
+      return acc;
+    } else {
+      loop$string = string5;
+      loop$times = times - 1;
+      loop$acc = acc + string5;
+    }
+  }
+}
+function repeat(string5, times) {
+  return repeat_loop(string5, times, "");
+}
+function join_loop(loop$strings, loop$separator, loop$accumulator) {
+  while (true) {
+    let strings = loop$strings;
+    let separator = loop$separator;
+    let accumulator = loop$accumulator;
+    if (strings instanceof Empty) {
+      return accumulator;
+    } else {
+      let string5 = strings.head;
+      let strings$1 = strings.tail;
+      loop$strings = strings$1;
+      loop$separator = separator;
+      loop$accumulator = accumulator + separator + string5;
+    }
+  }
+}
+function join(strings, separator) {
+  if (strings instanceof Empty) {
+    return "";
+  } else {
+    let first$1 = strings.head;
+    let rest = strings.tail;
+    return join_loop(rest, separator, first$1);
+  }
+}
+function do_to_utf_codepoints(string5) {
+  let _pipe = string5;
+  let _pipe$1 = string_to_codepoint_integer_list(_pipe);
+  return map(_pipe$1, codepoint);
+}
+function to_utf_codepoints(string5) {
+  return do_to_utf_codepoints(string5);
+}
+function inspect2(term) {
+  let _pipe = inspect(term);
+  return identity(_pipe);
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/dynamic/decode.mjs
+var DecodeError = class extends CustomType {
+  constructor(expected, found, path) {
+    super();
+    this.expected = expected;
+    this.found = found;
+    this.path = path;
+  }
+};
+var Decoder = class extends CustomType {
+  constructor(function$) {
+    super();
+    this.function = function$;
+  }
+};
+function run(data, decoder) {
+  let $ = decoder.function(data);
+  let maybe_invalid_data = $[0];
+  let errors = $[1];
+  if (errors instanceof Empty) {
+    return new Ok(maybe_invalid_data);
+  } else {
+    return new Error(errors);
+  }
+}
+function success(data) {
+  return new Decoder((_) => {
+    return [data, toList([])];
+  });
+}
+function map2(decoder, transformer) {
+  return new Decoder(
+    (d) => {
+      let $ = decoder.function(d);
+      let data = $[0];
+      let errors = $[1];
+      return [transformer(data), errors];
+    }
+  );
+}
+function run_decoders(loop$data, loop$failure, loop$decoders) {
+  while (true) {
+    let data = loop$data;
+    let failure2 = loop$failure;
+    let decoders = loop$decoders;
+    if (decoders instanceof Empty) {
+      return failure2;
+    } else {
+      let decoder = decoders.head;
+      let decoders$1 = decoders.tail;
+      let $ = decoder.function(data);
+      let layer = $;
+      let errors = $[1];
+      if (errors instanceof Empty) {
+        return layer;
+      } else {
+        loop$data = data;
+        loop$failure = failure2;
+        loop$decoders = decoders$1;
+      }
+    }
+  }
+}
+function one_of(first2, alternatives) {
+  return new Decoder(
+    (dynamic_data) => {
+      let $ = first2.function(dynamic_data);
+      let layer = $;
+      let errors = $[1];
+      if (errors instanceof Empty) {
+        return layer;
+      } else {
+        return run_decoders(dynamic_data, layer, alternatives);
+      }
+    }
+  );
+}
+function run_dynamic_function(data, name, f) {
+  let $ = f(data);
+  if ($ instanceof Ok) {
+    let data$1 = $[0];
+    return [data$1, toList([])];
+  } else {
+    let zero = $[0];
+    return [
+      zero,
+      toList([new DecodeError(name, classify_dynamic(data), toList([]))])
+    ];
+  }
+}
+function decode_int(data) {
+  return run_dynamic_function(data, "Int", int);
+}
+var int2 = /* @__PURE__ */ new Decoder(decode_int);
+function decode_string(data) {
+  return run_dynamic_function(data, "String", string);
+}
+var string2 = /* @__PURE__ */ new Decoder(decode_string);
+function push_path(layer, path) {
+  let decoder = one_of(
+    string2,
+    toList([
+      (() => {
+        let _pipe = int2;
+        return map2(_pipe, to_string);
+      })()
+    ])
+  );
+  let path$1 = map(
+    path,
+    (key) => {
+      let key$1 = identity(key);
+      let $ = run(key$1, decoder);
+      if ($ instanceof Ok) {
+        let key$2 = $[0];
+        return key$2;
+      } else {
+        return "<" + classify_dynamic(key$1) + ">";
+      }
+    }
+  );
+  let errors = map(
+    layer[1],
+    (error) => {
+      let _record = error;
+      return new DecodeError(
+        _record.expected,
+        _record.found,
+        append(path$1, error.path)
+      );
+    }
+  );
+  return [layer[0], errors];
+}
+function index3(loop$path, loop$position, loop$inner, loop$data, loop$handle_miss) {
+  while (true) {
+    let path = loop$path;
+    let position = loop$position;
+    let inner = loop$inner;
+    let data = loop$data;
+    let handle_miss = loop$handle_miss;
+    if (path instanceof Empty) {
+      let _pipe = inner(data);
+      return push_path(_pipe, reverse(position));
+    } else {
+      let key = path.head;
+      let path$1 = path.tail;
+      let $ = index2(data, key);
+      if ($ instanceof Ok) {
+        let $1 = $[0];
+        if ($1 instanceof Some) {
+          let data$1 = $1[0];
+          loop$path = path$1;
+          loop$position = prepend(key, position);
+          loop$inner = inner;
+          loop$data = data$1;
+          loop$handle_miss = handle_miss;
+        } else {
+          return handle_miss(data, prepend(key, position));
+        }
+      } else {
+        let kind = $[0];
+        let $1 = inner(data);
+        let default$ = $1[0];
+        let _pipe = [
+          default$,
+          toList([new DecodeError(kind, classify_dynamic(data), toList([]))])
+        ];
+        return push_path(_pipe, reverse(position));
+      }
+    }
+  }
+}
+function subfield(field_path, field_decoder, next) {
+  return new Decoder(
+    (data) => {
+      let $ = index3(
+        field_path,
+        toList([]),
+        field_decoder.function,
+        data,
+        (data2, position) => {
+          let $12 = field_decoder.function(data2);
+          let default$ = $12[0];
+          let _pipe = [
+            default$,
+            toList([new DecodeError("Field", "Nothing", toList([]))])
+          ];
+          return push_path(_pipe, reverse(position));
+        }
+      );
+      let out = $[0];
+      let errors1 = $[1];
+      let $1 = next(out).function(data);
+      let out$1 = $1[0];
+      let errors2 = $1[1];
+      return [out$1, append(errors1, errors2)];
+    }
+  );
+}
+
+// build/dev/javascript/gleam_stdlib/gleam_stdlib.mjs
+var Nil = void 0;
+var NOT_FOUND = {};
+function identity(x) {
+  return x;
+}
+function parse_int(value) {
+  if (/^[-+]?(\d+)$/.test(value)) {
+    return new Ok(parseInt(value));
+  } else {
+    return new Error(Nil);
+  }
+}
+function to_string(term) {
+  return term.toString();
+}
+function starts_with(haystack, needle) {
+  return haystack.startsWith(needle);
+}
+var unicode_whitespaces = [
+  " ",
+  // Space
+  "	",
+  // Horizontal tab
+  "\n",
+  // Line feed
+  "\v",
+  // Vertical tab
+  "\f",
+  // Form feed
+  "\r",
+  // Carriage return
+  "\x85",
+  // Next line
+  "\u2028",
+  // Line separator
+  "\u2029"
+  // Paragraph separator
+].join("");
+var trim_start_regex = /* @__PURE__ */ new RegExp(
+  `^[${unicode_whitespaces}]*`
+);
+var trim_end_regex = /* @__PURE__ */ new RegExp(`[${unicode_whitespaces}]*$`);
+function ceiling(float2) {
+  return Math.ceil(float2);
+}
+function floor(float2) {
+  return Math.floor(float2);
+}
+function round2(float2) {
+  return Math.round(float2);
+}
+function power2(base, exponent) {
+  return Math.pow(base, exponent);
+}
+function random_uniform() {
+  const random_uniform_result = Math.random();
+  if (random_uniform_result === 1) {
+    return random_uniform();
+  }
+  return random_uniform_result;
+}
+function codepoint(int5) {
+  return new UtfCodepoint(int5);
+}
+function string_to_codepoint_integer_list(string5) {
+  return List.fromArray(Array.from(string5).map((item) => item.codePointAt(0)));
+}
+function utf_codepoint_to_int(utf_codepoint) {
+  return utf_codepoint.value;
+}
+function new_map() {
+  return Dict.new();
+}
+function map_to_list(map7) {
+  return List.fromArray(map7.entries());
+}
+function map_get(map7, key) {
+  const value = map7.get(key, NOT_FOUND);
+  if (value === NOT_FOUND) {
+    return new Error(Nil);
+  }
+  return new Ok(value);
+}
+function map_insert(key, value, map7) {
+  return map7.set(key, value);
+}
+function classify_dynamic(data) {
+  if (typeof data === "string") {
+    return "String";
+  } else if (typeof data === "boolean") {
+    return "Bool";
+  } else if (data instanceof Result) {
+    return "Result";
+  } else if (data instanceof List) {
+    return "List";
+  } else if (data instanceof BitArray) {
+    return "BitArray";
+  } else if (data instanceof Dict) {
+    return "Dict";
+  } else if (Number.isInteger(data)) {
+    return "Int";
+  } else if (Array.isArray(data)) {
+    return `Array`;
+  } else if (typeof data === "number") {
+    return "Float";
+  } else if (data === null) {
+    return "Nil";
+  } else if (data === void 0) {
+    return "Nil";
+  } else {
+    const type = typeof data;
+    return type.charAt(0).toUpperCase() + type.slice(1);
+  }
+}
+function bitwise_and(x, y) {
+  return Number(BigInt(x) & BigInt(y));
+}
+function bitwise_or(x, y) {
+  return Number(BigInt(x) | BigInt(y));
+}
+function bitwise_exclusive_or(x, y) {
+  return Number(BigInt(x) ^ BigInt(y));
+}
+function bitwise_shift_left(x, y) {
+  return Number(BigInt(x) << BigInt(y));
+}
+function bitwise_shift_right(x, y) {
+  return Number(BigInt(x) >> BigInt(y));
+}
+function inspect(v) {
+  return new Inspector().inspect(v);
+}
+function float_to_string(float2) {
+  const string5 = float2.toString().replace("+", "");
+  if (string5.indexOf(".") >= 0) {
+    return string5;
+  } else {
+    const index4 = string5.indexOf("e");
+    if (index4 >= 0) {
+      return string5.slice(0, index4) + ".0" + string5.slice(index4);
+    } else {
+      return string5 + ".0";
+    }
+  }
+}
+var Inspector = class {
+  #references = /* @__PURE__ */ new Set();
+  inspect(v) {
+    const t = typeof v;
+    if (v === true) return "True";
+    if (v === false) return "False";
+    if (v === null) return "//js(null)";
+    if (v === void 0) return "Nil";
+    if (t === "string") return this.#string(v);
+    if (t === "bigint" || Number.isInteger(v)) return v.toString();
+    if (t === "number") return float_to_string(v);
+    if (v instanceof UtfCodepoint) return this.#utfCodepoint(v);
+    if (v instanceof BitArray) return this.#bit_array(v);
+    if (v instanceof RegExp) return `//js(${v})`;
+    if (v instanceof Date) return `//js(Date("${v.toISOString()}"))`;
+    if (v instanceof globalThis.Error) return `//js(${v.toString()})`;
+    if (v instanceof Function) {
+      const args = [];
+      for (const i of Array(v.length).keys())
+        args.push(String.fromCharCode(i + 97));
+      return `//fn(${args.join(", ")}) { ... }`;
+    }
+    if (this.#references.size === this.#references.add(v).size) {
+      return "//js(circular reference)";
+    }
+    let printed;
+    if (Array.isArray(v)) {
+      printed = `#(${v.map((v2) => this.inspect(v2)).join(", ")})`;
+    } else if (v instanceof List) {
+      printed = this.#list(v);
+    } else if (v instanceof CustomType) {
+      printed = this.#customType(v);
+    } else if (v instanceof Dict) {
+      printed = this.#dict(v);
+    } else if (v instanceof Set) {
+      return `//js(Set(${[...v].map((v2) => this.inspect(v2)).join(", ")}))`;
+    } else {
+      printed = this.#object(v);
+    }
+    this.#references.delete(v);
+    return printed;
+  }
+  #object(v) {
+    const name = Object.getPrototypeOf(v)?.constructor?.name || "Object";
+    const props = [];
+    for (const k of Object.keys(v)) {
+      props.push(`${this.inspect(k)}: ${this.inspect(v[k])}`);
+    }
+    const body = props.length ? " " + props.join(", ") + " " : "";
+    const head = name === "Object" ? "" : name + " ";
+    return `//js(${head}{${body}})`;
+  }
+  #dict(map7) {
+    let body = "dict.from_list([";
+    let first2 = true;
+    map7.forEach((value, key) => {
+      if (!first2) body = body + ", ";
+      body = body + "#(" + this.inspect(key) + ", " + this.inspect(value) + ")";
+      first2 = false;
+    });
+    return body + "])";
+  }
+  #customType(record) {
+    const props = Object.keys(record).map((label) => {
+      const value = this.inspect(record[label]);
+      return isNaN(parseInt(label)) ? `${label}: ${value}` : value;
+    }).join(", ");
+    return props ? `${record.constructor.name}(${props})` : record.constructor.name;
+  }
+  #list(list4) {
+    if (list4 instanceof Empty) {
+      return "[]";
+    }
+    let char_out = 'charlist.from_string("';
+    let list_out = "[";
+    let current = list4;
+    while (current instanceof NonEmpty) {
+      let element4 = current.head;
+      current = current.tail;
+      if (list_out !== "[") {
+        list_out += ", ";
+      }
+      list_out += this.inspect(element4);
+      if (char_out) {
+        if (Number.isInteger(element4) && element4 >= 32 && element4 <= 126) {
+          char_out += String.fromCharCode(element4);
+        } else {
+          char_out = null;
+        }
+      }
+    }
+    if (char_out) {
+      return char_out + '")';
+    } else {
+      return list_out + "]";
+    }
+  }
+  #string(str) {
+    let new_str = '"';
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+      switch (char) {
+        case "\n":
+          new_str += "\\n";
+          break;
+        case "\r":
+          new_str += "\\r";
+          break;
+        case "	":
+          new_str += "\\t";
+          break;
+        case "\f":
+          new_str += "\\f";
+          break;
+        case "\\":
+          new_str += "\\\\";
+          break;
+        case '"':
+          new_str += '\\"';
+          break;
+        default:
+          if (char < " " || char > "~" && char < "\xA0") {
+            new_str += "\\u{" + char.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0") + "}";
+          } else {
+            new_str += char;
+          }
+      }
+    }
+    new_str += '"';
+    return new_str;
+  }
+  #utfCodepoint(codepoint2) {
+    return `//utfcodepoint(${String.fromCodePoint(codepoint2.value)})`;
+  }
+  #bit_array(bits) {
+    if (bits.bitSize === 0) {
+      return "<<>>";
+    }
+    let acc = "<<";
+    for (let i = 0; i < bits.byteSize - 1; i++) {
+      acc += bits.byteAt(i).toString();
+      acc += ", ";
+    }
+    if (bits.byteSize * 8 === bits.bitSize) {
+      acc += bits.byteAt(bits.byteSize - 1).toString();
+    } else {
+      const trailingBitsCount = bits.bitSize % 8;
+      acc += bits.byteAt(bits.byteSize - 1) >> 8 - trailingBitsCount;
+      acc += `:size(${trailingBitsCount})`;
+    }
+    acc += ">>";
+    return acc;
+  }
+};
+function base16_encode(bit_array2) {
+  const trailingBitsCount = bit_array2.bitSize % 8;
+  let result = "";
+  for (let i = 0; i < bit_array2.byteSize; i++) {
+    let byte = bit_array2.byteAt(i);
+    if (i === bit_array2.byteSize - 1 && trailingBitsCount !== 0) {
+      const unusedBitsCount = 8 - trailingBitsCount;
+      byte = byte >> unusedBitsCount << unusedBitsCount;
+    }
+    result += byte.toString(16).padStart(2, "0").toUpperCase();
+  }
+  return result;
+}
+function index2(data, key) {
+  if (data instanceof Dict || data instanceof WeakMap || data instanceof Map) {
+    const token2 = {};
+    const entry = data.get(key, token2);
+    if (entry === token2) return new Ok(new None());
+    return new Ok(new Some(entry));
+  }
+  const key_is_int = Number.isInteger(key);
+  if (key_is_int && key >= 0 && key < 8 && data instanceof List) {
+    let i = 0;
+    for (const value of data) {
+      if (i === key) return new Ok(new Some(value));
+      i++;
+    }
+    return new Error("Indexable");
+  }
+  if (key_is_int && Array.isArray(data) || data && typeof data === "object" || data && Object.getPrototypeOf(data) === Object.prototype) {
+    if (key in data) return new Ok(new Some(data[key]));
+    return new Ok(new None());
+  }
+  return new Error(key_is_int ? "Indexable" : "Dict");
+}
+function int(data) {
+  if (Number.isInteger(data)) return new Ok(data);
+  return new Error(0);
+}
+function string(data) {
+  if (typeof data === "string") return new Ok(data);
+  return new Error("");
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/float.mjs
+function compare(a, b) {
+  let $ = a === b;
+  if ($) {
+    return new Eq();
+  } else {
+    let $1 = a < b;
+    if ($1) {
+      return new Lt();
+    } else {
+      return new Gt();
+    }
+  }
+}
+function power(base, exponent) {
+  let fractional = ceiling(exponent) - exponent > 0;
+  let $ = base < 0 && fractional || base === 0 && exponent < 0;
+  if ($) {
+    return new Error(void 0);
+  } else {
+    return new Ok(power2(base, exponent));
+  }
+}
+function square_root(x) {
+  return power(x, 0.5);
+}
+function negate(x) {
+  return -1 * x;
+}
+function round(x) {
+  let $ = x >= 0;
+  if ($) {
+    return round2(x);
+  } else {
+    return 0 - round2(negate(x));
+  }
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/result.mjs
+function is_ok(result) {
+  if (result instanceof Ok) {
+    return true;
+  } else {
+    return false;
+  }
+}
+function unwrap2(result, default$) {
+  if (result instanceof Ok) {
+    let v = result[0];
+    return v;
+  } else {
+    return default$;
+  }
+}
+
+// build/dev/javascript/iv/iv_ffi.mjs
+var empty = () => [];
+var singleton = (x) => [x];
+var append3 = (xs, x) => [...xs, x];
+var get1 = (idx, xs) => xs[idx - 1];
+var set1 = (idx, xs, x) => xs.with(idx - 1, x);
+var length3 = (xs) => xs.length;
+var bsl = (a, b) => a << b;
+var bsr = (a, b) => a >> b;
+
+// build/dev/javascript/iv/iv/internal/vector.mjs
+function fold_loop(loop$xs, loop$state, loop$idx, loop$len, loop$fun) {
+  while (true) {
+    let xs = loop$xs;
+    let state = loop$state;
+    let idx = loop$idx;
+    let len = loop$len;
+    let fun = loop$fun;
+    let $ = idx <= len;
+    if ($) {
+      loop$xs = xs;
+      loop$state = fun(state, get1(idx, xs));
+      loop$idx = idx + 1;
+      loop$len = len;
+      loop$fun = fun;
+    } else {
+      return state;
+    }
+  }
+}
+function fold_skip_first(xs, state, fun) {
+  let len = length3(xs);
+  return fold_loop(xs, state, 2, len, fun);
+}
+function fold_right_loop(loop$xs, loop$state, loop$idx, loop$fun) {
+  while (true) {
+    let xs = loop$xs;
+    let state = loop$state;
+    let idx = loop$idx;
+    let fun = loop$fun;
+    let $ = idx > 0;
+    if ($) {
+      loop$xs = xs;
+      loop$state = fun(state, get1(idx, xs));
+      loop$idx = idx - 1;
+      loop$fun = fun;
+    } else {
+      return state;
+    }
+  }
+}
+function fold_right(xs, state, fun) {
+  let len = length3(xs);
+  return fold_right_loop(xs, state, len, fun);
+}
+function index_fold_loop(loop$xs, loop$state, loop$idx, loop$len, loop$fun) {
+  while (true) {
+    let xs = loop$xs;
+    let state = loop$state;
+    let idx = loop$idx;
+    let len = loop$len;
+    let fun = loop$fun;
+    let $ = idx <= len;
+    if ($) {
+      loop$xs = xs;
+      loop$state = fun(state, get1(idx, xs), idx);
+      loop$idx = idx + 1;
+      loop$len = len;
+      loop$fun = fun;
+    } else {
+      return state;
+    }
+  }
+}
+function index_fold(xs, state, fun) {
+  let len = length3(xs);
+  return index_fold_loop(xs, state, 1, len, fun);
+}
+function index_map(xs, fun) {
+  return index_fold(
+    xs,
+    empty(),
+    (result, item, index4) => {
+      return append3(result, fun(item, index4));
+    }
+  );
+}
+
+// build/dev/javascript/iv/iv/internal/node.mjs
+var Balanced = class extends CustomType {
+  constructor(size3, children) {
+    super();
+    this.size = size3;
+    this.children = children;
+  }
+};
+var Unbalanced = class extends CustomType {
+  constructor(sizes, children) {
+    super();
+    this.sizes = sizes;
+    this.children = children;
+  }
+};
+var Leaf = class extends CustomType {
+  constructor(children) {
+    super();
+    this.children = children;
+  }
+};
+function leaf(items) {
+  return new Leaf(items);
+}
+function size(node2) {
+  if (node2 instanceof Balanced) {
+    let size$1 = node2.size;
+    return size$1;
+  } else if (node2 instanceof Unbalanced) {
+    let sizes = node2.sizes;
+    return get1(length3(sizes), sizes);
+  } else {
+    let children = node2.children;
+    return length3(children);
+  }
+}
+function compute_sizes(nodes) {
+  let first_size = size(get1(1, nodes));
+  return fold_skip_first(
+    nodes,
+    singleton(first_size),
+    (sizes, node2) => {
+      let size$1 = get1(length3(sizes), sizes) + size(node2);
+      return append3(sizes, size$1);
+    }
+  );
+}
+function find_size(loop$sizes, loop$size_idx_plus_one, loop$index) {
+  while (true) {
+    let sizes = loop$sizes;
+    let size_idx_plus_one = loop$size_idx_plus_one;
+    let index4 = loop$index;
+    let $ = get1(size_idx_plus_one, sizes) > index4;
+    if ($) {
+      return size_idx_plus_one - 1;
+    } else {
+      loop$sizes = sizes;
+      loop$size_idx_plus_one = size_idx_plus_one + 1;
+      loop$index = index4;
+    }
+  }
+}
+function fold_right2(node2, state, fun) {
+  if (node2 instanceof Balanced) {
+    let children = node2.children;
+    return fold_right(
+      children,
+      state,
+      (state2, node3) => {
+        return fold_right2(node3, state2, fun);
+      }
+    );
+  } else if (node2 instanceof Unbalanced) {
+    let children = node2.children;
+    return fold_right(
+      children,
+      state,
+      (state2, node3) => {
+        return fold_right2(node3, state2, fun);
+      }
+    );
+  } else {
+    let children = node2.children;
+    return fold_right(children, state, fun);
+  }
+}
+function balanced(shift, nodes) {
+  let len = length3(nodes);
+  let last_child = get1(len, nodes);
+  let max_size = bsl(1, shift);
+  let size$1 = max_size * (len - 1) + size(last_child);
+  return new Balanced(size$1, nodes);
+}
+function branch(shift, nodes) {
+  let len = length3(nodes);
+  let max_size = bsl(1, shift);
+  let sizes = compute_sizes(nodes);
+  let _block;
+  if (len === 1) {
+    _block = 0;
+  } else {
+    _block = get1(len - 1, sizes);
+  }
+  let prefix_size = _block;
+  let is_balanced = prefix_size === max_size * (len - 1);
+  if (is_balanced) {
+    let size$1 = get1(len, sizes);
+    return new Balanced(size$1, nodes);
+  } else {
+    return new Unbalanced(sizes, nodes);
+  }
+}
+var branch_bits = 5;
+function get(loop$node, loop$shift, loop$index) {
+  while (true) {
+    let node2 = loop$node;
+    let shift = loop$shift;
+    let index4 = loop$index;
+    if (node2 instanceof Balanced) {
+      let children = node2.children;
+      let node_index = bsr(index4, shift);
+      let index$1 = index4 - bsl(node_index, shift);
+      let child = get1(node_index + 1, children);
+      loop$node = child;
+      loop$shift = shift - branch_bits;
+      loop$index = index$1;
+    } else if (node2 instanceof Unbalanced) {
+      let sizes = node2.sizes;
+      let children = node2.children;
+      let start_search_index = bsr(index4, shift);
+      let node_index = find_size(sizes, start_search_index + 1, index4);
+      let _block;
+      if (node_index === 0) {
+        _block = index4;
+      } else {
+        _block = index4 - get1(node_index, sizes);
+      }
+      let index$1 = _block;
+      let child = get1(node_index + 1, children);
+      loop$node = child;
+      loop$shift = shift - branch_bits;
+      loop$index = index$1;
+    } else {
+      let children = node2.children;
+      return get1(index4 + 1, children);
+    }
+  }
+}
+function update(shift, node2, index4, fun) {
+  if (node2 instanceof Balanced) {
+    let size$1 = node2.size;
+    let children = node2.children;
+    let node_index = bsr(index4, shift);
+    let index$1 = index4 - bsl(node_index, shift);
+    let _block;
+    let _pipe = get1(node_index + 1, children);
+    let _pipe$1 = ((_capture) => {
+      return update(shift - branch_bits, _capture, index$1, fun);
+    })(_pipe);
+    _block = ((_capture) => {
+      return set1(node_index + 1, children, _capture);
+    })(_pipe$1);
+    let new_children = _block;
+    return new Balanced(size$1, new_children);
+  } else if (node2 instanceof Unbalanced) {
+    let sizes = node2.sizes;
+    let children = node2.children;
+    let start_search_index = bsr(index4, shift);
+    let node_index = find_size(sizes, start_search_index + 1, index4);
+    let _block;
+    if (node_index === 0) {
+      _block = index4;
+    } else {
+      _block = index4 - get1(node_index, sizes);
+    }
+    let index$1 = _block;
+    let _block$1;
+    let _pipe = get1(node_index + 1, children);
+    let _pipe$1 = ((_capture) => {
+      return update(shift - branch_bits, _capture, index$1, fun);
+    })(_pipe);
+    _block$1 = ((_capture) => {
+      return set1(node_index + 1, children, _capture);
+    })(_pipe$1);
+    let new_children = _block$1;
+    return new Unbalanced(sizes, new_children);
+  } else {
+    let children = node2.children;
+    let new_children = set1(
+      index4 + 1,
+      children,
+      fun(get1(index4 + 1, children))
+    );
+    return new Leaf(new_children);
+  }
+}
+var branch_factor = 32;
+function index_map2(offset, node2, fun) {
+  if (node2 instanceof Balanced) {
+    let size$1 = node2.size;
+    let children = node2.children;
+    let children$1 = index_map(
+      children,
+      (child, index4) => {
+        return index_map2(offset + (index4 - 1) * branch_factor, child, fun);
+      }
+    );
+    return new Balanced(size$1, children$1);
+  } else if (node2 instanceof Unbalanced) {
+    let sizes = node2.sizes;
+    let children = node2.children;
+    let children$1 = index_map(
+      children,
+      (child, index4) => {
+        let _block;
+        if (index4 === 1) {
+          _block = 0;
+        } else {
+          _block = get1(index4 - 1, sizes);
+        }
+        let child_offset = _block;
+        return index_map2(offset + child_offset, child, fun);
+      }
+    );
+    return new Unbalanced(sizes, children$1);
+  } else {
+    let children = node2.children;
+    let children$1 = index_map(
+      children,
+      (item, index4) => {
+        return fun(item, index4 + offset - 1);
+      }
+    );
+    return new Leaf(children$1);
+  }
+}
+
+// build/dev/javascript/iv/iv/internal/builder.mjs
+var Builder = class extends CustomType {
+  constructor(nodes, items, push_node, push_item) {
+    super();
+    this.nodes = nodes;
+    this.items = items;
+    this.push_node = push_node;
+    this.push_item = push_item;
+  }
+};
+function append_node(nodes, node2, shift) {
+  if (nodes instanceof Empty) {
+    return toList([singleton(node2)]);
+  } else {
+    let nodes$1 = nodes.head;
+    let rest = nodes.tail;
+    let $ = length3(nodes$1) < branch_factor;
+    if ($) {
+      return prepend(append3(nodes$1, node2), rest);
+    } else {
+      let shift$1 = shift + branch_bits;
+      let new_node = balanced(shift$1, nodes$1);
+      return prepend(
+        singleton(node2),
+        append_node(rest, new_node, shift$1)
+      );
+    }
+  }
+}
+function new$() {
+  return new Builder(toList([]), empty(), append_node, append3);
+}
+function push(builder, item) {
+  let nodes = builder.nodes;
+  let items = builder.items;
+  let push_node = builder.push_node;
+  let push_item = builder.push_item;
+  let $ = length3(items) === branch_factor;
+  if ($) {
+    let leaf2 = leaf(items);
+    return new Builder(
+      push_node(nodes, leaf2, 0),
+      singleton(item),
+      push_node,
+      push_item
+    );
+  } else {
+    return new Builder(nodes, push_item(items, item), push_node, push_item);
+  }
+}
+function compress_nodes(loop$nodes, loop$push_node, loop$shift) {
+  while (true) {
+    let nodes = loop$nodes;
+    let push_node = loop$push_node;
+    let shift = loop$shift;
+    if (nodes instanceof Empty) {
+      return new Error(void 0);
+    } else {
+      let $ = nodes.tail;
+      if ($ instanceof Empty) {
+        let root3 = nodes.head;
+        return new Ok([shift, root3]);
+      } else {
+        let nodes$1 = nodes.head;
+        let rest = $;
+        let shift$1 = shift + branch_bits;
+        let compressed = push_node(
+          rest,
+          branch(shift$1, nodes$1),
+          shift$1
+        );
+        loop$nodes = compressed;
+        loop$push_node = push_node;
+        loop$shift = shift$1;
+      }
+    }
+  }
+}
+function build(builder) {
+  let nodes = builder.nodes;
+  let items = builder.items;
+  let push_node = builder.push_node;
+  let items_len = length3(items);
+  let _block;
+  let $ = items_len > 0;
+  if ($) {
+    _block = push_node(nodes, leaf(items), 0);
+  } else {
+    _block = nodes;
+  }
+  let nodes$1 = _block;
+  return compress_nodes(nodes$1, push_node, 0);
+}
+
+// build/dev/javascript/iv/iv.mjs
+var Empty2 = class extends CustomType {
+};
+var Array2 = class extends CustomType {
+  constructor(shift, root3) {
+    super();
+    this.shift = shift;
+    this.root = root3;
+  }
+};
+function array(shift, nodes) {
+  let $ = length3(nodes);
+  if ($ === 0) {
+    return new Empty2();
+  } else if ($ === 1) {
+    return new Array2(shift, get1(1, nodes));
+  } else {
+    let shift$1 = shift + branch_bits;
+    return new Array2(shift$1, branch(shift$1, nodes));
+  }
+}
+function from_list2(list4) {
+  let $ = (() => {
+    let _pipe = list4;
+    let _pipe$1 = fold(_pipe, new$(), push);
+    return build(_pipe$1);
+  })();
+  if ($ instanceof Ok) {
+    let shift = $[0][0];
+    let nodes = $[0][1];
+    return array(shift, nodes);
+  } else {
+    return new Empty2();
+  }
+}
+function get2(array4, index4) {
+  if (array4 instanceof Empty2) {
+    return new Error(void 0);
+  } else {
+    let shift = array4.shift;
+    let root3 = array4.root;
+    let $ = 0 <= index4 && index4 < size(root3);
+    if ($) {
+      return new Ok(get(root3, shift, index4));
+    } else {
+      return new Error(void 0);
+    }
+  }
+}
+function update2(array4, index4, fun) {
+  if (array4 instanceof Empty2) {
+    return new Error(void 0);
+  } else {
+    let shift = array4.shift;
+    let root3 = array4.root;
+    let $ = 0 <= index4 && index4 < size(root3);
+    if ($) {
+      return new Ok(new Array2(shift, update(shift, root3, index4, fun)));
+    } else {
+      return new Error(void 0);
+    }
+  }
+}
+function set(array4, index4, item) {
+  return update2(array4, index4, (_) => {
+    return item;
+  });
+}
+function index_map3(array4, fun) {
+  if (array4 instanceof Empty2) {
+    return new Empty2();
+  } else {
+    let shift = array4.shift;
+    let root3 = array4.root;
+    return new Array2(shift, index_map2(0, root3, fun));
+  }
+}
+function fold_right3(array4, state, fun) {
+  if (array4 instanceof Empty2) {
+    return state;
+  } else {
+    let root3 = array4.root;
+    return fold_right2(root3, state, fun);
+  }
+}
+function to_list(array4) {
+  return fold_right3(array4, toList([]), prepend2);
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/function.mjs
+function identity2(x) {
+  return x;
+}
+function tap(arg, effect) {
+  effect(arg);
+  return arg;
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/set.mjs
+var Set2 = class extends CustomType {
+  constructor(dict2) {
+    super();
+    this.dict = dict2;
+  }
+};
+function new$3() {
+  return new Set2(new_map());
+}
+function contains(set2, member) {
+  let _pipe = set2.dict;
+  let _pipe$1 = map_get(_pipe, member);
+  return is_ok(_pipe$1);
+}
+var token = void 0;
+function insert2(set2, member) {
+  return new Set2(insert(set2.dict, member, token));
+}
+
+// build/dev/javascript/lustre/lustre/internals/constants.ffi.mjs
+var EMPTY_DICT = /* @__PURE__ */ Dict.new();
+var EMPTY_SET = /* @__PURE__ */ new$3();
+var empty_dict = () => EMPTY_DICT;
+var empty_set = () => EMPTY_SET;
+var document2 = () => globalThis?.document;
+var NAMESPACE_HTML = "http://www.w3.org/1999/xhtml";
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var DOCUMENT_FRAGMENT_NODE = 11;
+var SUPPORTS_MOVE_BEFORE = !!globalThis.HTMLElement?.prototype?.moveBefore;
+
+// build/dev/javascript/lustre/lustre/internals/constants.mjs
+var empty_list = /* @__PURE__ */ toList([]);
+var option_none = /* @__PURE__ */ new None();
+
+// build/dev/javascript/lustre/lustre/vdom/vattr.ffi.mjs
+var GT = /* @__PURE__ */ new Gt();
+var LT = /* @__PURE__ */ new Lt();
+var EQ = /* @__PURE__ */ new Eq();
+function compare3(a, b) {
+  if (a.name === b.name) {
+    return EQ;
+  } else if (a.name < b.name) {
+    return LT;
+  } else {
+    return GT;
+  }
+}
+
+// build/dev/javascript/lustre/lustre/vdom/vattr.mjs
+var Attribute = class extends CustomType {
+  constructor(kind, name, value) {
+    super();
+    this.kind = kind;
+    this.name = name;
+    this.value = value;
+  }
+};
+var Property = class extends CustomType {
+  constructor(kind, name, value) {
+    super();
+    this.kind = kind;
+    this.name = name;
+    this.value = value;
+  }
+};
+var Event2 = class extends CustomType {
+  constructor(kind, name, handler, include, prevent_default, stop_propagation, immediate2, debounce, throttle) {
+    super();
+    this.kind = kind;
+    this.name = name;
+    this.handler = handler;
+    this.include = include;
+    this.prevent_default = prevent_default;
+    this.stop_propagation = stop_propagation;
+    this.immediate = immediate2;
+    this.debounce = debounce;
+    this.throttle = throttle;
+  }
+};
+var Handler = class extends CustomType {
+  constructor(prevent_default, stop_propagation, message) {
+    super();
+    this.prevent_default = prevent_default;
+    this.stop_propagation = stop_propagation;
+    this.message = message;
+  }
+};
+var Never = class extends CustomType {
+  constructor(kind) {
+    super();
+    this.kind = kind;
+  }
+};
+function merge(loop$attributes, loop$merged) {
+  while (true) {
+    let attributes = loop$attributes;
+    let merged = loop$merged;
+    if (attributes instanceof Empty) {
+      return merged;
+    } else {
+      let $ = attributes.head;
+      if ($ instanceof Attribute) {
+        let $1 = $.name;
+        if ($1 === "") {
+          let rest = attributes.tail;
+          loop$attributes = rest;
+          loop$merged = merged;
+        } else if ($1 === "class") {
+          let $2 = $.value;
+          if ($2 === "") {
+            let rest = attributes.tail;
+            loop$attributes = rest;
+            loop$merged = merged;
+          } else {
+            let $3 = attributes.tail;
+            if ($3 instanceof Empty) {
+              let attribute$1 = $;
+              let rest = $3;
+              loop$attributes = rest;
+              loop$merged = prepend(attribute$1, merged);
+            } else {
+              let $4 = $3.head;
+              if ($4 instanceof Attribute) {
+                let $5 = $4.name;
+                if ($5 === "class") {
+                  let kind = $.kind;
+                  let class1 = $2;
+                  let rest = $3.tail;
+                  let class2 = $4.value;
+                  let value = class1 + " " + class2;
+                  let attribute$1 = new Attribute(kind, "class", value);
+                  loop$attributes = prepend(attribute$1, rest);
+                  loop$merged = merged;
+                } else {
+                  let attribute$1 = $;
+                  let rest = $3;
+                  loop$attributes = rest;
+                  loop$merged = prepend(attribute$1, merged);
+                }
+              } else {
+                let attribute$1 = $;
+                let rest = $3;
+                loop$attributes = rest;
+                loop$merged = prepend(attribute$1, merged);
+              }
+            }
+          }
+        } else if ($1 === "style") {
+          let $2 = $.value;
+          if ($2 === "") {
+            let rest = attributes.tail;
+            loop$attributes = rest;
+            loop$merged = merged;
+          } else {
+            let $3 = attributes.tail;
+            if ($3 instanceof Empty) {
+              let attribute$1 = $;
+              let rest = $3;
+              loop$attributes = rest;
+              loop$merged = prepend(attribute$1, merged);
+            } else {
+              let $4 = $3.head;
+              if ($4 instanceof Attribute) {
+                let $5 = $4.name;
+                if ($5 === "style") {
+                  let kind = $.kind;
+                  let style1 = $2;
+                  let rest = $3.tail;
+                  let style2 = $4.value;
+                  let value = style1 + ";" + style2;
+                  let attribute$1 = new Attribute(kind, "style", value);
+                  loop$attributes = prepend(attribute$1, rest);
+                  loop$merged = merged;
+                } else {
+                  let attribute$1 = $;
+                  let rest = $3;
+                  loop$attributes = rest;
+                  loop$merged = prepend(attribute$1, merged);
+                }
+              } else {
+                let attribute$1 = $;
+                let rest = $3;
+                loop$attributes = rest;
+                loop$merged = prepend(attribute$1, merged);
+              }
+            }
+          }
+        } else {
+          let attribute$1 = $;
+          let rest = attributes.tail;
+          loop$attributes = rest;
+          loop$merged = prepend(attribute$1, merged);
+        }
+      } else {
+        let attribute$1 = $;
+        let rest = attributes.tail;
+        loop$attributes = rest;
+        loop$merged = prepend(attribute$1, merged);
+      }
+    }
+  }
+}
+function prepare(attributes) {
+  if (attributes instanceof Empty) {
+    return attributes;
+  } else {
+    let $ = attributes.tail;
+    if ($ instanceof Empty) {
+      return attributes;
+    } else {
+      let _pipe = attributes;
+      let _pipe$1 = sort(_pipe, (a, b) => {
+        return compare3(b, a);
+      });
+      return merge(_pipe$1, empty_list);
+    }
+  }
+}
+var attribute_kind = 0;
+function attribute(name, value) {
+  return new Attribute(attribute_kind, name, value);
+}
+var property_kind = 1;
+var event_kind = 2;
+function event(name, handler, include, prevent_default, stop_propagation, immediate2, debounce, throttle) {
+  return new Event2(
+    event_kind,
+    name,
+    handler,
+    include,
+    prevent_default,
+    stop_propagation,
+    immediate2,
+    debounce,
+    throttle
+  );
+}
+var never_kind = 0;
+var never = /* @__PURE__ */ new Never(never_kind);
+var always_kind = 2;
+
+// build/dev/javascript/lustre/lustre/attribute.mjs
+function attribute2(name, value) {
+  return attribute(name, value);
+}
+function class$(name) {
+  return attribute2("class", name);
+}
+function placeholder(text5) {
+  return attribute2("placeholder", text5);
+}
+function type_(control_type) {
+  return attribute2("type", control_type);
+}
+
+// build/dev/javascript/lustre/lustre/effect.mjs
+var Effect = class extends CustomType {
+  constructor(synchronous, before_paint2, after_paint) {
+    super();
+    this.synchronous = synchronous;
+    this.before_paint = before_paint2;
+    this.after_paint = after_paint;
+  }
+};
+var empty3 = /* @__PURE__ */ new Effect(
+  /* @__PURE__ */ toList([]),
+  /* @__PURE__ */ toList([]),
+  /* @__PURE__ */ toList([])
+);
+function none() {
+  return empty3;
+}
+function from(effect) {
+  let task = (actions) => {
+    let dispatch = actions.dispatch;
+    return effect(dispatch);
+  };
+  let _record = empty3;
+  return new Effect(toList([task]), _record.before_paint, _record.after_paint);
+}
+
+// build/dev/javascript/lustre/lustre/internals/mutable_map.ffi.mjs
+function empty4() {
+  return null;
+}
+function get3(map7, key) {
+  const value = map7?.get(key);
+  if (value != null) {
+    return new Ok(value);
+  } else {
+    return new Error(void 0);
+  }
+}
+function insert3(map7, key, value) {
+  map7 ??= /* @__PURE__ */ new Map();
+  map7.set(key, value);
+  return map7;
+}
+function remove(map7, key) {
+  map7?.delete(key);
+  return map7;
+}
+
+// build/dev/javascript/lustre/lustre/vdom/path.mjs
+var Root = class extends CustomType {
+};
+var Key = class extends CustomType {
+  constructor(key, parent) {
+    super();
+    this.key = key;
+    this.parent = parent;
+  }
+};
+var Index = class extends CustomType {
+  constructor(index4, parent) {
+    super();
+    this.index = index4;
+    this.parent = parent;
+  }
+};
+function do_matches(loop$path, loop$candidates) {
+  while (true) {
+    let path = loop$path;
+    let candidates = loop$candidates;
+    if (candidates instanceof Empty) {
+      return false;
+    } else {
+      let candidate = candidates.head;
+      let rest = candidates.tail;
+      let $ = starts_with(path, candidate);
+      if ($) {
+        return true;
+      } else {
+        loop$path = path;
+        loop$candidates = rest;
+      }
+    }
+  }
+}
+function add3(parent, index4, key) {
+  if (key === "") {
+    return new Index(index4, parent);
+  } else {
+    return new Key(key, parent);
+  }
+}
+var root2 = /* @__PURE__ */ new Root();
+var separator_element = "	";
+function do_to_string(loop$path, loop$acc) {
+  while (true) {
+    let path = loop$path;
+    let acc = loop$acc;
+    if (path instanceof Root) {
+      if (acc instanceof Empty) {
+        return "";
+      } else {
+        let segments = acc.tail;
+        return concat2(segments);
+      }
+    } else if (path instanceof Key) {
+      let key = path.key;
+      let parent = path.parent;
+      loop$path = parent;
+      loop$acc = prepend(separator_element, prepend(key, acc));
+    } else {
+      let index4 = path.index;
+      let parent = path.parent;
+      loop$path = parent;
+      loop$acc = prepend(
+        separator_element,
+        prepend(to_string(index4), acc)
+      );
+    }
+  }
+}
+function to_string2(path) {
+  return do_to_string(path, toList([]));
+}
+function matches(path, candidates) {
+  if (candidates instanceof Empty) {
+    return false;
+  } else {
+    return do_matches(to_string2(path), candidates);
+  }
+}
+var separator_event = "\n";
+function event2(path, event4) {
+  return do_to_string(path, toList([separator_event, event4]));
+}
+
+// build/dev/javascript/lustre/lustre/vdom/vnode.mjs
+var Fragment = class extends CustomType {
+  constructor(kind, key, mapper, children, keyed_children, children_count) {
+    super();
+    this.kind = kind;
+    this.key = key;
+    this.mapper = mapper;
+    this.children = children;
+    this.keyed_children = keyed_children;
+    this.children_count = children_count;
+  }
+};
+var Element = class extends CustomType {
+  constructor(kind, key, mapper, namespace, tag, attributes, children, keyed_children, self_closing, void$) {
+    super();
+    this.kind = kind;
+    this.key = key;
+    this.mapper = mapper;
+    this.namespace = namespace;
+    this.tag = tag;
+    this.attributes = attributes;
+    this.children = children;
+    this.keyed_children = keyed_children;
+    this.self_closing = self_closing;
+    this.void = void$;
+  }
+};
+var Text = class extends CustomType {
+  constructor(kind, key, mapper, content) {
+    super();
+    this.kind = kind;
+    this.key = key;
+    this.mapper = mapper;
+    this.content = content;
+  }
+};
+var UnsafeInnerHtml = class extends CustomType {
+  constructor(kind, key, mapper, namespace, tag, attributes, inner_html) {
+    super();
+    this.kind = kind;
+    this.key = key;
+    this.mapper = mapper;
+    this.namespace = namespace;
+    this.tag = tag;
+    this.attributes = attributes;
+    this.inner_html = inner_html;
+  }
+};
+function is_void_element(tag, namespace) {
+  if (namespace === "") {
+    if (tag === "area") {
+      return true;
+    } else if (tag === "base") {
+      return true;
+    } else if (tag === "br") {
+      return true;
+    } else if (tag === "col") {
+      return true;
+    } else if (tag === "embed") {
+      return true;
+    } else if (tag === "hr") {
+      return true;
+    } else if (tag === "img") {
+      return true;
+    } else if (tag === "input") {
+      return true;
+    } else if (tag === "link") {
+      return true;
+    } else if (tag === "meta") {
+      return true;
+    } else if (tag === "param") {
+      return true;
+    } else if (tag === "source") {
+      return true;
+    } else if (tag === "track") {
+      return true;
+    } else if (tag === "wbr") {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+function advance(node2) {
+  if (node2 instanceof Fragment) {
+    let children_count = node2.children_count;
+    return 1 + children_count;
+  } else {
+    return 1;
+  }
+}
+var fragment_kind = 0;
+function fragment(key, mapper, children, keyed_children, children_count) {
+  return new Fragment(
+    fragment_kind,
+    key,
+    mapper,
+    children,
+    keyed_children,
+    children_count
+  );
+}
+var element_kind = 1;
+function element(key, mapper, namespace, tag, attributes, children, keyed_children, self_closing, void$) {
+  return new Element(
+    element_kind,
+    key,
+    mapper,
+    namespace,
+    tag,
+    prepare(attributes),
+    children,
+    keyed_children,
+    self_closing,
+    void$ || is_void_element(tag, namespace)
+  );
+}
+var text_kind = 2;
+function text(key, mapper, content) {
+  return new Text(text_kind, key, mapper, content);
+}
+var unsafe_inner_html_kind = 3;
+function unsafe_inner_html(key, mapper, namespace, tag, attributes, inner_html) {
+  return new UnsafeInnerHtml(
+    unsafe_inner_html_kind,
+    key,
+    mapper,
+    namespace,
+    tag,
+    prepare(attributes),
+    inner_html
+  );
+}
+function set_fragment_key(loop$key, loop$children, loop$index, loop$new_children, loop$keyed_children) {
+  while (true) {
+    let key = loop$key;
+    let children = loop$children;
+    let index4 = loop$index;
+    let new_children = loop$new_children;
+    let keyed_children = loop$keyed_children;
+    if (children instanceof Empty) {
+      return [reverse(new_children), keyed_children];
+    } else {
+      let $ = children.head;
+      if ($ instanceof Fragment) {
+        let node2 = $;
+        if (node2.key === "") {
+          let children$1 = children.tail;
+          let child_key = key + "::" + to_string(index4);
+          let $1 = set_fragment_key(
+            child_key,
+            node2.children,
+            0,
+            empty_list,
+            empty4()
+          );
+          let node_children = $1[0];
+          let node_keyed_children = $1[1];
+          let _block;
+          let _record = node2;
+          _block = new Fragment(
+            _record.kind,
+            _record.key,
+            _record.mapper,
+            node_children,
+            node_keyed_children,
+            _record.children_count
+          );
+          let new_node = _block;
+          let new_children$1 = prepend(new_node, new_children);
+          let index$1 = index4 + 1;
+          loop$key = key;
+          loop$children = children$1;
+          loop$index = index$1;
+          loop$new_children = new_children$1;
+          loop$keyed_children = keyed_children;
+        } else {
+          let node$1 = $;
+          if (node$1.key !== "") {
+            let children$1 = children.tail;
+            let child_key = key + "::" + node$1.key;
+            let keyed_node = to_keyed(child_key, node$1);
+            let new_children$1 = prepend(keyed_node, new_children);
+            let keyed_children$1 = insert3(
+              keyed_children,
+              child_key,
+              keyed_node
+            );
+            let index$1 = index4 + 1;
+            loop$key = key;
+            loop$children = children$1;
+            loop$index = index$1;
+            loop$new_children = new_children$1;
+            loop$keyed_children = keyed_children$1;
+          } else {
+            let node$2 = $;
+            let children$1 = children.tail;
+            let new_children$1 = prepend(node$2, new_children);
+            let index$1 = index4 + 1;
+            loop$key = key;
+            loop$children = children$1;
+            loop$index = index$1;
+            loop$new_children = new_children$1;
+            loop$keyed_children = keyed_children;
+          }
+        }
+      } else {
+        let node2 = $;
+        if (node2.key !== "") {
+          let children$1 = children.tail;
+          let child_key = key + "::" + node2.key;
+          let keyed_node = to_keyed(child_key, node2);
+          let new_children$1 = prepend(keyed_node, new_children);
+          let keyed_children$1 = insert3(
+            keyed_children,
+            child_key,
+            keyed_node
+          );
+          let index$1 = index4 + 1;
+          loop$key = key;
+          loop$children = children$1;
+          loop$index = index$1;
+          loop$new_children = new_children$1;
+          loop$keyed_children = keyed_children$1;
+        } else {
+          let node$1 = $;
+          let children$1 = children.tail;
+          let new_children$1 = prepend(node$1, new_children);
+          let index$1 = index4 + 1;
+          loop$key = key;
+          loop$children = children$1;
+          loop$index = index$1;
+          loop$new_children = new_children$1;
+          loop$keyed_children = keyed_children;
+        }
+      }
+    }
+  }
+}
+function to_keyed(key, node2) {
+  if (node2 instanceof Fragment) {
+    let children = node2.children;
+    let $ = set_fragment_key(
+      key,
+      children,
+      0,
+      empty_list,
+      empty4()
+    );
+    let children$1 = $[0];
+    let keyed_children = $[1];
+    let _record = node2;
+    return new Fragment(
+      _record.kind,
+      key,
+      _record.mapper,
+      children$1,
+      keyed_children,
+      _record.children_count
+    );
+  } else if (node2 instanceof Element) {
+    let _record = node2;
+    return new Element(
+      _record.kind,
+      key,
+      _record.mapper,
+      _record.namespace,
+      _record.tag,
+      _record.attributes,
+      _record.children,
+      _record.keyed_children,
+      _record.self_closing,
+      _record.void
+    );
+  } else if (node2 instanceof Text) {
+    let _record = node2;
+    return new Text(_record.kind, key, _record.mapper, _record.content);
+  } else {
+    let _record = node2;
+    return new UnsafeInnerHtml(
+      _record.kind,
+      key,
+      _record.mapper,
+      _record.namespace,
+      _record.tag,
+      _record.attributes,
+      _record.inner_html
+    );
+  }
+}
+
+// build/dev/javascript/lustre/lustre/internals/equals.ffi.mjs
+var isReferenceEqual = (a, b) => a === b;
+var isEqual2 = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  const type = typeof a;
+  if (type !== typeof b) {
+    return false;
+  }
+  if (type !== "object") {
+    return false;
+  }
+  const ctor = a.constructor;
+  if (ctor !== b.constructor) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    return areArraysEqual(a, b);
+  }
+  return areObjectsEqual(a, b);
+};
+var areArraysEqual = (a, b) => {
+  let index4 = a.length;
+  if (index4 !== b.length) {
+    return false;
+  }
+  while (index4--) {
+    if (!isEqual2(a[index4], b[index4])) {
+      return false;
+    }
+  }
+  return true;
+};
+var areObjectsEqual = (a, b) => {
+  const properties = Object.keys(a);
+  let index4 = properties.length;
+  if (Object.keys(b).length !== index4) {
+    return false;
+  }
+  while (index4--) {
+    const property4 = properties[index4];
+    if (!Object.hasOwn(b, property4)) {
+      return false;
+    }
+    if (!isEqual2(a[property4], b[property4])) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// build/dev/javascript/lustre/lustre/vdom/events.mjs
+var Events = class extends CustomType {
+  constructor(handlers, dispatched_paths, next_dispatched_paths) {
+    super();
+    this.handlers = handlers;
+    this.dispatched_paths = dispatched_paths;
+    this.next_dispatched_paths = next_dispatched_paths;
+  }
+};
+function new$5() {
+  return new Events(
+    empty4(),
+    empty_list,
+    empty_list
+  );
+}
+function tick(events) {
+  return new Events(
+    events.handlers,
+    events.next_dispatched_paths,
+    empty_list
+  );
+}
+function do_remove_event(handlers, path, name) {
+  return remove(handlers, event2(path, name));
+}
+function remove_event(events, path, name) {
+  let handlers = do_remove_event(events.handlers, path, name);
+  let _record = events;
+  return new Events(
+    handlers,
+    _record.dispatched_paths,
+    _record.next_dispatched_paths
+  );
+}
+function remove_attributes(handlers, path, attributes) {
+  return fold(
+    attributes,
+    handlers,
+    (events, attribute3) => {
+      if (attribute3 instanceof Event2) {
+        let name = attribute3.name;
+        return do_remove_event(events, path, name);
+      } else {
+        return events;
+      }
+    }
+  );
+}
+function handle(events, path, name, event4) {
+  let next_dispatched_paths = prepend(path, events.next_dispatched_paths);
+  let _block;
+  let _record = events;
+  _block = new Events(
+    _record.handlers,
+    _record.dispatched_paths,
+    next_dispatched_paths
+  );
+  let events$1 = _block;
+  let $ = get3(
+    events$1.handlers,
+    path + separator_event + name
+  );
+  if ($ instanceof Ok) {
+    let handler = $[0];
+    return [events$1, run(event4, handler)];
+  } else {
+    return [events$1, new Error(toList([]))];
+  }
+}
+function has_dispatched_events(events, path) {
+  return matches(path, events.dispatched_paths);
+}
+function do_add_event(handlers, mapper, path, name, handler) {
+  return insert3(
+    handlers,
+    event2(path, name),
+    map2(
+      handler,
+      (handler2) => {
+        let _record = handler2;
+        return new Handler(
+          _record.prevent_default,
+          _record.stop_propagation,
+          identity2(mapper)(handler2.message)
+        );
+      }
+    )
+  );
+}
+function add_event(events, mapper, path, name, handler) {
+  let handlers = do_add_event(events.handlers, mapper, path, name, handler);
+  let _record = events;
+  return new Events(
+    handlers,
+    _record.dispatched_paths,
+    _record.next_dispatched_paths
+  );
+}
+function add_attributes(handlers, mapper, path, attributes) {
+  return fold(
+    attributes,
+    handlers,
+    (events, attribute3) => {
+      if (attribute3 instanceof Event2) {
+        let name = attribute3.name;
+        let handler = attribute3.handler;
+        return do_add_event(events, mapper, path, name, handler);
+      } else {
+        return events;
+      }
+    }
+  );
+}
+function compose_mapper(mapper, child_mapper) {
+  let $ = isReferenceEqual(mapper, identity2);
+  let $1 = isReferenceEqual(child_mapper, identity2);
+  if ($1) {
+    return mapper;
+  } else if ($) {
+    return child_mapper;
+  } else {
+    return (msg) => {
+      return mapper(child_mapper(msg));
+    };
+  }
+}
+function do_remove_children(loop$handlers, loop$path, loop$child_index, loop$children) {
+  while (true) {
+    let handlers = loop$handlers;
+    let path = loop$path;
+    let child_index = loop$child_index;
+    let children = loop$children;
+    if (children instanceof Empty) {
+      return handlers;
+    } else {
+      let child = children.head;
+      let rest = children.tail;
+      let _pipe = handlers;
+      let _pipe$1 = do_remove_child(_pipe, path, child_index, child);
+      loop$handlers = _pipe$1;
+      loop$path = path;
+      loop$child_index = child_index + advance(child);
+      loop$children = rest;
+    }
+  }
+}
+function do_remove_child(handlers, parent, child_index, child) {
+  if (child instanceof Fragment) {
+    let children = child.children;
+    return do_remove_children(handlers, parent, child_index + 1, children);
+  } else if (child instanceof Element) {
+    let attributes = child.attributes;
+    let children = child.children;
+    let path = add3(parent, child_index, child.key);
+    let _pipe = handlers;
+    let _pipe$1 = remove_attributes(_pipe, path, attributes);
+    return do_remove_children(_pipe$1, path, 0, children);
+  } else if (child instanceof Text) {
+    return handlers;
+  } else {
+    let attributes = child.attributes;
+    let path = add3(parent, child_index, child.key);
+    return remove_attributes(handlers, path, attributes);
+  }
+}
+function remove_child(events, parent, child_index, child) {
+  let handlers = do_remove_child(events.handlers, parent, child_index, child);
+  let _record = events;
+  return new Events(
+    handlers,
+    _record.dispatched_paths,
+    _record.next_dispatched_paths
+  );
+}
+function do_add_children(loop$handlers, loop$mapper, loop$path, loop$child_index, loop$children) {
+  while (true) {
+    let handlers = loop$handlers;
+    let mapper = loop$mapper;
+    let path = loop$path;
+    let child_index = loop$child_index;
+    let children = loop$children;
+    if (children instanceof Empty) {
+      return handlers;
+    } else {
+      let child = children.head;
+      let rest = children.tail;
+      let _pipe = handlers;
+      let _pipe$1 = do_add_child(_pipe, mapper, path, child_index, child);
+      loop$handlers = _pipe$1;
+      loop$mapper = mapper;
+      loop$path = path;
+      loop$child_index = child_index + advance(child);
+      loop$children = rest;
+    }
+  }
+}
+function do_add_child(handlers, mapper, parent, child_index, child) {
+  if (child instanceof Fragment) {
+    let children = child.children;
+    let composed_mapper = compose_mapper(mapper, child.mapper);
+    let child_index$1 = child_index + 1;
+    return do_add_children(
+      handlers,
+      composed_mapper,
+      parent,
+      child_index$1,
+      children
+    );
+  } else if (child instanceof Element) {
+    let attributes = child.attributes;
+    let children = child.children;
+    let path = add3(parent, child_index, child.key);
+    let composed_mapper = compose_mapper(mapper, child.mapper);
+    let _pipe = handlers;
+    let _pipe$1 = add_attributes(_pipe, composed_mapper, path, attributes);
+    return do_add_children(_pipe$1, composed_mapper, path, 0, children);
+  } else if (child instanceof Text) {
+    return handlers;
+  } else {
+    let attributes = child.attributes;
+    let path = add3(parent, child_index, child.key);
+    let composed_mapper = compose_mapper(mapper, child.mapper);
+    return add_attributes(handlers, composed_mapper, path, attributes);
+  }
+}
+function add_child(events, mapper, parent, index4, child) {
+  let handlers = do_add_child(events.handlers, mapper, parent, index4, child);
+  let _record = events;
+  return new Events(
+    handlers,
+    _record.dispatched_paths,
+    _record.next_dispatched_paths
+  );
+}
+function add_children(events, mapper, path, child_index, children) {
+  let handlers = do_add_children(
+    events.handlers,
+    mapper,
+    path,
+    child_index,
+    children
+  );
+  let _record = events;
+  return new Events(
+    handlers,
+    _record.dispatched_paths,
+    _record.next_dispatched_paths
+  );
+}
+
+// build/dev/javascript/lustre/lustre/element.mjs
+function element2(tag, attributes, children) {
+  return element(
+    "",
+    identity2,
+    "",
+    tag,
+    attributes,
+    children,
+    empty4(),
+    false,
+    false
+  );
+}
+function namespaced(namespace, tag, attributes, children) {
+  return element(
+    "",
+    identity2,
+    namespace,
+    tag,
+    attributes,
+    children,
+    empty4(),
+    false,
+    false
+  );
+}
+function text2(content) {
+  return text("", identity2, content);
+}
+function none2() {
+  return text("", identity2, "");
+}
+function count_fragment_children(loop$children, loop$count) {
+  while (true) {
+    let children = loop$children;
+    let count = loop$count;
+    if (children instanceof Empty) {
+      return count;
+    } else {
+      let child = children.head;
+      let rest = children.tail;
+      loop$children = rest;
+      loop$count = count + advance(child);
+    }
+  }
+}
+function fragment2(children) {
+  return fragment(
+    "",
+    identity2,
+    children,
+    empty4(),
+    count_fragment_children(children, 0)
+  );
+}
+function unsafe_raw_html(namespace, tag, attributes, inner_html) {
+  return unsafe_inner_html(
+    "",
+    identity2,
+    namespace,
+    tag,
+    attributes,
+    inner_html
+  );
+}
+
+// build/dev/javascript/lustre/lustre/element/html.mjs
+function style(attrs, css) {
+  return unsafe_raw_html("", "style", attrs, css);
+}
+
+// build/dev/javascript/lustre/lustre/vdom/patch.mjs
+var Patch = class extends CustomType {
+  constructor(index4, removed, changes, children) {
+    super();
+    this.index = index4;
+    this.removed = removed;
+    this.changes = changes;
+    this.children = children;
+  }
+};
+var ReplaceText = class extends CustomType {
+  constructor(kind, content) {
+    super();
+    this.kind = kind;
+    this.content = content;
+  }
+};
+var ReplaceInnerHtml = class extends CustomType {
+  constructor(kind, inner_html) {
+    super();
+    this.kind = kind;
+    this.inner_html = inner_html;
+  }
+};
+var Update = class extends CustomType {
+  constructor(kind, added, removed) {
+    super();
+    this.kind = kind;
+    this.added = added;
+    this.removed = removed;
+  }
+};
+var Move = class extends CustomType {
+  constructor(kind, key, before, count) {
+    super();
+    this.kind = kind;
+    this.key = key;
+    this.before = before;
+    this.count = count;
+  }
+};
+var RemoveKey = class extends CustomType {
+  constructor(kind, key, count) {
+    super();
+    this.kind = kind;
+    this.key = key;
+    this.count = count;
+  }
+};
+var Replace = class extends CustomType {
+  constructor(kind, from2, count, with$) {
+    super();
+    this.kind = kind;
+    this.from = from2;
+    this.count = count;
+    this.with = with$;
+  }
+};
+var Insert = class extends CustomType {
+  constructor(kind, children, before) {
+    super();
+    this.kind = kind;
+    this.children = children;
+    this.before = before;
+  }
+};
+var Remove = class extends CustomType {
+  constructor(kind, from2, count) {
+    super();
+    this.kind = kind;
+    this.from = from2;
+    this.count = count;
+  }
+};
+function new$7(index4, removed, changes, children) {
+  return new Patch(index4, removed, changes, children);
+}
+var replace_text_kind = 0;
+function replace_text(content) {
+  return new ReplaceText(replace_text_kind, content);
+}
+var replace_inner_html_kind = 1;
+function replace_inner_html(inner_html) {
+  return new ReplaceInnerHtml(replace_inner_html_kind, inner_html);
+}
+var update_kind = 2;
+function update3(added, removed) {
+  return new Update(update_kind, added, removed);
+}
+var move_kind = 3;
+function move(key, before, count) {
+  return new Move(move_kind, key, before, count);
+}
+var remove_key_kind = 4;
+function remove_key(key, count) {
+  return new RemoveKey(remove_key_kind, key, count);
+}
+var replace_kind = 5;
+function replace2(from2, count, with$) {
+  return new Replace(replace_kind, from2, count, with$);
+}
+var insert_kind = 6;
+function insert4(children, before) {
+  return new Insert(insert_kind, children, before);
+}
+var remove_kind = 7;
+function remove2(from2, count) {
+  return new Remove(remove_kind, from2, count);
+}
+
+// build/dev/javascript/lustre/lustre/vdom/diff.mjs
+var Diff = class extends CustomType {
+  constructor(patch, events) {
+    super();
+    this.patch = patch;
+    this.events = events;
+  }
+};
+var AttributeChange = class extends CustomType {
+  constructor(added, removed, events) {
+    super();
+    this.added = added;
+    this.removed = removed;
+    this.events = events;
+  }
+};
+function is_controlled(events, namespace, tag, path) {
+  if (tag === "input") {
+    if (namespace === "") {
+      return has_dispatched_events(events, path);
+    } else {
+      return false;
+    }
+  } else if (tag === "select") {
+    if (namespace === "") {
+      return has_dispatched_events(events, path);
+    } else {
+      return false;
+    }
+  } else if (tag === "textarea") {
+    if (namespace === "") {
+      return has_dispatched_events(events, path);
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+function diff_attributes(loop$controlled, loop$path, loop$mapper, loop$events, loop$old, loop$new, loop$added, loop$removed) {
+  while (true) {
+    let controlled = loop$controlled;
+    let path = loop$path;
+    let mapper = loop$mapper;
+    let events = loop$events;
+    let old = loop$old;
+    let new$11 = loop$new;
+    let added = loop$added;
+    let removed = loop$removed;
+    if (new$11 instanceof Empty) {
+      if (old instanceof Empty) {
+        return new AttributeChange(added, removed, events);
+      } else {
+        let $ = old.head;
+        if ($ instanceof Event2) {
+          let prev = $;
+          let old$1 = old.tail;
+          let name = $.name;
+          let removed$1 = prepend(prev, removed);
+          let events$1 = remove_event(events, path, name);
+          loop$controlled = controlled;
+          loop$path = path;
+          loop$mapper = mapper;
+          loop$events = events$1;
+          loop$old = old$1;
+          loop$new = new$11;
+          loop$added = added;
+          loop$removed = removed$1;
+        } else {
+          let prev = $;
+          let old$1 = old.tail;
+          let removed$1 = prepend(prev, removed);
+          loop$controlled = controlled;
+          loop$path = path;
+          loop$mapper = mapper;
+          loop$events = events;
+          loop$old = old$1;
+          loop$new = new$11;
+          loop$added = added;
+          loop$removed = removed$1;
+        }
+      }
+    } else if (old instanceof Empty) {
+      let $ = new$11.head;
+      if ($ instanceof Event2) {
+        let next = $;
+        let new$1 = new$11.tail;
+        let name = $.name;
+        let handler = $.handler;
+        let added$1 = prepend(next, added);
+        let events$1 = add_event(events, mapper, path, name, handler);
+        loop$controlled = controlled;
+        loop$path = path;
+        loop$mapper = mapper;
+        loop$events = events$1;
+        loop$old = old;
+        loop$new = new$1;
+        loop$added = added$1;
+        loop$removed = removed;
+      } else {
+        let next = $;
+        let new$1 = new$11.tail;
+        let added$1 = prepend(next, added);
+        loop$controlled = controlled;
+        loop$path = path;
+        loop$mapper = mapper;
+        loop$events = events;
+        loop$old = old;
+        loop$new = new$1;
+        loop$added = added$1;
+        loop$removed = removed;
+      }
+    } else {
+      let next = new$11.head;
+      let remaining_new = new$11.tail;
+      let prev = old.head;
+      let remaining_old = old.tail;
+      let $ = compare3(prev, next);
+      if ($ instanceof Lt) {
+        if (prev instanceof Event2) {
+          let name = prev.name;
+          let removed$1 = prepend(prev, removed);
+          let events$1 = remove_event(events, path, name);
+          loop$controlled = controlled;
+          loop$path = path;
+          loop$mapper = mapper;
+          loop$events = events$1;
+          loop$old = remaining_old;
+          loop$new = new$11;
+          loop$added = added;
+          loop$removed = removed$1;
+        } else {
+          let removed$1 = prepend(prev, removed);
+          loop$controlled = controlled;
+          loop$path = path;
+          loop$mapper = mapper;
+          loop$events = events;
+          loop$old = remaining_old;
+          loop$new = new$11;
+          loop$added = added;
+          loop$removed = removed$1;
+        }
+      } else if ($ instanceof Eq) {
+        if (next instanceof Attribute) {
+          if (prev instanceof Attribute) {
+            let _block;
+            let $1 = next.name;
+            if ($1 === "value") {
+              _block = controlled || prev.value !== next.value;
+            } else if ($1 === "checked") {
+              _block = controlled || prev.value !== next.value;
+            } else if ($1 === "selected") {
+              _block = controlled || prev.value !== next.value;
+            } else {
+              _block = prev.value !== next.value;
+            }
+            let has_changes = _block;
+            let _block$1;
+            if (has_changes) {
+              _block$1 = prepend(next, added);
+            } else {
+              _block$1 = added;
+            }
+            let added$1 = _block$1;
+            loop$controlled = controlled;
+            loop$path = path;
+            loop$mapper = mapper;
+            loop$events = events;
+            loop$old = remaining_old;
+            loop$new = remaining_new;
+            loop$added = added$1;
+            loop$removed = removed;
+          } else if (prev instanceof Event2) {
+            let name = prev.name;
+            let added$1 = prepend(next, added);
+            let removed$1 = prepend(prev, removed);
+            let events$1 = remove_event(events, path, name);
+            loop$controlled = controlled;
+            loop$path = path;
+            loop$mapper = mapper;
+            loop$events = events$1;
+            loop$old = remaining_old;
+            loop$new = remaining_new;
+            loop$added = added$1;
+            loop$removed = removed$1;
+          } else {
+            let added$1 = prepend(next, added);
+            let removed$1 = prepend(prev, removed);
+            loop$controlled = controlled;
+            loop$path = path;
+            loop$mapper = mapper;
+            loop$events = events;
+            loop$old = remaining_old;
+            loop$new = remaining_new;
+            loop$added = added$1;
+            loop$removed = removed$1;
+          }
+        } else if (next instanceof Property) {
+          if (prev instanceof Property) {
+            let _block;
+            let $1 = next.name;
+            if ($1 === "scrollLeft") {
+              _block = true;
+            } else if ($1 === "scrollRight") {
+              _block = true;
+            } else if ($1 === "value") {
+              _block = controlled || !isEqual2(
+                prev.value,
+                next.value
+              );
+            } else if ($1 === "checked") {
+              _block = controlled || !isEqual2(
+                prev.value,
+                next.value
+              );
+            } else if ($1 === "selected") {
+              _block = controlled || !isEqual2(
+                prev.value,
+                next.value
+              );
+            } else {
+              _block = !isEqual2(prev.value, next.value);
+            }
+            let has_changes = _block;
+            let _block$1;
+            if (has_changes) {
+              _block$1 = prepend(next, added);
+            } else {
+              _block$1 = added;
+            }
+            let added$1 = _block$1;
+            loop$controlled = controlled;
+            loop$path = path;
+            loop$mapper = mapper;
+            loop$events = events;
+            loop$old = remaining_old;
+            loop$new = remaining_new;
+            loop$added = added$1;
+            loop$removed = removed;
+          } else if (prev instanceof Event2) {
+            let name = prev.name;
+            let added$1 = prepend(next, added);
+            let removed$1 = prepend(prev, removed);
+            let events$1 = remove_event(events, path, name);
+            loop$controlled = controlled;
+            loop$path = path;
+            loop$mapper = mapper;
+            loop$events = events$1;
+            loop$old = remaining_old;
+            loop$new = remaining_new;
+            loop$added = added$1;
+            loop$removed = removed$1;
+          } else {
+            let added$1 = prepend(next, added);
+            let removed$1 = prepend(prev, removed);
+            loop$controlled = controlled;
+            loop$path = path;
+            loop$mapper = mapper;
+            loop$events = events;
+            loop$old = remaining_old;
+            loop$new = remaining_new;
+            loop$added = added$1;
+            loop$removed = removed$1;
+          }
+        } else if (prev instanceof Event2) {
+          let name = next.name;
+          let handler = next.handler;
+          let has_changes = !isEqual(
+            prev.prevent_default,
+            next.prevent_default
+          ) || !isEqual(prev.stop_propagation, next.stop_propagation) || prev.immediate !== next.immediate || prev.debounce !== next.debounce || prev.throttle !== next.throttle;
+          let _block;
+          if (has_changes) {
+            _block = prepend(next, added);
+          } else {
+            _block = added;
+          }
+          let added$1 = _block;
+          let events$1 = add_event(events, mapper, path, name, handler);
+          loop$controlled = controlled;
+          loop$path = path;
+          loop$mapper = mapper;
+          loop$events = events$1;
+          loop$old = remaining_old;
+          loop$new = remaining_new;
+          loop$added = added$1;
+          loop$removed = removed;
+        } else {
+          let name = next.name;
+          let handler = next.handler;
+          let added$1 = prepend(next, added);
+          let removed$1 = prepend(prev, removed);
+          let events$1 = add_event(events, mapper, path, name, handler);
+          loop$controlled = controlled;
+          loop$path = path;
+          loop$mapper = mapper;
+          loop$events = events$1;
+          loop$old = remaining_old;
+          loop$new = remaining_new;
+          loop$added = added$1;
+          loop$removed = removed$1;
+        }
+      } else if (next instanceof Event2) {
+        let name = next.name;
+        let handler = next.handler;
+        let added$1 = prepend(next, added);
+        let events$1 = add_event(events, mapper, path, name, handler);
+        loop$controlled = controlled;
+        loop$path = path;
+        loop$mapper = mapper;
+        loop$events = events$1;
+        loop$old = old;
+        loop$new = remaining_new;
+        loop$added = added$1;
+        loop$removed = removed;
+      } else {
+        let added$1 = prepend(next, added);
+        loop$controlled = controlled;
+        loop$path = path;
+        loop$mapper = mapper;
+        loop$events = events;
+        loop$old = old;
+        loop$new = remaining_new;
+        loop$added = added$1;
+        loop$removed = removed;
+      }
+    }
+  }
+}
+function do_diff(loop$old, loop$old_keyed, loop$new, loop$new_keyed, loop$moved, loop$moved_offset, loop$removed, loop$node_index, loop$patch_index, loop$path, loop$changes, loop$children, loop$mapper, loop$events) {
+  while (true) {
+    let old = loop$old;
+    let old_keyed = loop$old_keyed;
+    let new$11 = loop$new;
+    let new_keyed = loop$new_keyed;
+    let moved = loop$moved;
+    let moved_offset = loop$moved_offset;
+    let removed = loop$removed;
+    let node_index = loop$node_index;
+    let patch_index = loop$patch_index;
+    let path = loop$path;
+    let changes = loop$changes;
+    let children = loop$children;
+    let mapper = loop$mapper;
+    let events = loop$events;
+    if (new$11 instanceof Empty) {
+      if (old instanceof Empty) {
+        return new Diff(
+          new Patch(patch_index, removed, changes, children),
+          events
+        );
+      } else {
+        let prev = old.head;
+        let old$1 = old.tail;
+        let _block;
+        let $ = prev.key === "" || !contains(moved, prev.key);
+        if ($) {
+          _block = removed + advance(prev);
+        } else {
+          _block = removed;
+        }
+        let removed$1 = _block;
+        let events$1 = remove_child(events, path, node_index, prev);
+        loop$old = old$1;
+        loop$old_keyed = old_keyed;
+        loop$new = new$11;
+        loop$new_keyed = new_keyed;
+        loop$moved = moved;
+        loop$moved_offset = moved_offset;
+        loop$removed = removed$1;
+        loop$node_index = node_index;
+        loop$patch_index = patch_index;
+        loop$path = path;
+        loop$changes = changes;
+        loop$children = children;
+        loop$mapper = mapper;
+        loop$events = events$1;
+      }
+    } else if (old instanceof Empty) {
+      let events$1 = add_children(
+        events,
+        mapper,
+        path,
+        node_index,
+        new$11
+      );
+      let insert5 = insert4(new$11, node_index - moved_offset);
+      let changes$1 = prepend(insert5, changes);
+      return new Diff(
+        new Patch(patch_index, removed, changes$1, children),
+        events$1
+      );
+    } else {
+      let next = new$11.head;
+      let prev = old.head;
+      if (prev.key !== next.key) {
+        let new_remaining = new$11.tail;
+        let old_remaining = old.tail;
+        let next_did_exist = get3(old_keyed, next.key);
+        let prev_does_exist = get3(new_keyed, prev.key);
+        let prev_has_moved = contains(moved, prev.key);
+        if (next_did_exist instanceof Ok) {
+          if (prev_does_exist instanceof Ok) {
+            if (prev_has_moved) {
+              loop$old = old_remaining;
+              loop$old_keyed = old_keyed;
+              loop$new = new$11;
+              loop$new_keyed = new_keyed;
+              loop$moved = moved;
+              loop$moved_offset = moved_offset - advance(prev);
+              loop$removed = removed;
+              loop$node_index = node_index;
+              loop$patch_index = patch_index;
+              loop$path = path;
+              loop$changes = changes;
+              loop$children = children;
+              loop$mapper = mapper;
+              loop$events = events;
+            } else {
+              let match = next_did_exist[0];
+              let count = advance(next);
+              let before = node_index - moved_offset;
+              let move2 = move(next.key, before, count);
+              let changes$1 = prepend(move2, changes);
+              let moved$1 = insert2(moved, next.key);
+              let moved_offset$1 = moved_offset + count;
+              loop$old = prepend(match, old);
+              loop$old_keyed = old_keyed;
+              loop$new = new$11;
+              loop$new_keyed = new_keyed;
+              loop$moved = moved$1;
+              loop$moved_offset = moved_offset$1;
+              loop$removed = removed;
+              loop$node_index = node_index;
+              loop$patch_index = patch_index;
+              loop$path = path;
+              loop$changes = changes$1;
+              loop$children = children;
+              loop$mapper = mapper;
+              loop$events = events;
+            }
+          } else {
+            let count = advance(prev);
+            let moved_offset$1 = moved_offset - count;
+            let events$1 = remove_child(events, path, node_index, prev);
+            let remove3 = remove_key(prev.key, count);
+            let changes$1 = prepend(remove3, changes);
+            loop$old = old_remaining;
+            loop$old_keyed = old_keyed;
+            loop$new = new$11;
+            loop$new_keyed = new_keyed;
+            loop$moved = moved;
+            loop$moved_offset = moved_offset$1;
+            loop$removed = removed;
+            loop$node_index = node_index;
+            loop$patch_index = patch_index;
+            loop$path = path;
+            loop$changes = changes$1;
+            loop$children = children;
+            loop$mapper = mapper;
+            loop$events = events$1;
+          }
+        } else if (prev_does_exist instanceof Ok) {
+          let before = node_index - moved_offset;
+          let count = advance(next);
+          let events$1 = add_child(
+            events,
+            mapper,
+            path,
+            node_index,
+            next
+          );
+          let insert5 = insert4(toList([next]), before);
+          let changes$1 = prepend(insert5, changes);
+          loop$old = old;
+          loop$old_keyed = old_keyed;
+          loop$new = new_remaining;
+          loop$new_keyed = new_keyed;
+          loop$moved = moved;
+          loop$moved_offset = moved_offset + count;
+          loop$removed = removed;
+          loop$node_index = node_index + count;
+          loop$patch_index = patch_index;
+          loop$path = path;
+          loop$changes = changes$1;
+          loop$children = children;
+          loop$mapper = mapper;
+          loop$events = events$1;
+        } else {
+          let prev_count = advance(prev);
+          let next_count = advance(next);
+          let change = replace2(
+            node_index - moved_offset,
+            prev_count,
+            next
+          );
+          let _block;
+          let _pipe = events;
+          let _pipe$1 = remove_child(_pipe, path, node_index, prev);
+          _block = add_child(_pipe$1, mapper, path, node_index, next);
+          let events$1 = _block;
+          loop$old = old_remaining;
+          loop$old_keyed = old_keyed;
+          loop$new = new_remaining;
+          loop$new_keyed = new_keyed;
+          loop$moved = moved;
+          loop$moved_offset = moved_offset - prev_count + next_count;
+          loop$removed = removed;
+          loop$node_index = node_index + next_count;
+          loop$patch_index = patch_index;
+          loop$path = path;
+          loop$changes = prepend(change, changes);
+          loop$children = children;
+          loop$mapper = mapper;
+          loop$events = events$1;
+        }
+      } else {
+        let $ = old.head;
+        if ($ instanceof Fragment) {
+          let $1 = new$11.head;
+          if ($1 instanceof Fragment) {
+            let next$1 = $1;
+            let new$1 = new$11.tail;
+            let prev$1 = $;
+            let old$1 = old.tail;
+            let node_index$1 = node_index + 1;
+            let prev_count = prev$1.children_count;
+            let next_count = next$1.children_count;
+            let composed_mapper = compose_mapper(mapper, next$1.mapper);
+            let child = do_diff(
+              prev$1.children,
+              prev$1.keyed_children,
+              next$1.children,
+              next$1.keyed_children,
+              empty_set(),
+              moved_offset,
+              0,
+              node_index$1,
+              -1,
+              path,
+              empty_list,
+              children,
+              composed_mapper,
+              events
+            );
+            let _block;
+            let $2 = child.patch.removed > 0;
+            if ($2) {
+              let remove_from = node_index$1 + next_count - moved_offset;
+              let patch = remove2(remove_from, child.patch.removed);
+              _block = append(
+                child.patch.changes,
+                prepend(patch, changes)
+              );
+            } else {
+              _block = append(child.patch.changes, changes);
+            }
+            let changes$1 = _block;
+            loop$old = old$1;
+            loop$old_keyed = old_keyed;
+            loop$new = new$1;
+            loop$new_keyed = new_keyed;
+            loop$moved = moved;
+            loop$moved_offset = moved_offset + next_count - prev_count;
+            loop$removed = removed;
+            loop$node_index = node_index$1 + next_count;
+            loop$patch_index = patch_index;
+            loop$path = path;
+            loop$changes = changes$1;
+            loop$children = child.patch.children;
+            loop$mapper = mapper;
+            loop$events = child.events;
+          } else {
+            let next$1 = $1;
+            let new_remaining = new$11.tail;
+            let prev$1 = $;
+            let old_remaining = old.tail;
+            let prev_count = advance(prev$1);
+            let next_count = advance(next$1);
+            let change = replace2(
+              node_index - moved_offset,
+              prev_count,
+              next$1
+            );
+            let _block;
+            let _pipe = events;
+            let _pipe$1 = remove_child(_pipe, path, node_index, prev$1);
+            _block = add_child(
+              _pipe$1,
+              mapper,
+              path,
+              node_index,
+              next$1
+            );
+            let events$1 = _block;
+            loop$old = old_remaining;
+            loop$old_keyed = old_keyed;
+            loop$new = new_remaining;
+            loop$new_keyed = new_keyed;
+            loop$moved = moved;
+            loop$moved_offset = moved_offset - prev_count + next_count;
+            loop$removed = removed;
+            loop$node_index = node_index + next_count;
+            loop$patch_index = patch_index;
+            loop$path = path;
+            loop$changes = prepend(change, changes);
+            loop$children = children;
+            loop$mapper = mapper;
+            loop$events = events$1;
+          }
+        } else if ($ instanceof Element) {
+          let $1 = new$11.head;
+          if ($1 instanceof Element) {
+            let next$1 = $1;
+            let prev$1 = $;
+            if (prev$1.namespace === next$1.namespace && prev$1.tag === next$1.tag) {
+              let new$1 = new$11.tail;
+              let old$1 = old.tail;
+              let composed_mapper = compose_mapper(
+                mapper,
+                next$1.mapper
+              );
+              let child_path = add3(path, node_index, next$1.key);
+              let controlled = is_controlled(
+                events,
+                next$1.namespace,
+                next$1.tag,
+                child_path
+              );
+              let $2 = diff_attributes(
+                controlled,
+                child_path,
+                composed_mapper,
+                events,
+                prev$1.attributes,
+                next$1.attributes,
+                empty_list,
+                empty_list
+              );
+              let added_attrs = $2.added;
+              let removed_attrs = $2.removed;
+              let events$1 = $2.events;
+              let _block;
+              if (removed_attrs instanceof Empty) {
+                if (added_attrs instanceof Empty) {
+                  _block = empty_list;
+                } else {
+                  _block = toList([update3(added_attrs, removed_attrs)]);
+                }
+              } else {
+                _block = toList([update3(added_attrs, removed_attrs)]);
+              }
+              let initial_child_changes = _block;
+              let child = do_diff(
+                prev$1.children,
+                prev$1.keyed_children,
+                next$1.children,
+                next$1.keyed_children,
+                empty_set(),
+                0,
+                0,
+                0,
+                node_index,
+                child_path,
+                initial_child_changes,
+                empty_list,
+                composed_mapper,
+                events$1
+              );
+              let _block$1;
+              let $3 = child.patch;
+              let $4 = $3.children;
+              if ($4 instanceof Empty) {
+                let $5 = $3.changes;
+                if ($5 instanceof Empty) {
+                  let $6 = $3.removed;
+                  if ($6 === 0) {
+                    _block$1 = children;
+                  } else {
+                    _block$1 = prepend(child.patch, children);
+                  }
+                } else {
+                  _block$1 = prepend(child.patch, children);
+                }
+              } else {
+                _block$1 = prepend(child.patch, children);
+              }
+              let children$1 = _block$1;
+              loop$old = old$1;
+              loop$old_keyed = old_keyed;
+              loop$new = new$1;
+              loop$new_keyed = new_keyed;
+              loop$moved = moved;
+              loop$moved_offset = moved_offset;
+              loop$removed = removed;
+              loop$node_index = node_index + 1;
+              loop$patch_index = patch_index;
+              loop$path = path;
+              loop$changes = changes;
+              loop$children = children$1;
+              loop$mapper = mapper;
+              loop$events = child.events;
+            } else {
+              let next$2 = $1;
+              let new_remaining = new$11.tail;
+              let prev$2 = $;
+              let old_remaining = old.tail;
+              let prev_count = advance(prev$2);
+              let next_count = advance(next$2);
+              let change = replace2(
+                node_index - moved_offset,
+                prev_count,
+                next$2
+              );
+              let _block;
+              let _pipe = events;
+              let _pipe$1 = remove_child(
+                _pipe,
+                path,
+                node_index,
+                prev$2
+              );
+              _block = add_child(
+                _pipe$1,
+                mapper,
+                path,
+                node_index,
+                next$2
+              );
+              let events$1 = _block;
+              loop$old = old_remaining;
+              loop$old_keyed = old_keyed;
+              loop$new = new_remaining;
+              loop$new_keyed = new_keyed;
+              loop$moved = moved;
+              loop$moved_offset = moved_offset - prev_count + next_count;
+              loop$removed = removed;
+              loop$node_index = node_index + next_count;
+              loop$patch_index = patch_index;
+              loop$path = path;
+              loop$changes = prepend(change, changes);
+              loop$children = children;
+              loop$mapper = mapper;
+              loop$events = events$1;
+            }
+          } else {
+            let next$1 = $1;
+            let new_remaining = new$11.tail;
+            let prev$1 = $;
+            let old_remaining = old.tail;
+            let prev_count = advance(prev$1);
+            let next_count = advance(next$1);
+            let change = replace2(
+              node_index - moved_offset,
+              prev_count,
+              next$1
+            );
+            let _block;
+            let _pipe = events;
+            let _pipe$1 = remove_child(_pipe, path, node_index, prev$1);
+            _block = add_child(
+              _pipe$1,
+              mapper,
+              path,
+              node_index,
+              next$1
+            );
+            let events$1 = _block;
+            loop$old = old_remaining;
+            loop$old_keyed = old_keyed;
+            loop$new = new_remaining;
+            loop$new_keyed = new_keyed;
+            loop$moved = moved;
+            loop$moved_offset = moved_offset - prev_count + next_count;
+            loop$removed = removed;
+            loop$node_index = node_index + next_count;
+            loop$patch_index = patch_index;
+            loop$path = path;
+            loop$changes = prepend(change, changes);
+            loop$children = children;
+            loop$mapper = mapper;
+            loop$events = events$1;
+          }
+        } else if ($ instanceof Text) {
+          let $1 = new$11.head;
+          if ($1 instanceof Text) {
+            let next$1 = $1;
+            let prev$1 = $;
+            if (prev$1.content === next$1.content) {
+              let new$1 = new$11.tail;
+              let old$1 = old.tail;
+              loop$old = old$1;
+              loop$old_keyed = old_keyed;
+              loop$new = new$1;
+              loop$new_keyed = new_keyed;
+              loop$moved = moved;
+              loop$moved_offset = moved_offset;
+              loop$removed = removed;
+              loop$node_index = node_index + 1;
+              loop$patch_index = patch_index;
+              loop$path = path;
+              loop$changes = changes;
+              loop$children = children;
+              loop$mapper = mapper;
+              loop$events = events;
+            } else {
+              let next$2 = $1;
+              let new$1 = new$11.tail;
+              let old$1 = old.tail;
+              let child = new$7(
+                node_index,
+                0,
+                toList([replace_text(next$2.content)]),
+                empty_list
+              );
+              loop$old = old$1;
+              loop$old_keyed = old_keyed;
+              loop$new = new$1;
+              loop$new_keyed = new_keyed;
+              loop$moved = moved;
+              loop$moved_offset = moved_offset;
+              loop$removed = removed;
+              loop$node_index = node_index + 1;
+              loop$patch_index = patch_index;
+              loop$path = path;
+              loop$changes = changes;
+              loop$children = prepend(child, children);
+              loop$mapper = mapper;
+              loop$events = events;
+            }
+          } else {
+            let next$1 = $1;
+            let new_remaining = new$11.tail;
+            let prev$1 = $;
+            let old_remaining = old.tail;
+            let prev_count = advance(prev$1);
+            let next_count = advance(next$1);
+            let change = replace2(
+              node_index - moved_offset,
+              prev_count,
+              next$1
+            );
+            let _block;
+            let _pipe = events;
+            let _pipe$1 = remove_child(_pipe, path, node_index, prev$1);
+            _block = add_child(
+              _pipe$1,
+              mapper,
+              path,
+              node_index,
+              next$1
+            );
+            let events$1 = _block;
+            loop$old = old_remaining;
+            loop$old_keyed = old_keyed;
+            loop$new = new_remaining;
+            loop$new_keyed = new_keyed;
+            loop$moved = moved;
+            loop$moved_offset = moved_offset - prev_count + next_count;
+            loop$removed = removed;
+            loop$node_index = node_index + next_count;
+            loop$patch_index = patch_index;
+            loop$path = path;
+            loop$changes = prepend(change, changes);
+            loop$children = children;
+            loop$mapper = mapper;
+            loop$events = events$1;
+          }
+        } else {
+          let $1 = new$11.head;
+          if ($1 instanceof UnsafeInnerHtml) {
+            let next$1 = $1;
+            let new$1 = new$11.tail;
+            let prev$1 = $;
+            let old$1 = old.tail;
+            let composed_mapper = compose_mapper(mapper, next$1.mapper);
+            let child_path = add3(path, node_index, next$1.key);
+            let $2 = diff_attributes(
+              false,
+              child_path,
+              composed_mapper,
+              events,
+              prev$1.attributes,
+              next$1.attributes,
+              empty_list,
+              empty_list
+            );
+            let added_attrs = $2.added;
+            let removed_attrs = $2.removed;
+            let events$1 = $2.events;
+            let _block;
+            if (removed_attrs instanceof Empty) {
+              if (added_attrs instanceof Empty) {
+                _block = empty_list;
+              } else {
+                _block = toList([update3(added_attrs, removed_attrs)]);
+              }
+            } else {
+              _block = toList([update3(added_attrs, removed_attrs)]);
+            }
+            let child_changes = _block;
+            let _block$1;
+            let $3 = prev$1.inner_html === next$1.inner_html;
+            if ($3) {
+              _block$1 = child_changes;
+            } else {
+              _block$1 = prepend(
+                replace_inner_html(next$1.inner_html),
+                child_changes
+              );
+            }
+            let child_changes$1 = _block$1;
+            let _block$2;
+            if (child_changes$1 instanceof Empty) {
+              _block$2 = children;
+            } else {
+              _block$2 = prepend(
+                new$7(node_index, 0, child_changes$1, toList([])),
+                children
+              );
+            }
+            let children$1 = _block$2;
+            loop$old = old$1;
+            loop$old_keyed = old_keyed;
+            loop$new = new$1;
+            loop$new_keyed = new_keyed;
+            loop$moved = moved;
+            loop$moved_offset = moved_offset;
+            loop$removed = removed;
+            loop$node_index = node_index + 1;
+            loop$patch_index = patch_index;
+            loop$path = path;
+            loop$changes = changes;
+            loop$children = children$1;
+            loop$mapper = mapper;
+            loop$events = events$1;
+          } else {
+            let next$1 = $1;
+            let new_remaining = new$11.tail;
+            let prev$1 = $;
+            let old_remaining = old.tail;
+            let prev_count = advance(prev$1);
+            let next_count = advance(next$1);
+            let change = replace2(
+              node_index - moved_offset,
+              prev_count,
+              next$1
+            );
+            let _block;
+            let _pipe = events;
+            let _pipe$1 = remove_child(_pipe, path, node_index, prev$1);
+            _block = add_child(
+              _pipe$1,
+              mapper,
+              path,
+              node_index,
+              next$1
+            );
+            let events$1 = _block;
+            loop$old = old_remaining;
+            loop$old_keyed = old_keyed;
+            loop$new = new_remaining;
+            loop$new_keyed = new_keyed;
+            loop$moved = moved;
+            loop$moved_offset = moved_offset - prev_count + next_count;
+            loop$removed = removed;
+            loop$node_index = node_index + next_count;
+            loop$patch_index = patch_index;
+            loop$path = path;
+            loop$changes = prepend(change, changes);
+            loop$children = children;
+            loop$mapper = mapper;
+            loop$events = events$1;
+          }
+        }
+      }
+    }
+  }
+}
+function diff(events, old, new$11) {
+  return do_diff(
+    toList([old]),
+    empty4(),
+    toList([new$11]),
+    empty4(),
+    empty_set(),
+    0,
+    0,
+    0,
+    0,
+    root2,
+    empty_list,
+    empty_list,
+    identity2,
+    tick(events)
+  );
+}
+
+// build/dev/javascript/lustre/lustre/vdom/reconciler.ffi.mjs
+var Reconciler = class {
+  offset = 0;
+  #root = null;
+  #dispatch = () => {
+  };
+  #useServerEvents = false;
+  #exposeKeys = false;
+  constructor(root3, dispatch, { useServerEvents = false, exposeKeys = false } = {}) {
+    this.#root = root3;
+    this.#dispatch = dispatch;
+    this.#useServerEvents = useServerEvents;
+    this.#exposeKeys = exposeKeys;
+  }
+  mount(vdom) {
+    appendChild(this.#root, this.#createChild(this.#root, 0, vdom));
+  }
+  #stack = [];
+  push(patch) {
+    const offset = this.offset;
+    if (offset) {
+      iterate(patch.changes, (change) => {
+        switch (change.kind) {
+          case insert_kind:
+          case move_kind:
+            change.before = (change.before | 0) + offset;
+            break;
+          case remove_kind:
+          case replace_kind:
+            change.from = (change.from | 0) + offset;
+            break;
+        }
+      });
+      iterate(patch.children, (child) => {
+        child.index = (child.index | 0) + offset;
+      });
+    }
+    this.#stack.push({ node: this.#root, patch });
+    this.#reconcile();
+  }
+  // PATCHING ------------------------------------------------------------------
+  #reconcile() {
+    const self = this;
+    while (self.#stack.length) {
+      const { node: node2, patch } = self.#stack.pop();
+      iterate(patch.changes, (change) => {
+        switch (change.kind) {
+          case insert_kind:
+            self.#insert(node2, change.children, change.before);
+            break;
+          case move_kind:
+            self.#move(node2, change.key, change.before, change.count);
+            break;
+          case remove_key_kind:
+            self.#removeKey(node2, change.key, change.count);
+            break;
+          case remove_kind:
+            self.#remove(node2, change.from, change.count);
+            break;
+          case replace_kind:
+            self.#replace(node2, change.from, change.count, change.with);
+            break;
+          case replace_text_kind:
+            self.#replaceText(node2, change.content);
+            break;
+          case replace_inner_html_kind:
+            self.#replaceInnerHtml(node2, change.inner_html);
+            break;
+          case update_kind:
+            self.#update(node2, change.added, change.removed);
+            break;
+        }
+      });
+      if (patch.removed) {
+        self.#remove(
+          node2,
+          node2.childNodes.length - patch.removed,
+          patch.removed
+        );
+      }
+      let lastIndex = -1;
+      let lastChild = null;
+      iterate(patch.children, (child) => {
+        const index4 = child.index | 0;
+        const next = lastChild && lastIndex - index4 === 1 ? lastChild.previousSibling : childAt(node2, index4);
+        self.#stack.push({ node: next, patch: child });
+        lastChild = next;
+        lastIndex = index4;
+      });
+    }
+  }
+  // CHANGES -------------------------------------------------------------------
+  #insert(node2, children, before) {
+    const fragment3 = createDocumentFragment();
+    let childIndex = before | 0;
+    iterate(children, (child) => {
+      const el = this.#createChild(node2, childIndex, child);
+      appendChild(fragment3, el);
+      childIndex += advance(child);
+    });
+    insertBefore(node2, fragment3, childAt(node2, before));
+  }
+  #move(node2, key, before, count) {
+    let el = getKeyedChild(node2, key);
+    const beforeEl = childAt(node2, before);
+    for (let i = 0; i < count && el !== null; ++i) {
+      const next = el.nextSibling;
+      if (SUPPORTS_MOVE_BEFORE) {
+        node2.moveBefore(el, beforeEl);
+      } else {
+        insertBefore(node2, el, beforeEl);
+      }
+      el = next;
+    }
+  }
+  #removeKey(node2, key, count) {
+    this.#removeFromChild(node2, getKeyedChild(node2, key), count);
+  }
+  #remove(node2, from2, count) {
+    this.#removeFromChild(node2, childAt(node2, from2), count);
+  }
+  #removeFromChild(parent, child, count) {
+    while (count-- > 0 && child !== null) {
+      const next = child.nextSibling;
+      const key = child[meta].key;
+      if (key) {
+        parent[meta].keyedChildren.delete(key);
+      }
+      for (const [_, { timeout }] of child[meta].debouncers ?? []) {
+        clearTimeout(timeout);
+      }
+      parent.removeChild(child);
+      child = next;
+    }
+  }
+  #replace(parent, from2, count, child) {
+    this.#remove(parent, from2, count);
+    const el = this.#createChild(parent, from2, child);
+    insertBefore(parent, el, childAt(parent, from2));
+  }
+  #replaceText(node2, content) {
+    node2.data = content ?? "";
+  }
+  #replaceInnerHtml(node2, inner_html) {
+    node2.innerHTML = inner_html ?? "";
+  }
+  #update(node2, added, removed) {
+    iterate(removed, (attribute3) => {
+      const name = attribute3.name;
+      if (node2[meta].handlers.has(name)) {
+        node2.removeEventListener(name, handleEvent);
+        node2[meta].handlers.delete(name);
+        if (node2[meta].throttles.has(name)) {
+          node2[meta].throttles.delete(name);
+        }
+        if (node2[meta].debouncers.has(name)) {
+          clearTimeout(node2[meta].debouncers.get(name).timeout);
+          node2[meta].debouncers.delete(name);
+        }
+      } else {
+        node2.removeAttribute(name);
+        SYNCED_ATTRIBUTES[name]?.removed?.(node2, name);
+      }
+    });
+    iterate(added, (attribute3) => {
+      this.#createAttribute(node2, attribute3);
+    });
+  }
+  // CONSTRUCTORS --------------------------------------------------------------
+  #createChild(parent, index4, vnode) {
+    switch (vnode.kind) {
+      case element_kind: {
+        const node2 = createChildElement(parent, index4, vnode);
+        this.#createAttributes(node2, vnode);
+        this.#insert(node2, vnode.children);
+        return node2;
+      }
+      case text_kind: {
+        return createChildText(parent, index4, vnode);
+      }
+      case fragment_kind: {
+        const node2 = createDocumentFragment();
+        const head = createChildText(parent, index4, vnode);
+        appendChild(node2, head);
+        let childIndex = index4 + 1;
+        iterate(vnode.children, (child) => {
+          appendChild(node2, this.#createChild(parent, childIndex, child));
+          childIndex += advance(child);
+        });
+        return node2;
+      }
+      case unsafe_inner_html_kind: {
+        const node2 = createChildElement(parent, index4, vnode);
+        this.#createAttributes(node2, vnode);
+        this.#replaceInnerHtml(node2, vnode.inner_html);
+        return node2;
+      }
+    }
+  }
+  #createAttributes(node2, { key, attributes }) {
+    if (this.#exposeKeys && key) {
+      node2.setAttribute("data-lustre-key", key);
+    }
+    iterate(attributes, (attribute3) => this.#createAttribute(node2, attribute3));
+  }
+  #createAttribute(node2, attribute3) {
+    const { debouncers, handlers, throttles } = node2[meta];
+    const {
+      kind,
+      name,
+      value,
+      prevent_default: prevent,
+      stop_propagation: stop,
+      immediate: immediate2,
+      include,
+      debounce: debounceDelay,
+      throttle: throttleDelay
+    } = attribute3;
+    switch (kind) {
+      case attribute_kind: {
+        const valueOrDefault = value ?? "";
+        if (name === "virtual:defaultValue") {
+          node2.defaultValue = valueOrDefault;
+          return;
+        }
+        if (valueOrDefault !== node2.getAttribute(name)) {
+          node2.setAttribute(name, valueOrDefault);
+        }
+        SYNCED_ATTRIBUTES[name]?.added?.(node2, value);
+        break;
+      }
+      case property_kind:
+        node2[name] = value;
+        break;
+      case event_kind: {
+        if (handlers.has(name)) {
+          node2.removeEventListener(name, handleEvent);
+        }
+        node2.addEventListener(name, handleEvent, {
+          passive: prevent.kind === never_kind
+        });
+        if (throttleDelay > 0) {
+          const throttle = throttles.get(name) ?? {};
+          throttle.delay = throttleDelay;
+          throttles.set(name, throttle);
+        } else {
+          throttles.delete(name);
+        }
+        if (debounceDelay > 0) {
+          const debounce = debouncers.get(name) ?? {};
+          debounce.delay = debounceDelay;
+          debouncers.set(name, debounce);
+        } else {
+          clearTimeout(debouncers.get(name)?.timeout);
+          debouncers.delete(name);
+        }
+        handlers.set(name, (event4) => {
+          if (prevent.kind === always_kind) event4.preventDefault();
+          if (stop.kind === always_kind) event4.stopPropagation();
+          const type = event4.type;
+          const path = event4.currentTarget[meta].path;
+          const data = this.#useServerEvents ? createServerEvent(event4, include ?? []) : event4;
+          const throttle = throttles.get(type);
+          if (throttle) {
+            const now = Date.now();
+            const last = throttle.last || 0;
+            if (now > last + throttle.delay) {
+              throttle.last = now;
+              throttle.lastEvent = event4;
+              this.#dispatch(data, path, type, immediate2);
+            }
+          }
+          const debounce = debouncers.get(type);
+          if (debounce) {
+            clearTimeout(debounce.timeout);
+            debounce.timeout = setTimeout(() => {
+              if (event4 === throttles.get(type)?.lastEvent) return;
+              this.#dispatch(data, path, type, immediate2);
+            }, debounce.delay);
+          }
+          if (!throttle && !debounce) {
+            this.#dispatch(data, path, type, immediate2);
+          }
+        });
+        break;
+      }
+    }
+  }
+};
+var iterate = (list4, callback) => {
+  if (Array.isArray(list4)) {
+    for (let i = 0; i < list4.length; i++) {
+      callback(list4[i]);
+    }
+  } else if (list4) {
+    for (list4; list4.tail; list4 = list4.tail) {
+      callback(list4.head);
+    }
+  }
+};
+var appendChild = (node2, child) => node2.appendChild(child);
+var insertBefore = (parent, node2, referenceNode) => parent.insertBefore(node2, referenceNode ?? null);
+var createChildElement = (parent, index4, { key, tag, namespace }) => {
+  const node2 = document2().createElementNS(namespace || NAMESPACE_HTML, tag);
+  initialiseMetadata(parent, node2, index4, key);
+  return node2;
+};
+var createChildText = (parent, index4, { key, content }) => {
+  const node2 = document2().createTextNode(content ?? "");
+  initialiseMetadata(parent, node2, index4, key);
+  return node2;
+};
+var createDocumentFragment = () => document2().createDocumentFragment();
+var childAt = (node2, at) => node2.childNodes[at | 0];
+var meta = Symbol("lustre");
+var initialiseMetadata = (parent, node2, index4 = 0, key = "") => {
+  const segment = `${key || index4}`;
+  switch (node2.nodeType) {
+    case ELEMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE:
+      node2[meta] = {
+        key,
+        path: segment,
+        keyedChildren: /* @__PURE__ */ new Map(),
+        handlers: /* @__PURE__ */ new Map(),
+        throttles: /* @__PURE__ */ new Map(),
+        debouncers: /* @__PURE__ */ new Map()
+      };
+      break;
+    case TEXT_NODE:
+      node2[meta] = { key };
+      break;
+  }
+  if (parent && parent[meta] && key) {
+    parent[meta].keyedChildren.set(key, new WeakRef(node2));
+  }
+  if (parent && parent[meta] && parent[meta].path) {
+    node2[meta].path = `${parent[meta].path}${separator_element}${segment}`;
+  }
+};
+var getKeyedChild = (node2, key) => node2[meta].keyedChildren.get(key).deref();
+var handleEvent = (event4) => {
+  const target = event4.currentTarget;
+  const handler = target[meta].handlers.get(event4.type);
+  if (event4.type === "submit") {
+    event4.detail ??= {};
+    event4.detail.formData = [...new FormData(event4.target).entries()];
+  }
+  handler(event4);
+};
+var createServerEvent = (event4, include = []) => {
+  const data = {};
+  if (event4.type === "input" || event4.type === "change") {
+    include.push("target.value");
+  }
+  if (event4.type === "submit") {
+    include.push("detail.formData");
+  }
+  for (const property4 of include) {
+    const path = property4.split(".");
+    for (let i = 0, input = event4, output = data; i < path.length; i++) {
+      if (i === path.length - 1) {
+        output[path[i]] = input[path[i]];
+        break;
+      }
+      output = output[path[i]] ??= {};
+      input = input[path[i]];
+    }
+  }
+  return data;
+};
+var syncedBooleanAttribute = (name) => {
+  return {
+    added(node2) {
+      node2[name] = true;
+    },
+    removed(node2) {
+      node2[name] = false;
+    }
+  };
+};
+var syncedAttribute = (name) => {
+  return {
+    added(node2, value) {
+      node2[name] = value;
+    }
+  };
+};
+var SYNCED_ATTRIBUTES = {
+  checked: syncedBooleanAttribute("checked"),
+  selected: syncedBooleanAttribute("selected"),
+  value: syncedAttribute("value"),
+  autofocus: {
+    added(node2) {
+      queueMicrotask(() => node2.focus?.());
+    }
+  },
+  autoplay: {
+    added(node2) {
+      try {
+        node2.play?.();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+};
+
+// build/dev/javascript/lustre/lustre/vdom/virtualise.ffi.mjs
+var virtualise = (root3) => {
+  const vdom = virtualiseNode(null, root3, "");
+  if (vdom === null || vdom.children instanceof Empty) {
+    const empty5 = emptyTextNode(root3);
+    root3.appendChild(empty5);
+    return none2();
+  } else if (vdom.children instanceof NonEmpty && vdom.children.tail instanceof Empty) {
+    return vdom.children.head;
+  } else {
+    const head = emptyTextNode(root3);
+    root3.insertBefore(head, root3.firstChild);
+    return fragment2(vdom.children);
+  }
+};
+var emptyTextNode = (parent) => {
+  const node2 = document2().createTextNode("");
+  initialiseMetadata(parent, node2);
+  return node2;
+};
+var virtualiseNode = (parent, node2, index4) => {
+  switch (node2.nodeType) {
+    case ELEMENT_NODE: {
+      const key = node2.getAttribute("data-lustre-key");
+      initialiseMetadata(parent, node2, index4, key);
+      if (key) {
+        node2.removeAttribute("data-lustre-key");
+      }
+      const tag = node2.localName;
+      const namespace = node2.namespaceURI;
+      const isHtmlElement = !namespace || namespace === NAMESPACE_HTML;
+      if (isHtmlElement && INPUT_ELEMENTS.includes(tag)) {
+        virtualiseInputEvents(tag, node2);
+      }
+      const attributes = virtualiseAttributes(node2);
+      const children = virtualiseChildNodes(node2);
+      const vnode = isHtmlElement ? element2(tag, attributes, children) : namespaced(namespace, tag, attributes, children);
+      return key ? to_keyed(key, vnode) : vnode;
+    }
+    case TEXT_NODE:
+      initialiseMetadata(parent, node2, index4);
+      return node2.data ? text2(node2.data) : null;
+    case DOCUMENT_FRAGMENT_NODE:
+      initialiseMetadata(parent, node2, index4);
+      return node2.childNodes.length > 0 ? fragment2(virtualiseChildNodes(node2)) : null;
+    default:
+      return null;
+  }
+};
+var INPUT_ELEMENTS = ["input", "select", "textarea"];
+var virtualiseInputEvents = (tag, node2) => {
+  const value = node2.value;
+  const checked = node2.checked;
+  if (tag === "input" && node2.type === "checkbox" && !checked) return;
+  if (tag === "input" && node2.type === "radio" && !checked) return;
+  if (node2.type !== "checkbox" && node2.type !== "radio" && !value) return;
+  queueMicrotask(() => {
+    node2.value = value;
+    node2.checked = checked;
+    node2.dispatchEvent(new Event("input", { bubbles: true }));
+    node2.dispatchEvent(new Event("change", { bubbles: true }));
+    if (document2().activeElement !== node2) {
+      node2.dispatchEvent(new Event("blur", { bubbles: true }));
+    }
+  });
+};
+var virtualiseChildNodes = (node2) => {
+  let children = null;
+  let index4 = 0;
+  let child = node2.firstChild;
+  let ptr = null;
+  while (child) {
+    const vnode = virtualiseNode(node2, child, index4);
+    const next = child.nextSibling;
+    if (vnode) {
+      const list_node = new NonEmpty(vnode, null);
+      if (ptr) {
+        ptr = ptr.tail = list_node;
+      } else {
+        ptr = children = list_node;
+      }
+      index4 += 1;
+    } else {
+      node2.removeChild(child);
+    }
+    child = next;
+  }
+  if (!ptr) return empty_list;
+  ptr.tail = empty_list;
+  return children;
+};
+var virtualiseAttributes = (node2) => {
+  let index4 = node2.attributes.length;
+  let attributes = empty_list;
+  while (index4-- > 0) {
+    attributes = new NonEmpty(
+      virtualiseAttribute(node2.attributes[index4]),
+      attributes
+    );
+  }
+  return attributes;
+};
+var virtualiseAttribute = (attr) => {
+  const name = attr.localName;
+  const value = attr.value;
+  return attribute2(name, value);
+};
+
+// build/dev/javascript/lustre/lustre/runtime/client/runtime.ffi.mjs
+var is_browser = () => !!document2();
+var Runtime = class {
+  constructor(root3, [model, effects], view2, update5) {
+    this.root = root3;
+    this.#model = model;
+    this.#view = view2;
+    this.#update = update5;
+    this.#reconciler = new Reconciler(this.root, (event4, path, name) => {
+      const [events, result] = handle(this.#events, path, name, event4);
+      this.#events = events;
+      if (result.isOk()) {
+        const handler = result[0];
+        if (handler.stop_propagation) event4.stopPropagation();
+        if (handler.prevent_default) event4.preventDefault();
+        this.dispatch(handler.message, false);
+      }
+    });
+    this.#vdom = virtualise(this.root);
+    this.#events = new$5();
+    this.#shouldFlush = true;
+    this.#tick(effects);
+  }
+  // PUBLIC API ----------------------------------------------------------------
+  root = null;
+  set offset(offset) {
+    this.#reconciler.offset = offset;
+  }
+  dispatch(msg, immediate2 = false) {
+    this.#shouldFlush ||= immediate2;
+    if (this.#shouldQueue) {
+      this.#queue.push(msg);
+    } else {
+      const [model, effects] = this.#update(this.#model, msg);
+      this.#model = model;
+      this.#tick(effects);
+    }
+  }
+  emit(event4, data) {
+    const target = this.root.host ?? this.root;
+    target.dispatchEvent(
+      new CustomEvent(event4, {
+        detail: data,
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  // PRIVATE API ---------------------------------------------------------------
+  #model;
+  #view;
+  #update;
+  #vdom;
+  #events;
+  #reconciler;
+  #shouldQueue = false;
+  #queue = [];
+  #beforePaint = empty_list;
+  #afterPaint = empty_list;
+  #renderTimer = null;
+  #shouldFlush = false;
+  #actions = {
+    dispatch: (msg, immediate2) => this.dispatch(msg, immediate2),
+    emit: (event4, data) => this.emit(event4, data),
+    select: () => {
+    },
+    root: () => this.root
+  };
+  // A `#tick` is where we process effects and trigger any synchronous updates.
+  // Once a tick has been processed a render will be scheduled if none is already.
+  // p0
+  #tick(effects) {
+    this.#shouldQueue = true;
+    while (true) {
+      for (let list4 = effects.synchronous; list4.tail; list4 = list4.tail) {
+        list4.head(this.#actions);
+      }
+      this.#beforePaint = listAppend(this.#beforePaint, effects.before_paint);
+      this.#afterPaint = listAppend(this.#afterPaint, effects.after_paint);
+      if (!this.#queue.length) break;
+      [this.#model, effects] = this.#update(this.#model, this.#queue.shift());
+    }
+    this.#shouldQueue = false;
+    if (this.#shouldFlush) {
+      cancelAnimationFrame(this.#renderTimer);
+      this.#render();
+    } else if (!this.#renderTimer) {
+      this.#renderTimer = requestAnimationFrame(() => {
+        this.#render();
+      });
+    }
+  }
+  #render() {
+    this.#shouldFlush = false;
+    this.#renderTimer = null;
+    const next = this.#view(this.#model);
+    const { patch, events } = diff(this.#events, this.#vdom, next);
+    this.#events = events;
+    this.#vdom = next;
+    this.#reconciler.push(patch);
+    if (this.#beforePaint instanceof NonEmpty) {
+      const effects = makeEffect(this.#beforePaint);
+      this.#beforePaint = empty_list;
+      queueMicrotask(() => {
+        this.#shouldFlush = true;
+        this.#tick(effects);
+      });
+    }
+    if (this.#afterPaint instanceof NonEmpty) {
+      const effects = makeEffect(this.#afterPaint);
+      this.#afterPaint = empty_list;
+      requestAnimationFrame(() => {
+        this.#shouldFlush = true;
+        this.#tick(effects);
+      });
+    }
+  }
+};
+function makeEffect(synchronous) {
+  return {
+    synchronous,
+    after_paint: empty_list,
+    before_paint: empty_list
+  };
+}
+function listAppend(a, b) {
+  if (a instanceof Empty) {
+    return b;
+  } else if (b instanceof Empty) {
+    return a;
+  } else {
+    return append(a, b);
+  }
+}
+
+// build/dev/javascript/lustre/lustre/runtime/server/runtime.mjs
+var EffectDispatchedMessage = class extends CustomType {
+  constructor(message) {
+    super();
+    this.message = message;
+  }
+};
+var EffectEmitEvent = class extends CustomType {
+  constructor(name, data) {
+    super();
+    this.name = name;
+    this.data = data;
+  }
+};
+var SystemRequestedShutdown = class extends CustomType {
+};
+
+// build/dev/javascript/lustre/lustre/component.mjs
+var Config2 = class extends CustomType {
+  constructor(open_shadow_root, adopt_styles, attributes, properties, is_form_associated, on_form_autofill, on_form_reset, on_form_restore) {
+    super();
+    this.open_shadow_root = open_shadow_root;
+    this.adopt_styles = adopt_styles;
+    this.attributes = attributes;
+    this.properties = properties;
+    this.is_form_associated = is_form_associated;
+    this.on_form_autofill = on_form_autofill;
+    this.on_form_reset = on_form_reset;
+    this.on_form_restore = on_form_restore;
+  }
+};
+function new$8(options) {
+  let init2 = new Config2(
+    false,
+    true,
+    empty_dict(),
+    empty_dict(),
+    false,
+    option_none,
+    option_none,
+    option_none
+  );
+  return fold(
+    options,
+    init2,
+    (config, option) => {
+      return option.apply(config);
+    }
+  );
+}
+
+// build/dev/javascript/lustre/lustre/runtime/client/spa.ffi.mjs
+var Spa = class _Spa {
+  static start({ init: init2, update: update5, view: view2 }, selector, flags) {
+    if (!is_browser()) return new Error(new NotABrowser());
+    const root3 = selector instanceof HTMLElement ? selector : document2().querySelector(selector);
+    if (!root3) return new Error(new ElementNotFound(selector));
+    return new Ok(new _Spa(root3, init2(flags), update5, view2));
+  }
+  #runtime;
+  constructor(root3, [init2, effects], update5, view2) {
+    this.#runtime = new Runtime(root3, [init2, effects], view2, update5);
+  }
+  send(message) {
+    switch (message.constructor) {
+      case EffectDispatchedMessage: {
+        this.dispatch(message.message, false);
+        break;
+      }
+      case EffectEmitEvent: {
+        this.emit(message.name, message.data);
+        break;
+      }
+      case SystemRequestedShutdown:
+        break;
+    }
+  }
+  dispatch(msg, immediate2) {
+    this.#runtime.dispatch(msg, immediate2);
+  }
+  emit(event4, data) {
+    this.#runtime.emit(event4, data);
+  }
+};
+var start = Spa.start;
+
+// build/dev/javascript/lustre/lustre.mjs
+var App = class extends CustomType {
+  constructor(init2, update5, view2, config) {
+    super();
+    this.init = init2;
+    this.update = update5;
+    this.view = view2;
+    this.config = config;
+  }
+};
+var ElementNotFound = class extends CustomType {
+  constructor(selector) {
+    super();
+    this.selector = selector;
+  }
+};
+var NotABrowser = class extends CustomType {
+};
+function application(init2, update5, view2) {
+  return new App(init2, update5, view2, new$8(empty_list));
+}
+function start3(app, selector, start_args) {
+  return guard(
+    !is_browser(),
+    new Error(new NotABrowser()),
+    () => {
+      return start(app, selector, start_args);
+    }
+  );
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/pair.mjs
+function map_second(pair2, fun) {
+  let a = pair2[0];
+  let b = pair2[1];
+  return [a, fun(b)];
+}
+
+// build/dev/javascript/lustre/lustre/event.mjs
+function is_immediate_event(name) {
+  if (name === "input") {
+    return true;
+  } else if (name === "change") {
+    return true;
+  } else if (name === "focus") {
+    return true;
+  } else if (name === "focusin") {
+    return true;
+  } else if (name === "focusout") {
+    return true;
+  } else if (name === "blur") {
+    return true;
+  } else if (name === "select") {
+    return true;
+  } else {
+    return false;
+  }
+}
+function on(name, handler) {
+  return event(
+    name,
+    map2(handler, (msg) => {
+      return new Handler(false, false, msg);
+    }),
+    empty_list,
+    never,
+    never,
+    is_immediate_event(name),
+    0,
+    0
+  );
+}
+function on_click(msg) {
+  return on("click", success(msg));
+}
+function on_input(msg) {
+  return on(
+    "input",
+    subfield(
+      toList(["target", "value"]),
+      string2,
+      (value) => {
+        return success(msg(value));
+      }
+    )
+  );
+}
+
+// build/dev/javascript/sketch/sketch.ffi.mjs
+var id = 0;
+function uniqueId() {
+  return id++;
+}
+
+// build/dev/javascript/murmur3a/murmur3a_ffi.mjs
+var signed_multiply = Math.imul;
+
+// build/dev/javascript/murmur3a/murmur3a.mjs
+var Hash = class extends CustomType {
+  constructor(seed, shift, state) {
+    super();
+    this.seed = seed;
+    this.shift = shift;
+    this.state = state;
+  }
+};
+function int_digest(hash) {
+  return hash.state;
+}
+function bit_array_digest(hash) {
+  return toBitArray([sizedInt(int_digest(hash), 32, true)]);
+}
+function hex_digest(hash) {
+  let _pipe = hash;
+  let _pipe$1 = bit_array_digest(_pipe);
+  return base16_encode(_pipe$1);
+}
+var c1 = 3432918353;
+var c2 = 461845907;
+var m1 = 4294967295;
+function rotate_left(n, shift) {
+  let n$1 = bitwise_and(n, m1);
+  let _pipe = bitwise_shift_left(n$1, shift);
+  let _pipe$1 = bitwise_and(_pipe, m1);
+  return bitwise_or(_pipe$1, bitwise_shift_right(n$1, 32 - shift));
+}
+function mix(state, seed) {
+  let _pipe = state;
+  let _pipe$1 = signed_multiply(_pipe, c1);
+  let _pipe$2 = rotate_left(_pipe$1, 15);
+  let _pipe$3 = signed_multiply(_pipe$2, c2);
+  let _pipe$4 = bitwise_exclusive_or(_pipe$3, seed);
+  let _pipe$5 = rotate_left(_pipe$4, 13);
+  let _pipe$6 = signed_multiply(_pipe$5, 5);
+  return add(_pipe$6, 3864292196);
+}
+function hash_chunk(hash, chunk) {
+  let _block;
+  let _pipe = chunk;
+  let _pipe$1 = bitwise_and(_pipe, 255);
+  let _pipe$2 = bitwise_shift_left(_pipe$1, hash.shift);
+  _block = bitwise_or(_pipe$2, hash.state);
+  let state = _block;
+  let $ = hash.shift;
+  if ($ === 24) {
+    return new Hash(mix(state, hash.seed), 0, 0);
+  } else {
+    let _record = hash;
+    return new Hash(_record.seed, hash.shift + 8, state);
+  }
+}
+function finalize(hash, length4) {
+  let _block;
+  let _block$1;
+  let $ = hash.state;
+  if ($ === 0) {
+    _block$1 = hash.seed;
+  } else {
+    let _pipe2 = hash.state;
+    let _pipe$12 = signed_multiply(_pipe2, c1);
+    let _pipe$22 = rotate_left(_pipe$12, 15);
+    let _pipe$32 = signed_multiply(_pipe$22, c2);
+    let _pipe$42 = bitwise_exclusive_or(_pipe$32, hash.seed);
+    _block$1 = bitwise_and(_pipe$42, m1);
+  }
+  let _pipe = _block$1;
+  _block = bitwise_exclusive_or(_pipe, length4);
+  let state = _block;
+  let _block$2;
+  let _pipe$1 = bitwise_shift_right(state, 16);
+  let _pipe$2 = bitwise_exclusive_or(_pipe$1, state);
+  let _pipe$3 = signed_multiply(_pipe$2, 2246822507);
+  _block$2 = bitwise_and(_pipe$3, m1);
+  let state$1 = _block$2;
+  let _block$3;
+  let _pipe$4 = bitwise_shift_right(state$1, 13);
+  let _pipe$5 = bitwise_exclusive_or(_pipe$4, state$1);
+  _block$3 = signed_multiply(_pipe$5, 3266489909);
+  let state$2 = _block$3;
+  let _record = hash;
+  return new Hash(
+    _record.seed,
+    _record.shift,
+    (() => {
+      let _pipe$6 = bitwise_shift_right(state$2, 16);
+      let _pipe$7 = bitwise_and(_pipe$6, 65535);
+      return bitwise_exclusive_or(_pipe$7, state$2);
+    })()
+  );
+}
+function hash_ints(key, seed) {
+  let _pipe = key;
+  let _pipe$1 = fold(_pipe, new Hash(seed, 0, 0), hash_chunk);
+  return finalize(_pipe$1, length(key));
+}
+function hash_string(key, seed) {
+  let _pipe = key;
+  let _pipe$1 = to_utf_codepoints(_pipe);
+  let _pipe$2 = map(_pipe$1, utf_codepoint_to_int);
+  return hash_ints(_pipe$2, seed);
+}
+
+// build/dev/javascript/sketch/sketch/internals/string.mjs
+function indent(indent2) {
+  return repeat(" ", indent2);
+}
+function wrap_class(id2, properties, indentation, pseudo) {
+  let base_indent = indent(indentation);
+  let pseudo_ = unwrap(pseudo, "");
+  let _pipe = prepend(base_indent + id2 + pseudo_ + " {", properties);
+  let _pipe$1 = join(_pipe, "\n");
+  return append2(_pipe$1, "\n" + base_indent + "}");
+}
+
+// build/dev/javascript/sketch/sketch/internals/cache/cache.mjs
+var FILEPATH = "src/sketch/internals/cache/cache.gleam";
+var Class = class extends CustomType {
+  constructor(as_string, content, name) {
+    super();
+    this.as_string = as_string;
+    this.content = content;
+    this.name = name;
+  }
+};
+var Definitions = class extends CustomType {
+  constructor(medias, selectors, class$5) {
+    super();
+    this.medias = medias;
+    this.selectors = selectors;
+    this.class = class$5;
+  }
+};
+var ComputedClass = class extends CustomType {
+  constructor(id2, name, class_name4, definitions) {
+    super();
+    this.id = id2;
+    this.name = name;
+    this.class_name = class_name4;
+    this.definitions = definitions;
+  }
+};
+var Cache = class extends CustomType {
+  constructor(cache, at_rules) {
+    super();
+    this.cache = cache;
+    this.at_rules = at_rules;
+  }
+};
+var Global = class extends CustomType {
+  constructor(class$5) {
+    super();
+    this.class = class$5;
+  }
+};
+var ClassName = class extends CustomType {
+  constructor(class$5) {
+    super();
+    this.class = class$5;
+  }
+};
+var Media = class extends CustomType {
+  constructor(query, styles) {
+    super();
+    this.query = query;
+    this.styles = styles;
+  }
+};
+var Selector = class extends CustomType {
+  constructor(selector, styles) {
+    super();
+    this.selector = selector;
+    this.styles = styles;
+  }
+};
+var Combinator = class extends CustomType {
+  constructor(selector, class$5, styles) {
+    super();
+    this.selector = selector;
+    this.class = class$5;
+    this.styles = styles;
+  }
+};
+var Property2 = class extends CustomType {
+  constructor(key, value, important) {
+    super();
+    this.key = key;
+    this.value = value;
+    this.important = important;
+  }
+};
+var Properties = class extends CustomType {
+  constructor(properties, medias, selectors, indentation) {
+    super();
+    this.properties = properties;
+    this.medias = medias;
+    this.selectors = selectors;
+    this.indentation = indentation;
+  }
+};
+var MediaProperty = class extends CustomType {
+  constructor(query, properties, selectors) {
+    super();
+    this.query = query;
+    this.properties = properties;
+    this.selectors = selectors;
+  }
+};
+var SelectorProperty = class extends CustomType {
+  constructor(selector, properties) {
+    super();
+    this.selector = selector;
+    this.properties = properties;
+  }
+};
+function new$10() {
+  return new Cache(new_map(), new_map());
+}
+function class$2(content) {
+  let as_string = inspect2(content);
+  return new Class(as_string, content, new None());
+}
+function named(name, content) {
+  let as_string = inspect2(content);
+  return new Class(as_string, content, new Some(name));
+}
+function empty_computed() {
+  let definitions = new Definitions(toList([]), toList([]), "");
+  return new ComputedClass("", "", "", definitions);
+}
+function compute_hash(to_hash) {
+  let _pipe = hash_string(to_hash, 1);
+  return hex_digest(_pipe);
+}
+function wrap_selectors(id2, indentation, selectors) {
+  return map(
+    selectors,
+    (selector) => {
+      let selector$1 = selector.selector;
+      let properties = selector.properties;
+      return wrap_class(
+        id2,
+        properties,
+        indentation,
+        new Some(selector$1)
+      );
+    }
+  );
+}
+function compute_classes(id2, name, properties) {
+  let class_name$1 = lazy_unwrap(name, () => {
+    return "css-" + id2;
+  });
+  let name$1 = lazy_unwrap(name, () => {
+    return ".css-" + id2;
+  });
+  let properties$1 = properties.properties;
+  let medias = properties.medias;
+  let selectors = properties.selectors;
+  let class$1 = wrap_class(name$1, properties$1, 0, new None());
+  let selectors$1 = wrap_selectors(name$1, 0, selectors);
+  return new ComputedClass(
+    id2,
+    name$1,
+    class_name$1,
+    new Definitions(
+      map(
+        medias,
+        (_use0) => {
+          let query = _use0.query;
+          let properties$2 = _use0.properties;
+          let selectors$2 = _use0.selectors;
+          let selectors$3 = wrap_selectors(name$1, 2, selectors$2);
+          let _pipe = toList([
+            query + " {",
+            wrap_class(name$1, properties$2, 2, new None())
+          ]);
+          let _pipe$1 = ((_capture) => {
+            return prepend2(toList([selectors$3, toList(["}"])]), _capture);
+          })(_pipe);
+          let _pipe$2 = flatten(_pipe$1);
+          return join(_pipe$2, "\n");
+        }
+      ),
+      selectors$1,
+      class$1
+    )
+  );
+}
+function compute_property(indent2, key, value, important) {
+  let base_indent = indent(indent2);
+  let _block;
+  if (important) {
+    _block = " !important";
+  } else {
+    _block = "";
+  }
+  let important$1 = _block;
+  return base_indent + key + ": " + value + important$1 + ";";
+}
+function handle_property(props, property4) {
+  if (!(property4 instanceof Property2)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "sketch/internals/cache/cache",
+      243,
+      "handle_property",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: property4,
+        start: 7133,
+        end: 7189,
+        pattern_start: 7144,
+        pattern_end: 7178
+      }
+    );
+  }
+  let key = property4.key;
+  let value = property4.value;
+  let important = property4.important;
+  let css_property = compute_property(props.indentation, key, value, important);
+  let properties = prepend(css_property, props.properties);
+  let _record = props;
+  return new Properties(
+    properties,
+    _record.medias,
+    _record.selectors,
+    _record.indentation
+  );
+}
+function merge_computed_properties(target, argument) {
+  return new Properties(
+    append(argument.properties, target.properties),
+    append(argument.medias, target.medias),
+    append(argument.selectors, target.selectors),
+    target.indentation
+  );
+}
+function get_definitions(class$5) {
+  let $ = class$5.definitions;
+  let medias = $.medias;
+  let selectors = $.selectors;
+  let class$1 = $.class;
+  let _pipe = toList([toList([class$1]), selectors, medias]);
+  return flatten(_pipe);
+}
+function render_sheet(cache) {
+  let _pipe = values(cache.at_rules);
+  let _pipe$1 = append(
+    _pipe,
+    flat_map(
+      values(cache.cache),
+      (c) => {
+        return get_definitions(c[0]);
+      }
+    )
+  );
+  return join(_pipe$1, "\n\n");
+}
+function handle_combinator(cache, props, combinator, existing_selector) {
+  if (!(combinator instanceof Combinator)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "sketch/internals/cache/cache",
+      285,
+      "handle_combinator",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: combinator,
+        start: 8551,
+        end: 8613,
+        pattern_start: 8562,
+        pattern_end: 8600
+      }
+    );
+  }
+  let selector = combinator.selector;
+  let class$1 = combinator.class;
+  let styles = combinator.styles;
+  let indentation = props.indentation + 2;
+  let $ = computed_class(class$1, cache);
+  let cache$1 = $[0];
+  let class$22 = $[1];
+  let selector$1 = existing_selector + selector + class$22.name;
+  let $1 = compute_properties(cache$1, styles, indentation, selector$1);
+  let cache$2 = $1[0];
+  let properties = $1[1];
+  let selector$2 = new SelectorProperty(selector$1, properties.properties);
+  let selectors = prepend(selector$2, properties.selectors);
+  let selectors$1 = append(selectors, props.selectors);
+  return [
+    cache$2,
+    (() => {
+      let _record = props;
+      return new Properties(
+        _record.properties,
+        _record.medias,
+        selectors$1,
+        _record.indentation
+      );
+    })()
+  ];
+}
+function compute_properties(cache, properties, indentation, existing_selector) {
+  let init2 = new Properties(toList([]), toList([]), toList([]), indentation);
+  return fold(
+    reverse(properties),
+    [cache, init2],
+    (_use0, p) => {
+      let cache$1 = _use0[0];
+      let acc = _use0[1];
+      if (p instanceof ClassName) {
+        let class$1 = p.class;
+        let $ = map_get(cache$1.cache, class$1.as_string);
+        if ($ instanceof Ok) {
+          let props = $[0][1];
+          return [cache$1, merge_computed_properties(acc, props)];
+        } else {
+          let _pipe = compute_properties(
+            cache$1,
+            class$1.content,
+            indentation,
+            ""
+          );
+          return map_second(
+            _pipe,
+            (_capture) => {
+              return merge_computed_properties(acc, _capture);
+            }
+          );
+        }
+      } else if (p instanceof Media) {
+        return handle_media(cache$1, acc, p);
+      } else if (p instanceof Selector) {
+        return handle_selector(cache$1, acc, p, existing_selector);
+      } else if (p instanceof Combinator) {
+        return handle_combinator(cache$1, acc, p, existing_selector);
+      } else if (p instanceof Property2) {
+        return [cache$1, handle_property(acc, p)];
+      } else {
+        return [cache$1, acc];
+      }
+    }
+  );
+}
+function insert_class_in_cache(cache, class$5) {
+  let $ = compute_properties(cache, class$5.content, 2, "");
+  let cache$1 = $[0];
+  let properties = $[1];
+  let hash = compute_hash(class$5.as_string);
+  let class_ = compute_classes(hash, class$5.name, properties);
+  let key = unwrap(class$5.name, class$5.as_string);
+  let cache_ = insert(cache$1.cache, key, [class_, properties]);
+  return [
+    (() => {
+      let _record = cache$1;
+      return new Cache(cache_, _record.at_rules);
+    })(),
+    class_
+  ];
+}
+function computed_class(class$5, cache) {
+  return lazy_guard(
+    is_empty2(class$5.content),
+    () => {
+      return [cache, empty_computed()];
+    },
+    () => {
+      let existing_class = map_get(cache.cache, class$5.as_string);
+      if (existing_class instanceof Ok) {
+        let class$1 = existing_class[0][0];
+        return [cache, class$1];
+      } else {
+        return insert_class_in_cache(cache, class$5);
+      }
+    }
+  );
+}
+function class_name(class$5, cache) {
+  return map_second(
+    computed_class(class$5, cache),
+    (class$6) => {
+      return class$6.class_name;
+    }
+  );
+}
+function handle_media(cache, props, media) {
+  if (!(media instanceof Media)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "sketch/internals/cache/cache",
+      254,
+      "handle_media",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: media,
+        start: 7462,
+        end: 7503,
+        pattern_start: 7473,
+        pattern_end: 7495
+      }
+    );
+  }
+  let query = media.query;
+  let styles = media.styles;
+  let indentation = props.indentation + 2;
+  let $ = compute_properties(cache, styles, indentation, "");
+  let cache$1 = $[0];
+  let properties = $[1];
+  let properties$1 = properties.properties;
+  let selectors = properties.selectors;
+  let medias = prepend(
+    new MediaProperty(query, properties$1, selectors),
+    props.medias
+  );
+  return [
+    cache$1,
+    (() => {
+      let _record = props;
+      return new Properties(
+        _record.properties,
+        medias,
+        _record.selectors,
+        _record.indentation
+      );
+    })()
+  ];
+}
+function handle_selector(cache, props, selector, existing_selector) {
+  if (!(selector instanceof Selector)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "sketch/internals/cache/cache",
+      268,
+      "handle_selector",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: selector,
+        start: 7944,
+        end: 7994,
+        pattern_start: 7955,
+        pattern_end: 7983
+      }
+    );
+  }
+  let selector$1 = selector.selector;
+  let styles = selector.styles;
+  let indentation = props.indentation + 2;
+  let selector$2 = existing_selector + selector$1;
+  let $ = compute_properties(cache, styles, indentation, selector$2);
+  let cache$1 = $[0];
+  let properties = $[1];
+  let selector$3 = new SelectorProperty(selector$2, properties.properties);
+  let selectors = prepend(selector$3, properties.selectors);
+  let selectors$1 = append(selectors, props.selectors);
+  return [
+    cache$1,
+    (() => {
+      let _record = props;
+      return new Properties(
+        _record.properties,
+        _record.medias,
+        selectors$1,
+        _record.indentation
+      );
+    })()
+  ];
+}
+
+// build/dev/javascript/sketch/sketch/css/length.mjs
+var Px = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Cm = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Mm = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Q = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var In = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Pc = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Pt = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Vh = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Vw = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Em = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Rem = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Lh = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Rlh = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Ch = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Pct = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Cap = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Ex = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Ic = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Rcap = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Rch = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Rex = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Ric = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Vmax = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Vmin = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Vb = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Vi = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Cqw = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Cqh = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Cqi = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Cqb = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+var Cqmin = class extends CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+};
+function px(value) {
+  return new Px(identity(value));
+}
+function percent(value) {
+  return new Pct(identity(value));
+}
+function vw(value) {
+  return new Vw(identity(value));
+}
+function em(value) {
+  return new Em(value);
+}
+function to_string4(size3) {
+  if (size3 instanceof Px) {
+    let value = size3[0];
+    return append2(float_to_string(value), "px");
+  } else if (size3 instanceof Cm) {
+    let value = size3[0];
+    return append2(float_to_string(value), "cm");
+  } else if (size3 instanceof Mm) {
+    let value = size3[0];
+    return append2(float_to_string(value), "mm");
+  } else if (size3 instanceof Q) {
+    let value = size3[0];
+    return append2(float_to_string(value), "q");
+  } else if (size3 instanceof In) {
+    let value = size3[0];
+    return append2(float_to_string(value), "in");
+  } else if (size3 instanceof Pc) {
+    let value = size3[0];
+    return append2(float_to_string(value), "pc");
+  } else if (size3 instanceof Pt) {
+    let value = size3[0];
+    return append2(float_to_string(value), "pt");
+  } else if (size3 instanceof Vh) {
+    let value = size3[0];
+    return append2(float_to_string(value), "vh");
+  } else if (size3 instanceof Vw) {
+    let value = size3[0];
+    return append2(float_to_string(value), "vw");
+  } else if (size3 instanceof Em) {
+    let value = size3[0];
+    return append2(float_to_string(value), "em");
+  } else if (size3 instanceof Rem) {
+    let value = size3[0];
+    return append2(float_to_string(value), "rem");
+  } else if (size3 instanceof Lh) {
+    let value = size3[0];
+    return append2(float_to_string(value), "lh");
+  } else if (size3 instanceof Rlh) {
+    let value = size3[0];
+    return append2(float_to_string(value), "rlh");
+  } else if (size3 instanceof Ch) {
+    let value = size3[0];
+    return append2(float_to_string(value), "ch");
+  } else if (size3 instanceof Pct) {
+    let value = size3[0];
+    return append2(float_to_string(value), "%");
+  } else if (size3 instanceof Cap) {
+    let value = size3[0];
+    return append2(float_to_string(value), "cap");
+  } else if (size3 instanceof Ex) {
+    let value = size3[0];
+    return append2(float_to_string(value), "ex");
+  } else if (size3 instanceof Ic) {
+    let value = size3[0];
+    return append2(float_to_string(value), "ic");
+  } else if (size3 instanceof Rcap) {
+    let value = size3[0];
+    return append2(float_to_string(value), "rcap");
+  } else if (size3 instanceof Rch) {
+    let value = size3[0];
+    return append2(float_to_string(value), "rch");
+  } else if (size3 instanceof Rex) {
+    let value = size3[0];
+    return append2(float_to_string(value), "rex");
+  } else if (size3 instanceof Ric) {
+    let value = size3[0];
+    return append2(float_to_string(value), "ric");
+  } else if (size3 instanceof Vmax) {
+    let value = size3[0];
+    return append2(float_to_string(value), "vmax");
+  } else if (size3 instanceof Vmin) {
+    let value = size3[0];
+    return append2(float_to_string(value), "vmin");
+  } else if (size3 instanceof Vb) {
+    let value = size3[0];
+    return append2(float_to_string(value), "vb");
+  } else if (size3 instanceof Vi) {
+    let value = size3[0];
+    return append2(float_to_string(value), "vi");
+  } else if (size3 instanceof Cqw) {
+    let value = size3[0];
+    return append2(float_to_string(value), "cqw");
+  } else if (size3 instanceof Cqh) {
+    let value = size3[0];
+    return append2(float_to_string(value), "cqh");
+  } else if (size3 instanceof Cqi) {
+    let value = size3[0];
+    return append2(float_to_string(value), "cqi");
+  } else if (size3 instanceof Cqb) {
+    let value = size3[0];
+    return append2(float_to_string(value), "cqb");
+  } else if (size3 instanceof Cqmin) {
+    let value = size3[0];
+    return append2(float_to_string(value), "cqmin");
+  } else {
+    let value = size3[0];
+    return append2(float_to_string(value), "cqmax");
+  }
+}
+
+// build/dev/javascript/sketch/sketch/css.mjs
+function class$4(styles) {
+  return class$2(styles);
+}
+function global(name, styles) {
+  return new Global(named(name, styles));
+}
+function property3(field2, content) {
+  return new Property2(field2, content, false);
+}
+function align_items(align) {
+  return property3("align-items", align);
+}
+function aspect_ratio(aspect_ratio2) {
+  return property3("aspect-ratio", aspect_ratio2);
+}
+function background(background2) {
+  return property3("background", background2);
+}
+function background_color(value) {
+  return property3("background-color", value);
+}
+function border(border2) {
+  return property3("border", border2);
+}
+function border_radius(border_radius2) {
+  return property3("border-radius", to_string4(border_radius2));
+}
+function color(color2) {
+  return property3("color", color2);
+}
+function display(display2) {
+  return property3("display", display2);
+}
+function flex_direction(flex_direction2) {
+  return property3("flex-direction", flex_direction2);
+}
+function gap(gap2) {
+  return property3("gap", to_string4(gap2));
+}
+function margin(margin2) {
+  return property3("margin", to_string4(margin2));
+}
+function margin_left(margin2) {
+  return property3("margin-left", to_string4(margin2));
+}
+function max_width(width2) {
+  return property3("max-width", to_string4(width2));
+}
+function padding(padding2) {
+  return property3("padding", to_string4(padding2));
+}
+function width(width2) {
+  return property3("width", to_string4(width2));
+}
+function width_(width2) {
+  return property3("width", width2);
+}
+
+// build/dev/javascript/sketch/sketch.mjs
+var StyleSheet = class extends CustomType {
+  constructor(cache, id2, is_persistent) {
+    super();
+    this.cache = cache;
+    this.id = id2;
+    this.is_persistent = is_persistent;
+  }
+};
+var Ephemeral = class extends CustomType {
+};
+var Persistent = class extends CustomType {
+};
+function render(cache) {
+  return render_sheet(cache.cache);
+}
+function class_name2(class$5, stylesheet2) {
+  let $ = class_name(class$5, stylesheet2.cache);
+  let cache = $[0];
+  let class_name$1 = $[1];
+  return [
+    (() => {
+      let _record = stylesheet2;
+      return new StyleSheet(cache, _record.id, _record.is_persistent);
+    })(),
+    class_name$1
+  ];
+}
+function global2(stylesheet2, global3) {
+  let $ = class_name(global3.class, stylesheet2.cache);
+  let cache = $[0];
+  let _record = stylesheet2;
+  return new StyleSheet(cache, _record.id, _record.is_persistent);
+}
+function stylesheet(strategy) {
+  let id2 = uniqueId();
+  return new Ok(
+    (() => {
+      if (strategy instanceof Ephemeral) {
+        return new StyleSheet(new$10(), id2, false);
+      } else {
+        return new StyleSheet(new$10(), id2, true);
+      }
+    })()
+  );
+}
+
+// build/dev/javascript/sketch_lustre/sketch/lustre/internals/css-stylesheet.ffi.mjs
+function replaceSync(content, stylesheet2) {
+  stylesheet2.replaceSync(content);
+}
+
+// build/dev/javascript/sketch_lustre/sketch/lustre/internals/global.ffi.mjs
+var currentStylesheet = null;
+var stylesheets = {};
+function setStyleSheet(stylesheet2) {
+  stylesheets[stylesheet2.id] = stylesheet2;
+  return new Ok(stylesheet2);
+}
+function setCurrentStylesheet(stylesheet2) {
+  currentStylesheet = stylesheet2.id;
+  return new Ok(stylesheet2);
+}
+function getStyleSheet() {
+  const stylesheet2 = stylesheets[currentStylesheet];
+  if (!stylesheet2) return new Error();
+  return new Ok(stylesheet2);
+}
+function dismissCurrentStylesheet() {
+  currentStylesheet = null;
+  return new Ok(void 0);
+}
+
+// build/dev/javascript/sketch_lustre/sketch/lustre.mjs
+var FILEPATH2 = "src/sketch/lustre.gleam";
+var Document2 = class extends CustomType {
+  constructor(css_stylesheet) {
+    super();
+    this.css_stylesheet = css_stylesheet;
+  }
+};
+var Shadow = class extends CustomType {
+  constructor(css_stylesheet) {
+    super();
+    this.css_stylesheet = css_stylesheet;
+  }
+};
+var Node = class extends CustomType {
+};
+function setup() {
+  let $ = stylesheet(new Persistent());
+  if ($ instanceof Ok) {
+    let stylesheet2 = $[0];
+    return setStyleSheet(stylesheet2);
+  } else {
+    return new Error(void 0);
+  }
+}
+function render2(stylesheet2, outputs, view2) {
+  let $ = setCurrentStylesheet(stylesheet2);
+  if (!($ instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH2,
+      "sketch/lustre",
+      117,
+      "render",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3944,
+        end: 4004,
+        pattern_start: 3955,
+        pattern_end: 3960
+      }
+    );
+  }
+  let new_view = view2();
+  let $1 = getStyleSheet();
+  if ($1 instanceof Ok) {
+    let stylesheet$1 = $1[0];
+    let content = render(stylesheet$1);
+    return fold(
+      outputs,
+      new_view,
+      (view3, stylesheet3) => {
+        if (stylesheet3 instanceof Document2) {
+          let css_stylesheet = stylesheet3.css_stylesheet;
+          return tap(
+            view3,
+            (_) => {
+              let $2 = dismissCurrentStylesheet();
+              return replaceSync(content, css_stylesheet);
+            }
+          );
+        } else if (stylesheet3 instanceof Shadow) {
+          let css_stylesheet = stylesheet3.css_stylesheet;
+          return tap(
+            view3,
+            (_) => {
+              let $2 = dismissCurrentStylesheet();
+              return replaceSync(content, css_stylesheet);
+            }
+          );
+        } else {
+          return fragment2(toList([style(toList([]), content), view3]));
+        }
+      }
+    );
+  } else {
+    return new_view;
+  }
+}
+function node() {
+  return new Node();
+}
+
+// build/dev/javascript/sketch_lustre/sketch/lustre/element.mjs
+var FILEPATH3 = "src/sketch/lustre/element.gleam";
+function element_(tag, attributes, children) {
+  return element2(tag, attributes, children);
+}
+var none3 = none2;
+var text3 = text2;
+var error_msg = "Stylesheet is not initialized in your application. Please, initialize a stylesheet before rendering some nodes.";
+function class_name3(class$5) {
+  let $ = getStyleSheet();
+  if ($ instanceof Ok) {
+    let stylesheet2 = $[0];
+    let $1 = class_name2(class$5, stylesheet2);
+    let stylesheet$1 = $1[0];
+    let class_name$1 = $1[1];
+    let $2 = setStyleSheet(stylesheet$1);
+    return class_name$1;
+  } else {
+    throw makeError(
+      "panic",
+      FILEPATH3,
+      "sketch/lustre/element",
+      77,
+      "class_name",
+      error_msg,
+      {}
+    );
+  }
+}
+function element3(tag, class$5, attributes, children) {
+  let class_name$1 = class_name3(class$5);
+  let attributes$1 = prepend(class$(class_name$1), attributes);
+  return element2(tag, attributes$1, children);
+}
+
+// build/dev/javascript/sketch_lustre/sketch/lustre/element/html.mjs
+function text4(content) {
+  return text3(content);
+}
+function button(class$5, attributes, children) {
+  return element3("button", class$5, attributes, children);
+}
+function div(class$5, attributes, children) {
+  return element3("div", class$5, attributes, children);
+}
+function h1_(attributes, children) {
+  return element_("h1", attributes, children);
+}
+function h4(class$5, attributes, children) {
+  return element3("h4", class$5, attributes, children);
+}
+function input_(attributes) {
+  return element_("input", attributes, toList([]));
+}
+function span(class$5, attributes, children) {
+  return element3("span", class$5, attributes, children);
+}
+
+// build/dev/javascript/voyagers_bingo/voyagers_bingo/styles.mjs
+function container() {
+  return class$4(
+    toList([
+      margin_left(vw(3)),
+      gap(em(0.5)),
+      display("flex"),
+      flex_direction("column"),
+      width_("fit-content"),
+      align_items("center")
+    ])
+  );
+}
+function grid() {
+  return class$4(
+    toList([
+      display("flex"),
+      flex_direction("column"),
+      background_color("black"),
+      width_("auto"),
+      gap(em(0.5)),
+      padding(em(0.5)),
+      border_radius(px(4)),
+      align_items("center"),
+      width_("fit-content")
+    ])
+  );
+}
+function row() {
+  return class$4(
+    toList([
+      display("flex"),
+      flex_direction("row"),
+      gap(em(0.5)),
+      width(percent(100))
+    ])
+  );
+}
+function square(checked) {
+  return class$4(
+    toList([
+      width(em(10)),
+      aspect_ratio("1 / 1"),
+      max_width(em(5)),
+      (() => {
+        if (checked) {
+          return background("yellow");
+        } else {
+          return background("white");
+        }
+      })(),
+      border("none"),
+      border_radius(px(4))
+    ])
+  );
+}
+
+// build/dev/javascript/voyagers_bingo/voyagers_bingo.mjs
+var FILEPATH4 = "src/voyagers_bingo.gleam";
+var UserRequestedNewSheet = class extends CustomType {
+  constructor(rows, columns) {
+    super();
+    this.rows = rows;
+    this.columns = columns;
+  }
+};
+var UserSelectedSquare = class extends CustomType {
+  constructor(x, y) {
+    super();
+    this.x = x;
+    this.y = y;
+  }
+};
+var UserDeselectedSquare = class extends CustomType {
+  constructor(x, y) {
+    super();
+    this.x = x;
+    this.y = y;
+  }
+};
+var CreatedNewSheet = class extends CustomType {
+  constructor(sheet) {
+    super();
+    this.sheet = sheet;
+  }
+};
+var FailedToCreateSheet = class extends CustomType {
+};
+var UserSetX = class extends CustomType {
+  constructor(x) {
+    super();
+    this.x = x;
+  }
+};
+var UserSetY = class extends CustomType {
+  constructor(y) {
+    super();
+    this.y = y;
+  }
+};
+var Square = class extends CustomType {
+  constructor(text5, crossed) {
+    super();
+    this.text = text5;
+    this.crossed = crossed;
+  }
+};
+var Model = class extends CustomType {
+  constructor(sheet, failed, x, y) {
+    super();
+    this.sheet = sheet;
+    this.failed = failed;
+    this.x = x;
+    this.y = y;
+  }
+};
+var available_squares = /* @__PURE__ */ toList([
+  "PC Flirting",
+  "Ben Blushing",
+  "Off Topic",
+  "Pidgeon"
+]);
+function sheet_with_size(rows, columns) {
+  let _block;
+  let _pipe = shuffle(available_squares);
+  let _pipe$1 = sized_chunk(_pipe, rows * columns);
+  _block = first(_pipe$1);
+  let $ = _block;
+  if (!($ instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH4,
+      "voyagers_bingo",
+      45,
+      "sheet_with_size",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 980, end: 1107, pattern_start: 991, pattern_end: 1009 }
+    );
+  }
+  let random_squares = $[0];
+  let _block$1;
+  let _pipe$2 = random_squares;
+  _block$1 = sized_chunk(_pipe$2, columns);
+  let square_rows = _block$1;
+  let _pipe$3 = square_rows;
+  let _pipe$4 = map(
+    _pipe$3,
+    (row2) => {
+      let _pipe$42 = row2;
+      let _pipe$5 = map(
+        _pipe$42,
+        (text5) => {
+          return new Square(text5, false);
+        }
+      );
+      return from_list2(_pipe$5);
+    }
+  );
+  return from_list2(_pipe$4);
+}
+function init(_) {
+  let _block;
+  let _pipe = square_root2(length(available_squares));
+  let _pipe$1 = unwrap2(_pipe, 2);
+  let _pipe$2 = floor(_pipe$1);
+  let _pipe$3 = round(_pipe$2);
+  _block = min(_pipe$3, 5);
+  let sqrt = _block;
+  return [
+    new Model(sheet_with_size(sqrt, sqrt), false, sqrt, sqrt),
+    none()
+  ];
+}
+function update4(model, msg) {
+  if (msg instanceof UserRequestedNewSheet) {
+    let rows = msg.rows;
+    let columns = msg.columns;
+    let too_big = rows * columns > length(available_squares);
+    return guard(
+      too_big,
+      [
+        model,
+        from(
+          (dispatch) => {
+            return dispatch(new FailedToCreateSheet());
+          }
+        )
+      ],
+      () => {
+        return [
+          model,
+          from(
+            (dispatch) => {
+              let sheet = sheet_with_size(rows, columns);
+              return dispatch(new CreatedNewSheet(sheet));
+            }
+          )
+        ];
+      }
+    );
+  } else if (msg instanceof UserSelectedSquare) {
+    let x = msg.x;
+    let y = msg.y;
+    let $ = get2(model.sheet, x);
+    if (!($ instanceof Ok)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH4,
+        "voyagers_bingo",
+        95,
+        "update",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $,
+          start: 2211,
+          end: 2254,
+          pattern_start: 2222,
+          pattern_end: 2229
+        }
+      );
+    }
+    let row2 = $[0];
+    let $1 = get2(row2, y);
+    if (!($1 instanceof Ok)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH4,
+        "voyagers_bingo",
+        96,
+        "update",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $1,
+          start: 2261,
+          end: 2298,
+          pattern_start: 2272,
+          pattern_end: 2281
+        }
+      );
+    }
+    let value = $1[0];
+    let $2 = set(
+      row2,
+      y,
+      (() => {
+        let _record = value;
+        return new Square(_record.text, true);
+      })()
+    );
+    if (!($2 instanceof Ok)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH4,
+        "voyagers_bingo",
+        97,
+        "update",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $2,
+          start: 2305,
+          end: 2388,
+          pattern_start: 2316,
+          pattern_end: 2331
+        }
+      );
+    }
+    let updated_row = $2[0];
+    let $3 = set(model.sheet, x, updated_row);
+    if (!($3 instanceof Ok)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH4,
+        "voyagers_bingo",
+        99,
+        "update",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $3,
+          start: 2395,
+          end: 2455,
+          pattern_start: 2406,
+          pattern_end: 2417
+        }
+      );
+    }
+    let updated = $3[0];
+    return [
+      (() => {
+        let _record = model;
+        return new Model(updated, _record.failed, _record.x, _record.y);
+      })(),
+      none()
+    ];
+  } else if (msg instanceof UserDeselectedSquare) {
+    let x = msg.x;
+    let y = msg.y;
+    let $ = get2(model.sheet, x);
+    if (!($ instanceof Ok)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH4,
+        "voyagers_bingo",
+        103,
+        "update",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $,
+          start: 2561,
+          end: 2604,
+          pattern_start: 2572,
+          pattern_end: 2579
+        }
+      );
+    }
+    let row2 = $[0];
+    let $1 = get2(row2, y);
+    if (!($1 instanceof Ok)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH4,
+        "voyagers_bingo",
+        104,
+        "update",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $1,
+          start: 2611,
+          end: 2648,
+          pattern_start: 2622,
+          pattern_end: 2631
+        }
+      );
+    }
+    let value = $1[0];
+    let $2 = set(
+      row2,
+      y,
+      (() => {
+        let _record = value;
+        return new Square(_record.text, false);
+      })()
+    );
+    if (!($2 instanceof Ok)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH4,
+        "voyagers_bingo",
+        105,
+        "update",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $2,
+          start: 2655,
+          end: 2739,
+          pattern_start: 2666,
+          pattern_end: 2681
+        }
+      );
+    }
+    let updated_row = $2[0];
+    let $3 = set(model.sheet, x, updated_row);
+    if (!($3 instanceof Ok)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH4,
+        "voyagers_bingo",
+        107,
+        "update",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $3,
+          start: 2746,
+          end: 2806,
+          pattern_start: 2757,
+          pattern_end: 2768
+        }
+      );
+    }
+    let updated = $3[0];
+    return [
+      (() => {
+        let _record = model;
+        return new Model(updated, _record.failed, _record.x, _record.y);
+      })(),
+      none()
+    ];
+  } else if (msg instanceof CreatedNewSheet) {
+    let sheet = msg.sheet;
+    return [
+      (() => {
+        let _record = model;
+        return new Model(sheet, false, _record.x, _record.y);
+      })(),
+      none()
+    ];
+  } else if (msg instanceof FailedToCreateSheet) {
+    return [
+      (() => {
+        let _record = model;
+        return new Model(_record.sheet, true, _record.x, _record.y);
+      })(),
+      none()
+    ];
+  } else if (msg instanceof UserSetX) {
+    let x = msg.x;
+    return [
+      (() => {
+        let _record = model;
+        return new Model(_record.sheet, false, x, _record.y);
+      })(),
+      none()
+    ];
+  } else {
+    let y = msg.y;
+    return [
+      (() => {
+        let _record = model;
+        return new Model(_record.sheet, false, _record.x, y);
+      })(),
+      none()
+    ];
+  }
+}
+function view(model) {
+  return div(
+    container(),
+    toList([]),
+    toList([
+      h1_(toList([]), toList([text4("Voyagers Bingo")])),
+      div(
+        grid(),
+        toList([]),
+        (() => {
+          let _pipe = model.sheet;
+          let _pipe$1 = index_map3(
+            _pipe,
+            (row2, x) => {
+              return span(
+                row(),
+                toList([]),
+                (() => {
+                  let _pipe$12 = index_map3(
+                    row2,
+                    (square2, y) => {
+                      return button(
+                        square(square2.crossed),
+                        toList([
+                          on_click(
+                            (() => {
+                              let $ = square2.crossed;
+                              if ($) {
+                                return new UserDeselectedSquare(x, y);
+                              } else {
+                                return new UserSelectedSquare(x, y);
+                              }
+                            })()
+                          )
+                        ]),
+                        toList([text4(square2.text)])
+                      );
+                    }
+                  );
+                  return to_list(_pipe$12);
+                })()
+              );
+            }
+          );
+          return to_list(_pipe$1);
+        })()
+      ),
+      input_(
+        toList([
+          type_("number"),
+          placeholder("Rows: 2"),
+          on_input(
+            (content) => {
+              let $ = parse_int(content);
+              if (!($ instanceof Ok)) {
+                throw makeError(
+                  "let_assert",
+                  FILEPATH4,
+                  "voyagers_bingo",
+                  152,
+                  "view",
+                  "Pattern match failed, no pattern matched the value.",
+                  {
+                    value: $,
+                    start: 4144,
+                    end: 4183,
+                    pattern_start: 4155,
+                    pattern_end: 4162
+                  }
+                );
+              }
+              let num = $[0];
+              return new UserSetX(num);
+            }
+          )
+        ])
+      ),
+      input_(
+        toList([
+          type_("number"),
+          placeholder("Columns: 2"),
+          on_input(
+            (content) => {
+              let $ = parse_int(content);
+              if (!($ instanceof Ok)) {
+                throw makeError(
+                  "let_assert",
+                  FILEPATH4,
+                  "voyagers_bingo",
+                  160,
+                  "view",
+                  "Pattern match failed, no pattern matched the value.",
+                  {
+                    value: $,
+                    start: 4361,
+                    end: 4400,
+                    pattern_start: 4372,
+                    pattern_end: 4379
+                  }
+                );
+              }
+              let num = $[0];
+              return new UserSetY(num);
+            }
+          )
+        ])
+      ),
+      button(
+        class$4(toList([width_("fit-content")])),
+        toList([on_click(new UserRequestedNewSheet(model.x, model.y))]),
+        toList([text4("New Sheet")])
+      ),
+      (() => {
+        let $ = model.failed;
+        if ($) {
+          return h4(
+            class$4(toList([color("red")])),
+            toList([]),
+            toList([
+              text4(
+                "Failed to create sheet of size " + to_string(
+                  model.x
+                ) + "x" + to_string(model.y) + " (" + to_string(
+                  model.x * model.y
+                ) + ") - maximum possible size is " + to_string(
+                  length(available_squares)
+                )
+              )
+            ])
+          );
+        } else {
+          return none3();
+        }
+      })()
+    ])
+  );
+}
+function css_view(model, stylesheet2) {
+  return render2(
+    stylesheet2,
+    toList([node()]),
+    () => {
+      return view(model);
+    }
+  );
+}
+function main() {
+  let $ = setup();
+  if (!($ instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH4,
+      "voyagers_bingo",
+      194,
+      "main",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5286,
+        end: 5330,
+        pattern_start: 5297,
+        pattern_end: 5311
+      }
+    );
+  }
+  let stylesheet2 = $[0];
+  global2(stylesheet2, global("body", toList([margin(vw(10))])));
+  let app = application(
+    init,
+    update4,
+    (_capture) => {
+      return css_view(_capture, stylesheet2);
+    }
+  );
+  let $1 = start3(app, "#app", void 0);
+  if (!($1 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH4,
+      "voyagers_bingo",
+      197,
+      "main",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 5473,
+        end: 5522,
+        pattern_start: 5484,
+        pattern_end: 5489
+      }
+    );
+  }
+  return void 0;
+}
+
+// build/.lustre/entry.mjs
+main();

src/voyagers_bingo.gleam

···
+import gleam/io
+
+pub fn main() -> Nil {
+  io.println("Hello from voyagers_bingo!")
+}

test/voyagers_bingo_test.gleam

···
+import gleeunit
+
+pub fn main() -> Nil {
+  gleeunit.main()
+}
+
+// gleeunit test functions end in `_test`
+pub fn hello_world_test() {
+  let name = "Joe"
+  let greeting = "Hello, " <> name <> "!"
+
+  assert greeting == "Hello, Joe!"
+}